Models

Document on one wiki:

• core model class
• any examples?

Models core class

The Model class extends tf.keras.Model, making it a specialized abstract base class (ABC) for creating machine learning models with TensorFlow. This class is designed to serve as a foundation for defining the architecture of various deep learning models. It provides a structured way to implement custom models by specifying the forward pass behavior and configuration management.

Constructor

__init__(self, **kwargs)

Initializes a new instance of the Model class. This constructor is designed to define all key variables required for all models, leveraging the initialization process of tf.keras.Model through super().__init__(**kwargs).

Parameters:

• **kwargs: Arbitrary keyword arguments that are passed to the parent tf.keras.Model constructor. This allows for the flexible configuration of the model, including naming the model, setting up layers, and other TensorFlow-specific settings.

Methods

call(self, inputs, training=False)

An abstract method that must be implemented by subclasses. This method defines the forward pass of the model. It determines how the model processes input data and returns the output. The training parameter indicates whether the model should behave in training mode or inference mode.

Parameters:

• inputs: The input tensor(s) to the model.
• training: Boolean flag indicating whether the model is in training mode. Default is False.

Returns:

• The output tensor(s) of the model after the forward pass.

save_cfg(self, location: str)

An abstract method that must be implemented by subclasses. This method should save the configuration of the model, such as its architecture, hyperparameters, and any other relevant settings. This is crucial for reproducing the model's behavior, sharing models, and maintaining model versioning.

save(self, location: str)

An abstract method that must be implemented by subclasses. This method should save the model weights and biases (including any learnable parameters) that can be loaded by the "load" method. This is crucial for trained model re-use later for inference and analysis.

load(self, location: str)

An abstract method that must be implemented by subclasses. This method should load the learnable parameters that the model have, and are saved by the "save" method. This is very useful for re-use of trained models later for inference and analysis.

Implementing a Custom Model

To create a specific machine learning model (e.g., a convolutional neural network for image classification, a recurrent neural network for sequence processing), one must subclass Model and provide concrete implementations for all the abstract methods. This involves defining the layers and operations that constitute the model's architecture in the call method and detailing how the model's configuration can be saved and potentially reloaded.

Examples

Here's an example of model core that may not be as advance as described here: https://github.com/JeffersonLab/SciOptControlToolkit/blob/main/jlab_opt_control/core/model_core.py \

Here's an example of actual model that uses above core: https://github.com/JeffersonLab/SciOptControlToolkit/blob/main/jlab_opt_control/models/actor_fcnn.py