W3cubDocs

/TensorFlow 2.3

tf.keras.Model

View source on GitHub

Model groups layers into an object with training and inference features.

Inherits From: Layer

View aliases

Main aliases

tf.keras.models.Model

Compat aliases for migration

See Migration guide for more details.

tf.compat.v1.keras.Model, tf.compat.v1.keras.models.Model

tf.keras.Model(
    *args, **kwargs
)

Arguments
`inputs`	The input(s) of the model: a `keras.Input` object or list of `keras.Input` objects.
`outputs`	The output(s) of the model. See Functional API example below.
`name`	String, the name of the model.

There are two ways to instantiate a Model:

1 - With the "Functional API", where you start from Input, you chain layer calls to specify the model's forward pass, and finally you create your model from inputs and outputs:

import tensorflow as tf

inputs = tf.keras.Input(shape=(3,))
x = tf.keras.layers.Dense(4, activation=tf.nn.relu)(inputs)
outputs = tf.keras.layers.Dense(5, activation=tf.nn.softmax)(x)
model = tf.keras.Model(inputs=inputs, outputs=outputs)

2 - By subclassing the Model class: in that case, you should define your layers in __init__ and you should implement the model's forward pass in call.

import tensorflow as tf

class MyModel(tf.keras.Model):

  def __init__(self):
    super(MyModel, self).__init__()
    self.dense1 = tf.keras.layers.Dense(4, activation=tf.nn.relu)
    self.dense2 = tf.keras.layers.Dense(5, activation=tf.nn.softmax)

  def call(self, inputs):
    x = self.dense1(inputs)
    return self.dense2(x)

model = MyModel()

If you subclass Model, you can optionally have a training argument (boolean) in call, which you can use to specify a different behavior in training and inference:

import tensorflow as tf

class MyModel(tf.keras.Model):

  def __init__(self):
    super(MyModel, self).__init__()
    self.dense1 = tf.keras.layers.Dense(4, activation=tf.nn.relu)
    self.dense2 = tf.keras.layers.Dense(5, activation=tf.nn.softmax)
    self.dropout = tf.keras.layers.Dropout(0.5)

  def call(self, inputs, training=False):
    x = self.dense1(inputs)
    if training:
      x = self.dropout(x, training=training)
    return self.dense2(x)

model = MyModel()

Once the model is created, you can config the model with losses and metrics with model.compile(), train the model with model.fit(), or use the model to do prediction with model.predict().

Attributes
`distribute_strategy`	The `tf.distribute.Strategy` this model was created under.
`layers`
`metrics_names`	Returns the model's display labels for all outputs. Note: `metrics_names` are available only after a `keras.Model` has been trained/evaluated on actual data. inputs = tf.keras.layers.Input(shape=(3,)) outputs = tf.keras.layers.Dense(2)(inputs) model = tf.keras.models.Model(inputs=inputs, outputs=outputs) model.compile(optimizer="Adam", loss="mse", metrics=["mae"]) model.metrics_names [] x = np.random.random((2, 3)) y = np.random.randint(0, 2, (2, 2)) model.fit(x, y) model.metrics_names ['loss', 'mae'] inputs = tf.keras.layers.Input(shape=(3,)) d = tf.keras.layers.Dense(2, name='out') output_1 = d(inputs) output_2 = d(inputs) model = tf.keras.models.Model( inputs=inputs, outputs=[output_1, output_2]) model.compile(optimizer="Adam", loss="mse", metrics=["mae", "acc"]) model.fit(x, (y, y)) model.metrics_names ['loss', 'out_loss', 'out_1_loss', 'out_mae', 'out_acc', 'out_1_mae', 'out_1_acc']
`run_eagerly`	Settable attribute indicating whether the model should run eagerly. Running eagerly means that your model will be run step by step, like Python code. Your model might run slower, but it should become easier for you to debug it by stepping into individual layer calls. By default, we will attempt to compile your model to a static graph to deliver the best execution performance.

