SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1603.01360 · 2016

Neural Architectures for Named Entity Recognition

arXiv · PDF · Open in the Atlas

Code that ran

29 of 36 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, 1 violated it and 17 have no contract verdict; 9 failures of our instrument; 7 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/1603.01360.json · badge: /api/ran/1603.01360.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
deepmipt/ner canonical (classifier label)
classifier basis: census
3 ran · 1 no recorded run
guillaumegenthial/sequence_tagging community (classifier label)
classifier basis not recorded on the link
4 ran · 0 no recorded run
riedlma/sequence_tagging community (classifier label)
classifier basis not recorded on the link
3 ran · 1 no recorded run
IBM/MAX-Named-Entity-Tagger community (classifier label)
classifier basis not recorded on the link
3 ran · 0 no recorded run
marekrei/sequence-labeler reimplementation (classifier label)
classifier basis: classifier_2025
2 ran · 1 no recorded run
guillaumegenthial/tf_ner community (classifier label)
classifier basis not recorded on the link
2 ran · 1 no recorded run
PKU-TANGENT/nlp-tutorial community (classifier label)
classifier basis not recorded on the link
2 ran · 0 no recorded run
autoih/runtime_ner community (classifier label)
classifier basis not recorded on the link
2 ran · 0 no recorded run
Hironsan/anago reimplementation (classifier label)
classifier basis: classifier_2025
2 ran · 0 no recorded run
yyHaker/NamedEntityRecognition reimplementation (classifier label)
classifier basis: classifier_2025
2 ran · 0 no recorded run
aymara/lima-tfner reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
samueljamesbell/sequence-labeler reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
ZubinGou/NER-BiLSTM-CRF-PyTorch reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
karlstratos/mention2vec reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
vunb/anago-tagger community (classifier label)
classifier basis not recorded on the link
0 ran · 3 no recorded run
FunctionStatusWhere it lives
align_data Ran
ran; our contract draft was wrong, not the code
aymara/lima-tfner/evaluate.py
code served (permissive licence) · get_code("2e30815d7869e90d")
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 torch

torch.manual_seed(0)

# The function align_data takes a dict where:
# - Keys are strings (like "x", "y")
# - Values are lists of strings (tokens)
# It aligns them by padding with spaces

data = {
    "x": ["I", "love", "you"],
    "y": ["O", "O", "O"]
}

