teras.models.TabNetEncoderBackbone

class teras.models.TabNetEncoderBackbone(input_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, reset_shared_layers=True, **kwargs)

TabNetEncoder proposed by Arik et al. in the “TabNet: Attentive Interpretable Tabular Learning” paper.

Reference(s):

https://arxiv.org/abs/1908.07442

Parameters:

• input_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

• reuse_shared_layers – bool, whether to reset shared layers of the TabNetFeatureTransformer layer. Although we want to use the same shared layers across multiple instances of TabNetFeatureTransformer but we may not want to use the same shared layers across different TabNetEncoder instances. Defaults to True.

__init__(input_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, reset_shared_layers=True, **kwargs)

Methods

__init__(input_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(input_shape)
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.