| aggregate_dicts |
Ran ran on a synthesized input |
lgalke/vec4ir/vec4ir/combination.py code served (permissive licence) · get_code("b283385e4542d942") 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
from collections import defaultdict, OrderedDict
from operator import itemgetter
torch.manual_seed(0)
# Construct test dictionaries with numeric values
dict1 = {'a': 0.8, 'b': 0.4, 'd': 0.4}
dict2 = {'a': 0.7, 'c': 0.3, 'd': 0.3}
dict3 = {'a': 0.5, 'b': 0.2, 'e': 0.9}
dicts_list = [dict1, dict2, dict3]
# Define aggregation function (default is sum, but can be any function that works on lists)
def custom_agg_fn(values):
return sum(values)
# Arguments for the function
ARGS = {
'dicts': dicts_list,
'agg_fn': sum
}
- 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
|
| all_but_the_top |
Ran ran on a synthesized input |
lgalke/vec4ir/vec4ir/postprocessing.py code served (permissive licence) · get_code("5d4fdb7bf9b69030") 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, 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
from sklearn.decomposition import PCA
# Create a small word vectors matrix (n_words=5, n_dimensions=4)
v = np.random.randn(5, 4).astype(np.float32)
# Number of principal components to subtract
D = 2
ARGS = {
"v": v,
"D": D
}
- 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 ndarray, ndim 2, dtype family float, shape (5, 4) — shape (5, 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
|
| compute_pc |
Ran ran on a synthesized input |
woctezuma/steam-descriptions/SIF_embedding.py code served (permissive licence) · get_code("da8430897fe9994d") 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 (1, 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
from sklearn.decomposition import TruncatedSVD
# Create a small data matrix
# Shape: (2, 4) - 2 data points, 4 features
np.random.seed(0)
x = np.random.randn(2, 4).astype(np.float64)
# Define the arguments dictionary
ARGS = {
'x': x,
'npc': 1
}
- 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 ndarray, ndim 2, dtype family float, shape (1, 4) — shape (1, 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
|
| compute_retrieval_score |
Ran ran on a synthesized input |
woctezuma/steam-descriptions/hard_coded_ground_truth.py code served (permissive licence) · get_code("c956460114b027c7") 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
import numpy as np
from collections import Counter
torch.manual_seed(0)
# Based on the function body, we need:
# - query_app_ids: a list of app IDs (integers) that exist in retrieval_ground_truth
# - reference_app_id_counters: a list of lists/iterables where each inner list contains ranked app IDs
# - num_elements_displayed: int (default 10)
# - verbose: bool (default True)
# We'll use some app IDs from the retrieval_ground_truth data
query_app_ids = [20, 10, 500, 50, 24240]
# For each query, create a list of ranked reference app IDs
# The function iterates through reference_app_id_counter and checks if items are in ground truth
# We need at least num_elements_displayed items in each reference list
reference_app_id_counters = [
[440, 943490, 100, 200, 300, 400, 500, 600, 700, 800], # for query 20
[80, 240, 730, 273110, 100, 150, 160, 170, 180, 190], # for query 10
[550, 560, 570, 580, 590, 600, 610, 620, 630, 640], # for query 500
[70, 130, 220, 280, 320, 340, 360, 380, 420, 466270], # for query 50
[218620, 400, 620, 104600, 247120, 684410, 659, 52003, 450390, 999] # for query 24240
]
ARGS = {
'query_app_ids': query_app_ids,
'reference_app_id_counters': reference_app_id_counters,
'num_elements_displayed': 10,
'verbose': True
}
- 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 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
|
| compute_retrieval_score_based_on_sharing_meta_data |
Ran ran on a synthesized input |
woctezuma/steam-descriptions/steam_spy_based_ground_truth.py code served (permissive licence) · get_code("d8ff6aad1114d84f") 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
import numpy as np
from collections import Counter
# Set seed for reproducibility
torch.manual_seed(0)
# Define the arguments for the function
query_app_ids = ["1001", "1002", "1003"]
# reference_app_id_counters is a list of Counters (or lists) where each element
# contains app_ids ranked by relevance
reference_app_id_counters = [
Counter({"1002": 10, "1004": 8, "1005": 5, "1006": 3, "1007": 1}),
Counter({"1001": 12, "1003": 9, "1008": 6, "1009": 4, "1010": 2}),
Counter({"1002": 11, "1001": 7, "1011": 5, "1012": 3, "1013": 1}),
]
# retrieval_ground_truth maps metadata to sets of app_ids that have that metadata
retrieval_ground_truth = {
"permission_camera": {1001, 1002, 1004, 1008},
"permission_location": {1001, 1003, 1005, 1009},
"permission_contacts": {1002, 1006, 1010, 1011},
"category_social": {1001, 1002, 1003, 1007},
"category_utility": {1004, 1005, 1006, 1012},
}
meta_data_str = 'meta-data'
num_elements_displayed = 10
verbose = True
ARGS = {
"query_app_ids": query_app_ids,
"reference_app_id_counters": reference_app_id_counters,
"retrieval_ground_truth": retrieval_ground_truth,
"meta_data_str": meta_data_str,
"num_elements_displayed": num_elements_displayed,
"verbose": verbose,
}
- 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 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
|
| delta |
Ran ran on a synthesized input |
lgalke/vec4ir/vec4ir/eqlm.py code served (permissive licence) · get_code("9b9bf22b3f9692b7") 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 torch
import numpy as np
from scipy.spatial.distance import cosine
from scipy.special import expit
torch.manual_seed(0)
# The function delta takes two parameters: u and v
# Looking at the function body, it calls cosine(u, v) which expects array-like inputs
# Then it passes the result to expit (sigmoid)
# The docstring examples show lists being passed
# Create two small array-like objects for u and v
u = [0.2, 0.5, -0.3, 0.1]
v = [0.3, -0.1, 0.2, 0.4]
ARGS = {
"u": u,
"v": v
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, scipy, torch — 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
|
| f1_score |
Ran ran on a synthesized input |
lgalke/vec4ir/vec4ir/base.py code served (permissive licence) · get_code("4e503c5d0be1ac1c") 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 numpy as np
# Construct arguments for f1_score function
# The function takes precision and recall as parameters
# Both are numeric values used in arithmetic operations
# Test case 1: Normal case with valid precision and recall values
precision = 0.8
recall = 0.75
ARGS = {
"precision": precision,
"recall": recall
}
- 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 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
|
| filter_none |
Ran ran on a synthesized input |
lgalke/vec4ir/vec4ir/base.py code served (permissive licence) · get_code("f3932c5856a22a48") 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)
# The function filter_none takes a list and filters out None elements
# It returns a tuple of (filtered_list, count_of_removed_elements)
# We need to construct a list with some None and some non-None elements
some_list = [1, None, "hello", None, 42, [1, 2, 3], None, {"key": "value"}]
ARGS = {
"some_list": some_list
}
- 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
|
| filter_out_words_not_in_vocabulary |
Ran ran on a synthesized input |
woctezuma/steam-descriptions/sentence_models.py code served (permissive licence) · get_code("ff6ad3cdd392ee59") 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
import numpy as np
# Mock word vector object with has_vector attribute
class MockWordVector:
def __init__(self, has_vector=True):
self.has_vector = has_vector
# Mock word vector space similar to spacy
class MockWordVectorSpace:
def __init__(self):
self.vectors = {
'hello': MockWordVector(has_vector=True),
'world': MockWordVector(has_vector=True),
'unknown': MockWordVector(has_vector=False),
'test': MockWordVector(has_vector=True),
}
def __getitem__(self, word):
if word in self.vectors:
return self.vectors[word]
return MockWordVector(has_vector=False)
# Create test data
tokenized_sentence = ['hello', 'world', 'unknown', 'test']
index2word_set = {'hello', 'world', 'test'}
wv_spacy = MockWordVectorSpace()
ARGS = {
'tokenized_sentence': tokenized_sentence,
'index2word_set': index2word_set,
'wv_spacy': wv_spacy,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list, ndim 1, dtype family 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
|
| fuzzy_or |
Ran ran on a synthesized input |
lgalke/vec4ir/vec4ir/combination.py code served (permissive licence) · get_code("14985f458b636e07") 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 numpy as np
torch.manual_seed(0)
# fuzzy_or takes a list of values in [0, 1]
# It applies the fuzzy-or operation: 1 - (1-x)*(1-y)
# The function uses: min(values), max(values), and iterates through values with reduce
ARGS = {
'values': [0.5, 0.3, 0.7, 0.2]
}
- 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 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
|
| get_small_banner_url |
Ran ran on a synthesized input |
woctezuma/steam-descriptions/find_unique_games.py code served (permissive licence) · get_code("89ab94b0acec1f01") 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.
ARGS = {
'app_id': 570
}
- 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 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
|
| get_store_url |
Ran ran on a synthesized input |
woctezuma/steam-descriptions/benchmark_utils.py code served (permissive licence) · get_code("d8940449fdc20406") 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)
ARGS = {
'app_id': 570 # Steam app ID for Dota 2
}
- 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
|
| get_store_url_as_bb_code |
Ran ran on a synthesized input |
woctezuma/steam-descriptions/sentence_models.py code served (permissive licence) · get_code("dd93a92c0ff9a838") 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
# Analyze the function: get_store_url_as_bb_code takes app_id as a parameter
# and concatenates it into a Steam store URL in BB code format.
# The function expects app_id to be a string (based on string concatenation operations)
ARGS = {
'app_id': '730'
}
- 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
|
| get_weighted_average |
Ran ran on a synthesized input |
woctezuma/steam-descriptions/SIF_embedding.py code served (permissive licence) · get_code("026881372c1acba1") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
np.random.seed(0)
# word_embed: We[i,:] is the vector for word i
# Shape: (vocab_size, embedding_dim)
word_embed = np.random.randn(10, 4)
# x: x[i, :] are the indices of the words in sentence i
# Shape: (n_samples, max_words_per_sentence)
# Values should be valid indices into word_embed (0-9)
x = np.array([
[0, 1, 2, 3],
[5, 6, 7, 8]
], dtype=int)
# w: w[i, :] are the weights for the words in sentence i
# Shape: (n_samples, max_words_per_sentence)
# Some weights should be zero, some nonzero
w = np.array([
[1.0, 0.5, 0.0, 0.3],
[0.2, 0.0, 0.8, 1.0]
], dtype=float)
ARGS = {
"word_embed": word_embed,
"x": x,
"w": w
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| harvest |
Ran ran on a synthesized input |
lgalke/vec4ir/vec4ir/base.py code served (permissive licence) · get_code("007dc399b4466aa1") 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 numpy as np
import pandas as pd
# Test case 1: list of lists (2D array-like structure)
source_list = [[2, 3, 4, 5], [22, 33, 42, 55]]
# Test case 2: numpy array
source_array = np.array([[2, 3, 4, 5], [22, 33, 42, 55]])
# Test case 3: list of dicts
source_list_dicts = [
{"d1": 2, "d2": 3, "d3": 4, "d4": 5},
{"d1": 22, "d2": 33, "d3": 42, "d4": 55}
]
# Test case 4: pandas Series with nested structure
source_pd = pd.Series({
0: {"d1": 2, "d2": 3, "d3": 4, "d4": 5},
1: {"d1": 22, "d2": 33, "d3": 42, "d4": 55}
})
# Test case 5: pandas Series with MultiIndex (query_id, doc_id) pairs
index = pd.MultiIndex.from_tuples([(0, "d1"), (0, "d2"), (0, "d3"), (0, "d4"),
(1, "d1"), (1, "d2"), (1, "d3"), (1, "d4")])
source_pd_multiindex = pd.Series([2, 3, 4, 5, 22, 33, 42, 55], index=index)
ARGS = {
"source": source_list,
"query_id": 1,
"doc_id": 2,
"default": 0
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, pandas — 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
|
| harvest_docs |
Ran ran on a synthesized input |
lgalke/vec4ir/vec4ir/datasets.py code served (permissive licence) · get_code("6affee200375e11e") 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 tempfile
import os
# Create a temporary directory with test files
temp_dir = tempfile.mkdtemp()
# Create test files with integer labels as filenames
test_data = {
"0": "Document content for label 0",
"1": "Document content for label 1",
"2": "Document content for label 2"
}
for label, content in test_data.items():
with open(os.path.join(temp_dir, label), 'w') as f:
f.write(content)
ARGS = {
"path": temp_dir,
"verify_integrity": True
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- pandas — 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
|
| mean_reciprocal_rank |
Ran ran, honoured the contract we drafted |
lgalke/vec4ir/vec4ir/rank_metrics.py pointer only (licence: MIT); the stored copy get_code serves, from ukplab/emnlp2023_jiu_jitsu_argumentation_for_rebuttals, is pointer only (licence: NOASSERTION) · get_code("65bd69884cbfbdc9") 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 ukplab/emnlp2023_jiu_jitsu_argumentation_for_rebuttals, 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. |
| precision_at_k |
Ran ran on a synthesized input |
lgalke/vec4ir/vec4ir/rank_metrics.py code served (permissive licence) · get_code("0b5204fbf39cb428") 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
# Test case 1: typical case with some relevant items
r1 = [0, 0, 1]
k1 = 3
# Test case 2: all relevant items
r2 = [1, 1, 1, 1]
k2 = 2
# Test case 3: single item relevant
r3 = [1, 0, 0]
k3 = 1
# Use the first test case for ARGS
ARGS = {
'r': r1,
'k': k1
}
- 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
|
| r_precision |
Ran ran, honoured the contract we drafted |
lgalke/vec4ir/vec4ir/rank_metrics.py pointer only (licence: MIT); the stored copy get_code serves, from ukplab/emnlp2023_jiu_jitsu_argumentation_for_rebuttals, is pointer only (licence: NOASSERTION) · get_code("1c940d569262c1bb") 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 ukplab/emnlp2023_jiu_jitsu_argumentation_for_rebuttals, 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. |
| remove_pc |
Ran ran on a synthesized input |
woctezuma/steam-descriptions/SIF_embedding.py code served (permissive licence) · get_code("84d9ddc54e992bf6") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Create a small data matrix
# x should be a 2D array where x[i,:] is a data point
# Using shape (2, 4) - 2 data points, 4 features
np.random.seed(0)
x = np.random.randn(2, 4).astype(np.float64)
# npc is the number of principal components to remove
npc = 1
ARGS = {
"x": x,
"npc": npc,
}
- 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 ndarray, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| synthesize_topics |
Ran ran on a synthesized input |
lgalke/vec4ir/vec4ir/datasets.py code served (permissive licence) · get_code("0ee5810d2cce719e") 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 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
def _first_preflabel(node):
return node['prefLabel'][0]
# Construct valid arguments for synthesize_topics
# gold: a dict mapping labels (query_ids) to values
# The function calls set(gold.keys()) to get unique labels
gold = {
'topic_001': 'some_value',
'topic_002': 'another_value',
'topic_003': 'third_value'
}
# thesaurus: a dict that can be indexed by labels
# The function accesses thesaurus[label] for each label in gold.keys()
# It then calls accessor(thesaurus[label]), which by default calls _first_preflabel
# _first_preflabel expects node['prefLabel'][0], so each value needs a 'prefLabel' key
# with a list/sequence as its value
thesaurus = {
'topic_001': {'prefLabel': ['Computer Science', 'CS']},
'topic_002': {'prefLabel': ['Machine Learning', 'ML']},
'topic_003': {'prefLabel': ['Natural Language Processing', 'NLP']}
}
# accessor: defaults to _first_preflabel
# It's a callable that takes a thesaurus node and returns a query string
accessor = _first_preflabel
ARGS = {
'gold': gold,
'thesaurus': thesaurus,
'accessor': accessor
}
- 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 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
|
| eqe1 |
Not yet run unverified (harvested, no recorded run) |
lgalke/vec4ir/vec4ir/eqlm.py code served (permissive licence) · get_code("3514fb2cdfab561d") How it ran |
| expand |
Not yet run unverified (harvested, no recorded run) |
lgalke/vec4ir/vec4ir/eqlm.py code served (permissive licence) · get_code("3c032c9ef0a071ed") How it ran |
| get_word_model_vocabulary |
Not yet run unverified (harvested, no recorded run) |
woctezuma/steam-descriptions/word_model.py code served (permissive licence) · get_code("74ad04dddaa20e30") How it ran |
| mine_gold |
Not yet run unverified (harvested, no recorded run) |
lgalke/vec4ir/vec4ir/datasets.py code served (permissive licence) · get_code("8292abe95b52ea1c") How it ran |
| test_word |
Not yet run unverified (harvested, no recorded run) |
woctezuma/steam-descriptions/word_model.py code served (permissive licence) · get_code("d4b5206c822ba5a1") How it ran |