teras.models.TabNetDecoder

class teras.models.TabNetDecoder(data_dim, feature_transformer_dim, decision_step_dim, num_decision_steps=5, num_shared_layers=2, num_decision_dependent_layers=5, relaxation_factor=1.5, batch_momentum=0.9, epsilon=1e-05, **kwargs)

TabNetDecoder model for self-supervised learning, proposed by Arik et al. in the “TabNet: Attentive Interpretable Tabular Learning” paper.

Reference(s):

https://arxiv.org/abs/1908.07442

Parameters:

• data_dim (int) – int, The dimensionality of the input dataset.

• feature_transformer_dim (int) – int, the dimensionality of the hidden representation in feature transformation block. The dense layer inside the TabNetFeatureTransformer first maps the inputs to feature_transformer_dim * 2 dimension hidden representations and later the glu activation maps the hidden representations to feature_transformer_dim dimensions.

• decision_step_dim (int) – int, the dimensionality of output at each decision step, which is later mapped to the final classification or regression output. It is recommended to keep decision_step_dim and feature_transformer_dim equal to each other. Adjusting these two parameters values is a good way of obtaining a tradeoff between performance and complexity.

• num_decision_steps (int) – int, the number of sequential decision steps. For most datasets a value in the range [3, 10] is optimal. If there are more informative features in the dataset, the value tends to be higher. That said, a very high value of num_decision_steps may suffer from overfitting. Defaults to 5.

• num_shared_layers (int) – int, Number of shared layers to use in the TabNetFeatureTransformer. These shared layers are shared across decision steps. Defaults to 2.

• num_decision_dependent_layers (int) – int, number of decision dependent layers to use in the TabNetFeatureTransformer. In simple words, num_decision_dependent_layers are created for each decision step in the num_decision_steps. For instance, if num_decision_steps = 5 and num_decision_dependent_layers = 2 then 10 layers will be created, 2 for each decision step.

• relaxation_factor (float) – float, relaxation factor that promotes the reuse of each feature at different decision steps. When it is 1, a feature is enforced to be used only at one decision step and as it increases, more flexibility is provided to use a feature at multiple decision steps. An optimal value of relaxation_factor can have a major role on the performance. Typically, a larger value for num_decision_steps favors for a larger relaxation_factor.

• batch_momentum (float) – float, momentum value to use for BatchNormalization layer. Defaults to 0.9

• epsilon (float) – float, epsilon is a small number for numerical stability during the computation of entropy loss. Defaults to 0.00001

__init__(data_dim, feature_transformer_dim, decision_step_dim, num_decision_steps=5, num_shared_layers=2, num_decision_dependent_layers=5, relaxation_factor=1.5, batch_momentum=0.9, epsilon=1e-05, **kwargs)

Methods

__init__(data_dim, feature_transformer_dim, ...)
add_loss(loss)	Can be called inside of the call() method to add a scalar loss.
add_metric()
add_variable(shape, initializer[, dtype, ...])	Add a weight variable to the layer.
add_weight([shape, initializer, dtype, ...])	Add a weight variable to the layer.
build(input_shape)
build_from_config(build_config)	Builds the layer's states with the supplied config dict.
call(inputs[, mask])
compile([optimizer, loss, loss_weights, ...])	Configures the model for training.
compile_from_config(config)	Compiles the model with the information given in config.
compiled_loss(y, y_pred[, sample_weight, ...])
compute_loss([x, y, y_pred, sample_weight, ...])	Compute the total loss, validate it, and return it.
compute_mask(inputs, previous_mask)
compute_metrics(x, y, y_pred[, sample_weight])	Update metric states and collect all metrics to be returned.
compute_output_shape(*args, **kwargs)
compute_output_spec(*args, **kwargs)
count_params()	Count the total number of scalars composing the weights.
evaluate([x, y, batch_size, verbose, ...])	Returns the loss value & metrics values for the model in test mode.
export(filepath[, format])	Create a TF SavedModel artifact for inference.
fit([x, y, batch_size, epochs, verbose, ...])	Trains the model for a fixed number of epochs (dataset iterations).
from_config(config[, custom_objects])	Creates an operation from its config.
get_build_config()	Returns a dictionary with the layer's input shape.
get_compile_config()	Returns a serialized config with information for compiling the model.
get_config()	Returns the config of the object.
get_layer([name, index])	Retrieves a layer based on either its name (unique) or index.
get_metrics_result()	Returns the model's metrics values as a dict.
get_weights()	Return the values of layer.weights as a list of NumPy arrays.
load_own_variables(store)	Loads the state of the layer.
load_weights(filepath[, skip_mismatch])	Load weights from a file saved via save_weights().
loss(y, y_pred[, sample_weight])
make_predict_function([force])
make_test_function([force])
make_train_function([force])
predict(x[, batch_size, verbose, steps, ...])	Generates output predictions for the input samples.
predict_on_batch(x)	Returns predictions for a single batch of samples.
predict_step(data)
quantize(mode)	Quantize the weights of the model.
quantized_call(*args, **kwargs)
reset_metrics()
save(filepath[, overwrite, zipped])	Saves a model as a .keras file.
save_own_variables(store)	Saves the state of the layer.
save_weights(filepath[, overwrite])	Saves all layer weights to a .weights.h5 file.
set_weights(weights)	Sets the values of layer.weights from a list of NumPy arrays.
stateless_call(trainable_variables, ...[, ...])	Call the layer without any side effects.
stateless_compute_loss(trainable_variables, ...)
summary([line_length, positions, print_fn, ...])	Prints a string summary of the network.
symbolic_call(*args, **kwargs)
test_on_batch(x[, y, sample_weight, return_dict])	Test the model on a single batch of samples.
test_step(data)
to_json(**kwargs)	Returns a JSON string containing the network configuration.
train_on_batch(x[, y, sample_weight, ...])	Runs a single gradient update on a single batch of data.
train_step(data)

Attributes

compiled_metrics
compute_dtype	The dtype of the computations performed by the layer.
distribute_reduction_method
distribute_strategy
dtype	Alias of layer.variable_dtype.
dtype_policy
input	Retrieves the input tensor(s) of a symbolic operation.
input_dtype	The dtype layer inputs should be converted to.
input_spec
jit_compile
layers
losses	List of scalar losses from add_loss, regularizers and sublayers.
metrics	List of all metrics.
metrics_names
metrics_variables	List of all metric variables.
non_trainable_variables	List of all non-trainable layer state.
non_trainable_weights	List of all non-trainable weight variables of the layer.
output	Retrieves the output tensor(s) of a layer.
path	The path of the layer.
quantization_mode	The quantization mode of this layer, None if not quantized.
run_eagerly
supports_masking	Whether this layer supports computing a mask using compute_mask.
trainable	Settable boolean, whether this layer should be trainable or not.
trainable_variables	List of all trainable layer state.
trainable_weights	List of all trainable weight variables of the layer.
variable_dtype	The dtype of the state (weights) of the layer.
variables	List of all layer state, including random seeds.
weights	List of all weight variables of the layer.