SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1908.07442 · 2019

TabNet: Attentive Interpretable Tabular Learning

arXiv · PDF · Open in the Atlas

Code that ran

13 of 17 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; 0 honoured the contract we drafted, 0 violated it and 12 have no contract verdict; 1 failure of our instrument; 4 no recorded run), measured 2026-11-21; 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/1908.07442.json · badge: /api/ran/1908.07442.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
dreamquark-ai/tabnet community (classifier label)
classifier basis not recorded on the link
6 ran · 3 no recorded run
96imranahmed/TabNet community (classifier label)
classifier basis not recorded on the link
3 ran · 0 no recorded run
titu1994/tf-TabNet community (classifier label)
classifier basis not recorded on the link
3 ran · 0 no recorded run
sourabhdattawad/TabNet reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
mgrankin/fast_tabnet community (classifier label)
classifier basis not recorded on the link
0 ran · 1 no recorded run
FunctionStatusWhere it lives
UnsupervisedLoss Ran
ran on a synthesized input
dreamquark-ai/tabnet/pytorch_tabnet/metrics.py
code served (permissive licence) · get_code("4e827b6c5e535f24")
How it ran

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

import torch
import numpy as np

torch.manual_seed(0)

# Create small tensors for the function
batch_size = 2
num_features = 4

# y_pred: reconstructed prediction with embeddings
# Shape: (batch_size, num_features)
y_pred = torch.randn(batch_size, num_features)

# embedded_x: original input embedded by network
# Shape: (batch_size, num_features)
embedded_x = torch.randn(batch_size, num_features)

# obf_vars: binary mask for obfuscated variables
# Shape: (batch_size, num_features) with values 0 or 1
obf_vars = torch.randint(0, 2, (batch_size, num_features)).float()

# eps: small float to avoid division by zero
eps = 1e-09

ARGS = {
    "y_pred": y_pred,
    "embedded_x": embedded_x,
    "obf_vars": obf_vars,
    "eps": eps,
}
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 Tensor, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
UnsupervisedLossNumpy Ran
ran on a synthesized input
dreamquark-ai/tabnet/pytorch_tabnet/metrics.py
code served (permissive licence) · get_code("c1773d6fbf26567b")
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 float32, 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 numpy as np

# Analyze the function to understand parameter requirements:
# - y_pred: used in subtraction with embedded_x, so same shape
# - embedded_x: used for np.mean, np.std with axis=0, so shape (batch_size, n_features)
# - obf_vars: used in np.multiply with errors, then np.sum(axis=1), so shape (batch_size, n_features)
# - eps: scalar, default 1e-09

batch_size = 2
n_features = 4

# y_pred: predictions, shape (batch_size, n_features)
y_pred = np.random.randn(batch_size, n_features).astype(np.float32)

# embedded_x: embedded features, shape (batch_size, n_features)
# Make sure it has non-zero mean and std to avoid edge cases
embedded_x = np.random.randn(batch_size, n_features).astype(np.float32) + 2.0

# obf_vars: obfuscation/masking variables, shape (batch_size, n_features)
# Binary mask or weights
obf_vars = np.random.randint(0, 2, size=(batch_size, n_features)).astype(np.float32)
# Ensure at least some non-zero values to avoid division issues
obf_vars[0, 0] = 1.0

# eps: small constant for numerical stability
eps = 1e-09

ARGS = {
    "y_pred": y_pred,
    "embedded_x": embedded_x,
    "obf_vars": obf_vars,
    "eps": eps,
}
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 float32, 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
create_dataloaders Ran
ran on a synthesized input
dreamquark-ai/tabnet/pytorch_tabnet/utils.py
code served (permissive licence) · get_code("e26b17641debb3ed")
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
import scipy.sparse

torch.manual_seed(0)

# Create small training data
X_train = np.random.randn(8, 4).astype(np.float32)
y_train = np.array([0, 1, 0, 1, 0, 1, 0, 1])

# Create evaluation set with one example
X_eval = np.random.randn(4, 4).astype(np.float32)
y_eval = np.array([0, 1, 0, 1])
eval_set = [(X_eval, y_eval)]

# Parameters for create_dataloaders
batch_size = 2
num_workers = 0
drop_last = False
pin_memory = False
weights = 0  # No weights applied