ARGS = {
    "data": data
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
build_vocab Ran
ran on a synthesized input
PKU-TANGENT/nlp-tutorial/ChineseNER/preprocess_data.py
code served (permissive licence) · get_code("dd8a923e22406d00")
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 os
import tempfile

class Config:
    def __init__(self, data_path, train_file):
        self.data_path = data_path
        self.train_file = train_file

# Create a temporary directory and file with sample data
temp_dir = tempfile.mkdtemp()
train_file_path = os.path.join(temp_dir, 'train.txt')

# Write sample training data with single characters
with open(train_file_path, 'w', encoding='utf-8') as fw:
    fw.write('a\n')
    fw.write('b\n')
    fw.write('c\n')
    fw.write('a\n')
    fw.write('d\n')

config = Config(data_path=temp_dir, train_file='train.txt')

ARGS = {
    'config': config
}
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
chunk_finder Ran
ran on a synthesized input
deepmipt/ner/ner/evaluation.py
code served (permissive licence) · get_code("65ae5d1c944b2714")
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 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.

# Setup code for chunk_finder function

# Analyze the function:
# - current_token: string, used with .split() and string concatenation
# - previous_token: string, used with .split() and string concatenation
# - tag: string, used in comparisons and string concatenation

ARGS = {
    "current_token": "B-PER",
    "previous_token": "O",
    "tag": "PER"
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
collate_fn Ran
ran on a synthesized input
PKU-TANGENT/nlp-tutorial/ChineseNER/utils.py
code served (permissive licence) · get_code("d32e7d27376cb204")
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 numpy as np

# Construct a batch of samples
# Each sample is a tuple of (input_ids, labels, length)
# where input_ids is a list of token IDs, labels is a list of labels, and length is the sequence length

batch = [
    ([1, 2, 3], [0, 1, 0], 3),           # First sample: 3 tokens
    ([4, 5], [1, 1], 2),                 # Second sample: 2 tokens
]

ARGS = {
    "batch": batch
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
conv Ran
ran on a synthesized input
riedlma/sequence_tagging/transfer_learning.py
code served (permissive licence) · get_code("48c533147efe494a")
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

def conv(n):
    n = n.decode('utf-8')
    n = n.replace(';', '')
    n = n.replace(':', '')
    n = n.replace('%', '')
    return n

# The function expects a bytes object that can be decoded to UTF-8
test_string = "hello;world:test%value"
test_bytes = test_string.encode('utf-8')

ARGS = {
    'n': test_bytes
}
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
extract_tokens Ran
ran on a synthesized input
autoih/runtime_ner/api/predict.py
code served (permissive licence) · get_code("4cedf40326fbff61")
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 3, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import tempfile
import os

# Create a temporary CSV file with content containing pipe-delimited tokens
temp_dir = tempfile.mkdtemp()
csv_file_path = os.path.join(temp_dir, "test.csv")

with open(csv_file_path, 'w', newline='') as f:
    f.write("|token1||token2|,|token3||token4|\n")
    f.write("|alpha||beta|,|gamma|\n")

ARGS = {
    "csv_file": csv_file_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 list, ndim 3, 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
filter_embeddings Ran
ran; our contract draft was wrong, not the code
Hironsan/anago/anago/utils.py
code served (permissive licence) · get_code("2cbf9d02fc7275e8")
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 ndarray, ndim 2, dtype family float, shape (4, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Create a small vocabulary
vocab = {
    'hello': 0,
    'world': 1,
    'test': 2,
    'python': 3
}

# Create embeddings dictionary with numpy arrays
# Only include some words from vocab to test the filtering logic
embeddings = {
    'hello': np.array([0.1, 0.2, 0.3, 0.4]),
    'world': np.array([0.5, 0.6, 0.7, 0.8]),
    'python': np.array([0.9, 1.0, 1.1, 1.2])
    # Note: 'test' is not in embeddings, so it should get zeros
}

dim = 4

ARGS = {
    'embeddings': embeddings,
    'vocab': vocab,
    'dim': dim
}
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 ndarray, ndim 2, dtype family float, shape (4, 4) — shape (4, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
gather_index Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
yyHaker/NamedEntityRecognition/src/LSTM-CNNs-CRF/model.py
pointer only (licence: NONE) · get_code("ebd40f0b98a8f2a4")
How it ran

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

get_char_vocab Ran
ran on a synthesized input
guillaumegenthial/sequence_tagging/model/data_utils.py
code served (permissive licence) · get_code("d8fcea9be53400c5")
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 set. 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)

# The function iterates over dataset, unpacking each item as (words, tags)
# For each words element, it iterates over it (words is iterable)
# For each word in words, it calls word.update() - wait, that's not right
# Actually it calls vocab_char.update(word), where word is a string
# So word is a string, words is a list of strings, and the tuple is (words_list, tags)

# Create a simple dataset as an iterable of (words, tags) tuples
dataset = [
    (["hello", "world"], ["NOUN", "NOUN"]),
    (["foo", "bar", "baz"], ["VERB", "ADJ", "NOUN"]),
]

ARGS = {
    "dataset": dataset
}
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 set — a set output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a set 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_glove_vocab Ran
ran on a synthesized input
guillaumegenthial/sequence_tagging/model/data_utils.py
code served (permissive licence) · get_code("05efd5b7ae13cf0c")
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 set. 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
import os

# Create a temporary GloVe-format file
temp_file = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt')
temp_filename = temp_file.name

# Write some sample GloVe vectors in the correct format
# Format: word vec1 vec2 vec3 ...
sample_vectors = [
    "the 0.418 0.24968 -0.41242 0.1217\n",
    "and 0.35457 0.475371 -0.12181 0.89121\n",
    "a 0.21794 0.64765 -0.12181 0.15421\n",
    "to 0.68047 -0.039263 0.30186 -0.17118\n",
    "of 0.26818 -0.69417 -0.51332 -0.52478\n",
]

temp_file.writelines(sample_vectors)
temp_file.close()

ARGS = {
    "filename": temp_filename
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type set — a set output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a set 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_logger Ran
ran; our contract draft was wrong, not the code
guillaumegenthial/sequence_tagging/model/general_utils.py
code served (permissive licence) · get_code("75ed1ef1f8c3d22b")
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 Logger. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import logging
import tempfile
import os

# Create a temporary file for logging
temp_dir = tempfile.gettempdir()
log_filename = os.path.join(temp_dir, 'test_log.txt')

ARGS = {
    'filename': log_filename
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Logger — a Logger output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Logger 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_processing_word Ran
ran on a synthesized input
IBM/MAX-Named-Entity-Tagger/core/utils.py
code served (permissive licence) · get_code("f9c3ecd4c9aa6833")
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 function. 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.

# Construct valid arguments for get_processing_word

UNK = '$UNK$'
NUM = '$NUM$'

# Create small vocabularies for words and characters
vocab_words = {
    'cat': 1,
    'dog': 2,
    'bird': 3,
    UNK: 0,
}

vocab_chars = {
    'c': 10,
    'a': 11,
    't': 12,
    'd': 13,
    'o': 14,
    'g': 15,
    'b': 16,
    'i': 17,
    'r': 18,
}

ARGS = {
    'vocab_words': vocab_words,
    'vocab_chars': vocab_chars,
    'lowercase': False,
    'chars': True,
    'allow_unk': True,
}
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 function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function 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_vocab Ran
ran on a synthesized input
riedlma/sequence_tagging/model/data_utils.py
code served (permissive licence) · get_code("85e5be88dbd9ad46")
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 set. 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
import os

# Create a temporary file with GloVe-like format
temp_file = tempfile.NamedTemporaryFile(mode='w', delete=False, encoding='utf8', suffix='.txt')
temp_filename = temp_file.name

# Write some sample GloVe vectors
sample_vectors = [
    "the 0.1 0.2 0.3 0.4",
    "hello 0.5 0.6 0.7 0.8",
    "world 0.9 1.0 1.1 1.2",
    "python 1.3 1.4 1.5 1.6",
]

for line in sample_vectors:
    temp_file.write(line + '\n')

temp_file.close()

ARGS = {
    'filename': temp_filename
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type set — a set output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a set 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_vocabs Ran
ran on a synthesized input
guillaumegenthial/sequence_tagging/model/data_utils.py
code served (permissive licence) · get_code("384baa37e7d09ae3")
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 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

# Create simple dataset objects that can be iterated over
class SimpleDataset:
    def __init__(self, data):
        self.data = data
    
    def __iter__(self):
        return iter(self.data)

# Create sample data: list of (words, tags) tuples
dataset1_data = [
    (['the', 'cat', 'sat'], ['DET', 'NOUN', 'VERB']),
    (['on', 'a', 'mat'], ['PREP', 'DET', 'NOUN']),
]

dataset2_data = [
    (['dogs', 'run', 'fast'], ['NOUN', 'VERB', 'ADV']),
    (['birds', 'fly'], ['NOUN', 'VERB']),
]

# Create dataset objects
dataset1 = SimpleDataset(dataset1_data)
dataset2 = SimpleDataset(dataset2_data)

# Create the datasets list
datasets = [dataset1, dataset2]

# Define ARGS with the required parameter
ARGS = {
    'datasets': datasets
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_vocabs Ran
ran on a synthesized input
riedlma/sequence_tagging/model/data_utils.py
code served (permissive licence) · get_code("3a2be4774b779b43")
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 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

class SimpleDataset:
    def __init__(self, samples):
        self.samples = samples
    
    def __iter__(self):
        return iter(self.samples)

# Create sample datasets with (words, tags) pairs
dataset1 = SimpleDataset([
    (['hello', 'world'], ['GREETING', 'NOUN']),
    (['foo', 'bar', 'baz'], ['NOUN', 'NOUN', 'NOUN']),
])

dataset2 = SimpleDataset([
    (['hello', 'there'], ['GREETING', 'GREETING']),
    (['test', 'word'], ['NOUN', 'NOUN']),
])

datasets = [dataset1, dataset2]

ARGS = {
    'datasets': datasets
}
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, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
is_end_of_sentence Ran
ran on a synthesized input
deepmipt/ner/ner/utils.py
code served (permissive licence) · get_code("aff994b4180ca0f6")
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 bool, 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

ARGS = {
    'prev_token': '.',
    'current_token': 'Hello'
}
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 bool, 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
is_float Ran
ran, violated the contract we drafted
marekrei/sequence-labeler/experiment.py
pointer only (licence: NONE) · get_code("0a315a31212d041f")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, marekrei/sequence-labeler when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

load_data_and_labels Ran
ran; our contract draft was wrong, not the code
Hironsan/anago/anago/utils.py
code served (permissive licence) · get_code("541693fb200297a7")
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 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
import os

# Create a temporary file with NER data in the expected format
temp_file = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt', encoding='utf-8')
temp_filename = temp_file.name

# Write sample NER data in tab-separated format
sample_data = """EU	B-ORG
rejects	O
German	B-MISC
call	O
to	O
boycott	O
British	B-MISC
lamb	O
.	O

Peter	B-PER
Blackburn	I-PER
is	O
here	O

"""

temp_file.write(sample_data)
temp_file.close()

ARGS = {
    'filename': temp_filename,
    'encoding': 'utf-8'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
load_sentence_id Ran
ran, honoured the contract we drafted
samueljamesbell/sequence-labeler/experiment.py
pointer only (licence: NONE) · get_code("3cb2bb18d24e858e")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, samueljamesbell/sequence-labeler when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

load_vocab Ran
ran on a synthesized input
IBM/MAX-Named-Entity-Tagger/core/utils.py
code served (permissive licence) · get_code("a0562f49c954c62c")
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 tempfile
import os

# Create a temporary file with sample vocabulary
temp_dir = tempfile.mkdtemp()
vocab_file = os.path.join(temp_dir, "vocab.txt")

with open(vocab_file, 'w', encoding='ISO-8859-1') as f:
    f.write("apple\n")
    f.write("banana\n")
    f.write("cherry\n")
    f.write("date\n")

ARGS = {
    "filename": vocab_file
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
log_sum_exp Ran
ran, honoured the contract we drafted
ZubinGou/NER-BiLSTM-CRF-PyTorch/src/model.py
code served (permissive licence) · get_code("d4329236872658c9")
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 Tensor, ndim 2, dtype family float, shape (1, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# Construct a small tensor for log_sum_exp
# The function expects a tensor with shape (n, m) where:
# - max(dim=0) reduces along dimension 0
# - exp().sum(axis=0) sums along dimension 0
# - keepdim=True preserves dimensions
# Using shape (4, 3) for a small matrix
smat = torch.randn(4, 3)

ARGS = {
    "smat": smat
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (1, 3) — shape (1, 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
log_sum_exp Ran
ran; our contract draft was wrong, not the code
yyHaker/NamedEntityRecognition/src/LSTM-CNNs-CRF/model.py
pointer only (licence: NONE) · get_code("ca4d0de367bcc625")
How it ran

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

pad_sequences Ran
ran; our contract draft was wrong, not the code
IBM/MAX-Named-Entity-Tagger/core/utils.py
code served (permissive licence) · get_code("57efe0447a3a3ab6")
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
import numpy as np

# For nlevels=1: sequences is a generator/list of sequences
# Each sequence is a list/tuple of items that can be padded
# pad_tok is the padding token to use

# Test case 1: nlevels=1 (simple sequences)
sequences_level1 = [
    [1, 2, 3],
    [4, 5],
    [6, 7, 8, 9]
]
pad_tok_level1 = 0

# Test case 2: nlevels=2 (nested sequences - list of sentences, where each sentence is a list of words)
# Each word is represented as a list of character ids
sequences_level2 = [
    [[1, 2], [3, 4, 5], [6]],      # sentence 1: word1, word2, word3
    [[7, 8, 9], [10]]               # sentence 2: word1, word2
]
pad_tok_level2 = 0

# Using level 1 for the main test
ARGS = {
    "sequences": sequences_level1,
    "pad_tok": pad_tok_level1,
    "nlevels": 1
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
parse_fn Ran
ran on a synthesized input
guillaumegenthial/tf_ner/models/chars_conv_lstm_crf/serve.py
code served (permissive licence) · get_code("de2e9c6541708aa6")
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

torch.manual_seed(0)

# Analyze the function signature
# parse_fn takes one parameter: line
# It expects line to be a string that can be stripped and split into words

def create_test_line():
    """Create a simple test line string"""
    return "hello world python"

ARGS = {
    "line": create_test_line()
}
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
peak_memory Ran
ran on a synthesized input
autoih/runtime_ner/api/mem_util.py
code served (permissive licence) · get_code("e514cb73330d43e5")
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

# Create a minimal stand-in class for AllocationRecord
class AllocationRecord:
    def __init__(self, alloc_micros, alloc_bytes):
        self.alloc_micros = alloc_micros
        self.alloc_bytes = alloc_bytes

# Create a minimal stand-in class for Memory
class Memory:
    def __init__(self, allocator_name, allocation_records=None):
        self.allocator_name = allocator_name
        self.allocation_records = allocation_records if allocation_records is not None else []

# Create a minimal stand-in class for TensorDescription
class TensorDescription:
    def __init__(self):
        self.allocation_description = None

# Create a minimal stand-in class for Output
class Output:
    def __init__(self):
        self.tensor_description = TensorDescription()

# Create a minimal stand-in class for NodeExecStats
class NodeExecStats:
    def __init__(self, node_name, all_start_micros, memory_list, output_list=None):
        self.node_name = node_name
        self.all_start_micros = all_start_micros
        self.memory = memory_list
        self.output = output_list if output_list is not None else []

# Create a minimal stand-in class for DevStat
class DevStat:
    def __init__(self, device, node_stats):
        self.device = device
        self.node_stats = node_stats

# Create a minimal stand-in class for StepStats
class StepStats:
    def __init__(self, dev_stats):
        self.dev_stats = dev_stats

# Create a minimal stand-in class for RunMetadata
class RunMetadata:
    def __init__(self, step_stats):
        self.step_stats = step_stats

# Build minimal node stats with memory records
node1_memory = [Memory(allocator_name='cpu', allocation_records=[
    AllocationRecord(alloc_micros=1509481813012895, alloc_bytes=1000496),
    AllocationRecord(alloc_micros=1509481813012961, alloc_bytes=-1000000),
])]
node1 = NodeExecStats(node_name='concat', all_start_micros=1509481813012890, memory_list=node1_memory)

node2_memory = [Memory(allocator_name='cpu', allocation_records=[])]
node2 = NodeExecStats(node_name='TanhGrad', all_start_micros=1509481813012968, memory_list=node2_memory, output_list=[Output()])

# Build dev_stats
dev_stat = DevStat(device='/job:localhost/replica:0/task:0/device:CPU:0', node_stats=[node1, node2])

# Build step_stats
step_stats = StepStats(dev_stats=[dev_stat])

# Build run_metadata
run_metadata = RunMetadata(step_stats=step_stats)

ARGS = {
    'run_metadata': run_metadata
}
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
precision_recall_f1 Ran
ran on a synthesized input
deepmipt/ner/ner/evaluation.py
code served (permissive licence) · get_code("6481b2ee4c62c0ba")
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 OrderedDict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

from collections import OrderedDict

# Construct small valid arguments for precision_recall_f1
y_true = ['B-PER', 'I-PER', 'O', 'B-LOC', 'I-LOC', 'O']
y_pred = ['B-PER', 'I-PER', 'O', 'B-LOC', 'O', 'O']

ARGS = {
    'y_true': y_true,
    'y_pred': y_pred,
    'print_results': False,
    'short_report': False,
    'entity_of_interest': 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 OrderedDict — a OrderedDict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a OrderedDict 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
predict_input_fn Ran
ran on a synthesized input
guillaumegenthial/tf_ner/models/chars_conv_lstm_crf/interact.py
code served (permissive licence) · get_code("40a3f270c3650e14")
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 tensorflow as tf

# The function predict_input_fn takes a single parameter: line
# which should be a string containing space-separated words

line = "hello world test"

ARGS = {
    "line": line
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
read_embeddings Ran
ran; our contract draft was wrong, not the code
karlstratos/mention2vec/display_nearest_neighbors.py
code served (permissive licence) · get_code("3d1adae4e91a62b3")
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 tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import tempfile
import os

# Create a temporary embedding file
temp_dir = tempfile.mkdtemp()
embedding_path = os.path.join(temp_dir, "embeddings.txt")

# Write a sample embedding file with word embeddings
with open(embedding_path, 'w') as f:
    f.write("hello 0.1 0.2 0.3 0.4\n")
    f.write("world 0.5 0.6 0.7 0.8\n")
    f.write("test 0.2 0.3 0.4 0.5\n")

ARGS = {
    "embedding_path": embedding_path
}
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 tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
read_input_files Ran
ran; our contract draft was wrong, not the code
marekrei/sequence-labeler/experiment.py
pointer only (licence: NONE) · get_code("be54407c183e294b")
How it ran

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

masked_conv1d_and_max Not yet run
unverified (harvested, no recorded run)
guillaumegenthial/tf_ner/models/chars_conv_lstm_crf/masked_conv.py
code served (permissive licence) · get_code("db78ae8b86c8f609")
How it ran

no invocation recorded.

parse_config Not yet run
unverified (harvested, no recorded run)
marekrei/sequence-labeler/experiment.py
pointer only (licence: NONE) · get_code("e81267fcf798eeaa")
How it ran

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

path_energy Not yet run
unverified (harvested, no recorded run)
vunb/anago-tagger/anago/layers.py
code served (permissive licence) · get_code("6f5b259e1a881655")
How it ran

no invocation recorded.

path_energy0 Not yet run
unverified (harvested, no recorded run)
vunb/anago-tagger/anago/layers.py
code served (permissive licence) · get_code("e13517b914ec8cfe")
How it ran

no invocation recorded.

readResults Not yet run
unverified (harvested, no recorded run)
riedlma/sequence_tagging/transfer_learning.py
code served (permissive licence) · get_code("2334e2e11796f5a6")
How it ran

no invocation recorded.

sparse_chain_crf_loss Not yet run
unverified (harvested, no recorded run)
vunb/anago-tagger/anago/layers.py
code served (permissive licence) · get_code("1ba390350088f072")
How it ran

no invocation recorded.

stacked_rnn Not yet run
unverified (harvested, no recorded run)
deepmipt/ner/ner/layers.py
code served (permissive licence) · get_code("4e47f6f283743daa")
How it ran

no invocation recorded.

Also present in other papers' code

Of 36 samples lifted from this paper's linked repositories, 36 carry a function identity and 0 do not. Of the 36 distinct functions with an identity, 9 are also present in other papers whose code we hold (2 with at least one paper dated earlier, 5 the same month, 6 later) and 27 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
get_logger 3 other papers
1 dated earlier, 1 the same month, 1 later
1509.02971 (2015-09)
Continuous control with deep reinforcement learning
1603.01354 (2016-03)
End-to-end Sequence Labeling via Bi-directional LSTM-CNNs-CRF
2024.findings-emnlp.944 (2024 (year only))
Multi-label Sequential Sentence Classification via Large Language Model
get_vocabs 2 other papers
1 the same month, 1 later
1603.01354 (2016-03)
End-to-end Sequence Labeling via Bi-directional LSTM-CNNs-CRF
2010.12777 (2020-10)
Improving Multilingual Models with Language-Clustered Vocabularies
log_sum_exp 2 other papers
1 dated earlier, 1 the same month
1511.08308 (2015-11)
Named Entity Recognition with Bidirectional LSTM-CNNs
1603.01354 (2016-03)
End-to-end Sequence Labeling via Bi-directional LSTM-CNNs-CRF
path_energy 2 other papers
2 later
1802.05365 (2018-02)
Deep contextualized word representations
1803.09578 (2018-03)
Why Comparing Single Performance Scores Does Not Allow to Draw Conclusions About Machine Learning Approaches
path_energy0 2 other papers
2 later
1802.05365 (2018-02)
Deep contextualized word representations
1803.09578 (2018-03)
Why Comparing Single Performance Scores Does Not Allow to Draw Conclusions About Machine Learning Approaches
sparse_chain_crf_loss 2 other papers
2 later
1802.05365 (2018-02)
Deep contextualized word representations
1803.09578 (2018-03)
Why Comparing Single Performance Scores Does Not Allow to Draw Conclusions About Machine Learning Approaches
align_data 1 other paper
1 the same month
1603.01354 (2016-03)
End-to-end Sequence Labeling via Bi-directional LSTM-CNNs-CRF
get_char_vocab 1 other paper
1 the same month
1603.01354 (2016-03)
End-to-end Sequence Labeling via Bi-directional LSTM-CNNs-CRF
pad_sequences 1 other paper
1 later
2010.12777 (2020-10)
Improving Multilingual Models with Language-Clustered Vocabularies

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

State-of-the-art named entity recognition systems rely heavily on hand-crafted features and domain-specific knowledge in order to learn effectively from the small, supervised training corpora that are available. In this paper, we introduce two new neural architectures---one based on bidirectional LSTMs and conditional random fields, and the other that constructs and labels segments using a transition-based approach inspired by shift-reduce parsers. Our models rely on two sources of information about words: character-based word representations learned from the supervised corpus and unsupervised word representations learned from unannotated corpora. Our models obtain state-of-the-art performance in NER in four languages without resorting to any language-specific knowledge or resources such as gazetteers.

For agents

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

get_harvested_code_for_paper("1603.01360")
get_code_for_paper("1603.01360")
have("1603.01360")

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

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

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

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

Connect an agent — have() is free.