fusionlab.nn.models.SuperXTFT

class fusionlab.nn.models.SuperXTFT[source]

Bases: XTFT

SuperXTFT: An enhanced version of XTFT with Variable Selection Networks (VSNs) and integrated Gate → Add & Norm → GRN pipeline in attention layers.

__init__(static_input_dim, dynamic_input_dim, future_input_dim, embed_dim=32, forecast_horizon=1, quantiles=None, max_window_size=10, memory_size=100, num_heads=4, dropout_rate=0.1, output_dim=1, attention_units=32, hidden_units=64, lstm_units=64, scales=None, multi_scale_agg='auto', activation='relu', use_residuals=True, use_batch_norm=False, final_agg='last', anomaly_config=None, anomaly_detection_strategy=None, anomaly_loss_weight=1.0, **kw)[source]
Parameters:

  • static_input_dim (int)

  • dynamic_input_dim (int)

  • future_input_dim (int)

  • embed_dim (int)

  • forecast_horizon (int)

  • quantiles (str | List[float] | None)

  • max_window_size (int)

  • memory_size (int)

  • num_heads (int)

  • dropout_rate (float)

  • output_dim (int)

  • attention_units (int)

  • hidden_units (int)

  • lstm_units (int)

  • scales (str | List[int] | None)

  • multi_scale_agg (str | None)

  • activation (str)

  • use_residuals (bool)

  • use_batch_norm (bool)

  • final_agg (str)

  • anomaly_config (Dict[str, Any] | None)

  • anomaly_detection_strategy (str | None)

  • anomaly_loss_weight (float)

Methods

__init__(static_input_dim, ...[, embed_dim, ...])

add_loss(losses, **kwargs)

Add loss tensor(s), potentially dependent on layer inputs.

add_metric(value[, name])

Adds metric tensor to the layer.

add_update(updates)

Add update op(s), potentially dependent on layer inputs.

add_variable(*args, **kwargs)

Deprecated, do NOT use! Alias for add_weight.

add_weight([name, shape, dtype, ...])

Adds a new variable to the layer.

build(input_shape)

Builds the model based on input shapes received.

build_from_config(config)

Builds the layer's states with the supplied config dict.

call(inputs[, training])

Forward pass of the XTFT model.

compile(optimizer[, loss])

Compile the XTFT model, allowing an explicit user-specified loss to override the defaults.

compile_from_config(config)

Compiles the model with the information given in config.

compute_loss([x, y, y_pred, sample_weight])

Compute the total loss, validate it, and return it.

compute_mask(inputs[, mask])

Computes an output mask tensor.

compute_metrics(x, y, y_pred, sample_weight)

Update metric states and collect all metrics to be returned.

compute_output_shape(input_shape)

Computes the output shape of the layer.

compute_output_signature(input_signature)

Compute the output tensor signature of the layer based on the inputs.

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.

evaluate_generator(generator[, steps, ...])

Evaluates the model on a data generator.

export(filepath)

Create a SavedModel artifact for inference (e.g. via TF-Serving).

finalize_state()

Finalizes the layers state after updating layer weights.

fit([x, y, batch_size, epochs, verbose, ...])

Trains the model for a fixed number of epochs (dataset iterations).

fit_generator(generator[, steps_per_epoch, ...])

Fits the model on data yielded batch-by-batch by a Python generator.

from_config(config)

Reconstruct model instance from configuration dictionary.

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()

Get serialization configuration for model saving/loading.

get_input_at(node_index)

Retrieves the input tensor(s) of a layer at a given node.

get_input_mask_at(node_index)

Retrieves the input mask tensor(s) of a layer at a given node.

get_input_shape_at(node_index)

Retrieves the input shape(s) of a layer at a given node.

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_output_at(node_index)

Retrieves the output tensor(s) of a layer at a given node.

get_output_mask_at(node_index)

Retrieves the output mask tensor(s) of a layer at a given node.

get_output_shape_at(node_index)

Retrieves the output shape(s) of a layer at a given node.

get_params([deep])

Get the parameters for this learner.

get_weight_paths()

Retrieve all the variables and their paths for the model.

get_weights()

Retrieves the weights of the model.

help(**kwargs)

load(file_path[, format])

Load the learner's state from a specified file in the desired format.

load_own_variables(store)

Loads the state of the layer.

load_weights(filepath[, skip_mismatch, ...])

Loads all layer weights from a saved files.

make_predict_function([force])

Creates a function that executes one step of inference.

make_test_function([force])

Creates a function that executes one step of evaluation.

make_train_function([force])

Creates a function that executes one step of training.

predict(x[, batch_size, verbose, steps, ...])

Generates output predictions for the input samples.

predict_generator(generator[, steps, ...])

Generates predictions for the input samples from a data generator.

predict_on_batch(x)

Returns predictions for a single batch of samples.

predict_step(data)

The logic for one inference step.

reset_metrics()

Resets the state of all the metrics in the model.

reset_states()

save(filepath[, overwrite, save_format])

Saves a model as a TensorFlow SavedModel or HDF5 file.

save_own_variables(store)

Saves the state of the layer.

save_spec([dynamic_batch])

Returns the tf.TensorSpec of call args as a tuple (args, kwargs).

save_weights(filepath[, overwrite, ...])

Saves all layer weights.

set_params(**params)

Set the parameters of this learner.

set_weights(weights)

Sets the weights of the layer, from NumPy arrays.

summary([line_length, positions, print_fn, ...])

Prints a string summary of the network.

test_on_batch(x[, y, sample_weight, ...])

Test the model on a single batch of samples.

test_step(data)

The logic for one evaluation step.

to_json(**kwargs)

Returns a JSON string containing the network configuration.

to_yaml(**kwargs)

Returns a yaml 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)

