SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1702.01417 · 2017

All-but-the-Top: Simple and Effective Postprocessing for Word Representations

arXiv · PDF · Open in the Atlas

Code that ran

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

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

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

RepositoryRoleRan
lgalke/vec4ir community (classifier label)
classifier basis not recorded on the link
12 ran · 3 no recorded run
woctezuma/steam-descriptions community (classifier label)
classifier basis not recorded on the link
9 ran · 2 no recorded run
FunctionStatusWhere it lives
aggregate_dicts Ran
ran on a synthesized input
lgalke/vec4ir/vec4ir/combination.py
code served (permissive licence) · get_code("b283385e4542d942")
How it ran

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

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

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

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

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

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

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

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

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

import torch

torch.manual_seed(0)

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

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

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

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

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

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 ran

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

import torch
import numpy as np

torch.manual_seed(0)

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 ran

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

import torch

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

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

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

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

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

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

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

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

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

no invocation recorded.

expand Not yet run
unverified (harvested, no recorded run)
lgalke/vec4ir/vec4ir/eqlm.py
code served (permissive licence) · get_code("3c032c9ef0a071ed")
How it ran

no invocation recorded.

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

no invocation recorded.

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

no invocation recorded.

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

no invocation recorded.

Also present in other papers' code

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

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

FunctionAlso present inEarliest-datedOthers named
mean_reciprocal_rank 4 other papers
4 later
1911.08621 (2019-11)
Open Cross-Domain Visual Search
2208.11083 (2022-08)
Learn Basic Skills and Reuse: Modularized Adaptive Neural Architecture Search (MANAS)
2310.14481 (2023-10)
Efficient Heterogeneous Graph Learning via Random Projection
and 1 more not named here
r_precision 3 other papers
3 later
1911.08621 (2019-11)
Open Cross-Domain Visual Search
2208.11083 (2022-08)
Learn Basic Skills and Reuse: Modularized Adaptive Neural Architecture Search (MANAS)
2311.03998 (2023-11)
Exploring Jiu-Jitsu Argumentation for Writing Peer Review Rebuttals
precision_at_k 1 other paper
1 later
1911.08621 (2019-11)
Open Cross-Domain Visual Search

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

Repositories linked to this paper

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

Abstract

Real-valued word representations have transformed NLP applications; popular examples are word2vec and GloVe, recognized for their ability to capture linguistic regularities. In this paper, we demonstrate a {\em very simple}, and yet counter-intuitive, postprocessing technique -- eliminate the common mean vector and a few top dominating directions from the word vectors -- that renders off-the-shelf representations {\em even stronger}. The postprocessing is empirically validated on a variety of lexical-level intrinsic tasks (word similarity, concept categorization, word analogy) and sentence-level tasks (semantic textural similarity and { text classification}) on multiple datasets and with a variety of representation methods and hyperparameter choices in multiple languages; in each case, the processed representations are consistently better than the original ones.

For agents

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

get_harvested_code_for_paper("1702.01417")
get_code_for_paper("1702.01417")
have("1702.01417")

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

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

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

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

Connect an agent — have() is free.