Arguments
`optimizer`	String (name of optimizer) or optimizer instance. See `tf.keras.optimizers`.
`loss`	String (name of objective function), objective function or `tf.keras.losses.Loss` instance. See `tf.keras.losses`. An objective function is any callable with the signature `loss = fn(y_true, y_pred)`, where y_true = ground truth values with shape = `[batch_size, d0, .. dN]`, except sparse loss functions such as sparse categorical crossentropy where shape = `[batch_size, d0, .. dN-1]`. y_pred = predicted values with shape = `[batch_size, d0, .. dN]`. It returns a weighted loss float tensor. If a custom `Loss` instance is used and reduction is set to NONE, return value has the shape [batch_size, d0, .. dN-1] ie. per-sample or per-timestep loss values; otherwise, it is a scalar. If the model has multiple outputs, you can use a different loss on each output by passing a dictionary or a list of losses. The loss value that will be minimized by the model will then be the sum of all individual losses.
`metrics`	List of metrics to be evaluated by the model during training and testing. Each of this can be a string (name of a built-in function), function or a `tf.keras.metrics.Metric` instance. See `tf.keras.metrics`. Typically you will use `metrics=['accuracy']`. A function is any callable with the signature `result = fn(y_true, y_pred)`. To specify different metrics for different outputs of a multi-output model, you could also pass a dictionary, such as `metrics={'output_a': 'accuracy', 'output_b': ['accuracy', 'mse']}`. You can also pass a list (len = len(outputs)) of lists of metrics such as `metrics=[['accuracy'], ['accuracy', 'mse']]` or `metrics=['accuracy', ['accuracy', 'mse']]`. When you pass the strings 'accuracy' or 'acc', we convert this to one of `tf.keras.metrics.BinaryAccuracy`, `tf.keras.metrics.CategoricalAccuracy`, `tf.keras.metrics.SparseCategoricalAccuracy` based on the loss function used and the model output shape. We do a similar conversion for the strings 'crossentropy' and 'ce' as well.
`loss_weights`	Optional list or dictionary specifying scalar coefficients (Python floats) to weight the loss contributions of different model outputs. The loss value that will be minimized by the model will then be the weighted sum of all individual losses, weighted by the `loss_weights` coefficients. If a list, it is expected to have a 1:1 mapping to the model's outputs. If a dict, it is expected to map output names (strings) to scalar coefficients.
`weighted_metrics`	List of metrics to be evaluated and weighted by sample_weight or class_weight during training and testing.
`run_eagerly`	Bool. Defaults to `False`. If `True`, this `Model`'s logic will not be wrapped in a `tf.function`. Recommended to leave this as `None` unless your `Model` cannot be run inside a `tf.function`.
`**kwargs`	Any additional arguments. Supported arguments: `experimental_steps_per_execution`: Int. The number of batches to run during each `tf.function` call. Running multiple batches inside a single `tf.function` call can greatly improve performance on TPUs or small models with a large Python overhead. Note that if this value is set to `N`, `Callback.on_batch` methods will only be called every `N` batches. This currently defaults to `1`. At most, one full epoch will be run each execution. If a number larger than the size of the epoch is passed, the execution will be truncated to the size of the epoch. `sample_weight_mode` for backward compatibility.

Arguments
`x`	Input data. It could be: A Numpy array (or array-like), or a list of arrays (in case the model has multiple inputs). A TensorFlow tensor, or a list of tensors (in case the model has multiple inputs). A dict mapping input names to the corresponding array/tensors, if the model has named inputs. A `tf.data` dataset. Should return a tuple of either `(inputs, targets)` or `(inputs, targets, sample_weights)`. A generator or `keras.utils.Sequence` returning `(inputs, targets)` or `(inputs, targets, sample_weights)`. A more detailed description of unpacking behavior for iterator types (Dataset, generator, Sequence) is given in the `Unpacking behavior for iterator-like inputs` section of `Model.fit`.
`y`	Target data. Like the input data `x`, it could be either Numpy array(s) or TensorFlow tensor(s). It should be consistent with `x` (you cannot have Numpy inputs and tensor targets, or inversely). If `x` is a dataset, generator or `keras.utils.Sequence` instance, `y` should not be specified (since targets will be obtained from the iterator/dataset).
`batch_size`	Integer or `None`. Number of samples per batch of computation. If unspecified, `batch_size` will default to 32. Do not specify the `batch_size` if your data is in the form of a dataset, generators, or `keras.utils.Sequence` instances (since they generate batches).
`verbose`	0 or 1. Verbosity mode. 0 = silent, 1 = progress bar.
`sample_weight`	Optional Numpy array of weights for the test samples, used for weighting the loss function. You can either pass a flat (1D) Numpy array with the same length as the input samples (1:1 mapping between weights and samples), or in the case of temporal data, you can pass a 2D array with shape `(samples, sequence_length)`, to apply a different weight to every timestep of every sample. This argument is not supported when `x` is a dataset, instead pass sample weights as the third element of `x`.
`steps`	Integer or `None`. Total number of steps (batches of samples) before declaring the evaluation round finished. Ignored with the default value of `None`. If x is a `tf.data` dataset and `steps` is None, 'evaluate' will run until the dataset is exhausted. This argument is not supported with array inputs.
`callbacks`	List of `keras.callbacks.Callback` instances. List of callbacks to apply during evaluation. See callbacks.
`max_queue_size`	Integer. Used for generator or `keras.utils.Sequence` input only. Maximum size for the generator queue. If unspecified, `max_queue_size` will default to 10.
`workers`	Integer. Used for generator or `keras.utils.Sequence` input only. Maximum number of processes to spin up when using process-based threading. If unspecified, `workers` will default to 1. If 0, will execute the generator on the main thread.
`use_multiprocessing`	Boolean. Used for generator or `keras.utils.Sequence` input only. If `True`, use process-based threading. If unspecified, `use_multiprocessing` will default to `False`. Note that because this implementation relies on multiprocessing, you should not pass non-picklable arguments to the generator as they can't be passed easily to children processes.
`return_dict`	If `True`, loss and metric results are returned as a dict, with each key being the name of the metric. If `False`, they are returned as a list.

