TensorFlow 1 version
|
View source on GitHub
|
Model groups layers into an object with training and inference features.
tf.keras.Model(
*args, **kwargs
)
Used in the notebooks
| Used in the guide | Used in the tutorials |
|---|---|
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.
|
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. |
Methods
compile
compile(
optimizer='rmsprop', loss=None, metrics=None, loss_weights=None,
weighted_metrics=None, run_eagerly=None, steps_per_execution=None, **kwargs
)
Configures the model for training.
| 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.
|
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).
|
**kwargs
|
Arguments supported for backwards compatibility only. |
| Raises | |
|---|---|
ValueError
|
In case of invalid arguments for
optimizer, loss or metrics.
|
evaluate
evaluate(
x=None, y=None, batch_size=None, verbose=1, sample_weight=None, steps=None,
callbacks=None, max_queue_size=10, workers=1, use_multiprocessing=False,
return_dict=False
)
Returns the loss value & metrics values for the model in test mode.
Computation is done in batches (see the batch_size arg.)
| Arguments | |
|---|---|
x
|
Input data. It could be:
|
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 |