FullyConnected

class typhon.retrieval.qrnn.models.keras.FullyConnected(*args, **kwargs)[source]

Keras implementation of fully-connected networks.

__init__(input_dimension, quantiles, arch, layers=None)[source]

Create a fully-connected neural network.

Parameters:

input_dimension (int) – Number of input features
quantiles (array) – The quantiles to predict given as fractions within [0, 1].
arch (tuple) – Tuple (d, w, a) containing d, the number of hidden layers in the network, w, the width of the network and a, the type of activation functions to be used as string.

Methods

`__init__`(input_dimension, quantiles, arch[, ...])	Create a fully-connected neural network.
`add`(layer[, rebuild])	Adds a layer instance on top of the layer stack.
`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`(config)	Builds the layer's states with the supplied config dict.
`call`(inputs[, training, 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`(inputs[, training, mask])
`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])	[TF backend only]* Create a TF SavedModel artifact for inference (e.g. via TF-Serving).
`fit`([x, y, batch_size, epochs, verbose, ...])	Trains the model for a fixed number of epochs (dataset iterations).
`from_config`(config[, custom_objects])	Creates a layer 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])
`pop`([rebuild])	Removes the last layer in the model.
`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`()	Reinitialize the state of the model.
`reset_metrics`()
`save`(filepath[, overwrite])	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.
`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`(training_data[, validation_data, ...])
`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.
`input`	Retrieves the input tensor(s) of a symbolic operation.
`input_dtype`	The dtype layer inputs should be converted to.
`input_shape`
`input_spec`
`inputs`
`jit_compile`
`layers`
`losses`	List of scalar losses from add_loss, regularizers and sublayers.
`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.
`output_shape`
`outputs`
`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.