Raises
`RuntimeError`	If `model.evaluate` is wrapped in `tf.function`.
`ValueError`	in case of invalid arguments.

Raises
`RuntimeError`	If the model was never compiled or, If `model.fit` is wrapped in `tf.function`.
`ValueError`	In case of mismatch between the provided input data and what the model expects.

Arguments
`filepath`	String, path to the weights file to load. For weight files in TensorFlow format, this is the file prefix (the same as was passed to `save_weights`).
`by_name`	Boolean, whether to load weights by name or by topological order. Only topological loading is supported for weight files in TensorFlow format.
`skip_mismatch`	Boolean, whether to skip loading of layers where there is a mismatch in the number of weights, or a mismatch in the shape of the weight (only valid when `by_name=True`).
`options`	Optional `tf.train.CheckpointOptions` object that specifies options for loading weights.

Raises
`ImportError`	If h5py is not available and the weight file is in HDF5 format.
`ValueError`	If `skip_mismatch` is set to `True` when `by_name` is `False`.

Arguments
`x`	Input samples. It could be: A Numpy array (or array-like), or a list of arrays (in case the model has multiple inputs). A TensorFlow tensor, or a list of tensors (in case the model has multiple inputs). A `tf.data` dataset. A generator or `keras.utils.Sequence` instance. A more detailed description of unpacking behavior for iterator types (Dataset, generator, Sequence) is given in the `Unpacking behavior for iterator-like inputs` section of `Model.fit`.
`batch_size`	Integer or `None`. Number of samples per batch. If unspecified, `batch_size` will default to 32. Do not specify the `batch_size` if your data is in the form of dataset, generators, or `keras.utils.Sequence` instances (since they generate batches).
`verbose`	Verbosity mode, 0 or 1.
`steps`	Total number of steps (batches of samples) before declaring the prediction round finished. Ignored with the default value of `None`. If x is a `tf.data` dataset and `steps` is None, `predict` will run until the input dataset is exhausted.
`callbacks`	List of `keras.callbacks.Callback` instances. List of callbacks to apply during prediction. See callbacks.
`max_queue_size`	Integer. Used for generator or `keras.utils.Sequence` input only. Maximum size for the generator queue. If unspecified, `max_queue_size` will default to 10.
`workers`	Integer. Used for generator or `keras.utils.Sequence` input only. Maximum number of processes to spin up when using process-based threading. If unspecified, `workers` will default to 1. If 0, will execute the generator on the main thread.
`use_multiprocessing`	Boolean. Used for generator or `keras.utils.Sequence` input only. If `True`, use process-based threading. If unspecified, `use_multiprocessing` will default to `False`. Note that because this implementation relies on multiprocessing, you should not pass non-picklable arguments to the generator as they can't be passed easily to children processes.

Raises
`RuntimeError`	If `model.predict` is wrapped in `tf.function`.
`ValueError`	In case of mismatch between the provided input data and the model's expectations, or in case a stateful model receives a number of samples that is not a multiple of the batch size.