ARGS = {
    "X_train": X_train,
    "y_train": y_train,
    "eval_set": eval_set,
    "weights": weights,
    "batch_size": batch_size,
    "num_workers": num_workers,
    "drop_last": drop_last,
    "pin_memory": pin_memory,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
create_sampler Ran
ran on a synthesized input
dreamquark-ai/tabnet/pytorch_tabnet/utils.py
code served (permissive licence) · get_code("145cd251b469e65e")
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
from torch.utils.data import DataLoader, WeightedRandomSampler

torch.manual_seed(0)

# Create a small training target array with multiple classes
y_train = np.array([0, 0, 1, 1, 2, 2, 0, 1])

# Test case 1: weights = 0 (no weighting, shuffle)
ARGS = {
    "weights": 0,
    "y_train": y_train
}
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
generate_categorical_to_ordinal_map Ran
ran on a synthesized input
96imranahmed/TabNet/src/utils.py
code served (permissive licence) · get_code("f51c0d9ee544502f")
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 numpy as np
import pandas as pd

# Test with a simple list of categorical values
categorical_inputs = ["Dog", "Cat", "Human", "Dog", "Cat"]

ARGS = {
    "inputs": categorical_inputs
}

# Alternative test case with pandas Series
categorical_series = pd.Series(["Apple", "Banana", "Apple", "Cherry", "Banana", "Cherry"])

ARGS_PANDAS = {
    "inputs": categorical_series
}

# Use the first one as the primary ARGS
ARGS = {
    "inputs": categorical_inputs
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
glu Ran
ran; our contract draft was wrong, not the code
sourabhdattawad/TabNet/TabNet.py
pointer only (licence: NONE) · get_code("dbe20d7502d58b0f")
How it ran

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

glu Ran
ran on a synthesized input
titu1994/tf-TabNet/tabnet/custom_objects.py
code served (permissive licence) · get_code("ebd9ea87cb2c74f1")
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 EagerTensor, ndim 2, dtype family float, shape (2, 2) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import tensorflow as tf
import numpy as np

# Create a small TensorFlow tensor for input
# The function uses x[..., :n_units] and x[..., n_units:] 
# so we need a tensor with even last dimension
x = tf.constant(np.random.randn(2, 4).astype(np.float32))

# n_units is optional - can be None or an integer
n_units = None

ARGS = {
    "x": x,
    "n_units": n_units,
}
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 EagerTensor, ndim 2, dtype family float, shape (2, 2) — shape (2, 2) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
is_multilabel Ran
ran on a synthesized input
dreamquark-ai/tabnet/pytorch_tabnet/multiclass_utils.py
code served (permissive licence) · get_code("c6f9a241825feb6a")
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 numpy as np
from scipy.sparse import dok_matrix, lil_matrix, csr_matrix

# Test case 1: 2D numpy array with multilabel format (binary indicators)
# This should return True - has shape (3, 2) with values 0 and 1
multilabel_array = np.array([[1, 0], [0, 1], [1, 1]], dtype=np.int32)

ARGS = {
    "y": multilabel_array
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy — 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
map_categoricals_to_one_hot Ran
ran on a synthesized input
96imranahmed/TabNet/src/utils.py
code served (permissive licence) · get_code("78dd6ec9ceccedbe")
How it ran

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

torch.manual_seed(0)

# Create a small numpy array of categorical values
# Using integers 0, 1, 2 as categorical indices
categoricals = np.array([[0, 1, 2, 0], [1, 2, 0, 1]])

# Create a mapping dictionary that maps each categorical value to an ordinal
# We have 3 categories (0, 1, 2), so we need 3 entries in the mapping
mapping = {
    0: 0,
    1: 1,
    2: 2
}

ARGS = {
    "categoricals": categoricals,
    "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 Tensor, ndim 2, dtype family int, shape (8, 3) — shape (8, 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
map_categoricals_to_ordinals Ran
ran on a synthesized input
96imranahmed/TabNet/src/utils.py
code served (permissive licence) · get_code("d0fa7cc3c31baf33")
How it ran

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

import torch
import numpy as np

torch.manual_seed(0)

# Create sample categorical data as a numpy array
categoricals = np.array([['cat_a', 'cat_b'], 
                         ['cat_c', 'cat_a']], dtype=object)

# Create a mapping dictionary from categorical values to ordinals
mapping = {
    'cat_a': 0,
    'cat_b': 1,
    'cat_c': 2
}

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

# Create a simple custom class to register
class CustomDenseLayer(tf.keras.layers.Layer):
    """A simple custom Keras layer for testing registration."""
    def __init__(self, units=32):
        super(CustomDenseLayer, self).__init__()
        self.units = units
    
    def build(self, input_shape):
        self.w = self.add_weight(
            name='w',
            shape=(input_shape[-1], self.units),
            initializer='glorot_uniform',
            trainable=True
        )
        self.b = self.add_weight(
            name='b',
            shape=(self.units,),
            initializer='zeros',
            trainable=True
        )
    
    def call(self, inputs):
        return tf.matmul(inputs, self.w) + self.b

ARGS = {
    'cls': CustomDenseLayer
}
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 type — a type output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a type 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
sparsemax Ran
ran on a synthesized input
titu1994/tf-TabNet/tabnet/custom_objects.py
code served (permissive licence) · get_code("475e548a481445a8")
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 EagerTensor, ndim 2, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import tensorflow as tf

# Create a small batch of logits
logits = tf.constant([
    [1.0, 2.0, 0.5, 1.5],
    [0.5, 1.5, 2.0, 0.8]
], dtype=tf.float32)

# axis parameter
axis = -1

ARGS = {
    "logits": logits,
    "axis": axis
}
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 EagerTensor, ndim 2, dtype family float — no output shape is stated: observe_signature.py recorded SymbolicTensor ndim 2, which disagrees with the fixture run
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
type_of_target Ran
ran on a synthesized input
dreamquark-ai/tabnet/pytorch_tabnet/multiclass_utils.py
code served (permissive licence) · get_code("ec054cde4a3bbc5d")
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 numpy as np
from scipy.sparse import csr_matrix, dok_matrix
from collections.abc import Sequence

# Test case 1: Simple binary classification with list
y_binary = [0, 1, 0, 1]

# Test case 2: Multiclass with numpy array
y_multiclass = np.array([1, 2, 3, 1, 2])

# Test case 3: Continuous values
y_continuous = np.array([0.1, 0.5, 0.9, 1.2])

# Test case 4: Multilabel indicator (2D array with binary values)
y_multilabel = np.array([[1, 0], [0, 1], [1, 1]])

# Test case 5: Sparse matrix (multilabel format)
y_sparse = csr_matrix(np.array([[1, 0], [0, 1], [1, 0]]))

# Test case 6: String labels
y_string = ['a', 'b', 'a', 'c']

# Test case 7: Continuous multioutput
y_continuous_multioutput = np.array([[0.1, 0.2], [0.3, 0.4], [0.5, 0.6]])

# Choose a representative test case - binary classification
test_y = y_binary

ARGS = {
    'y': test_y
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy — 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
check_metrics Not yet run
unverified (harvested, no recorded run)
dreamquark-ai/tabnet/pytorch_tabnet/metrics.py
code served (permissive licence) · get_code("148ea925a59f9fde")
How it ran

no invocation recorded.

create_explain_matrix Not yet run
unverified (harvested, no recorded run)
dreamquark-ai/tabnet/pytorch_tabnet/utils.py
code served (permissive licence) · get_code("3e1394cff80ce6d7")
How it ran

no invocation recorded.

custom_doc_links Not yet run
unverified (harvested, no recorded run)
mgrankin/fast_tabnet/fast_tabnet/_nbdev.py
code served (permissive licence) · get_code("c00f1d9594b0678a")
How it ran

no invocation recorded.

infer_output_dim Not yet run
unverified (harvested, no recorded run)
dreamquark-ai/tabnet/pytorch_tabnet/multiclass_utils.py
code served (permissive licence) · get_code("7fd6c8b7c9ddbf04")
How it ran

no invocation recorded.

Also present in other papers' code

Of 17 samples lifted from this paper's linked repositories, 17 carry a function identity and 0 do not. Of the 17 distinct functions with an identity, 4 are also present in other papers whose code we hold (1 with at least one paper dated earlier, 0 the same month, 4 later) and 13 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
custom_doc_links 9 other papers
5 dated earlier, 4 later
1403.6652 (2014-03)
DeepWalk: Online Learning of Social Representations
1604.07143 (2016-04)
Neural Random Forests
1812.08693 (2018-12)
An Empirical Study on Learning Bug-Fixing Patches in the Wild via Neural Machine Translation
and 6 more not named here
check_metrics 1 other paper
1 later
aaai_20309 (2022 (year only))
DANETs: Deep Abstract Networks for Tabular Data Classification and Regression
infer_output_dim 1 other paper
1 later
aaai_20309 (2022 (year only))
DANETs: Deep Abstract Networks for Tabular Data Classification and Regression
is_multilabel 1 other paper
1 later
aaai_20309 (2022 (year only))
DANETs: Deep Abstract Networks for Tabular Data Classification and Regression

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-21.

Repositories linked to this paper

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

Abstract

We propose a novel high-performance and interpretable canonical deep tabular data learning architecture, TabNet. TabNet uses sequential attention to choose which features to reason from at each decision step, enabling interpretability and more efficient learning as the learning capacity is used for the most salient features. We demonstrate that TabNet outperforms other neural network and decision tree variants on a wide range of non-performance-saturated tabular datasets and yields interpretable feature attributions plus insights into the global model behavior. Finally, for the first time to our knowledge, we demonstrate self-supervised learning for tabular data, significantly improving performance with unsupervised representation learning when unlabeled data is abundant.

For agents

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

get_harvested_code_for_paper("1908.07442")
get_code_for_paper("1908.07442")
have("1908.07442")

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

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

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

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

Connect an agent — have() is free.