SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1301.3781 · ICLR · 2013

Efficient Estimation of Word Representations in Vector Space

Kai Chen, Tomas Mikolov, Jeffrey Dean, Greg Corrado

arXiv · PDF · Open in the Atlas

Code that ran

43 of 62 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (7 of them constructed an object rather than computing a result; 4 honoured the contract we drafted, 1 violated it and 32 have no contract verdict; 6 failures of our instrument; 19 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/1301.3781.json · badge: /api/ran/1301.3781.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
ringbdstack/socialed community (classifier label)
classifier basis not recorded on the link
12 ran · 7 no recorded run
ExtensityAI/symbolicai community (classifier label)
classifier basis not recorded on the link
8 ran · 1 no recorded run
casszhao/reagent community (classifier label)
classifier basis not recorded on the link
3 ran · 5 no recorded run
jeremycz/word-vectors community
not in the paper's declared repositories
3 ran · 0 no recorded run
Bigscity-VecCity/VecCity community
Papers with Code archive
2 ran · 0 no recorded run
Robotmurlock/Deepwalk-and-Node2vec community
Papers with Code archive
2 ran · 0 no recorded run
oliverquintana/CBOWWordPrediction community (classifier label)
classifier basis not recorded on the link
2 ran · 0 no recorded run
chaneeh/Word2Vec_implementation community
not in the paper's declared repositories
1 ran · 1 no recorded run
chikalabouka/INF8225-TP4 community
not in the paper's declared repositories
1 ran · 1 no recorded run
rajshrivastava/Skipgram community
not in the paper's declared repositories
1 ran · 0 no recorded run
rajshrivastava/Word-embeddings community
not in the paper's declared repositories
1 ran · 0 no recorded run
gladisor/TextGenerator community
not in the paper's declared repositories
1 ran · 0 no recorded run
zhang2010hao/cw2vec-pytorch community
not in the paper's declared repositories
1 ran · 0 no recorded run
orenmel/synth-clinical-notes community
not in the paper's declared repositories
1 ran · 0 no recorded run
mkserge/word2vec_np community
not in the paper's declared repositories
1 ran · 0 no recorded run
lateral/minkowski community
not in the paper's declared repositories
1 ran · 0 no recorded run
gartland98/word2vec_basic community
not in the paper's declared repositories
1 ran · 0 no recorded run
copy not recorded community
not in the paper's declared repositories
1 ran · 0 no recorded run
graykode/nlp-tutorial community
not in the paper's declared repositories
0 ran · 1 no recorded run
ghlee0304/NLP-with-tensorflow-pytorch community
not in the paper's declared repositories
0 ran · 1 no recorded run
AotY/MPyWE community
Papers with Code archive
0 ran · 1 no recorded run
ni9elf/Word2VecImplementation community
not in the paper's declared repositories
0 ran · 1 no recorded run
FunctionStatusWhere it lives
AbstractModel Ran
ran on a synthesized input · constructed an object; no result was computed
Bigscity-VecCity/VecCity/veccity/upstream/poi_representation/w2v.py
code served (permissive licence) · get_code("f531245c73ab5076")
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 an instance of its own class, AbstractModel: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# Create a minimal config dict
config = {
    "input_dim": 4,
    "hidden_dim": 8,
    "output_dim": 3,
}

# Create a minimal data_feature object
class DataFeature:
    def __init__(self):
        self.num_features = 4
        self.feature_names = ["feat1", "feat2", "feat3", "feat4"]

data_feature = DataFeature()

ARGS = {
    "config": config,
    "data_feature": data_feature,
}
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 AbstractModel — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a AbstractModel 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
Const Ran
ran on a synthesized input
ExtensityAI/symbolicai/symai/models/base.py
code served (permissive licence) · get_code("a16c5b85f109253c")
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 FieldInfo. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

from pydantic import BaseModel, Field, create_model, model_validator

def Const(value: str):
    return Field(default=value, json_schema_extra={'const_value': value})

# The function Const takes a single parameter: value (a string)
# It returns a Field object with default and json_schema_extra set
# No complex objects or tensors are needed

ARGS = {
    'value': 'test_constant_value'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
pydantic — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type FieldInfo — a FieldInfo output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a FieldInfo 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
NeuralNet Ran
ran on a synthesized input · constructed an object; no result was computed
rajshrivastava/Skipgram/train_minibatch.py
pointer only (licence: NONE) · get_code("c2d4b7803f146ec0")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, rajshrivastava/Skipgram 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.

NeuralNet Ran
ran on a synthesized input · constructed an object; no result was computed
rajshrivastava/Word-embeddings/skipgram_csv2.py
pointer only (licence: NONE) · get_code("5b73c65cb12c7a4b")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, rajshrivastava/Word-embeddings 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.

SeqToProb Ran
ran on a synthesized input
gladisor/TextGenerator/models.py
pointer only (licence: NONE) · get_code("d9751d8bd1a1338c")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, gladisor/TextGenerator 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.

SkipGram Ran
ran on a synthesized input · constructed an object; no result was computed
Bigscity-VecCity/VecCity/veccity/upstream/poi_representation/w2v.py
code served (permissive licence) · get_code("3e8fc83d99d67fcc")
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 an instance of its own class, SkipGram: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
from torch.nn import functional as F

torch.manual_seed(0)

# Create a minimal config dict
config = {
    'embed_size': 4,
    'model': 'SkipGram'  # Not 'CBOW' to test the main branch
}

# Create a minimal data_feature dict
data_feature = {
    'num_loc': 10
}

# Create batch data for calculate_loss
# The forward method expects: pos_u, pos_v, neg_v
# For SkipGram (not CBOW):
# - pos_u: shape [batch_size]
# - pos_v: shape [batch_size]
# - neg_v: shape [batch_size, num_negatives]

batch_size = 2
num_negatives = 3

pos_u = torch.tensor([0, 1], dtype=torch.long)
pos_v = torch.tensor([2, 3], dtype=torch.long)
neg_v = torch.tensor([[4, 5, 6], [7, 8, 9]], dtype=torch.long)

batch = (batch_size, pos_u, pos_v, neg_v)

ARGS = {
    'config': config,
    'data_feature': data_feature
}
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 SkipGram — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a SkipGram 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
SkipGram Ran
ran on a synthesized input
Robotmurlock/Deepwalk-and-Node2vec/shallow_encoders/word2vec/model.py
code served (permissive licence) · get_code("2d6abc235905d906")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, 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
from torch import nn

class W2VBase(nn.Module):
    """
    Base W2V model. Contains embeddings for both input and context words.
    """

    def __init__(self, vocab_size: int, embedding_size: int, max_norm=None):
        """
        Args:
            vocab_size: Dataset vocabulary size
            embedding_size: Embeddings dimensionality
            max_norm: Maximum norm
        """
        super().__init__()
        self._input_embedding = nn.Embedding(vocab_size, embedding_size, max_norm=max_norm)
        self._output_embedding = nn.Embedding(vocab_size, embedding_size, max_norm=max_norm)
        torch.nn.init.xavier_uniform_(self._input_embedding.weight)
        torch.nn.init.xavier_uniform_(self._output_embedding.weight)

    @property
    def input_embedding(self) -> torch.Tensor:
        """
        Fetch input embedding weights.

        Returns:
            Input embedding weights
        """
        return self._input_embedding.weight.to('cpu').data

    @property
    def output_embedding(self) -> torch.Tensor:
        """
        Fetch output embedding weights.

        Returns:
            Output embedding weights
        """
        return self._output_embedding.weight.to('cpu').data

    def embed_inputs(self, inputs: torch.Tensor) -> torch.Tensor:
        """
        Transforms input word indices (long) to their vector representation (embedding lookup)

        Args:
            inputs: Input word indices

        Returns:
            Inputs embeddings
        """
        return self._input_embedding(inputs)

    def embed_outs(self, outputs: torch.Tensor) -> torch.Tensor:
        """
        Transforms context word indices (long) to their vector representation (embedding lookup)


        Args:
            outputs: Output word indices

        Returns:
            Outputs (context) embeddings
        """
        return self._output_embedding(outputs)

class SkipGram(W2VBase):
    """
    Implementation of SkipGram model.
    """

    def forward(self, inputs: torch.Tensor, outputs: torch.Tensor, proba: bool=True) -> torch.Tensor:
        batch_size, _ = outputs.shape
        inputs_emb = self.embed_inputs(inputs).view(batch_size, -1, 1)
        outputs_emb = self.embed_outs(outputs)
        scalars = torch.bmm(outputs_emb, inputs_emb).view(batch_size, -1)
        if proba:
            scalars = torch.sigmoid(scalars)
        return scalars


INIT_ARGS = {
    'vocab_size': 10,
    'embedding_size': 4,
    'max_norm': None,
}

ARGS = {
    'inputs': torch.tensor([[2], [5]], dtype=torch.long),
    'outputs': torch.tensor([[1, 3, 4], [2, 6, 7]], dtype=torch.long),
    'proba': True,
}

model = SkipGram(**INIT_ARGS)
output = model(**ARGS)
print(output)
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
SkipGramModel Ran
ran on a synthesized input · constructed an object; no result was computed
zhang2010hao/cw2vec-pytorch/skip_gram.py
pointer only (licence: NONE) · get_code("bab7847c74c24245")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, zhang2010hao/cw2vec-pytorch 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.

Vectors Ran
ran on a synthesized input · constructed an object; no result was computed
orenmel/synth-clinical-notes/BioNLP-2016-master/wvlib/wvlib.py
pointer only (licence: NONE) · get_code("06b0dc2c0df530b8")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, orenmel/synth-clinical-notes 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.

Vocab Ran
ran on a synthesized input
chaneeh/Word2Vec_implementation/word2vec_project.py
pointer only (licence: NONE) · get_code("688209f36245d884")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, chaneeh/Word2Vec_implementation 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.

W2VBase Ran
ran on a synthesized input · constructed an object; no result was computed
Robotmurlock/Deepwalk-and-Node2vec/shallow_encoders/word2vec/model.py
code served (permissive licence) · get_code("220a6630a25806ce")
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 an instance of its own class, W2VBase: the run constructed the object and did not call it, so no result was computed. 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
from torch import nn

torch.manual_seed(0)

ARGS = {
    "vocab_size": 100,
    "embedding_size": 8,
    "max_norm": None,
}
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 W2VBase — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a W2VBase 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
angleDocs Ran
ran on a synthesized input
oliverquintana/CBOWWordPrediction/utils.py
code served (permissive licence) · get_code("0fc6e77c78f61452")
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

# Create two small document vectors
doc1 = np.array([1.0, 2.0, 3.0, 4.0])
doc2 = np.array([2.0, 1.0, 4.0, 3.0])

ARGS = {
    "doc1": doc1,
    "doc2": doc2
}
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
common_loss Ran
ran on a synthesized input
ringbdstack/socialed/SocialED/detector/etgnn.py
code served (permissive licence) · get_code("b1b2a5b2fb19d1b0")
How it ran

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

import torch

torch.manual_seed(0)

# The function takes two embedding tensors
# It centers them, normalizes them, computes covariance matrices, and calculates MSE
# Both tensors need to be 2D (batch_size, embedding_dim)

emb1 = torch.randn(2, 4)  # batch_size=2, embedding_dim=4
emb2 = torch.randn(2, 4)  # batch_size=2, embedding_dim=4

ARGS = {
    "emb1": emb1,
    "emb2": emb2,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
coo_trans Ran
ran on a synthesized input
ringbdstack/socialed/SocialED/detector/finevent.py
code served (permissive licence) · get_code("71a2ba68c43caf51")
How it ran

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

import torch
from scipy import sparse
import numpy as np
import tempfile
import os

# Create a temporary directory and sparse matrix file
temp_dir = tempfile.mkdtemp()
datapath = os.path.join(temp_dir, 's_m_tid_userid_tid.npz')

# Create a small sparse matrix and save it
row = np.array([0, 1, 2, 0])
col = np.array([1, 2, 0, 2])
data = np.array([1, 2, 3, 4])
coo = sparse.coo_matrix((data, (row, col)), shape=(3, 3))
csr = coo.tocsr()
sparse.save_npz(datapath, csr)

ARGS = {
    'datapath': datapath
}
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 Tensor, ndim 2, dtype family int, 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
create_dataset Ran
ran on a synthesized input
ringbdstack/socialed/SocialED/detector/finevent.py
code served (permissive licence) · get_code("b2af81ffeb8edfe7")
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 Data. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np
import os
import tempfile
from scipy import sparse
from scipy.sparse import csr_matrix

torch.manual_seed(0)
np.random.seed(0)

# Create a temporary directory structure to simulate the data layout
tmpdir = tempfile.mkdtemp()

# Create subdirectories for mode[1] = 0
mode_dir = os.path.join(tmpdir, '0')
os.makedirs(mode_dir, exist_ok=True)

# Create dummy features (2 samples, 4 features)
features = np.random.randn(2, 4).astype(np.float32)
np.save(os.path.join(mode_dir, 'features.npy'), features)

# Create dummy labels (2 samples)
labels = np.array([0, 1], dtype=np.int64)
np.save(os.path.join(mode_dir, 'labels.npy'), labels)

# Create dummy sparse edge index matrix (2x2)
# This represents edges between 2 nodes
edge_data = np.array([0, 1, 1, 0])
edge_row = np.array([0, 0, 1, 1])
edge_col = np.array([0, 1, 0, 1])
sparse_matrix = csr_matrix((edge_data, (edge_row, edge_col)), shape=(2, 2))
sparse.save_npz(os.path.join(mode_dir, 's_m_tid_userid_tid.npz'), sparse_matrix)

# Create data_split array indicating the number of samples at each time step
data_split = np.array([2, 2, 2], dtype=np.int64)
np.save(os.path.join(tmpdir, 'data_split.npy'), data_split)

ARGS = {
    'loadpath': tmpdir,
    'relation': 'userid',
    'mode': (0, 0)  # (train_i, i) - both 0 means training/validation mode
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy, torch, torch_geometric — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Data — a Data 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
distDocs Ran
ran on a synthesized input
oliverquintana/CBOWWordPrediction/utils.py
code served (permissive licence) · get_code("f70d6f8816ba5f02")
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

# Create two simple numpy arrays representing documents
# Using distinct sizes to make shapes unambiguous
doc1 = np.array([1.0, 2.0, 3.0, 4.0])
doc2 = np.array([5.0, 6.0, 7.0, 8.0])

ARGS = {
    "doc1": doc1,
    "doc2": doc2,
}
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
encode_image_local Ran
ran on a synthesized input
ExtensityAI/symbolicai/symai/utils.py
code served (permissive licence) · get_code("8ad3e5c372254946")
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 tempfile
from pathlib import Path
import base64

# Create a temporary PNG image file for testing
with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as tmp_file:
    # Write a minimal valid PNG file (1x1 pixel, transparent)
    png_data = (
        b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01'
        b'\x08\x06\x00\x00\x00\x1f\x15\xc4\x89\x00\x00\x00\nIDATx\x9cc\x00\x01'
        b'\x00\x00\x05\x00\x01\r\n-\xb4\x00\x00\x00\x00IEND\xaeB`\x82'
    )
    tmp_file.write(png_data)
    tmp_path = tmp_file.name

ARGS = {
    'image_path': tmp_path
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
encode_media_frames Ran
ran on a synthesized input
ExtensityAI/symbolicai/symai/utils.py
code served (permissive licence) · get_code("17c79bb9d41d58fa")
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 base64
import io
import tempfile
from pathlib import Path
from PIL import Image

# Create a temporary image file for testing
temp_dir = tempfile.mkdtemp()

# Create a simple PNG image
img = Image.new('RGB', (10, 10), color='red')
png_path = Path(temp_dir) / "test.png"
img.save(png_path)

# Create a simple JPEG image
jpg_path = Path(temp_dir) / "test.jpg"
img.save(jpg_path)

# Create a simple WebP image
webp_path = Path(temp_dir) / "test.webp"
img.save(webp_path)

# Create a simple GIF image
gif_path = Path(temp_dir) / "test.gif"
img.save(gif_path)

ARGS = {
    "file_path": str(png_path),
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL, cv2, httpx — 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
forward_sm Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
mkserge/word2vec_np/word2vec_np/utils/propagate.py
code served (permissive licence) · get_code("5f1343393642a992")
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) 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 numpy as np

# Set random seed for reproducibility
np.random.seed(0)

# Define dimensions
V = 5  # vocabulary size
N = 3  # hidden layer size
m = 2  # number of samples (batch size)

# Create input X: Many-Hot encoded, shape (V, m)
X = np.random.randn(V, m).astype(np.float32)

# Create weight matrices
W1 = np.random.randn(V, N).astype(np.float32)
W2 = np.random.randn(N, V).astype(np.float32)

# Create parameters dictionary
parameters = {
    'V': V,
    'N': N,
    'm': m,
    'W1': W1,
    'W2': W2
}

# Define ARGS
ARGS = {
    'X': X,
    'parameters': parameters
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_one_line_for_one_FA Ran
ran on a synthesized input
casszhao/reagent/summarise_ante_nod.py
code served (permissive licence) · get_code("c8c9f3f8d1ec1fb2")
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 pandas as pd
import tempfile
import os

# Create temporary directory structure for test data
temp_dir = tempfile.mkdtemp()
os.makedirs(f'{temp_dir}/evaluation_results/analogies/gpt2_baseline', exist_ok=True)
os.makedirs(f'{temp_dir}/evaluation_results/analogies/gpt2_ours/top5_replace0.3_max5000_batch8', exist_ok=True)

# Create sample CSV files for baseline method
baseline_csv_100 = pd.DataFrame({
    'Ratio contain relative': [0.85],
    'Ratio no distractor': [0.92]
})
baseline_csv_100.to_csv(f'{temp_dir}/evaluation_results/analogies/gpt2_baseline/100_ante_nod.csv', index=False)

baseline_csv_200 = pd.DataFrame({
    'Ratio contain relative': [0.88],
    'Ratio no distractor': [0.94]
})
baseline_csv_200.to_csv(f'{temp_dir}/evaluation_results/analogies/gpt2_baseline/200_ante_nod.csv', index=False)

# Create sample CSV files for "ours" method
ours_csv_100 = pd.DataFrame({
    'Ratio contain relative': [0.90],
    'Ratio no distractor': [0.95]
})
ours_csv_100.to_csv(f'{temp_dir}/evaluation_results/analogies/gpt2_ours/top5_replace0.3_max5000_batch8/100_ante_nod.csv', index=False)

ours_csv_200 = pd.DataFrame({
    'Ratio contain relative': [0.92],
    'Ratio no distractor': [0.96]
})
ours_csv_200.to_csv(f'{temp_dir}/evaluation_results/analogies/gpt2_ours/top5_replace0.3_max5000_batch8/200_ante_nod.csv', index=False)

# Change working directory to temp_dir so relative paths work
original_cwd = os.getcwd()
os.chdir(temp_dir)

ARGS = {
    'model_name': 'gpt2',
    'FA_name': 'baseline',
    'len_list': [100, 200]
}
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
get_one_line_for_one_FA Ran
ran on a synthesized input
casszhao/reagent/summarise_sequencelevel.py
code served (permissive licence) · get_code("c8d1933d80333219")
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 pandas as pd
import os
import tempfile
import math

# Create a temporary directory structure with mock CSV files
temp_dir = tempfile.mkdtemp()
eval_base = os.path.join(temp_dir, 'evaluation_results', 'benchmark')

# Create directories for different model/FA/task combinations
model_name = 'bert'
FA_name = 'norm'
task_name = 'sentiment'

eval_path = os.path.join(eval_base, f'{model_name}_{FA_name}', task_name)
os.makedirs(eval_path, exist_ok=True)

# Create mock CSV files with required columns
csv_data_1 = pd.DataFrame({
    'norm_suff_mean': [2.5],
    'random_suff_mean': [1.0],
    'norm_comp_mean': [3.0],
    'random_comp_mean': [1.2]
})
csv_data_1.to_csv(os.path.join(eval_path, 'results_1_mean.csv'), index=False)

csv_data_2 = pd.DataFrame({
    'norm_suff_mean': [2.0],
    'random_suff_mean': [0.8],
    'norm_comp_mean': [2.5],
    'random_comp_mean': [1.0]
})
csv_data_2.to_csv(os.path.join(eval_path, 'results_2_mean.csv'), index=False)

# Patch os.path to use our temporary directory
original_expanduser = os.path.expanduser

def mock_expanduser(path):
    if path.startswith('evaluation_results'):
        return os.path.join(temp_dir, path)
    return original_expanduser(path)

os.path.expanduser = mock_expanduser

# Also need to handle the fsencode/fsdecode with our temp directory
original_listdir = os.listdir

def mock_listdir(path):
    if isinstance(path, bytes):
        path = os.fsdecode(path)
    if 'evaluation_results' in str(path):
        path = os.path.join(temp_dir, path.lstrip('/'))
    return original_listdir(path)

os.listdir = mock_listdir

ARGS = {
    'model_name': 'bert',
    'FA_name': 'norm',
    'task_name': 'sentiment'
}
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 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
get_one_line_for_one_FA Ran
ran on a synthesized input
casszhao/reagent/summarise_tokenlevel.py
code served (permissive licence) · get_code("b58e346294fba584")
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 pandas as pd
import os
import tempfile

# Create temporary directory structure and mock CSV files
temp_dir = tempfile.mkdtemp()
os.makedirs(f'{temp_dir}/evaluation_results/analogies/gpt2_ours/top3_replace0.1_max5000_batch5', exist_ok=True)
os.makedirs(f'{temp_dir}/evaluation_results/analogies/gpt2_baseline', exist_ok=True)

# Create mock CSV files with required columns
mock_data = pd.DataFrame({
    'suff': [0.85],
    'comp': [0.72],
    'random_suff': [0.45],
    'random_comp': [0.38]
})

mock_data.to_csv(f'{temp_dir}/evaluation_results/analogies/gpt2_ours/top3_replace0.1_max5000_batch5/mean_1.0.csv', index=False)
mock_data.to_csv(f'{temp_dir}/evaluation_results/analogies/gpt2_baseline/mean_1.0.csv', index=False)

# Change working directory to temp directory for file access
original_cwd = os.getcwd()
os.chdir(temp_dir)

ARGS = {
    'model_name': 'gpt2',
    'FA_name': 'ours'
}
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
get_task Ran
ran on a synthesized input
ringbdstack/socialed/SocialED/detector/hcrc.py
code served (permissive licence) · get_code("410fc5e1b2944e14")
How it ran

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

import torch

torch.manual_seed(0)

# The function get_task takes a single parameter 'strs' which is a list of strings
# It checks the contents and length of this list to determine which task to return

# Test case 1: single element list
strs_case1 = ['something']

# Test case 2: two elements with '--task'
strs_case2 = ['--task', 'value']

# Test case 3: three elements with '--task' and valid task name
strs_case3 = ['--task', 'ignored', 'DRL']

ARGS = {
    'strs': strs_case1
}
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
hardest_negative Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
ringbdstack/socialed/SocialED/detector/bilstm.py
code served (permissive licence) · get_code("28431bd8429ef046")
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 int64, 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

# The function takes loss_values and:
# 1. Calls np.argmax(loss_values) - needs array-like
# 2. Indexes into loss_values with the result
# 3. Compares the value to 0
# So loss_values should be a numpy array of numeric values

# Create a small numpy array with some positive and negative loss values
loss_values = np.array([0.5, -0.2, 1.3, 0.1])

ARGS = {
    "loss_values": loss_values
}
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 int64, 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
missing_dependency Ran
ran on a synthesized input
ExtensityAI/symbolicai/symai/utils.py
code served (permissive licence) · get_code("2e8d7337716058a5")
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 ImportError. 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
from enum import StrEnum

class Extra(StrEnum):
    """Optional-dependency extras; pass a member as the `extra` argument of `missing_dependency`."""
    HF = 'hf'
    SCRAPE = 'scrape'
    LEAN = 'lean'
    WHISPER = 'whisper'
    VIDEO = 'video'
    SEARCH = 'search'
    SERVICES = 'services'
    QDRANT = 'qdrant'
    CLUSTER = 'cluster'

def missing_dependency(extra: Extra, dep: str, *, package: str | None=None) -> ImportError:
    """Build a standardized ImportError naming the extra that provides a missing optional dependency.

    Use as `raise missing_dependency(...)` from a `None`-sentinel guard or an
    `except ImportError` block for an optional dependency, so users get a consistent
    "install symbolicai[<extra>]" hint instead of a bare ModuleNotFoundError. `dep` is the
    missing import name; pass `package` when the pip distribution name differs
    (e.g. cv2 -> opencv-python) to also suggest the bare install. Inside an `except` block,
    chain with `from None` to drop the noisy ModuleNotFoundError traceback.
    """
    install = f'`pip install symbolicai[{extra}]`'
    if package:
        install += f' (or `pip install {package}`)'
    msg = f"'{dep}' is required for this feature but is not installed. Install it with {install}."
    return ImportError(msg)


ARGS = {
    'extra': Extra.HF,
    'dep': 'transformers',
    'package': 'transformers'
}
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 ImportError — a ImportError output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a ImportError 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
mobius_add Ran
ran on a synthesized input
ringbdstack/socialed/SocialED/detector/Hypersed.py
code served (permissive licence) · get_code("cc3ca7d17098a0da")
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 small test arrays for Möbius addition
# The function expects:
# - x: array of shape (batch_size, dim) with values in hyperbolic space
# - y: array of shape (batch_size, dim) with values in hyperbolic space
# Both should be numpy arrays

batch_size = 2
dim = 4

# Create small random arrays with values in a reasonable range
# for hyperbolic space (typically small magnitudes)
np.random.seed(0)
x = np.random.randn(batch_size, dim).astype(np.float32) * 0.1
y = np.random.randn(batch_size, dim).astype(np.float32) * 0.1

ARGS = {
    "x": x,
    "y": y,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
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
mobius_mul Ran
ran on a synthesized input
ringbdstack/socialed/SocialED/detector/Hypersed.py
code served (permissive licence) · get_code("3227efec9ee98936")
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

# Examine the function signature and body:
# - x: numpy array used in arithmetic operations, shape should be (batch, features)
# - t: scalar value used in arithmetic

# Create a small batch of data
batch_size = 2
feature_dim = 4

# x should be a 2D array (batch_size, feature_dim)
x = np.random.randn(batch_size, feature_dim).astype(np.float32)

# t should be a scalar (or array-like scalar)
t = 0.5

ARGS = {
    "x": x,
    "t": t,
}
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
naiveSoftmaxLossAndGradient Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
jeremycz/word-vectors/a2/word2vec.py
pointer only (licence: NONE) · get_code("f8bd87d31faa3569")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, jeremycz/word-vectors 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.

pdist Ran
ran, honoured the contract we drafted
ringbdstack/socialed/SocialED/detector/bilstm.py
pointer only (licence: BSD-2-Clause); the stored copy get_code serves, from PeiqinZhuang/API-Net, is pointer only (licence: NONE) · get_code("21868b96f7d7b0a3")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (BSD-2-Clause), but get_code serves the stored copy, first harvested from PeiqinZhuang/API-Net, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

random_hard_negative Ran
ran, violated the contract we drafted
ringbdstack/socialed/SocialED/detector/bilstm.py
code served (permissive licence) · get_code("ac72a4aca5c29a4a")
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 int64, 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

# Set random seed for reproducibility
np.random.seed(0)

# Create a small array of loss values
# Some values > 0 (hard negatives), some <= 0
loss_values = np.array([0.5, -0.2, 1.3, 0.0, 2.1, -1.0])

ARGS = {
    "loss_values": loss_values
}
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 int64, 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
run_training Ran
ran; our contract draft was wrong, not the code
lateral/minkowski/python/train_skipgram.py
pointer only (licence: NONE) · get_code("23c2c9ab6bae4826")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, lateral/minkowski 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.

semi_loss Ran
ran on a synthesized input
ringbdstack/socialed/SocialED/detector/hcrc.py
code served (permissive licence) · get_code("aed233c4604a5b91")
How it ran

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

import torch

torch.manual_seed(0)

# The function semi_loss takes two arguments: z1 and z2
# Both are used in sim() which calls F.normalize() and torch.mm()
# So they need to be 2D tensors (matrices)
# The function computes similarities and loss, so they should have compatible shapes

z1 = torch.randn(2, 4)  # batch_size=2, embedding_dim=4
z2 = torch.randn(2, 4)  # batch_size=2, embedding_dim=4

ARGS = {
    "z1": z1,
    "z2": z2,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 1, dtype family float, shape (2,) — shape (2,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
sigmoid Ran
ran, honoured the contract we drafted
chikalabouka/INF8225-TP4/word2vec.py
pointer only (licence: NONE) · get_code("79f11a734356d4da")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, chikalabouka/INF8225-TP4 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.

sim Ran
ran on a synthesized input
ringbdstack/socialed/SocialED/detector/hcrc.py
code served (permissive licence) · get_code("56d44f1f9b80ffe4")
How it ran

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

import torch
import torch.nn.functional as F

torch.manual_seed(0)

# Create two small distinct tensors for z1 and z2
# z1: batch_size=2, dim=4
# z2: batch_size=3, dim=4 (distinct batch size to show shapes clearly)
z1 = torch.randn(2, 4)
z2 = torch.randn(3, 4)

ARGS = {
    "z1": z1,
    "z2": z2,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 3) — shape (2, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
skipgram Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
gartland98/word2vec_basic/word2vec.py
pointer only (licence: NONE) · get_code("6eb02a1906f4d641")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, gartland98/word2vec_basic 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.

skipgram Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
jeremycz/word-vectors/a2/word2vec.py
pointer only (licence: NONE) · get_code("b612bef913199f32")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, jeremycz/word-vectors 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.

softmax Ran
ran, honoured the contract we drafted
this paper's copy was not recorded; identical code first harvested from nlpdata/dialogre
pointer only; the stored copy get_code serves, from nlpdata/dialogre, is pointer only (licence: NOASSERTION) · get_code("cb5cbea0e8219ff5")
How it ran

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

softmax Ran
ran, honoured the contract we drafted
jeremycz/word-vectors/a2/word2vec.py
pointer only (licence: NONE) · get_code("9374cbb282b14e3e")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, jeremycz/word-vectors 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.

sparse_trans Ran
ran on a synthesized input
ringbdstack/socialed/SocialED/detector/finevent.py
code served (permissive licence) · get_code("a2ee88f8d946defb")
How it ran

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

import torch
from scipy import sparse
import numpy as np
import tempfile
import os

torch.manual_seed(0)

# Create a small sparse matrix and save it to a temporary file
temp_dir = tempfile.mkdtemp()
temp_file = os.path.join(temp_dir, 's_m_tid_userid_tid.npz')

# Create a small sparse matrix (5x5) with some non-zero entries
data = np.array([1, 1, 1, 1, 1])
row = np.array([0, 1, 1, 2, 3])
col = np.array([1, 0, 2, 1, 4])
sparse_matrix = sparse.csr_matrix((data, (row, col)), shape=(5, 5))
sparse.save_npz(temp_file, sparse_matrix)

ARGS = {
    'datapath': temp_file
}
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 Tensor, ndim 2, dtype family int, shape (2, 10) — shape (2, 10) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
split_cache_breakpoints Ran
ran on a synthesized input
ExtensityAI/symbolicai/symai/prompts.py
code served (permissive licence) · get_code("e7855c90eab09886")
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

CACHE_BREAKPOINT = 'symai:cache_breakpoint'

# Construct valid arguments for split_cache_breakpoints
text_with_breakpoints = f"segment1{CACHE_BREAKPOINT}segment2{CACHE_BREAKPOINT}segment3"

ARGS = {
    'text': text_with_breakpoints
}
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
strip_cache_breakpoints Ran
ran on a synthesized input
ExtensityAI/symbolicai/symai/prompts.py
code served (permissive licence) · get_code("cd404a7c2cdd44b2")
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

CACHE_BREAKPOINT = 'symai:cache_breakpoint'

def strip_cache_breakpoints(text: str) -> str:
    """Remove every :data:`CACHE_BREAKPOINT` marker from ``text`` (no-op when absent)."""
    if not text:
        return text
    return text.replace(CACHE_BREAKPOINT, '')


ARGS = {
    'text': 'This is some text with ' + CACHE_BREAKPOINT + ' marker and more text'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
strip_cache_breakpoints_from_messages Ran
ran on a synthesized input
ExtensityAI/symbolicai/symai/prompts.py
code served (permissive licence) · get_code("6dbe161f4e6b9dc6")
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.

CACHE_BREAKPOINT = 'symai:cache_breakpoint'

ARGS = {
    'messages': [
        {
            'role': 'user',
            'content': f'Hello{CACHE_BREAKPOINT}world'
        },
        {
            'role': 'assistant',
            'content': 'This is a normal message without breakpoint'
        },
        {
            'role': 'user',
            'content': [
                {'type': 'text', 'text': f'First block{CACHE_BREAKPOINT}'},
                {'type': 'image', 'url': 'https://example.com/img.png'}
            ]
        },
        {
            'role': 'assistant',
            'content': [
                {'type': 'text', 'text': 'No breakpoint here'},
                {'type': 'text', 'text': f'Second block with{CACHE_BREAKPOINT}marker'}
            ]
        },
        {
            'role': 'user',
            'content': ''
        },
        {
            'role': 'user',
            'content': None
        }
    ]
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
transform_schema Ran
ran on a synthesized input
ExtensityAI/symbolicai/symai/strategy.py
code served (permissive licence) · get_code("f49c77050d6248bb")
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 inspect
from typing import Any

# Test case 1: Simple object schema
simple_schema = {
    'type': 'object',
    'title': 'SimpleObject',
    'description': 'A simple test object',
    'properties': {
        'name': {'type': 'string'},
        'age': {'type': 'integer'}
    },
    'required': ['name'],
    'additionalProperties': True
}

# Test case 2: Schema with nested definitions
schema_with_defs = {
    'type': 'object',
    'properties': {
        'user': {'$ref': '#/$defs/User'}
    },
    '$defs': {
        'User': {
            'type': 'object',
            'properties': {
                'id': {'type': 'integer'},
                'email': {'type': 'string', 'format': 'email'}
            },
            'required': ['id']
        }
    }
}

# Test case 3: Schema with anyOf
schema_with_anyof = {
    'anyOf': [
        {'type': 'string'},
        {'type': 'integer'}
    ]
}

# Test case 4: Schema with array type
schema_with_array = {
    'type': 'array',
    'items': {'type': 'string'},
    'minItems': 1,
    'description': 'A list of strings'
}

# Test case 5: Schema with string format
schema_with_format = {
    'type': 'string',
    'format': 'uuid',
    'description': 'A unique identifier'
}

# Test case 6: Minimal valid schema
minimal_schema = {
    'type': 'string'
}

ARGS = {
    'json_schema': simple_schema
}
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
Word2Vec Not yet run
unverified (harvested, no recorded run)
graykode/nlp-tutorial/1-2.Word2Vec/Word2Vec-Skipgram(Softmax).py
code served (permissive licence) · get_code("cb413dce924c80c3")
How it ran

no invocation recorded.

Word2Vec Not yet run
unverified (harvested, no recorded run)
chaneeh/Word2Vec_implementation/word2vec_project.py
pointer only (licence: NONE) · get_code("7e03ebb212af7253")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, chaneeh/Word2Vec_implementation 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. No invocation recorded.

build_dynamic_llm_datamodel Not yet run
unverified (harvested, no recorded run)
ExtensityAI/symbolicai/symai/models/base.py
code served (permissive licence) · get_code("a468a9f145a9f9a6")
How it ran

no invocation recorded.

create_process_open_set Not yet run
unverified (harvested, no recorded run)
ringbdstack/socialed/SocialED/detector/adpsemevent.py
code served (permissive licence) · get_code("ed0eefd95e1fccf0")
How it ran

no invocation recorded.

generate_batch Not yet run
unverified (harvested, no recorded run)
ghlee0304/NLP-with-tensorflow-pytorch/basic_CBOW/basic_CBOW.py
pointer only (licence: NONE) · get_code("257786122ed50760")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, ghlee0304/NLP-with-tensorflow-pytorch 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. No invocation recorded.

geodesic_fn Not yet run
unverified (harvested, no recorded run)
ringbdstack/socialed/SocialED/detector/Hypersed.py
code served (permissive licence) · get_code("5091749da9008315")
How it ran

no invocation recorded.

get_one_line_for_one_FA Not yet run
unverified (harvested, no recorded run)
casszhao/reagent/summarise_all_results_OPT.py
code served (permissive licence) · get_code("e1450335ce7c54ad")
How it ran

no invocation recorded.

get_one_model Not yet run
unverified (harvested, no recorded run)
casszhao/reagent/summarise_tokenlevel.py
code served (permissive licence) · get_code("f49a20e109812ffc")
How it ran

no invocation recorded.

get_one_model Not yet run
unverified (harvested, no recorded run)
casszhao/reagent/summarise_tokenlevel_log.py
code served (permissive licence) · get_code("385d280441051250")
How it ran

no invocation recorded.

get_stable_point Not yet run
unverified (harvested, no recorded run)
ringbdstack/socialed/SocialED/detector/adpsemevent.py
code served (permissive licence) · get_code("bbd96a9acc9acbe5")
How it ran

no invocation recorded.

get_stable_point Not yet run
unverified (harvested, no recorded run)
ringbdstack/socialed/SocialED/detector/hisevent.py
code served (permissive licence) · get_code("53a3a27da0cc0a04")
How it ran

no invocation recorded.

minus_and_save Not yet run
unverified (harvested, no recorded run)
casszhao/reagent/summarise_tokenlevel.py
code served (permissive licence) · get_code("295d1364f369d162")
How it ran

no invocation recorded.

minus_and_save Not yet run
unverified (harvested, no recorded run)
casszhao/reagent/summarise_tokenlevel_log.py
code served (permissive licence) · get_code("954fc518b6e0972c")
How it ran

no invocation recorded.

run_hier_2D_SE_mini_closed_set Not yet run
unverified (harvested, no recorded run)
ringbdstack/socialed/SocialED/detector/adpsemevent.py
code served (permissive licence) · get_code("82a88916b8a8ddb7")
How it ran

no invocation recorded.

run_hier_2D_SE_mini_data Not yet run
unverified (harvested, no recorded run)
ringbdstack/socialed/SocialED/detector/hisevent.py
code served (permissive licence) · get_code("40b9005901943e52")
How it ran

no invocation recorded.

search_stable_points Not yet run
unverified (harvested, no recorded run)
ringbdstack/socialed/SocialED/detector/hisevent.py
code served (permissive licence) · get_code("c890ab0f8aa129ca")
How it ran

no invocation recorded.

train_process Not yet run
unverified (harvested, no recorded run)
chikalabouka/INF8225-TP4/word2vec.py
pointer only (licence: NONE) · get_code("5a1edbc205df1b0c")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, chikalabouka/INF8225-TP4 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. No invocation recorded.

Showing the first 60. An agent gets every one from get_harvested_code_for_paper("1301.3781").

Also present in other papers' code

Of 62 samples lifted from this paper's linked repositories, 62 carry a function identity and 0 do not. Of the 62 distinct functions with an identity, 5 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 5 later) and 57 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
softmax
brick of this paper's assembly: helper
5 other papers
5 later
1503.02531 (2015-03)
Distilling the Knowledge in a Neural Network
2004.08056 (2020-04)
Dialogue-Based Relation Extraction
2007.05233 (2020-07)
Continual Adaptation for Deep Stereo
and 2 more not named here
pdist 2 other papers
2 later
1703.07737 (2017-03)
In Defense of the Triplet Loss for Person Re-Identification
2002.10191 (2020-02)
Learning Attentive Pairwise Interaction for Fine-Grained Classification
AbstractModel
brick of this paper's assembly: helper
1 other paper
1 later
2301.07945 (2023-01)
PDFormer: Propagation Delay-Aware Dynamic Long-Range Transformer for Traffic Flow Prediction
hardest_negative 1 other paper
1 later
1703.07737 (2017-03)
In Defense of the Triplet Loss for Person Re-Identification
random_hard_negative 1 other paper
1 later
1703.07737 (2017-03)
In Defense of the Triplet Loss for Person Re-Identification

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

Repositories linked to this paper

More are linked than shown here.

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

Abstract

We propose two novel model architectures for computing continuous vector representations of words from very large data sets. The quality of these representations is measured in a word similarity task, and the results are compared to the previously best performing techniques based on different types of neural networks. We observe large improvements in accuracy at much lower computational cost, i.e. it takes less than a day to learn high quality word vectors from a 1.6 billion words data set. Furthermore, we show that these vectors provide state-of-the-art performance on our test set for measuring syntactic and semantic word similarities.

For agents

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

get_harvested_code_for_paper("1301.3781")
get_code_for_paper("1301.3781")
have("1301.3781")

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

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

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

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

Connect an agent — have() is free.