tf.keras.Model

View source on GitHub

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

Inherits From: Layer, Module

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
)

Args
`inputs`	The input(s) of the model: a `keras.Input` object or a combination of `keras.Input` objects in a dict, list or tuple.
`outputs`	The output(s) of the model: a tensor that originated from `keras.Input` objects or a combination of such tensors in a dict, list or tuple. 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)

A new Functional API model can also be created by using the intermediate tensors. This enables you to quickly extract sub-components of the model.

Example:

inputs = keras.Input(shape=(None, None, 3))
processed = keras.layers.RandomCrop(width=32, height=32)(inputs)
conv = keras.layers.Conv2D(filters=2, kernel_size=3)(processed)
pooling = keras.layers.GlobalAveragePooling2D()(conv)
feature = keras.layers.Dense(10)(pooling)

full_model = keras.Model(inputs, feature)
backbone = keras.Model(processed, conv)
activations = keras.Model(conv, feature)

Note that the backbone and activations models are not created with keras.Input objects, but with the tensors that are originated from keras.Input objects. Under the hood, the layers and weights will be shared across these models, so that user can train the full_model, and use backbone or activations to do feature extraction. The inputs and outputs of the model can be nested structures of tensors as well, and the created models are standard Functional API models that support all the existing APIs.

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().__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().__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_reduction_method`	The method employed to reduce per-replica values during training. Unless specified, the value "auto" will be assumed, indicating that the reduction strategy should be chosen based on the current running environment. See `reduce_per_replica` function for more details.
`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.

Args
`inputs`	Input tensor, or dict/list/tuple of input tensors.
`training`	Boolean or boolean scalar tensor, indicating whether to run the `Network` in training mode or inference mode.
`mask`	A mask or list of masks. A mask can be either a boolean tensor or None (no mask). For more details, check the guide here.

Args
`optimizer`	String (name of optimizer) or optimizer instance. See `tf.keras.optimizers`.
`loss`	Loss function. May be a string (name of loss function), or a `tf.keras.losses.Loss` instance. See `tf.keras.losses`. A loss function is any callable with the signature `loss = fn(y_true, y_pred)`, where `y_true` are the ground truth values, and `y_pred` are the model's predictions. `y_true` should have shape `(batch_size, d0, .. dN)` (except in the case of sparse loss functions such as sparse categorical crossentropy which expects integer arrays of shape `(batch_size, d0, .. dN-1)`). `y_pred` should have shape `(batch_size, d0, .. dN)`. The loss function should return a float tensor. If a custom `Loss` instance is used and reduction is set to `None`, return value has shape `(batch_size, d0, .. dN-1)` i.e. 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, unless `loss_weights` is specified.
`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 to specify a metric or a list of metrics for each output, 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 shapes of the targets and of the model output. We do a similar conversion for the strings 'crossentropy' and 'ce' as well. The metrics passed here are evaluated without sample weighting; if you would like sample weighting to apply, you can specify your metrics via the `weighted_metrics` argument instead.
`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`. `run_eagerly=True` is not supported when using `tf.distribute.experimental.ParameterServerStrategy`.
`steps_per_execution`	Int. Defaults to 1. 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. 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. Note that if `steps_per_execution` is set to `N`, `Callback.on_batch_begin` and `Callback.on_batch_end` methods will only be called every `N` batches (i.e. before/after each `tf.function` execution).
`jit_compile`	If `True`, compile the model training step with XLA. XLA is an optimizing compiler for machine learning. `jit_compile` is not enabled for by default. This option cannot be enabled with `run_eagerly=True`. Note that `jit_compile=True` may not necessarily work for all models. For more information on supported operations please refer to the XLA documentation. Also refer to known XLA issues for more details.
`**kwargs`	Arguments supported for backwards compatibility only.

Args
`x`	Input data.
`y`	Target data.
`y_pred`	Predictions returned by the model (output of `model(x)`)
`sample_weight`	Sample weights for weighting the loss function.

Args
`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`	`"auto"`, 0, 1, or 2. Verbosity mode. 0 = silent, 1 = progress bar, 2 = single line. `"auto"` defaults to 1 for most cases, and to 2 when used with `ParameterServerStrategy`. Note that the progress bar is not particularly useful when logged to a file, so `verbose=2` is recommended when not running interactively (e.g. in a production environment).
`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.
`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.
`**kwargs`	Unused at this time.

Returns
A `dict` containing values of the metrics listed in `self.metrics`.
`Example`	`{'loss': 0.2, 'accuracy': 0.7}`.

Args
`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`). This can also be a path to a SavedModel saved from `model.save`.
`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`.

Args
`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`	`"auto"`, 0, 1, or 2. Verbosity mode. 0 = silent, 1 = progress bar, 2 = single line. `"auto"` defaults to 1 for most cases, and to 2 when used with `ParameterServerStrategy`. Note that the progress bar is not particularly useful when logged to a file, so `verbose=2` is recommended when not running interactively (e.g. in a production environment).
`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.
`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 a `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.

Args
`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`	(only applies to SavedModel format) `tf.saved_model.SaveOptions` object that specifies options for saving to SavedModel.
`save_traces`	(only applies to SavedModel format) When enabled, the SavedModel will store the function traces for each layer. This can be disabled, so that only the configs of each layer are stored. Defaults to `True`. Disabling this will decrease serialization time and reduce file size, but it requires that all custom layers/models implement a `get_config()` method.

Args
`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.

Args
`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.
`expand_nested`	Whether to expand the nested models. If not provided, defaults to `False`.
`show_trainable`	Whether to show if a layer is trainable. If not provided, defaults to `False`.
`layer_range`	a list or tuple of 2 strings, which is the starting layer name and ending layer name (both inclusive) indicating the range of layers to be printed in summary. It also accepts regex patterns instead of exact name. In such case, start predicate will be the first element it matches to `layer_range[0]` and the end predicate will be the last element it matches to `layer_range[1]`. By default `None` which considers all layers of model.

tf.keras.Model

View aliases

Args

Example:

Attributes

Methods

call

compile

Example:

compute_loss

Example:

compute_metrics

Example:

evaluate

fit

get_layer

get_metrics_result

get_weight_paths

Example:

load_weights

make_predict_function

make_test_function

make_train_function

predict

predict_on_batch

predict_step

reset_metrics

Examples:

reset_states

save

Example:

save_spec

save_weights

summary

test_on_batch

test_step

to_json

to_yaml

train_on_batch

train_step

`call`

`compile`

`compute_loss`

`compute_metrics`

`evaluate`

`fit`

`get_layer`

`get_metrics_result`

`get_weight_paths`

`load_weights`

`make_predict_function`

`make_test_function`

`make_train_function`

`predict`

`predict_on_batch`

`predict_step`

`reset_metrics`

`reset_states`

`save`

`save_spec`

`save_weights`

`summary`

`test_on_batch`

`test_step`

`to_json`

`to_yaml`

`train_on_batch`

`train_step`