Raises
`RuntimeError`	If `model.predict_on_batch` is wrapped in `tf.function`.
`ValueError`	In case of mismatch between given number of inputs and expectations of the model.

Arguments
`filepath`	String, PathLike, path to SavedModel or H5 file to save the model.
`overwrite`	Whether to silently overwrite any existing file at the target location, or provide the user with a manual prompt.
`include_optimizer`	If True, save optimizer's state together.
`save_format`	Either `'tf'` or `'h5'`, indicating whether to save the model to Tensorflow SavedModel or HDF5. Defaults to 'tf' in TF 2.X, and 'h5' in TF 1.X.
`signatures`	Signatures to save with the SavedModel. Applicable to the 'tf' format only. Please see the `signatures` argument in `tf.saved_model.save` for details.
`options`	Optional `tf.saved_model.SaveOptions` object that specifies options for saving to SavedModel.

Arguments
`name`	String, name of layer.
`index`	Integer, index of layer.

Arguments
`line_length`	Total length of printed lines (e.g. set this to adapt the display to different terminal window sizes).
`positions`	Relative or absolute positions of log elements in each line. If not provided, defaults to `[.33, .55, .67, 1.]`.
`print_fn`	Print function to use. Defaults to `print`. It will be called on each line of the summary. You can set it to a custom function in order to capture the string summary.

Arguments
`filepath`	String or PathLike, path to the file to save the weights to. When saving in TensorFlow format, this is the prefix used for checkpoint files (multiple files are generated). Note that the '.h5' suffix causes weights to be saved in HDF5 format.
`overwrite`	Whether to silently overwrite any existing file at the target location, or provide the user with a manual prompt.
`save_format`	Either 'tf' or 'h5'. A `filepath` ending in '.h5' or '.keras' will default to HDF5 if `save_format` is `None`. Otherwise `None` defaults to 'tf'.
`options`	Optional `tf.train.CheckpointOptions` object that specifies options for saving weights.

Raises
`ImportError`	If h5py is not available when attempting to save in HDF5 format.
`ValueError`	For invalid/unknown format arguments.

Arguments
`x`	Input data. It could be: - A Numpy array (or array-like), or a list of arrays (in case the model has multiple inputs). - A TensorFlow tensor, or a list of tensors (in case the model has multiple inputs). A dict mapping input names to the corresponding array/tensors, if the model has named inputs.
`y`	Target data. Like the input data `x`, it could be either Numpy array(s) or TensorFlow tensor(s). It should be consistent with `x` (you cannot have Numpy inputs and tensor targets, or inversely).
`sample_weight`	Optional array of the same length as x, containing weights to apply to the model's loss for each sample. In the case of temporal data, you can pass a 2D array with shape (samples, sequence_length), to apply a different weight to every timestep of every sample.
`reset_metrics`	If `True`, the metrics returned will be only for this batch. If `False`, the metrics will be statefully accumulated across batches.
`return_dict`	If `True`, loss and metric results are returned as a dict, with each key being the name of the metric. If `False`, they are returned as a list.

Raises
`RuntimeError`	If `model.test_on_batch` is wrapped in `tf.function`.
`ValueError`	In case of invalid user-provided arguments.

Raises
`RuntimeError`	If `model.train_on_batch` is wrapped in `tf.function`.
`ValueError`	In case of invalid user-provided arguments.

tf.keras.Model

View aliases

Methods

compile

evaluate

evaluate_generator

DEPRECATED:

fit

fit_generator

DEPRECATED:

get_layer

load_weights

make_predict_function

make_test_function

make_train_function

predict

predict_generator

DEPRECATED:

predict_on_batch

predict_step

reset_metrics

Examples:

reset_states

save

The savefile includes:

Example:

save_weights

summary

test_on_batch

test_step

to_json

to_yaml

train_on_batch

train_step

`compile`

`evaluate`

`evaluate_generator`

`fit`

`fit_generator`

`get_layer`

`load_weights`

`make_predict_function`

`make_test_function`

`make_train_function`

`predict`

`predict_generator`

`predict_on_batch`

`predict_step`

`reset_metrics`

`reset_states`

`save`

`save_weights`

`summary`

`test_on_batch`

`test_step`

`to_json`

`to_yaml`

`train_on_batch`

`train_step`