Custom training step with anomaly detection strategy handling.

with_name_scope(method)

Decorator to automatically enter the module name scope.

Attributes

activity_regularizer

Optional regularizer function for the output of this layer.

autotune_steps_per_execution

Settable property to enable tuning for steps_per_execution

compute_dtype

The dtype of the layer's computations.

distribute_reduction_method

The method employed to reduce per-replica values during training.

distribute_strategy

The tf.distribute.Strategy this model was created under.

dtype

The dtype of the layer weights.

dtype_policy

The dtype policy associated with this layer.

dynamic

Whether the layer is dynamic (eager-only); set in the constructor.

inbound_nodes

Return Functional API nodes upstream of this layer.

input

Retrieves the input tensor(s) of a layer.

input_mask

Retrieves the input mask tensor(s) of a layer.

input_shape

Retrieves the input shape(s) of a layer.

input_spec

InputSpec instance(s) describing the input format for this layer.

jit_compile

Specify whether to compile the model with XLA.

layers

losses

List of losses added using the add_loss() API.

metrics

Return metrics added using compile() or add_metric().

metrics_names

Returns the model's display labels for all outputs.

my_params

name

Name of the layer (string), set in the constructor.

name_scope

Returns a tf.name_scope instance for this class.

non_trainable_variables

Sequence of non-trainable variables owned by this module and its submodules.

non_trainable_weights

List of all non-trainable weights tracked by this layer.

outbound_nodes

Return Functional API nodes downstream of this layer.

output

Retrieves the output tensor(s) of a layer.

output_mask

Retrieves the output mask tensor(s) of a layer.

output_shape

Retrieves the output shape(s) of a layer.

run_eagerly

Settable attribute indicating whether the model should run eagerly.

state_updates

Deprecated, do NOT use!

stateful

steps_per_execution

Settable `steps_per_execution variable. Requires a compiled model.

submodules

Sequence of all sub-modules.

supports_masking

Whether this layer supports computing a mask using compute_mask.

trainable

trainable_variables

Sequence of trainable variables owned by this module and its submodules.

trainable_weights

List of all trainable weights tracked by this layer.

updates

variable_dtype

Alias of Layer.dtype, the dtype of the weights.

variables

Returns the list of all layer variables/weights.

weights

Returns the list of all layer variables/weights.
__init__(static_input_dim, dynamic_input_dim, future_input_dim, embed_dim=32, forecast_horizon=1, quantiles=None, max_window_size=10, memory_size=100, num_heads=4, dropout_rate=0.1, output_dim=1, attention_units=32, hidden_units=64, lstm_units=64, scales=None, multi_scale_agg='auto', activation='relu', use_residuals=True, use_batch_norm=False, final_agg='last', anomaly_config=None, anomaly_detection_strategy=None, anomaly_loss_weight=1.0, **kw)[source]
Parameters:

  • static_input_dim (int)

  • dynamic_input_dim (int)

  • future_input_dim (int)

  • embed_dim (int)

  • forecast_horizon (int)

  • quantiles (str | List[float] | None)

  • max_window_size (int)

  • memory_size (int)

  • num_heads (int)

  • dropout_rate (float)

  • output_dim (int)

  • attention_units (int)

  • hidden_units (int)

  • lstm_units (int)

  • scales (str | List[int] | None)

  • multi_scale_agg (str | None)

  • activation (str)

  • use_residuals (bool)

  • use_batch_norm (bool)

  • final_agg (str)

  • anomaly_config (Dict[str, Any] | None)

  • anomaly_detection_strategy (str | None)

  • anomaly_loss_weight (float)

call(inputs, training=False, **kwargs)[source]

Forward pass of the XTFT model.

Parameters:

  • inputs (tuple or list) – Input data containing three elements: 1. Static features (batch_size, static_input_dim) 2. Dynamic historical features (batch_size, time_steps, dynamic_input_dim) 3. Future covariates (batch_size, horizon, future_input_dim)

  • training (bool, optional) – Whether the model is in training mode, by default False

  • **kwargs – Additional keyword arguments

Returns:

Predictions tensor of shape: - (batch_size, horizon, len(quantiles)) if quantiles specified - (batch_size, horizon, output_dim) otherwise

Return type:

tf.Tensor

Raises:

ValueError – If input validation fails through validate_xtft_inputs

Notes

  • Handles three types of anomaly detection strategies: 1. ‘feature_based’: Generates scores from attention mechanisms 2. ‘prediction_based’: Handled in loss function 3. ‘from_config’: Uses precomputed anomaly scores

  • Implements multi-scale temporal processing with: - Positional encoding - Hierarchical attention - Memory-augmented attention - Dynamic time windowing

help(**kwargs)
my_params = SuperXTFT(     static_input_dim,     dynamic_input_dim,     future_input_dim,     embed_dim=32,     forecast_horizon=1,     quantiles=None,     max_window_size=10,     memory_size=100,     num_heads=4,     dropout_rate=0.1,     output_dim=1,     attention_units=32,     hidden_units=64,     lstm_units=64,     scales=None,     multi_scale_agg='auto',     activation='relu',     use_residuals=True,     use_batch_norm=False,     final_agg='last',     anomaly_config=None,     anomaly_detection_strategy=None,     anomaly_loss_weight=1.0 )
classmethod from_config(config)[source]

Reconstruct model instance from configuration dictionary.

Parameters:

config (dict) – Configuration dictionary generated by get_config()

Returns:

Fully reconstructed model instance

Return type:

XTFT

Notes

  • Handles special conversions: - Anomaly scores list -> numpy array - Quantile list restoration - Custom layer reconstruction

  • Maintains logger instance during reconstruction

Example

>>> loaded_model = XTFT.from_config(json.load(open('model_config.json')))