SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1409.0473 · ICLR · 2014

Neural Machine Translation by Jointly Learning to Align and Translate

Yoshua Bengio, Kyunghyun Cho, Dzmitry Bahdanau

arXiv · PDF · Open in the Atlas

Code that ran

41 of 44 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (2 of them constructed an object rather than computing a result; 4 honoured the contract we drafted, 0 violated it and 20 have no contract verdict; 17 failures of our instrument; 3 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/1409.0473.json · badge: /api/ran/1409.0473.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
copy not recorded community
not in the paper's declared repositories
8 ran · 0 no recorded run
qq345736500/sarcasm community (classifier label)
classifier basis not recorded on the link
6 ran · 2 no recorded run
mpavlovic/insincere-questions-classifier community (classifier label)
classifier basis not recorded on the link
4 ran · 1 no recorded run
Baichenjia/NMT-eager reimplementation (classifier label)
classifier basis: classifier_2025
4 ran · 0 no recorded run
IpastorSan/seq2seq-with-attention-OCR-translation community (classifier label)
classifier basis not recorded on the link
4 ran · 0 no recorded run
YvesWang/Machine_Translation_NLP reimplementation (classifier label)
classifier basis: classifier_2025
3 ran · 0 no recorded run
thunlp/TensorFlow-Summarization community (classifier label)
classifier basis not recorded on the link
3 ran · 0 no recorded run
prakhargurawa/Neural-Machine-Translation-Keras-German-English community (classifier label)
classifier basis not recorded on the link
3 ran · 0 no recorded run
thunlp-mt/ckd extension (classifier label)
classifier basis: classifier_2025
2 ran · 0 no recorded run
prakhargurawa/Neural-Machine-Translation-Keras-Attention reimplementation (classifier label)
classifier basis: classifier_2025
2 ran · 0 no recorded run
THUNLP-MT/THUMT reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
rileynwong/pytorch-seq2seq-joke2punchline reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
FunctionStatusWhere it lives
LayerNorm Ran
ran; our contract draft was wrong, not the code · constructed an object; no result was computed
YvesWang/Machine_Translation_NLP/Transformer/Decoder_Transformer.py
pointer only (licence: NONE) · get_code("02408cb7d7b045d1")
How it ran

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

Linear Ran
ran; our contract draft was wrong, not the code · constructed an object; no result was computed
YvesWang/Machine_Translation_NLP/Transformer/Decoder_Transformer.py
pointer only (licence: NONE) · get_code("10865bbb99140edd")
How it ran

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

batch Ran
ran, honoured the contract we drafted
this paper's copy was not recorded; identical code first harvested from Guillem96/pointer-nn-pytorch
pointer only; the stored copy get_code serves, from Guillem96/pointer-nn-pytorch, is pointer only (licence: GPL-3.0) · get_code("796b2511367209ba")
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.

build_model Ran
ran on a synthesized input
mpavlovic/insincere-questions-classifier/build_model.py
code served (permissive licence) · get_code("01cec36b70027919")
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 Functional. 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
from tensorflow import keras
import numpy as np
import random

# Create a small embedding matrix for testing
embedding_matrix = np.random.randn(100, 16).astype(np.float32)

# Define hyperparameters dict
hparams = {
    'random_state': 42,
    'max_length': 8,
    'max_words': 100,
    'emb_out_dim': 16,
    'dropout_rate': 0.2,
    'optimizer': 'adam'
}

ARGS = {
    'hparams': hparams,
    'embedding_matrix': embedding_matrix
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Functional — a Functional output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Functional 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_model Ran
ran on a synthesized input
qq345736500/sarcasm/src/dl_models.py
code served (permissive licence) · get_code("15bace44de8d1350")
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 Functional. 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 keras
from keras.models import Model, Sequential
from keras.layers import Dense, Dropout, Flatten, LSTM, GRU, Bidirectional, Input, Multiply
from keras.layers import Activation, Permute, RepeatVector, Lambda
import numpy as np

# Create a small embedding layer
embedding_layer = keras.layers.Embedding(input_dim=100, output_dim=8, input_length=10)

# Create a simple dnn_architecture callable that takes max_tweet_length, embeddings, hidden_units, dropout
class SimpleDNNArchitecture:
    def __call__(self, max_tweet_length, embeddings, hidden_units, dropout):
        # This callable receives embeddings and returns processed output
        x = Flatten()(embeddings)
        x = Dense(hidden_units, activation='relu')(x)
        x = Dropout(dropout)(x)
        return x

dnn_architecture = SimpleDNNArchitecture()

# Define parameters
max_len = 10
hidden_units = 16
dropout = 0.5

ARGS = {
    'max_len': max_len,
    'embedding_layer': embedding_layer,
    'hidden_units': hidden_units,
    'dropout': dropout,
    'dnn_architecture': dnn_architecture
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
keras, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Functional — a Functional output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Functional 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_subj_dicionary Ran
ran on a synthesized input
qq345736500/sarcasm/src/data_processing.py
code served (permissive licence) · get_code("f86db1bbd98544ec")
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.

# Analyzing the function, it expects:
# - lines: an iterable of strings
# Each line should have at least 6 space-separated parts where:
#   - splits[0] starts with "type=" (5 chars) followed by word_type
#   - splits[2] starts with "word=" (6 chars) followed by word
#   - splits[3] starts with "pos=" (4 chars) followed by pos
#   - splits[5] starts with "polarity=" (9 chars) followed by polarity

lines = [
    "type=adjective word=beautiful pos=JJ x=val polarity=positive",
    "type=noun word=book pos=NN x=val polarity=neutral",
    "type=adjective word=terrible pos=JJ x=val polarity=negative",
    "type=adjective word=beautiful pos=VB x=val polarity=mixed",
]

ARGS = {
    "lines": lines
}
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
clean_contractions Ran
ran on a synthesized input
mpavlovic/insincere-questions-classifier/utils.py
code served (permissive licence) · get_code("f3a2acb3ab6ac45d")
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.

# Setup code for clean_contractions function

# The function takes a text string and an optional mapping dictionary
# It cleans contractions in the text by replacing them with their expanded forms

# Minimal test inputs
text_input = "I can't believe you won't help. They're amazing! It's what I'd expect."
mapping_input = {
    "ain't": 'is not',
    "can't": 'cannot',
    "won't": 'will not',
    "they're": 'they are',
    "it's": 'it is',
    "i'd": 'i would'
}

ARGS = {
    "text": text_input,
    "mapping": mapping_input
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
corpus_map2id Ran
ran on a synthesized input
thunlp/TensorFlow-Summarization/src/data_util.py
code served (permissive licence) · get_code("7d8cac963599093c")
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

ID_UNK = 1

# Build test data: a corpus represented as a list of documents
# Each document is a list of words (strings)
data = [
    ["hello", "world", "foo"],
    ["bar", "hello", "unknown_word", "baz"]
]

# Build a token-to-id mapping dictionary
tok2id = {
    "hello": 5,
    "world": 10,
    "foo": 15,
    "bar": 20,
    "baz": 25
}

ARGS = {
    "data": data,
    "tok2id": tok2id
}
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
correct_spelling Ran
ran on a synthesized input
mpavlovic/insincere-questions-classifier/submission_script.py
code served (permissive licence) · get_code("b7993440578a50e0")
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

# Define the mispell_mapping dictionary as provided
mispell_mapping = {'colour': 'color', 'centre': 'center', 'favourite': 'favorite', 'travelling': 'traveling', 'counselling': 'counseling', 'theatre': 'theater', 'cancelled': 'canceled', 'labour': 'labor', 'organisation': 'organization', 'wwii': 'world war 2', 'citicise': 'criticize', 'youtu ': 'youtube ', 'Qoura': 'Quora', 'sallary': 'salary', 'Whta': 'What', 'narcisist': 'narcissist', 'howdo': 'how do', 'whatare': 'what are', 'howcan': 'how can', 'howmuch': 'how much', 'howmany': 'how many', 'whydo': 'why do', 'doI': 'do I', 'theBest': 'the best', 'howdoes': 'how does', 'mastrubation': 'masturbation', 'mastrubate': 'masturbate', 'mastrubating': 'masturbating', 'pennis': 'penis', 'Etherium': 'Ethereum', 'narcissit': 'narcissist', 'bigdata': 'big data', '2k17': '2017', '2k18': '2018', 'qouta': 'quota', 'exboyfriend': 'ex boyfriend', 'airhostess': 'air hostess', 'whst': 'what', 'watsapp': 'whatsapp', 'demonitisation': 'demonetization', 'demonitization': 'demonetization', 'demonetisation': 'demonetization', 'pokémon': 'pokemon'}

# Construct arguments for correct_spelling function
# text: a string containing some misspelled words from the mapping
text = "I like the colour of the theatre and my favourite is travelling there. The organisation will howdo we fix this? Check my watsapp for bigdata info from 2k18."

# mapping: use the provided mispell_mapping dictionary
mapping = mispell_mapping

ARGS = {
    'text': text,
    'mapping': mapping
}
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
count_apparitions Ran
ran on a synthesized input
qq345736500/sarcasm/src/extract_baseline_features.py
code served (permissive licence) · get_code("24b6069ed695e8f3")
How it ran

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

import torch
import torch.nn as nn

torch.manual_seed(0)

# Analyzing the function:
# - tokens: needs to support .count() method, so it should be a list or string
# - list_to_count_from: iterable of items to count in tokens
# The function counts occurrences of each item in list_to_count_from within tokens

# tokens could be a list of strings/integers, or a string
# list_to_count_from should be a list of items to search for

tokens = ["hello", "world", "hello", "test", "hello"]
list_to_count_from = ["hello", "world", "missing"]

ARGS = {
    "tokens": tokens,
    "list_to_count_from": list_to_count_from
}
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 float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
count_parameters Ran
ran, honoured the contract we drafted
this paper's copy was not recorded; identical code first harvested from hnt4499/seq2seq
pointer only · get_code("0f26a596e83c5565")
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.

create_dataset Ran
ran; our contract draft was wrong, not the code
Baichenjia/NMT-eager/NMT-eager.py
pointer only (licence: NONE) · get_code("6294101bad54572d")
How it ran

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

create_dict Ran
ran on a synthesized input
thunlp/TensorFlow-Summarization/src/data_util.py
code served (permissive licence) · get_code("e0be7626138d362f")
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 logging
import tempfile
import os

logging.basicConfig(level=logging.INFO)

# Create a temporary directory for the dict file
temp_dir = tempfile.mkdtemp()
dict_path = os.path.join(temp_dir, "test_dict.txt")

# Create a simple corpus with word lists
# Each line is a list of words
corpus = [
    ['hello', 'world', 'hello'],
    ['foo', 'bar', 'baz'],
    ['hello', 'foo', 'test'],
    ['world', 'bar', 'test']
]

# Define arguments
ARGS = {
    'dict_path': dict_path,
    'corpus': corpus,
    'max_vocab': 10
}
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
create_tokenizer Ran
ran on a synthesized input
prakhargurawa/Neural-Machine-Translation-Keras-German-English/translation_neural_network_model.py
code served (permissive licence) · get_code("ad4e30338e48aa2c")
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 Tokenizer. 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 tensorflow.keras.preprocessing.text import Tokenizer

ARGS = {
    "lines": [
        "hello world this is a test",
        "another sample text for tokenization",
        "one more line to process",
        "final example sentence here"
    ]
}
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 Tokenizer — a Tokenizer output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Tokenizer 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_pos_features Ran
ran on a synthesized input
qq345736500/sarcasm/src/extract_statistical_features.py
code served (permissive licence) · get_code("39685672f02e1067")
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

def get_pos_features(pos_tweet):
    pos_dict = dict.fromkeys(['N', 'O', 'S', '^', 'Z', 'L', 'M', 'V', 'A', 'R', '!', 'D', 'P', '&', 'T', 'X', 'Y', '#', '@', '~', 'U', 'E', '$', ',', 'G'], 0)
    for pos in pos_tweet:
        pos_dict[pos] += 1
    return pos_dict

# pos_tweet is expected to be an iterable of POS tags (strings)
# The function iterates through pos_tweet and counts occurrences of each tag
pos_tweet_example = ['N', 'V', 'A', 'N', 'O', 'V', 'R', 'N']

ARGS = {
    'pos_tweet': pos_tweet_example
}
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
get_regularization_params Ran
ran on a synthesized input
qq345736500/sarcasm/src/classifiers.py
code served (permissive licence) · get_code("66e01a8e39117589")
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 1, dtype family float, shape (6,) 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

ARGS = {
    'a': -1,
    'b': 1,
    'c': 3,
    'd': 1,
    'e': 5
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 1, dtype family float, shape (6,) — shape (6,) 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
import_params Ran
ran; our contract draft was wrong, not the code
thunlp-mt/ckd/thumt/bin/trainer.py
code served (permissive licence) · get_code("bb55d10bc8ee2bfa")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) and returned MockParams. 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
import json

class MockParams:
    def __init__(self):
        self.data = {}
    
    def parse_json(self, json_str):
        parsed = json.loads(json_str)
        self.data.update(parsed)

# Create a temporary directory with the necessary files
temp_dir = tempfile.mkdtemp()

# Create params.json
params_data = {"learning_rate": 0.001, "batch_size": 32}
params_path = os.path.join(temp_dir, "params.json")
with open(params_path, "w") as f:
    f.write(json.dumps(params_data))

# Create model.json (using "model" as model_name)
model_data = {"num_layers": 3, "hidden_size": 128}
model_path = os.path.join(temp_dir, "model.json")
with open(model_path, "w") as f:
    f.write(json.dumps(model_data))

params_obj = MockParams()

ARGS = {
    "model_dir": temp_dir,
    "model_name": "model",
    "params": params_obj
}
Setup block drafted by
a language model, Claude Sonnet 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 MockParams — a MockParams output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a MockParams output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
load_clean_sentences Ran
ran; our contract draft was wrong, not the code
prakhargurawa/Neural-Machine-Translation-Keras-Attention/translation_neural_network_model.py
code served (permissive licence) · get_code("5a7a5d4f405c2fd5")
How it ran

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

import pickle
import os
import tempfile

# Create a temporary file with pickled data
temp_dir = tempfile.mkdtemp()
filename = os.path.join(temp_dir, 'model.h5')

# Create some sample clean sentences data to pickle
clean_sentences = [
    ['this', 'is', 'a', 'sentence'],
    ['another', 'sentence', 'here'],
    ['third', 'example', 'sentence']
]

# Write the pickled data to the file
with open(filename, 'wb') as f:
    pickle.dump(clean_sentences, f)

ARGS = {
    'filename': filename
}
Setup block drafted by
a language model, Claude Sonnet 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 list — a list 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_clean_sentences Ran
ran on a synthesized input
prakhargurawa/Neural-Machine-Translation-Keras-German-English/translation_evaluation_model.py
code served (permissive licence) · get_code("250a25c8c9e1b730")
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 pickle
import tempfile
import os

# Create a temporary pickle file with sample data
sample_sentences = [
    "This is the first sentence.",
    "Here is another sentence.",
    "And a third one for good measure."
]

# Create a temporary file and write the pickled data
temp_file = tempfile.NamedTemporaryFile(mode='wb', delete=False, suffix='.pkl')
pickle.dump(sample_sentences, temp_file)
temp_file.close()
temp_filename = temp_file.name

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 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
load_dict Ran
ran on a synthesized input
thunlp/TensorFlow-Summarization/src/data_util.py
code served (permissive licence) · get_code("6354c695b0345eaa")
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 logging
import tempfile
import os

# Set up logging
logging.basicConfig(level=logging.INFO)

# Create a temporary dictionary file with valid format
temp_dir = tempfile.mkdtemp()
dict_path = os.path.join(temp_dir, "test_dict.txt")

# Write a sample dictionary file with format: id word
with open(dict_path, 'w') as f:
    f.write("0 the\n")
    f.write("1 a\n")
    f.write("2 cat\n")
    f.write("3 dog\n")
    f.write("4 bird\n")
    f.write("5 tree\n")

ARGS = {
    'dict_path': dict_path,
    'max_vocab': 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 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
load_doc Ran
ran on a synthesized input
prakhargurawa/Neural-Machine-Translation-Keras-German-English/translation_preprocessing.py
code served (permissive licence) · get_code("23e3b013d3d7c0e3")
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 tempfile
import os

# Create a temporary file with some test text content
temp_dir = tempfile.mkdtemp()
temp_file = os.path.join(temp_dir, 'deu.txt')

with open(temp_file, mode='wt', encoding='utf-8') as f:
    f.write('This is a test document in German.\nEin Testdokument.\n')

filename = temp_file

ARGS = {
    'filename': 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 str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
load_train_data Ran
ran on a synthesized input
mpavlovic/insincere-questions-classifier/submission_script.py
code served (permissive licence) · get_code("15021775e16a477e")
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 pandas as pd
import tempfile
import os

# Create a temporary CSV file with test data
temp_dir = tempfile.mkdtemp()
csv_file = os.path.join(temp_dir, "train_data.csv")

# Create sample data
df = pd.DataFrame({
    'features': ['text1', 'text2', 'text3', 'text4'],
    'label1': [0, 1, 0, 1],
    'label2': [1, 0, 1, 0]
})
df.to_csv(csv_file, index=False)

ARGS = {
    'file_path': csv_file,
    'train_column': 'features',
    'label_columns': ['label1', 'label2']
}
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 — 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
max_len Ran
ran on a synthesized input
IpastorSan/seq2seq-with-attention-OCR-translation/model/attention_seq2seq/seq2seq_model_with_attention.py
code served (permissive licence) · get_code("f5175a54203ad8ea")
How it ran

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

import torch
import numpy as np

torch.manual_seed(0)

# Analyzing the function:
# max_len(data) iterates over lines in data, splits each line by whitespace,
# and returns the maximum length. So 'data' should be an iterable of strings.

data = [
    "hello world this is a test",
    "short line",
    "medium length string here"
]

ARGS = {
    "data": data
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
max_length Ran
ran, honoured the contract we drafted
prakhargurawa/Neural-Machine-Translation-Keras-Attention/translation_neural_network_model.py
code served (permissive licence) · get_code("64ded720acd0ec65")
How it ran

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

lines = [
    "This is a test line",
    "Short line",
    "This is a longer test line with more words",
    "Another line"
]

ARGS = {
    "lines": lines
}
Setup block drafted by
a language model, Claude Sonnet 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 int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
normalize_string Ran
ran; our contract draft was wrong, not the code
this paper's copy was not recorded; identical code first harvested from rileynwong/pytorch-seq2seq-joke2punchline
pointer only; the stored copy get_code serves, from rileynwong/pytorch-seq2seq-joke2punchline, is pointer only (licence: NONE) · get_code("0249f2927bd76913")
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.

open_data Ran
ran on a synthesized input
IpastorSan/seq2seq-with-attention-OCR-translation/model/ocr_text_recognition.py
code served (permissive licence) · get_code("6d38556f066c4b14")
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 tempfile
import os

# Create a temporary file with sample data
temp_file = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt')
temp_file.write("line 1\n")
temp_file.write("line 2\n")
temp_file.write("line 3\n")
temp_file.write("line 4\n")
temp_file.write("line 5\n")
temp_file.close()

ARGS = {
    'dataset': temp_file.name,
    'num_examples': 3
}
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
open_txt Ran
ran on a synthesized input
IpastorSan/seq2seq-with-attention-OCR-translation/model/text_preprocessing.py
code served (permissive licence) · get_code("cfd02a8466a5c1e8")
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 tempfile
import os

# Create a temporary text file with some sample content
with tempfile.NamedTemporaryFile(mode='w', encoding='utf-8', delete=False, suffix='.txt') as f:
    temp_file = f.name
    f.write("This is sample text data.\nLine 2 of the file.\nLine 3.")

try:
    ARGS = {
        'dataset': temp_file
    }
finally:
    # Clean up the temporary file after defining ARGS
    # Note: In practice, the file will be deleted after the function executes
    pass
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
parse_args Ran
ran; our contract draft was wrong, not the code
thunlp-mt/ckd/thumt/bin/trainer.py
code served (permissive licence) · get_code("a172d56eb6c789db")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) and returned Namespace. 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 argparse
import sys

# Create a list of command-line argument strings that parse_args will parse
args_list = [
    '--model', 'transformer',
    '--input', 'source.txt', 'target.txt',
    '--vocabulary', 'src_vocab.txt', 'tgt_vocab.txt',
    '--output', 'checkpoints',
    '--teacher', 'teacher_model',
    '--teacher_path', 'teacher_checkpoint.pt',
    '--validation', 'valid.txt',
    '--references', 'ref*.txt',
    '--checkpoint', 'pretrained.pt',
    '--hparam_set', 'base',
    '--parameters', 'learning_rate=0.001,batch_size=32',
    '--local_rank', '0',
    '--distributed',
    '--half'
]

ARGS = {'args': args_list}
Setup block drafted by
a language model, Claude Sonnet 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 Namespace — a Namespace output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Namespace 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
parse_args Ran
ran; our contract draft was wrong, not the code
THUNLP-MT/THUMT/thumt/bin/trainer.py
code served (permissive licence) · get_code("f83b8f1f177c138e")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) and returned Namespace. 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 argparse
import sys

# parse_args expects a list of command-line argument strings (or None to use sys.argv)
# We need to construct a list of strings that would be valid command-line arguments

args_list = [
    '--input', 'source.txt', 'target.txt',
    '--output', 'train_output',
    '--vocabulary', 'source_vocab.txt', 'target_vocab.txt',
    '--validation', 'validation.txt',
    '--references', 'ref*.txt',
    '--checkpoint', 'checkpoint.pt',
    '--distributed',
    '--local_rank', '0',
    '--half',
    '--hparam_set', 'base',
    '--model', 'transformer',
    '--parameters', 'learning_rate=0.001,batch_size=32'
]

ARGS = {'args': args_list}
Setup block drafted by
a language model, Claude Sonnet 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 Namespace — a Namespace output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Namespace 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
parse_arguments Ran
ran; our contract draft was wrong, not the code
this paper's copy was not recorded; identical code first harvested from hnt4499/seq2seq
pointer only · get_code("2a74b7a19b47b566")
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.

preprocess_chinese Ran
ran; our contract draft was wrong, not the code
Baichenjia/NMT-eager/NMT-eager-chinese-eng.py
pointer only (licence: NONE) · get_code("72f8e5deeaf2f42f")
How it ran

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

preprocess_eng Ran
ran; our contract draft was wrong, not the code
Baichenjia/NMT-eager/NMT-eager-chinese-eng.py
pointer only (licence: NONE) · get_code("d23765a7df2697f9")
How it ran

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

preprocess_sentence Ran
ran; our contract draft was wrong, not the code
Baichenjia/NMT-eager/NMT-eager.py
pointer only (licence: NONE) · get_code("cd26c09003aad137")
How it ran

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

readLangs Ran
ran; our contract draft was wrong, not the code
this paper's copy was not recorded; identical code first harvested from rileynwong/pytorch-seq2seq-joke2punchline
pointer only; the stored copy get_code serves, from rileynwong/pytorch-seq2seq-joke2punchline, is pointer only (licence: NONE) · get_code("52625852fa241e82")
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.

readLangs Ran
ran; our contract draft was wrong, not the code
rileynwong/pytorch-seq2seq-joke2punchline/joke2punchline.py
pointer only (licence: NONE) · get_code("bd123a7513397989")
How it ran

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

sample Ran
ran, honoured the contract we drafted
this paper's copy was not recorded; identical code first harvested from Guillem96/pointer-nn-pytorch
pointer only; the stored copy get_code serves, from Guillem96/pointer-nn-pytorch, is pointer only (licence: GPL-3.0) · get_code("8b887331144b7967")
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.

select_active_features Ran
ran on a synthesized input
qq345736500/sarcasm/src/feature_analysis.py
code served (permissive licence) · get_code("ea2003016da44e7f")
How it ran

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

import torch
import numpy as np

torch.manual_seed(0)

# Construct all_features: a list of dicts where each dict has feature data
all_features = [
    {
        'feature_a': torch.randn(2, 4),
        'feature_b': torch.randn(3, 5),
        'feature_c': np.array([1, 2, 3]),
        'feature_d': 'some_string'
    },
    {
        'feature_a': torch.randn(2, 4),
        'feature_b': torch.randn(3, 5),
        'feature_c': np.array([4, 5, 6]),
        'feature_d': 'another_string'
    }
]

# selected_features: list of keys to select from each feature dict
selected_features = ['feature_a', 'feature_c']

ARGS = {
    'all_features': all_features,
    'selected_features': selected_features
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
sequence_mask Ran
ran; our contract draft was wrong, not the code
YvesWang/Machine_Translation_NLP/AttentionRNN/Multilayers_Decoder.py
pointer only (licence: NONE) · get_code("149c4508c7494e2a")
How it ran

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

unicode_to_ascii Ran
ran; our contract draft was wrong, not the code
this paper's copy was not recorded; identical code first harvested from bonaventuredossou/ffr-v1
pointer only; the stored copy get_code serves, from bonaventuredossou/ffr-v1, is pointer only (licence: NOASSERTION) · get_code("3b0218c9534b6ee7")
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.

unicode_to_ascii Ran
ran; our contract draft was wrong, not the code
this paper's copy was not recorded; identical code first harvested from rileynwong/pytorch-seq2seq-joke2punchline
pointer only; the stored copy get_code serves, from rileynwong/pytorch-seq2seq-joke2punchline, is pointer only (licence: NONE) · get_code("a2ec1e65cd2e8ef4")
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.

unicode_to_ascii Ran
ran on a synthesized input
IpastorSan/seq2seq-with-attention-OCR-translation/model/text_preprocessing.py
code served (permissive licence) · get_code("65942c6c527f361b")
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 unicodedata

def unicode_to_ascii(text):
    return ''.join((c for c in unicodedata.normalize('NFD', text) if unicodedata.category(c) != 'Mn'))

# The function takes a single parameter: text (a string)
# It normalizes the text and filters out combining marks (diacritics)

ARGS = {
    'text': 'Héllo Wörld! Café naïve'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
clean_special_chars Not yet run
unverified (harvested, no recorded run)
mpavlovic/insincere-questions-classifier/submission_script.py
code served (permissive licence) · get_code("d8dfaa83f9283e10")
How it ran

no invocation recorded.

get_sentiment_features Not yet run
unverified (harvested, no recorded run)
qq345736500/sarcasm/src/extract_ml_features.py
code served (permissive licence) · get_code("e5420ffff4171204")
How it ran

no invocation recorded.

perform_function Not yet run
unverified (harvested, no recorded run)
qq345736500/sarcasm/src/feature_analysis.py
code served (permissive licence) · get_code("5a84cd52152103ed")
How it ran

no invocation recorded.

Also present in other papers' code

Of 44 samples lifted from this paper's linked repositories, 44 carry a function identity and 0 do not. Of the 43 distinct functions with an identity, 11 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 7 the same month, 8 later) and 32 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
Linear 58 other papers
58 later · 5 only as an assembly brick
1706.03762 (2017-06)
Attention Is All You Need
1904.01681 (2019-04)
Augmented Neural ODEs
1905.11600 (2019-05)
GraphNVP: An Invertible Flow Model for Generating Molecular Graphs
and 55 more not named here
LayerNorm 8 other papers
8 later · 3 only as an assembly brick
1906.00295 (2019-06)
Multimodal Transformer for Unaligned Multimodal Language Sequences
1906.01787 (2019-06)
Learning Deep Transformer Models for Machine Translation
2111.08456 (2021-11)
Trustworthy Multimodal Regression with Mixture of Normal-inverse Gamma Distributions
and 5 more not named here
unicode_to_ascii 4 other papers
4 later
1703.03906 (2017-03)
Massive Exploration of Neural Machine Translation Architectures
1810.12541 (2018-10)
Robots Learn Social Skills: End-to-End Learning of Co-Speech Gesture Generation for Humanoid Robots
1811.00239 (2018-11)
Progressive Memory Banks for Incremental Domain Adaptation
and 1 more not named here
batch 2 other papers
1 the same month, 1 later
1409.3215 (2014-09)
Sequence to Sequence Learning with Neural Networks
1506.03134 (2015-06)
Pointer Networks
count_parameters 2 other papers
1 the same month, 1 later
1409.3215 (2014-09)
Sequence to Sequence Learning with Neural Networks
1508.04025 (2015-08)
Effective Approaches to Attention-based Neural Machine Translation
import_params 2 other papers
2 later
2110.06609 (2021-10)
MSP: Multi-Stage Prompting for Making Pre-trained Language Models Better Translators
2022.findings-acl.203 (2022 (year only))
Prompt-Driven Neural Machine Translation
parse_arguments 2 other papers
1 the same month, 1 later
1409.3215 (2014-09)
Sequence to Sequence Learning with Neural Networks
1508.04025 (2015-08)
Effective Approaches to Attention-based Neural Machine Translation
sample 2 other papers
1 the same month, 1 later
1409.3215 (2014-09)
Sequence to Sequence Learning with Neural Networks
1506.03134 (2015-06)
Pointer Networks
normalize_string 1 other paper
1 the same month
1409.3215 (2014-09)
Sequence to Sequence Learning with Neural Networks
readLangs 1 other paper
1 the same month
1409.3215 (2014-09)
Sequence to Sequence Learning with Neural Networks
unicode_to_ascii 1 other paper
1 the same month
1409.3215 (2014-09)
Sequence to Sequence Learning with Neural Networks

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

Neural machine translation is a recently proposed approach to machine translation. Unlike the traditional statistical machine translation, the neural machine translation aims at building a single neural network that can be jointly tuned to maximize the translation performance. The models proposed recently for neural machine translation often belong to a family of encoder-decoders and encode a source sentence into a fixed-length vector from which a decoder generates a translation. In this paper, we conjecture that the use of a fixed-length vector is a bottleneck in improving the performance of this basic encoder-decoder architecture, and propose to extend this by allowing a model to automatically (soft-)search for parts of a source sentence that are relevant to predicting a target word, without having to form these parts as a hard segment explicitly. With this new approach, we achieve a translation performance comparable to the existing state-of-the-art phrase-based system on the task of English-to-French translation. Furthermore, qualitative analysis reveals that the (soft-)alignments found by the model agree well with our intuition.

For agents

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

get_harvested_code_for_paper("1409.0473")
get_code_for_paper("1409.0473")
have("1409.0473")

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

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

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

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

Connect an agent — have() is free.