wf_psf.psf_models.models.psf_model_semiparametric

PSF Model Semi-Parametric.

A module which defines the classes and methods to manage the parameters of the psf semi-parametric model.

Authors:: Tobias Liaudat <tobiasliaudat@gmail.com> and Jennifer Pollack <jennifer.pollack@cea.fr>

Classes

`SemiParamFieldFactory`()	Factory class for the SemiParametric PSF Field Model.
`TFSemiParametricField`(args, *kwargs)	PSF field forward model.

class wf_psf.psf_models.models.psf_model_semiparametric.SemiParamFieldFactory[source]

Bases: PSFModelBaseFactory

Factory class for the SemiParametric PSF Field Model.

This factory class is responsible for instantiating instances of the SemiParametric PSF Field Model. It is registered with the PSF model factory registry.

Parameters:: ids (tuple) – A tuple containing identifiers for the factory class.

get_model_instance(model_params, training_params, data=None, coeff_mat=None)[source]: Instantiates an instance of the SemiParametric PSF Field Model with the provided parameters.

Methods

get_model_instance(model_params, training_params)

Get Model Instance.

get_model_instance(model_params, training_params, data=None, coeff_mat=None)[source]

Get Model Instance.

This method creates an instance of the SemiParametric PSF Field Model using the provided parameters.

Parameters:

model_params (Recursive Namespace) – Recursive Namespace object containing parameters for this PSF model class.
training_params (Recursive Namespace) – Parameters for training the PSF model.
data (object or None, optional) – Data used for training the PSF model.
coeff_mat (Tensor or None, optional) – Zernike coefficient matrix for the parametric PSF field model.

Returns:

An instance of the SemiParametric PSF Field Model.

Return type:

TFSemiParametricField

ids = ('poly',)

class wf_psf.psf_models.models.psf_model_semiparametric.TFSemiParametricField(*args, **kwargs)[source]

Bases: Model

PSF field forward model.

Semi parametric model based on the Zernike polynomial basis.

Parameters:

model_params (Recursive Namespace) – Recursive Namespace object containing parameters for this PSF model class.
training_params (Recursive Namespace) – Recursive Namespace object containing training hyperparameters for this PSF model class.
coeff_mat (Tensor or None) – Zernike coefficient matrix for the parametric PSF field model.

Attributes:

activity_regularizer: Optional regularizer function for the output of this layer.
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.
layers
losses: List of losses added using the add_loss() API.
metrics: Returns the model’s metrics added using compile(), add_metric() APIs.
metrics_names: Returns the model’s display labels for all outputs.
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
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.

Methods

`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.
`assign_S_mat`(s_mat)	Assign DD features matrix.
`assign_coeff_matrix`(coeff_mat)	Assign coefficient matrix.
`build`(input_shape)	Builds the model based on input shapes received.
`call`(inputs, **kwargs)	Define the PSF field forward model.
`compile`([optimizer, loss, metrics, ...])	Configures the model for training.
`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.
`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 (iterations on a dataset).
`fit_generator`(generator[, steps_per_epoch, ...])	Fits the model on data yielded batch-by-batch by a Python generator.
`from_config`(config[, custom_objects])	Creates a layer from its config.
`get_coeff_matrix`()	Get coefficient matrix.
`get_config`()	Returns the config of the Model.
`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_weight_paths`()	Retrieve all the variables and their paths for the model.
`get_weights`()	Retrieves the weights of the model.
`load_weights`(filepath[, by_name, ...])	Loads all layer weights, either from a TensorFlow or an HDF5 weight file.
`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_mono_psfs`(input_positions, ...)	Predict a set of monochromatic PSF at desired positions.
`predict_on_batch`(x)	Returns predictions for a single batch of samples.
`predict_opd`(input_positions)	Predict the OPD at some positions.
`predict_step`(data)	The logic for one inference step.
`project_DD_features`([tf_zernike_cube])	Project data-driven features.
`reset_metrics`()	Resets the state of all the metrics in the model.
`save`(filepath[, overwrite, ...])	Saves the model to Tensorflow SavedModel or a single HDF5 file.
`save_spec`([dynamic_batch])	Returns the tf.TensorSpec of call inputs as a tuple (args, kwargs).
`save_weights`(filepath[, overwrite, ...])	Saves all layer weights.
`set_nonzero_nonparam`()	Set to non-zero the non-parametric part.
`set_output_Q`(output_Q[, output_dim])	Set the value of the output_Q parameter.
`set_trainable_layers`([param_bool, nonparam_bool])	Set Trainable Layers.
`set_weights`(weights)	Sets the weights of the layer, from NumPy arrays.
`set_zero_nonparam`()	Set to zero the non-parametric part.
`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)	The logic for one training step.
`with_name_scope`(method)	Decorator to automatically enter the module name scope.

__call__
reset_states

assign_S_mat(s_mat)[source]: Assign DD features matrix.

assign_coeff_matrix(coeff_mat)[source]

Assign coefficient matrix.

A function to set the coefficient matrix.

Parameters:: coeff_mat (float) – Tensor Flow coefficient matrix for the parametric PSF field model

call(inputs, **kwargs)[source]

Define the PSF field forward model.

[1] From positions to Zernike coefficients [2] From Zernike coefficients to OPD maps [3] From OPD maps and SED info to polychromatic PSFs

OPD: Optical Path Differences

get_coeff_matrix()[source]

Get coefficient matrix.

A function to get the coefficient matrix for parametric model.

Returns:: coefficient matrix – Tensor Flow coefficient matrix for the parametric PSF field model
Return type:: float

predict_mono_psfs(input_positions, lambda_obs, phase_N)[source]

Predict a set of monochromatic PSF at desired positions.

Parameters:

input_positions (Tensor(batch_dim x 2))
lambda_obs (float) – Observed wavelength in um.
phase_N (int) – Required wavefront dimension. Should be calculated with as: simPSF_np = wf_psf.sims.psf_simulator.PSFSimulator(...) phase_N = simPSF_np.feasible_N(lambda_obs)

predict_opd(input_positions)[source]

Predict the OPD at some positions.

Parameters:: input_positions (tf.Tensor) – Positions to predict the OPD. Tensor dimensions are (batch_dim, 2)
Returns:: opd_maps – OPD at requested positions. Tensor dimensions are (batch, opd_dim, opd_dim)
Return type:: tf.Tensor

project_DD_features(tf_zernike_cube=None)[source]

Project data-driven features.

Project non-parametric wavefront onto first n_z Zernikes and transfer their parameters to the parametric model. This method updates the value of the S matrix in the non-parametric layer self.tf_np_poly_opd.

Parameters:: tf_zernike_cube (tf.Tensor) – Zernike maps used for the projection.

set_nonzero_nonparam()[source]

Set to non-zero the non-parametric part.

A function to set non-parametric alpha parameters equal to non-zero values.

set_output_Q(output_Q, output_dim=None)[source]

Set the value of the output_Q parameter.

Useful for generating/predicting PSFs at a different sampling wrt the observation sampling.

Parameters:

output_Q (float) – Oversampling factor
output_dim (int) – Output dimension

set_trainable_layers(param_bool=True, nonparam_bool=True)[source]

Set Trainable Layers.

A function to set the layers to be trainable or not.

Parameters:

param_bool (bool) – Boolean flag for the parametric layers
nonparam_bool (bool) – Boolean flag for the non-parametric layers

set_zero_nonparam()[source]

Set to zero the non-parametric part.

A function to set non-parametric alpha parameters equal to zero.