index
int64 0
731k
| package
stringlengths 2
98
⌀ | name
stringlengths 1
76
| docstring
stringlengths 0
281k
⌀ | code
stringlengths 4
1.07M
⌀ | signature
stringlengths 2
42.8k
⌀ |
|---|---|---|---|---|---|
725,037 | tf_keras.src.engine.training | reset_metrics | Resets the state of all the metrics in the model.
Examples:
>>> 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"])
>>> x = np.random.random((2, 3))
>>> y = np.random.randint(0, 2, (2, 2))
>>> _ = model.fit(x, y, verbose=0)
>>> assert all(float(m.result()) for m in model.metrics)
>>> model.reset_metrics()
>>> assert all(float(m.result()) == 0 for m in model.metrics)
| def reset_metrics(self):
"""Resets the state of all the metrics in the model.
Examples:
>>> 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"])
>>> x = np.random.random((2, 3))
>>> y = np.random.randint(0, 2, (2, 2))
>>> _ = model.fit(x, y, verbose=0)
>>> assert all(float(m.result()) for m in model.metrics)
>>> model.reset_metrics()
>>> assert all(float(m.result()) == 0 for m in model.metrics)
"""
for m in self.metrics:
m.reset_state()
| (self) |
725,038 | tf_keras.src.engine.training | reset_states | null | def reset_states(self):
for layer in self.layers:
if hasattr(layer, "reset_states") and getattr(
layer, "stateful", False
):
layer.reset_states()
| (self) |
725,039 | tf_keras.src.engine.training | save | Saves a model as a TensorFlow SavedModel or HDF5 file.
See the [Serialization and Saving guide](
https://keras.io/guides/serialization_and_saving/) for details.
Args:
model: TF-Keras model instance to be saved.
filepath: `str` or `pathlib.Path` object. Path where to save the
model.
overwrite: Whether we should overwrite any existing model at the
target location, or instead ask the user via an interactive
prompt.
save_format: Either `"keras"`, `"tf"`, `"h5"`,
indicating whether to save the model
in the native TF-Keras format (`.keras`),
in the TensorFlow SavedModel format
(referred to as "SavedModel" below),
or in the legacy HDF5 format (`.h5`).
Defaults to `"tf"` in TF 2.X, and `"h5"` in TF 1.X.
SavedModel format arguments:
include_optimizer: Only applied to SavedModel and legacy HDF5
formats. If False, do not save the optimizer state.
Defaults to `True`.
signatures: Only applies to SavedModel format. Signatures to save
with the SavedModel. See the `signatures` argument in
`tf.saved_model.save` for details.
options: Only applies to SavedModel format.
`tf.saved_model.SaveOptions` object that specifies SavedModel
saving options.
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.
Example:
```python
model = tf.keras.Sequential([
tf.keras.layers.Dense(5, input_shape=(3,)),
tf.keras.layers.Softmax()])
model.save("model.keras")
loaded_model = tf.keras.models.load_model("model.keras")
x = tf.random.uniform((10, 3))
assert np.allclose(model.predict(x), loaded_model.predict(x))
```
Note that `model.save()` is an alias for `tf.keras.models.save_model()`.
| # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Training-related part of the TF-Keras engine."""
import copy
import itertools
import json
import warnings
import weakref
import numpy as np
import tensorflow.compat.v2 as tf
from tensorflow.python.distribute import distribute_utils
from tensorflow.python.distribute import input_ops
from tensorflow.python.eager import context
from tensorflow.python.platform import tf_logging as logging
from tensorflow.python.util.tf_export import keras_export
from tensorflow.tools.docs import doc_controls
from tf_keras.src import backend
from tf_keras.src import callbacks as callbacks_module
from tf_keras.src import optimizers
from tf_keras.src.dtensor import dtensor_api
from tf_keras.src.dtensor import layout_map as layout_map_lib
from tf_keras.src.engine import base_layer
from tf_keras.src.engine import base_layer_utils
from tf_keras.src.engine import compile_utils
from tf_keras.src.engine import data_adapter
from tf_keras.src.engine import input_layer as input_layer_module
from tf_keras.src.engine import training_utils
from tf_keras.src.metrics import base_metric
from tf_keras.src.mixed_precision import loss_scale_optimizer as lso
from tf_keras.src.optimizers import optimizer
from tf_keras.src.optimizers import optimizer_v1
from tf_keras.src.saving import pickle_utils
from tf_keras.src.saving import saving_api
from tf_keras.src.saving import saving_lib
from tf_keras.src.saving import serialization_lib
from tf_keras.src.saving.legacy import serialization
from tf_keras.src.saving.legacy.saved_model import json_utils
from tf_keras.src.saving.legacy.saved_model import model_serialization
from tf_keras.src.utils import generic_utils
from tf_keras.src.utils import io_utils
from tf_keras.src.utils import layer_utils
from tf_keras.src.utils import steps_per_execution_tuning
from tf_keras.src.utils import tf_inspect
from tf_keras.src.utils import tf_utils
from tf_keras.src.utils import traceback_utils
from tf_keras.src.utils import version_utils
from tf_keras.src.utils.mode_keys import ModeKeys
try:
import h5py
except ImportError:
h5py = None
@keras_export("keras.Model", "keras.models.Model")
class Model(base_layer.Layer, version_utils.ModelVersionSelector):
"""A model grouping layers into an object with training/inference features.
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:
```python
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)
```
Note: Only dicts, lists, and tuples of input tensors are supported. Nested
inputs are not supported (e.g. lists of list or dicts of dict).
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:
```python
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()`.
```python
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:
```python
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()`.
"""
_TF_MODULE_IGNORED_PROPERTIES = frozenset(
itertools.chain(
(
"_train_counter",
"_test_counter",
"_predict_counter",
"_steps_per_execution",
"_compiled_trainable_state",
),
base_layer.Layer._TF_MODULE_IGNORED_PROPERTIES,
)
)
_SCALAR_UPRANKING_ON = False
def __new__(cls, *args, **kwargs):
# Signature detection
if is_functional_model_init_params(args, kwargs) and cls == Model:
# Functional model
from tf_keras.src.engine import functional
return functional.Functional(skip_init=True, *args, **kwargs)
else:
return super(Model, cls).__new__(cls, *args, **kwargs)
@tf.__internal__.tracking.no_automatic_dependency_tracking
@traceback_utils.filter_traceback
def __init__(self, *args, **kwargs):
self._is_model_for_instrumentation = True
# Special case for Subclassed Functional Model, which we couldn't detect
# when __new__ is called. We only realize it is a functional model when
# it calls super.__init__ with input and output tensor.
from tf_keras.src.engine import functional
if is_functional_model_init_params(args, kwargs) and not isinstance(
self, functional.Functional
):
# Filter the kwargs for multiple inheritance.
supported_kwargs = [
"inputs",
"outputs",
"name",
"trainable",
"skip_init",
]
model_kwargs = {
k: kwargs[k] for k in kwargs if k in supported_kwargs
}
other_kwargs = {
k: kwargs[k] for k in kwargs if k not in supported_kwargs
}
inject_functional_model_class(self.__class__)
functional.Functional.__init__(self, *args, **model_kwargs)
# In case there is any multiple inheritance here, we need to call
# the __init__ for any class that appears after the Functional
# class.
clz_to_init = []
found_functional_class = False
for clz in self.__class__.__bases__:
if issubclass(clz, functional.Functional):
found_functional_class = True
continue
if found_functional_class:
clz_to_init.append(clz)
if clz_to_init:
for clz in clz_to_init:
clz.__init__(self, *args, **other_kwargs)
elif other_kwargs:
# In case there are unused kwargs, we should raise an error to
# user, in case they have a typo in the param name.
raise TypeError(
"The following keyword arguments passed to `Model` aren't "
"supported: {}.".format(other_kwargs)
)
return
# The following are implemented as property functions:
# self.trainable_weights
# self.non_trainable_weights
# `inputs` / `outputs` will only appear in kwargs if either are
# misspelled.
generic_utils.validate_kwargs(
kwargs,
{
"trainable",
"dtype",
"dynamic",
"name",
"autocast",
"inputs",
"outputs",
},
)
super().__init__(**kwargs)
# By default, Model is a subclass model, which is not in graph network.
self._is_graph_network = False
self.inputs = None
self.outputs = None
self.input_names = None
self.output_names = None
# stop_training is used by callback to stop training when error happens
self.stop_training = False
self.history = None
# These objects are used in the default `Model.compile`. They are not
# guaranteed to be set after `Model.compile` is called, as users can
# override compile with custom logic.
self.compiled_loss = None
self.compiled_metrics = None
# This is True for Sequential networks and Functional networks.
self._compute_output_and_mask_jointly = False
# Don't reset compilation if already done. This may occur if calling
# `__init__` (or `_init_graph_network`) on an already-compiled model
# such as a Sequential model. Sequential models may need to rebuild
# themselves after compilation.
self._maybe_create_attribute("_is_compiled", False)
self._maybe_create_attribute("optimizer", None)
# Model must be created under scope of DistStrat it will be trained
# with.
if tf.distribute.has_strategy():
self._distribution_strategy = tf.distribute.get_strategy()
else:
self._distribution_strategy = None
self._distribute_reduction_method = None
self._cluster_coordinator = None
# Defaults to value of `tf.config.experimental_functions_run_eagerly`.
self._run_eagerly = None
# Initialize cache attrs.
self._reset_compile_cache()
# Fault-tolerance handler. Set in `ModelCheckpoint`.
self._training_state = None
self._saved_model_inputs_spec = None
self._saved_model_arg_spec = None
self._checkpoint = tf.train.Checkpoint(root=weakref.ref(self))
self._steps_per_execution = None
self._steps_per_execution_tuner = None
self._autotune_steps_per_execution = False
self._layout_map = layout_map_lib.get_current_layout_map()
self._init_batch_counters()
self._base_model_initialized = True
# `jit_compile` starts off with None as default and gets overwritten by
# the value specified in `Model.compile`, and this is effective for
# `fit`, `evaluate`, and `predict`.
self._jit_compile = None
def _create_counter_variable(self, init_value):
"""Helper function for counter variable creation.
For the DTensor use case with layout map, since the variable are not
tracked by model, they can't be visited by the layout map, and need to
be properly initialized as DVariable.
"""
# This function should be removed after we move to the strategy based
# implementation for DTensor.
if self._layout_map is None:
agg = tf.VariableAggregation.ONLY_FIRST_REPLICA
return tf.Variable(init_value, dtype="int64", aggregation=agg)
else:
layout = dtensor_api.Layout.replicated(
mesh=self._layout_map.get_default_mesh(), rank=0
)
return dtensor_api.DVariable(
init_value, dtype="int64", layout=layout
)
@tf.__internal__.tracking.no_automatic_dependency_tracking
def _init_batch_counters(self):
# Untracked Variables, used to keep track of mini-batches seen in `fit`,
# `evaluate`, and `predict`.
if not tf.inside_function():
# Creating variables inside tf.function is not allowed, hence
# these would otherwise prevent users from creating TF-Keras layers
# inside tf.function.
# These variables are not connected to outputs so they have no
# effect on graph generation anyway.
self._train_counter = self._create_counter_variable(0)
self._test_counter = self._create_counter_variable(0)
self._predict_counter = self._create_counter_variable(0)
def __setattr__(self, name, value):
if not getattr(self, "_self_setattr_tracking", True):
super().__setattr__(name, value)
return
if all(
isinstance(v, (base_layer.Layer, tf.Variable))
or base_layer_utils.has_weights(v)
for v in tf.nest.flatten(value)
):
try:
self._base_model_initialized
except AttributeError:
raise RuntimeError(
"It looks like you are subclassing `Model` and you "
"forgot to call `super().__init__()`."
" Always start with this line."
)
super().__setattr__(name, value)
def __reduce__(self):
if self.built:
return (
pickle_utils.deserialize_model_from_bytecode,
(pickle_utils.serialize_model_as_bytecode(self),),
)
else:
# SavedModel (and hence serialize_model_as_bytecode) only support
# built models, but if the model is not built,
# it may be possible to serialize as a plain Python object,
# as long as the constituent parts (layers, optimizers, losses,
# etc.) can be serialized as plain Python objects. Thus we call up
# the superclass hierarchy to get an implementation of __reduce__
# that can pickle this Model as a plain Python object.
return super().__reduce__()
def __deepcopy__(self, memo):
if self.built:
new = pickle_utils.deserialize_model_from_bytecode(
pickle_utils.serialize_model_as_bytecode(self)
)
memo[id(self)] = new
else:
# See comment in __reduce__ for explanation
deserializer, serialized, *rest = super().__reduce__()
new = deserializer(*serialized)
memo[id(self)] = new
if rest:
state = copy.deepcopy(rest[0], memo=memo)
new.__setstate__(state)
return new
def __copy__(self):
return self.__deepcopy__({})
@generic_utils.default
def build(self, input_shape):
"""Builds the model based on input shapes received.
This is to be used for subclassed models, which do not know at
instantiation time what their inputs look like.
This method only exists for users who want to call `model.build()` in a
standalone way (as a substitute for calling the model on real data to
build it). It will never be called by the framework (and thus it will
never throw unexpected errors in an unrelated workflow).
Args:
input_shape: Single tuple, `TensorShape` instance, or list/dict of
shapes, where shapes are tuples, integers, or `TensorShape`
instances.
Raises:
ValueError:
1. In case of invalid user-provided data (not of type tuple,
list, `TensorShape`, or dict).
2. If the model requires call arguments that are agnostic
to the input shapes (positional or keyword arg in call
signature).
3. If not all layers were properly built.
4. If float type inputs are not supported within the layers.
In each of these cases, the user should build their model by calling
it on real tensor data.
"""
if self._is_graph_network:
super().build(input_shape)
return
if input_shape is None:
raise ValueError(
"Input shape must be defined when calling `build()` on "
"a `Model` subclass."
)
valid_types = (tuple, list, tf.TensorShape, dict)
if not isinstance(input_shape, valid_types):
raise ValueError(
"Specified input shape is not one of the valid types. "
"Please specify a batch input shape of type tuple or "
"list of input shapes. User provided "
"input type: {}.".format(type(input_shape))
)
if input_shape and not self.inputs:
# We create placeholders for the `None`s in the shape and build the
# model in a Graph. Since tf.Variable is compatible with both eager
# execution and graph building, the variables created after building
# the model in a Graph are still valid when executing eagerly.
if tf.executing_eagerly():
graph = tf.__internal__.FuncGraph("build_graph")
else:
graph = backend.get_graph()
with graph.as_default():
if isinstance(input_shape, list) and all(
d is None or isinstance(d, int) for d in input_shape
):
input_shape = tuple(input_shape)
if isinstance(input_shape, list):
x = [
base_layer_utils.generate_placeholders_from_shape(shape)
for shape in input_shape
]
elif isinstance(input_shape, dict):
x = {
k: base_layer_utils.generate_placeholders_from_shape(
shape
)
for k, shape in input_shape.items()
}
else:
x = base_layer_utils.generate_placeholders_from_shape(
input_shape
)
kwargs = {}
call_signature = self._call_spec.full_argspec
call_args = call_signature.args
# Exclude `self`, `inputs`, and any argument with a default
# value.
if len(call_args) > 2:
if call_signature.defaults:
call_args = call_args[2 : -len(call_signature.defaults)]
else:
call_args = call_args[2:]
for arg in call_args:
if arg == "training":
# Case where `training` is a positional arg with no
# default.
kwargs["training"] = False
else:
# Has invalid call signature with unknown positional
# arguments.
raise ValueError(
"Currently, you cannot build your model if it "
"has positional or keyword arguments that are "
"not inputs to the model, but are required for "
"its `call()` method. Instead, in order to "
"instantiate and build your model, `call()` "
"your model on real tensor data with all "
"expected call arguments. The argument "
"for `call()` can be a single list/tuple that "
"contains multiple inputs."
)
elif len(call_args) < 2:
# Signature without `inputs`.
raise ValueError(
"You can only call `build()` on a model if its "
"`call()` method accepts an `inputs` argument."
)
try:
self.call(x, **kwargs)
except (tf.errors.InvalidArgumentError, TypeError) as e:
raise ValueError(
"You cannot build your model by calling `build` "
"if your layers do not support float type inputs. "
"Instead, in order to instantiate and build your "
"model, call your model on real tensor data (of "
"the correct dtype).\n\nThe actual error from "
f"`call` is: {e}."
)
super().build(input_shape)
@traceback_utils.filter_traceback
def __call__(self, *args, **kwargs):
if self._layout_map is not None and not self.built:
# Note that this method is only overridden for DTensor and layout
# injection purpose.
# Capture the inputs and create graph input as replacement for model
# to initialize its weights first.
copied_args = copy.copy(args)
copied_kwargs = copy.copy(kwargs)
(
inputs,
copied_args,
copied_kwargs,
) = self._call_spec.split_out_first_arg(copied_args, copied_kwargs)
def _convert_to_graph_inputs(x):
if isinstance(x, (tf.Tensor, np.ndarray, float, int)):
x = tf.convert_to_tensor(x)
return input_layer_module.Input(x.shape)
# TODO(scottzhu): maybe better handle mask and training flag.
inputs = tf.nest.map_structure(_convert_to_graph_inputs, inputs)
copied_args = tf.nest.map_structure(
_convert_to_graph_inputs, copied_args
)
copied_kwargs = tf.nest.map_structure(
_convert_to_graph_inputs, copied_kwargs
)
with layout_map_lib.layout_map_scope(self._layout_map):
# We ignore the result here.
super().__call__(inputs, *copied_args, **copied_kwargs)
layout_map_lib._map_subclass_model_variable(self, self._layout_map)
return super().__call__(*args, **kwargs)
@doc_controls.doc_in_current_and_subclasses
def call(self, inputs, training=None, mask=None):
"""Calls the model on new inputs and returns the outputs as tensors.
In this case `call()` just reapplies
all ops in the graph to the new inputs
(e.g. build a new computational graph from the provided inputs).
Note: This method should not be called directly. It is only meant to be
overridden when subclassing `tf.keras.Model`.
To call a model on an input, always use the `__call__()` method,
i.e. `model(inputs)`, which relies on the underlying `call()` method.
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](https://www.tensorflow.org/guide/keras/masking_and_padding).
Returns:
A tensor if there is a single output, or
a list of tensors if there are more than one outputs.
"""
raise NotImplementedError(
"Unimplemented `tf.keras.Model.call()`: if you "
"intend to create a `Model` with the Functional "
"API, please provide `inputs` and `outputs` "
"arguments. Otherwise, subclass `Model` with an "
"overridden `call()` method."
)
@traceback_utils.filter_traceback
def compile(
self,
optimizer="rmsprop",
loss=None,
metrics=None,
loss_weights=None,
weighted_metrics=None,
run_eagerly=None,
steps_per_execution=None,
jit_compile=None,
pss_evaluation_shards=0,
**kwargs,
):
"""Configures the model for training.
Example:
```python
model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=1e-3),
loss=tf.keras.losses.BinaryCrossentropy(),
metrics=[tf.keras.metrics.BinaryAccuracy(),
tf.keras.metrics.FalseNegatives()])
```
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. 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`. Defaults to
`False`.
steps_per_execution: Int or `'auto'`. The number of batches to
run during each `tf.function` call. If set to "auto", keras will
automatically tune `steps_per_execution` during runtime. Running
multiple batches inside a single `tf.function` call can greatly
improve performance on TPUs, when used with distributed strategies
such as `ParameterServerStrategy`, or with 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). Defaults to `1`.
jit_compile: If `True`, compile the model training step with XLA.
[XLA](https://www.tensorflow.org/xla) is an optimizing compiler
for machine learning.
`jit_compile` is not enabled for by default.
Note that `jit_compile=True`
may not necessarily work for all models.
For more information on supported operations please refer to the
[XLA documentation](https://www.tensorflow.org/xla).
Also refer to
[known XLA issues](https://www.tensorflow.org/xla/known_issues)
for more details.
pss_evaluation_shards: Integer or 'auto'. Used for
`tf.distribute.ParameterServerStrategy` training only. This arg
sets the number of shards to split the dataset into, to enable an
exact visitation guarantee for evaluation, meaning the model will
be applied to each dataset element exactly once, even if workers
fail. The dataset must be sharded to ensure separate workers do
not process the same data. The number of shards should be at least
the number of workers for good performance. A value of 'auto'
turns on exact evaluation and uses a heuristic for the number of
shards based on the number of workers. 0, meaning no
visitation guarantee is provided. NOTE: Custom implementations of
`Model.test_step` will be ignored when doing exact evaluation.
Defaults to `0`.
**kwargs: Arguments supported for backwards compatibility only.
"""
if jit_compile and not tf_utils.can_jit_compile(warn=True):
jit_compile = False
self._compile_config = serialization_lib.Config(
optimizer=optimizer,
loss=loss,
metrics=metrics,
loss_weights=loss_weights,
weighted_metrics=weighted_metrics,
run_eagerly=run_eagerly,
steps_per_execution=steps_per_execution,
jit_compile=jit_compile,
)
with self.distribute_strategy.scope():
if "experimental_steps_per_execution" in kwargs:
logging.warning(
"The argument `steps_per_execution` is no longer "
"experimental. Pass `steps_per_execution` instead of "
"`experimental_steps_per_execution`."
)
if not steps_per_execution:
steps_per_execution = kwargs.pop(
"experimental_steps_per_execution"
)
# When compiling from an already-serialized model, we do not want to
# reapply some processing steps (e.g. metric renaming for
# multi-output models, which have prefixes added for each
# corresponding output name).
from_serialized = kwargs.pop("from_serialized", False)
self._validate_compile(optimizer, metrics, **kwargs)
self._run_eagerly = run_eagerly
self.optimizer = self._get_optimizer(optimizer)
mesh = None
if self._layout_map is not None:
mesh = self._layout_map.get_default_mesh()
if isinstance(loss, compile_utils.LossesContainer):
self.compiled_loss = loss
else:
self.compiled_loss = compile_utils.LossesContainer(
loss,
loss_weights,
output_names=self.output_names,
mesh=mesh,
)
self.compiled_metrics = compile_utils.MetricsContainer(
metrics,
weighted_metrics,
output_names=self.output_names,
from_serialized=from_serialized,
mesh=mesh,
)
if steps_per_execution == "auto":
if self._steps_per_execution is None:
self._configure_steps_per_execution(1)
self._steps_per_execution_tuner = (
steps_per_execution_tuning.StepsPerExecutionTuner(
self.optimizer, self._steps_per_execution
)
)
self._autotune_steps_per_execution = True
else:
self._configure_steps_per_execution(steps_per_execution or 1)
self._pss_evaluation_shards = self._infer_exact_eval_shards(
pss_evaluation_shards
)
# Initializes attrs that are reset each time `compile` is called.
self._reset_compile_cache()
self._is_compiled = True
self.loss = loss or {}
if (self._run_eagerly or self.dynamic) and jit_compile:
raise ValueError(
"You cannot enable `run_eagerly` and `jit_compile` "
"at the same time."
)
else:
self._jit_compile = jit_compile
def _get_optimizer(self, optimizer):
"""Wraps `optimizer` in `LossScaleOptimizer` if necessary."""
def _get_single_optimizer(opt):
opt = optimizers.get(opt)
if self.dtype_policy.name == "mixed_float16" and not isinstance(
opt, lso.BaseLossScaleOptimizer
):
# Loss scaling is necessary with mixed_float16 for models to
# converge to the same accuracy as with float32.
opt = lso.BaseLossScaleOptimizer(opt)
return opt
return tf.nest.map_structure(_get_single_optimizer, optimizer)
@tf.__internal__.tracking.no_automatic_dependency_tracking
def _reset_compile_cache(self):
self.train_function = None
self.test_function = None
self.predict_function = None
# Used to cache the `tf.function`'ed `train_function` to be logged in
# TensorBoard, since the original `train_function` is not necessarily
# a `tf.function` (e.g., with ParameterServerStrategy, the
# `train_function` is a scheduling of the actual training function to a
# remote worker).
self.train_tf_function = None
# Used to cache `trainable` attr of `Layer`s for `fit`.
self._compiled_trainable_state = self._get_trainable_state()
@tf.__internal__.tracking.no_automatic_dependency_tracking
def _configure_steps_per_execution(self, steps_per_execution):
self._steps_per_execution = self._create_counter_variable(
steps_per_execution
)
@property
def _should_compute_mask(self):
return False
@property
def metrics(self):
"""Return metrics added using `compile()` or `add_metric()`.
Note: Metrics passed to `compile()` are available only after a
`keras.Model` has been trained/evaluated on actual data.
Examples:
>>> 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"])
>>> [m.name for m in model.metrics]
[]
>>> x = np.random.random((2, 3))
>>> y = np.random.randint(0, 2, (2, 2))
>>> model.fit(x, y)
>>> [m.name for m in model.metrics]
['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.add_metric(
... tf.reduce_sum(output_2), name='mean', aggregation='mean')
>>> model.compile(optimizer="Adam", loss="mse", metrics=["mae", "acc"])
>>> model.fit(x, (y, y))
>>> [m.name for m in model.metrics]
['loss', 'out_loss', 'out_1_loss', 'out_mae', 'out_acc', 'out_1_mae',
'out_1_acc', 'mean']
"""
metrics = []
if self._is_compiled:
if self.compiled_loss is not None:
metrics += self.compiled_loss.metrics
if self.compiled_metrics is not None:
metrics += self.compiled_metrics.metrics
for l in self._flatten_layers():
metrics.extend(l._metrics)
return metrics
@property
def metrics_names(self):
"""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.
Examples:
>>> 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']
"""
# This property includes all output names including `loss` and
# per-output losses for backward compatibility.
return [m.name for m in self.metrics]
@property
def distribute_strategy(self):
"""The `tf.distribute.Strategy` this model was created under."""
return self._distribution_strategy or tf.distribute.get_strategy()
@property
def run_eagerly(self):
"""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.
Returns:
Boolean, whether the model should run eagerly.
"""
if self.dynamic and self._run_eagerly == False:
# TODO(fchollet): consider using py_func to enable this.
raise ValueError(
"Your model contains layers that can only be "
"successfully run in eager execution (layers "
"constructed with `dynamic=True`). "
"You cannot set `run_eagerly=False`."
)
if self._cluster_coordinator and self._run_eagerly:
raise ValueError(
"When using `Model` with `ParameterServerStrategy`, "
"`run_eagerly` is not supported."
)
# Run eagerly logic, by priority:
# (1) Dynamic models must be run eagerly.
# (2) Explicitly setting run_eagerly causes a Model to be run eagerly.
# (3) Not explicitly setting run_eagerly defaults to TF's global
# setting.
return (
self.dynamic
or self._run_eagerly
or (tf.config.functions_run_eagerly() and self._run_eagerly is None)
)
@run_eagerly.setter
def run_eagerly(self, value):
self._run_eagerly = value
@property
def autotune_steps_per_execution(self):
"""Settable property to enable tuning for steps_per_execution"""
return self._autotune_steps_per_execution
@autotune_steps_per_execution.setter
def autotune_steps_per_execution(self, value):
self._autotune_steps_per_execution = value
if value and self._steps_per_execution_tuner is None:
if self._steps_per_execution is None:
self._configure_steps_per_execution(1)
self._steps_per_execution_tuner = (
steps_per_execution_tuning.StepsPerExecutionTuner(
self.optimizer, self._steps_per_execution
)
)
@property
def steps_per_execution(self):
"""Settable `steps_per_execution variable. Requires a compiled model."""
return self._steps_per_execution
@steps_per_execution.setter
def steps_per_execution(self, value):
if self._steps_per_execution is None:
self._configure_steps_per_execution(value)
else:
self._steps_per_execution.assign(value)
@property
def jit_compile(self):
"""Specify whether to compile the model with XLA.
[XLA](https://www.tensorflow.org/xla) is an optimizing compiler
for machine learning. `jit_compile` is not enabled by default.
Note that `jit_compile=True` may not necessarily work for all models.
For more information on supported operations please refer to the
[XLA documentation](https://www.tensorflow.org/xla). Also refer to
[known XLA issues](https://www.tensorflow.org/xla/known_issues)
for more details.
"""
return self._jit_compile
@jit_compile.setter
def jit_compile(self, value):
# Function remains cached with previous jit_compile settings
if self._jit_compile == value:
# Avoid resetting compiler cache if possible if the value is the
# same
return
# Check if TensorFlow is compiled with XLA before setting the value
if value and not tf_utils.can_jit_compile(warn=True):
self._jit_compile = False
return
self._jit_compile = value
# Setting `jit_compile` should invalidate previously cached functions.
self._reset_compile_cache()
@property
def distribute_reduction_method(self):
"""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.
"""
return self._distribute_reduction_method or "auto"
@distribute_reduction_method.setter
def distribute_reduction_method(self, value):
self._distribute_reduction_method = value
def _validate_target_and_loss(self, y, loss):
"""Raises error if target or loss is not found.
This method verifies that the target and loss are properly populated
when applicable, or raises errors.
Args:
y: the target for training.
loss: the total loss tensor including loss added via `compile` and
`add_loss`.
"""
# `self.loss` references the loss added via `compile` call. If users
# have provided such, the target must be provided; otherwise it's a user
# error. Note that `self.loss` does not include losses added via
# `add_loss`, and it is a valid use when such loss from `add_loss`
# exists and target does not.
if self.loss and y is None:
raise ValueError(
"Target data is missing. Your model was compiled with "
f"loss={self.loss}, "
"and therefore expects target data to be provided in `fit()`."
)
# For training, there must be compiled loss or regularization loss to
# exist in order to apply the gradients. If one is not found, it means
# no loss was supplied via `compile` or `add_loss`.
elif loss is None:
raise ValueError(
"No loss found. You may have forgotten to provide a `loss` "
"argument in the `compile()` method."
)
def train_step(self, data):
"""The logic for one training step.
This method can be overridden to support custom training logic.
For concrete examples of how to override this method see
[Customizing what happens in fit](
https://www.tensorflow.org/guide/keras/customizing_what_happens_in_fit).
This method is called by `Model.make_train_function`.
This method should contain the mathematical logic for one step of
training. This typically includes the forward pass, loss calculation,
backpropagation, and metric updates.
Configuration details for *how* this logic is run (e.g. `tf.function`
and `tf.distribute.Strategy` settings), should be left to
`Model.make_train_function`, which can also be overridden.
Args:
data: A nested structure of `Tensor`s.
Returns:
A `dict` containing values that will be passed to
`tf.keras.callbacks.CallbackList.on_train_batch_end`. Typically, the
values of the `Model`'s metrics are returned. Example:
`{'loss': 0.2, 'accuracy': 0.7}`.
"""
x, y, sample_weight = data_adapter.unpack_x_y_sample_weight(data)
# Run forward pass.
with tf.GradientTape() as tape:
y_pred = self(x, training=True)
loss = self.compute_loss(x, y, y_pred, sample_weight)
self._validate_target_and_loss(y, loss)
# Run backwards pass.
self.optimizer.minimize(loss, self.trainable_variables, tape=tape)
return self.compute_metrics(x, y, y_pred, sample_weight)
def compute_loss(self, x=None, y=None, y_pred=None, sample_weight=None):
"""Compute the total loss, validate it, and return it.
Subclasses can optionally override this method to provide custom loss
computation logic.
Example:
```python
class MyModel(tf.keras.Model):
def __init__(self, *args, **kwargs):
super(MyModel, self).__init__(*args, **kwargs)
self.loss_tracker = tf.keras.metrics.Mean(name='loss')
def compute_loss(self, x, y, y_pred, sample_weight):
loss = tf.reduce_mean(tf.math.squared_difference(y_pred, y))
loss += tf.add_n(self.losses)
self.loss_tracker.update_state(loss)
return loss
def reset_metrics(self):
self.loss_tracker.reset_states()
@property
def metrics(self):
return [self.loss_tracker]
tensors = tf.random.uniform((10, 10)), tf.random.uniform((10,))
dataset = tf.data.Dataset.from_tensor_slices(tensors).repeat().batch(1)
inputs = tf.keras.layers.Input(shape=(10,), name='my_input')
outputs = tf.keras.layers.Dense(10)(inputs)
model = MyModel(inputs, outputs)
model.add_loss(tf.reduce_sum(outputs))
optimizer = tf.keras.optimizers.SGD()
model.compile(optimizer, loss='mse', steps_per_execution=10)
model.fit(dataset, epochs=2, steps_per_epoch=10)
print('My custom loss: ', model.loss_tracker.result().numpy())
```
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.
Returns:
The total loss as a `tf.Tensor`, or `None` if no loss results (which
is the case when called by `Model.test_step`).
"""
del x # The default implementation does not use `x`.
return self.compiled_loss(
y, y_pred, sample_weight, regularization_losses=self.losses
)
def compute_metrics(self, x, y, y_pred, sample_weight):
"""Update metric states and collect all metrics to be returned.
Subclasses can optionally override this method to provide custom metric
updating and collection logic.
Example:
```python
class MyModel(tf.keras.Sequential):
def compute_metrics(self, x, y, y_pred, sample_weight):
# This super call updates `self.compiled_metrics` and returns
# results for all metrics listed in `self.metrics`.
metric_results = super(MyModel, self).compute_metrics(
x, y, y_pred, sample_weight)
# Note that `self.custom_metric` is not listed in `self.metrics`.
self.custom_metric.update_state(x, y, y_pred, sample_weight)
metric_results['custom_metric_name'] = self.custom_metric.result()
return metric_results
```
Args:
x: Input data.
y: Target data.
y_pred: Predictions returned by the model (output of `model.call(x)`)
sample_weight: Sample weights for weighting the loss function.
Returns:
A `dict` containing values that will be passed to
`tf.keras.callbacks.CallbackList.on_train_batch_end()`. Typically, the
values of the metrics listed in `self.metrics` are returned. Example:
`{'loss': 0.2, 'accuracy': 0.7}`.
"""
del x # The default implementation does not use `x`.
self.compiled_metrics.update_state(y, y_pred, sample_weight)
return self.get_metrics_result()
def get_metrics_result(self):
"""Returns the model's metrics values as a dict.
If any of the metric result is a dict (containing multiple metrics),
each of them gets added to the top level returned dict of this method.
Returns:
A `dict` containing values of the metrics listed in `self.metrics`.
Example:
`{'loss': 0.2, 'accuracy': 0.7}`.
"""
# Collect metrics to return
return_metrics = {}
for metric in self.metrics:
result = metric.result()
if isinstance(result, dict):
return_metrics.update(result)
else:
return_metrics[metric.name] = result
return return_metrics
def _validate_and_get_metrics_result(self, logs):
"""Returns model metrics as a dict if the keys match with input logs.
When the training / evalution is performed with asynchronous steps, such
as the case with `tf.distribute.ParameterServerStrategy`, the last
scheduled `train / test_step` may not give the latest metrics because it
is not guaranteed to be executed the last. This method gets metrics from
the model directly instead of relying on the return from last step
function.
It logs a warning if the metric results could not be overridden when
used with `tf.distribute.ParameterServerStrategy`.
When the user has custom train / test step functions, the metrics
returned may be different from `Model.metrics`. In those instances,
this function will be no-op and return the logs.
Args:
logs: A `dict` of metrics returned by train / test step function.
Returns:
A `dict` containing values of the metrics listed in `self.metrics`
when logs and model metrics keys match. Otherwise it returns input
`logs`.
"""
PSS_WARN_MSG = "Could not get Model metric results. \
Using the results of last step function could lead to incorrect \
results when used with ParameterServerStrategy"
try:
metric_logs = self.get_metrics_result()
except TypeError:
if self._cluster_coordinator:
logging.warning(PSS_WARN_MSG)
else:
# Verify that train / test step logs passed and metric logs have
# matching keys. Could be different when using custom step functions
if isinstance(logs, dict) and set(logs.keys()) == set(
metric_logs.keys()
):
logs = tf_utils.sync_to_numpy_or_python_type(metric_logs)
elif self._cluster_coordinator:
logging.warning(PSS_WARN_MSG)
return logs
def _aggregate_exact_metrics(self, logs):
# When doing exact evaluation, `logs` is a list of each data shard's
# metric variables, which will be used to update the metrics.
for shard_result in logs:
for metric in self.metrics:
if metric.name not in shard_result.keys():
logging.log_first_n(
logging.WARN,
f"No matching result found for metric {metric.name}. "
"This metric's computed result may be incorrect.",
3,
)
continue
metric_result = shard_result[metric.name]
if len(metric_result) != len(metric.weights):
raise ValueError(
f"Expected {len(metric.weights)} variables in result "
f"for metric {metric.name}, but found "
f"{len(metric_result)}."
)
for weight, val in zip(metric.weights, metric_result):
weight.assign_add(val)
return self.get_metrics_result()
def make_train_function(self, force=False):
"""Creates a function that executes one step of training.
This method can be overridden to support custom training logic.
This method is called by `Model.fit` and `Model.train_on_batch`.
Typically, this method directly controls `tf.function` and
`tf.distribute.Strategy` settings, and delegates the actual training
logic to `Model.train_step`.
This function is cached the first time `Model.fit` or
`Model.train_on_batch` is called. The cache is cleared whenever
`Model.compile` is called. You can skip the cache and generate again the
function with `force=True`.
Args:
force: Whether to regenerate the train function and skip the cached
function if available.
Returns:
Function. The function created by this method should accept a
`tf.data.Iterator`, and return a `dict` containing values that will
be passed to `tf.keras.Callbacks.on_train_batch_end`, such as
`{'loss': 0.2, 'accuracy': 0.7}`.
"""
if self.train_function is not None and not force:
return self.train_function
def step_function(model, iterator):
"""Runs a single training step."""
def run_step(data):
outputs = model.train_step(data)
# Ensure counter is updated only if `train_step` succeeds.
with tf.control_dependencies(_minimum_control_deps(outputs)):
model._train_counter.assign_add(1)
return outputs
if self.jit_compile:
run_step = tf.function(
run_step, jit_compile=True, reduce_retracing=True
)
data = next(iterator)
outputs = model.distribute_strategy.run(run_step, args=(data,))
outputs = reduce_per_replica(
outputs,
self.distribute_strategy,
reduction=self.distribute_reduction_method,
)
return outputs
# Special case if steps_per_execution is one.
if (
self._steps_per_execution is None
or self._steps_per_execution.numpy().item() == 1
and not self.autotune_steps_per_execution
):
def train_function(iterator):
"""Runs a training execution with a single step."""
return step_function(self, iterator)
if not self.run_eagerly:
train_function = tf.function(
train_function, reduce_retracing=True
)
self.train_tf_function = train_function
if self._cluster_coordinator:
self.train_function = (
lambda it: self._cluster_coordinator.schedule(
train_function, args=(it,)
)
)
else:
self.train_function = train_function
# If we're using a coordinator, use the value of
# self._steps_per_execution at the time the function is
# called/scheduled, and not when it is actually executed.
elif self._cluster_coordinator:
def train_function(iterator, steps_per_execution):
"""Runs a training execution with multiple steps."""
for _ in tf.range(steps_per_execution):
outputs = step_function(self, iterator)
return outputs
if not self.run_eagerly:
train_function = tf.function(
train_function, reduce_retracing=True
)
self.train_tf_function = train_function
self.train_function = lambda it: self._cluster_coordinator.schedule(
train_function, args=(it, self._steps_per_execution.value())
)
else:
def train_function(iterator):
"""Runs a training execution with multiple steps."""
for _ in tf.range(self._steps_per_execution):
outputs = step_function(self, iterator)
return outputs
if not self.run_eagerly:
train_function = tf.function(
train_function, reduce_retracing=True
)
self.train_tf_function = train_function
self.train_function = train_function
return self.train_function
@traceback_utils.filter_traceback
def fit(
self,
x=None,
y=None,
batch_size=None,
epochs=1,
verbose="auto",
callbacks=None,
validation_split=0.0,
validation_data=None,
shuffle=True,
class_weight=None,
sample_weight=None,
initial_epoch=0,
steps_per_epoch=None,
validation_steps=None,
validation_batch_size=None,
validation_freq=1,
max_queue_size=10,
workers=1,
use_multiprocessing=False,
):
"""Trains the model for a fixed number of epochs (dataset iterations).
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 `tf.keras.utils.experimental.DatasetCreator`, which wraps a
callable that takes a single argument of type
`tf.distribute.InputContext`, and returns a `tf.data.Dataset`.
`DatasetCreator` should be used when users prefer to specify the
per-replica batching and sharding logic for the `Dataset`.
See `tf.keras.utils.experimental.DatasetCreator` doc for more
information.
A more detailed description of unpacking behavior for iterator
types (Dataset, generator, Sequence) is given below. If these
include `sample_weights` as a third component, note that sample
weighting applies to the `weighted_metrics` argument but not the
`metrics` argument in `compile()`. If using
`tf.distribute.experimental.ParameterServerStrategy`, only
`DatasetCreator` type is supported for `x`.
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 `x`).
batch_size: Integer or `None`.
Number of samples per gradient update.
If unspecified, `batch_size` will default to 32.
Do not specify the `batch_size` if your data is in the
form of datasets, generators, or `keras.utils.Sequence`
instances (since they generate batches).
epochs: Integer. Number of epochs to train the model.
An epoch is an iteration over the entire `x` and `y`
data provided
(unless the `steps_per_epoch` flag is set to
something other than None).
Note that in conjunction with `initial_epoch`,
`epochs` is to be understood as "final epoch".
The model is not trained for a number of iterations
given by `epochs`, but merely until the epoch
of index `epochs` is reached.
verbose: 'auto', 0, 1, or 2. Verbosity mode.
0 = silent, 1 = progress bar, 2 = one line per epoch.
'auto' becomes 1 for most cases, but 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 (eg, in a production
environment). Defaults to 'auto'.
callbacks: List of `keras.callbacks.Callback` instances.
List of callbacks to apply during training.
See `tf.keras.callbacks`. Note
`tf.keras.callbacks.ProgbarLogger` and
`tf.keras.callbacks.History` callbacks are created automatically
and need not be passed into `model.fit`.
`tf.keras.callbacks.ProgbarLogger` is created or not based on
`verbose` argument to `model.fit`.
Callbacks with batch-level calls are currently unsupported with
`tf.distribute.experimental.ParameterServerStrategy`, and users
are advised to implement epoch-level calls instead with an
appropriate `steps_per_epoch` value.
validation_split: Float between 0 and 1.
Fraction of the training data to be used as validation data.
The model will set apart this fraction of the training data,
will not train on it, and will evaluate
the loss and any model metrics
on this data at the end of each epoch.
The validation data is selected from the last samples
in the `x` and `y` data provided, before shuffling. This
argument is not supported when `x` is a dataset, generator or
`keras.utils.Sequence` instance.
If both `validation_data` and `validation_split` are provided,
`validation_data` will override `validation_split`.
`validation_split` is not yet supported with
`tf.distribute.experimental.ParameterServerStrategy`.
validation_data: Data on which to evaluate
the loss and any model metrics at the end of each epoch.
The model will not be trained on this data. Thus, note the fact
that the validation loss of data provided using
`validation_split` or `validation_data` is not affected by
regularization layers like noise and dropout.
`validation_data` will override `validation_split`.
`validation_data` could be:
- A tuple `(x_val, y_val)` of Numpy arrays or tensors.
- A tuple `(x_val, y_val, val_sample_weights)` of NumPy
arrays.
- A `tf.data.Dataset`.
- A Python generator or `keras.utils.Sequence` returning
`(inputs, targets)` or `(inputs, targets, sample_weights)`.
`validation_data` is not yet supported with
`tf.distribute.experimental.ParameterServerStrategy`.
shuffle: Boolean (whether to shuffle the training data
before each epoch) or str (for 'batch'). This argument is
ignored when `x` is a generator or an object of tf.data.Dataset.
'batch' is a special option for dealing
with the limitations of HDF5 data; it shuffles in batch-sized
chunks. Has no effect when `steps_per_epoch` is not `None`.
class_weight: Optional dictionary mapping class indices (integers)
to a weight (float) value, used for weighting the loss function
(during training only).
This can be useful to tell the model to
"pay more attention" to samples from
an under-represented class. When `class_weight` is specified
and targets have a rank of 2 or greater, either `y` must be
one-hot encoded, or an explicit final dimension of `1` must
be included for sparse class labels.
sample_weight: Optional Numpy array of weights for
the training samples, used for weighting the loss function
(during training only). 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, generator,
or `keras.utils.Sequence` instance, instead provide the
sample_weights as the third element of `x`.
Note that sample weighting does not apply to metrics specified
via the `metrics` argument in `compile()`. To apply sample
weighting to your metrics, you can specify them via the
`weighted_metrics` in `compile()` instead.
initial_epoch: Integer.
Epoch at which to start training
(useful for resuming a previous training run).
steps_per_epoch: Integer or `None`.
Total number of steps (batches of samples)
before declaring one epoch finished and starting the
next epoch. When training with input tensors such as
TensorFlow data tensors, the default `None` is equal to
the number of samples in your dataset divided by
the batch size, or 1 if that cannot be determined. If x is a
`tf.data` dataset, and 'steps_per_epoch'
is None, the epoch will run until the input dataset is
exhausted. When passing an infinitely repeating dataset, you
must specify the `steps_per_epoch` argument. If
`steps_per_epoch=-1` the training will run indefinitely with an
infinitely repeating dataset. This argument is not supported
with array inputs.
When using `tf.distribute.experimental.ParameterServerStrategy`:
* `steps_per_epoch=None` is not supported.
validation_steps: Only relevant if `validation_data` is provided and
is a `tf.data` dataset. Total number of steps (batches of
samples) to draw before stopping when performing validation
at the end of every epoch. If 'validation_steps' is None,
validation will run until the `validation_data` dataset is
exhausted. In the case of an infinitely repeated dataset, it
will run into an infinite loop. If 'validation_steps' is
specified and only part of the dataset will be consumed, the
evaluation will start from the beginning of the dataset at each
epoch. This ensures that the same validation samples are used
every time.
validation_batch_size: Integer or `None`.
Number of samples per validation batch.
If unspecified, will default to `batch_size`.
Do not specify the `validation_batch_size` if your data is in
the form of datasets, generators, or `keras.utils.Sequence`
instances (since they generate batches).
validation_freq: Only relevant if validation data is provided.
Integer or `collections.abc.Container` instance (e.g. list, tuple,
etc.). If an integer, specifies how many training epochs to run
before a new validation run is performed, e.g. `validation_freq=2`
runs validation every 2 epochs. If a Container, specifies the
epochs on which to run validation, e.g.
`validation_freq=[1, 2, 10]` runs validation at the end of the
1st, 2nd, and 10th epochs.
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-pickleable arguments to
the generator as they can't be passed easily to children
processes.
Unpacking behavior for iterator-like inputs:
A common pattern is to pass a tf.data.Dataset, generator, or
tf.keras.utils.Sequence to the `x` argument of fit, which will in fact
yield not only features (x) but optionally targets (y) and sample
weights. TF-Keras requires that the output of such iterator-likes be
unambiguous. The iterator should return a tuple of length 1, 2, or 3,
where the optional second and third elements will be used for y and
sample_weight respectively. Any other type provided will be wrapped in
a length one tuple, effectively treating everything as 'x'. When
yielding dicts, they should still adhere to the top-level tuple
structure.
e.g. `({"x0": x0, "x1": x1}, y)`. TF-Keras will not attempt to
separate features, targets, and weights from the keys of a single
dict.
A notable unsupported data type is the namedtuple. The reason is
that it behaves like both an ordered datatype (tuple) and a mapping
datatype (dict). So given a namedtuple of the form:
`namedtuple("example_tuple", ["y", "x"])`
it is ambiguous whether to reverse the order of the elements when
interpreting the value. Even worse is a tuple of the form:
`namedtuple("other_tuple", ["x", "y", "z"])`
where it is unclear if the tuple was intended to be unpacked into x,
y, and sample_weight or passed through as a single element to `x`. As
a result the data processing code will simply raise a ValueError if it
encounters a namedtuple. (Along with instructions to remedy the
issue.)
Returns:
A `History` object. Its `History.history` attribute is
a record of training loss values and metrics values
at successive epochs, as well as validation loss values
and validation metrics values (if applicable).
Raises:
RuntimeError: 1. If the model was never compiled or,
2. If `model.fit` is wrapped in `tf.function`.
ValueError: In case of mismatch between the provided input data
and what the model expects or when the input data is empty.
"""
# Legacy graph support is contained in `training_v1.Model`.
version_utils.disallow_legacy_graph("Model", "fit")
self._assert_compile_was_called()
self._check_call_args("fit")
_disallow_inside_tf_function("fit")
verbose = _get_verbosity(verbose, self.distribute_strategy)
if validation_split and validation_data is None:
# Create the validation data using the training data. Only supported
# for `Tensor` and `NumPy` input.
(
x,
y,
sample_weight,
), validation_data = data_adapter.train_validation_split(
(x, y, sample_weight), validation_split=validation_split
)
if validation_data:
(
val_x,
val_y,
val_sample_weight,
) = data_adapter.unpack_x_y_sample_weight(validation_data)
if self.distribute_strategy._should_use_with_coordinator:
self._cluster_coordinator = (
tf.distribute.experimental.coordinator.ClusterCoordinator(
self.distribute_strategy
)
)
with self.distribute_strategy.scope(), training_utils.RespectCompiledTrainableState( # noqa: E501
self
):
# Creates a `tf.data.Dataset` and handles batch and epoch iteration.
data_handler = data_adapter.get_data_handler(
x=x,
y=y,
sample_weight=sample_weight,
batch_size=batch_size,
steps_per_epoch=steps_per_epoch,
initial_epoch=initial_epoch,
epochs=epochs,
shuffle=shuffle,
class_weight=class_weight,
max_queue_size=max_queue_size,
workers=workers,
use_multiprocessing=use_multiprocessing,
model=self,
steps_per_execution=self._steps_per_execution,
)
# Container that configures and calls `tf.keras.Callback`s.
if not isinstance(callbacks, callbacks_module.CallbackList):
callbacks = callbacks_module.CallbackList(
callbacks,
add_history=True,
add_progbar=verbose != 0,
model=self,
verbose=verbose,
epochs=epochs,
steps=data_handler.inferred_steps,
)
self.stop_training = False
self.train_function = self.make_train_function()
self._train_counter.assign(0)
callbacks.on_train_begin()
training_logs = None
if self.autotune_steps_per_execution:
self._steps_per_execution_tuner.start()
# Handle fault-tolerance for multi-worker.
# TODO(omalleyt): Fix the ordering issues that mean this has to
# happen after `callbacks.on_train_begin`.
steps_per_epoch_inferred = (
steps_per_epoch or data_handler.inferred_steps
)
(
data_handler._initial_epoch,
data_handler._initial_step,
) = self._maybe_load_initial_counters_from_ckpt(
steps_per_epoch_inferred, initial_epoch
)
logs = None
for epoch, iterator in data_handler.enumerate_epochs():
self.reset_metrics()
callbacks.on_epoch_begin(epoch)
with data_handler.catch_stop_iteration():
for step in data_handler.steps():
with tf.profiler.experimental.Trace(
"train",
epoch_num=epoch,
step_num=step,
batch_size=batch_size,
_r=1,
):
callbacks.on_train_batch_begin(step)
tmp_logs = self.train_function(iterator)
if data_handler.should_sync:
context.async_wait()
# No error, now safe to assign to logs.
logs = tmp_logs
end_step = step + data_handler.step_increment
callbacks.on_train_batch_end(end_step, logs)
if self.stop_training:
break
logs = tf_utils.sync_to_numpy_or_python_type(logs)
if logs is None:
raise ValueError(
"Unexpected result of `train_function` "
"(Empty logs). This could be due to issues in input "
"pipeline that resulted in an empty dataset. "
"Otherwise, please use "
"`Model.compile(..., run_eagerly=True)`, or "
"`tf.config.run_functions_eagerly(True)` for more "
"information of where went wrong, or file a "
"issue/bug to `tf.keras`."
)
# Override with model metrics instead of last step logs
logs = self._validate_and_get_metrics_result(logs)
epoch_logs = copy.copy(logs)
# Run validation.
if validation_data and self._should_eval(
epoch, validation_freq
):
if self._pss_evaluation_shards:
self._disallow_exact_eval_with_add_metrics()
# Create data_handler for evaluation and cache it.
if getattr(self, "_eval_data_handler", None) is None:
self._eval_data_handler = data_adapter.get_data_handler(
x=val_x,
y=val_y,
sample_weight=val_sample_weight,
batch_size=validation_batch_size or batch_size,
steps_per_epoch=validation_steps,
initial_epoch=0,
epochs=1,
max_queue_size=max_queue_size,
workers=workers,
use_multiprocessing=use_multiprocessing,
model=self,
steps_per_execution=self._steps_per_execution,
pss_evaluation_shards=self._pss_evaluation_shards,
)
val_logs = self.evaluate(
x=val_x,
y=val_y,
sample_weight=val_sample_weight,
batch_size=validation_batch_size or batch_size,
steps=validation_steps,
callbacks=callbacks,
max_queue_size=max_queue_size,
workers=workers,
use_multiprocessing=use_multiprocessing,
return_dict=True,
_use_cached_eval_dataset=True,
)
val_logs = {
"val_" + name: val for name, val in val_logs.items()
}
epoch_logs.update(val_logs)
callbacks.on_epoch_end(epoch, epoch_logs)
training_logs = epoch_logs
if self.stop_training:
break
if isinstance(self.optimizer, optimizer.Optimizer) and epochs > 0:
self.optimizer.finalize_variable_values(
self.trainable_variables
)
# If eval data_handler exists, delete it after all epochs are done.
if getattr(self, "_eval_data_handler", None) is not None:
del self._eval_data_handler
if self.autotune_steps_per_execution:
self._steps_per_execution_tuner.stop()
callbacks.on_train_end(logs=training_logs)
return self.history
def test_step(self, data):
"""The logic for one evaluation step.
This method can be overridden to support custom evaluation logic.
This method is called by `Model.make_test_function`.
This function should contain the mathematical logic for one step of
evaluation.
This typically includes the forward pass, loss calculation, and metrics
updates.
Configuration details for *how* this logic is run (e.g. `tf.function`
and `tf.distribute.Strategy` settings), should be left to
`Model.make_test_function`, which can also be overridden.
Args:
data: A nested structure of `Tensor`s.
Returns:
A `dict` containing values that will be passed to
`tf.keras.callbacks.CallbackList.on_train_batch_end`. Typically, the
values of the `Model`'s metrics are returned.
"""
x, y, sample_weight = data_adapter.unpack_x_y_sample_weight(data)
y_pred = self(x, training=False)
# Updates stateful loss metrics.
self.compute_loss(x, y, y_pred, sample_weight)
return self.compute_metrics(x, y, y_pred, sample_weight)
def _make_test_function_exact(self):
if getattr(self, "_shard_test_function", None):
return self._shard_test_function
def step_function(batch):
def run_step(data):
# TODO(b/272050910): Use sample_weight for weighted metrics.
x, y, sample_weight = data_adapter.unpack_x_y_sample_weight(
data
)
y_pred = self(x, training=False)
return x, y, y_pred, sample_weight
if self._jit_compile:
run_step = tf.function(
run_step, jit_compile=True, reduce_retracing=True
)
outputs = self.distribute_strategy.run(run_step, args=(batch,))
outputs = reduce_per_replica(
outputs,
self.distribute_strategy,
reduction=self.distribute_reduction_method,
)
return outputs
def shard_test_function(dataset, total_shards, shard_idx):
# Copy loss and metric variables to the worker and work with them
# locally. This ensures each shard function is atomic: if a worker
# is preempted, the intermediate progress is discarded and that
# shard is retried. This in turn guarantees exactly-once visitation.
local_unweighted_metrics, local_weighted_metrics = [], []
with tf_utils.with_metric_local_vars_scope():
# TODO(jmullenbach): implement and use a clone for
# `MetricsContainer` and use its `update_state` method directly.
for metric in self.compiled_metrics.unweighted_metrics:
if metric is not None:
local_unweighted_metrics.append(
base_metric.clone_metric(metric)
)
for metric in self.compiled_metrics.weighted_metrics:
if metric is not None:
local_weighted_metrics.append(
base_metric.clone_metric(metric)
)
local_loss = compile_utils.LossesContainer.from_config(
self.compiled_loss.get_config()
)
dataset = input_ops.auto_shard_dataset(
dataset, total_shards, shard_idx
)
iterator = iter(dataset)
with distribute_utils.cache_variable_reads():
for batch in iterator:
x, y, y_pred, sample_weight = step_function(batch)
for weighted_metric in local_weighted_metrics:
weighted_metric.update_state(y, y_pred, sample_weight)
for unweighted_metric in local_unweighted_metrics:
unweighted_metric.update_state(y, y_pred)
local_loss(y, y_pred, sample_weight)
local_metrics = (
local_unweighted_metrics
+ local_weighted_metrics
+ local_loss.metrics
)
outputs = {metric.name: metric.weights for metric in local_metrics}
with tf.control_dependencies(_minimum_control_deps(outputs)):
self._test_counter.assign_add(1)
return outputs
if not self.run_eagerly:
shard_test_function = tf.function(
shard_test_function, reduce_retracing=True
)
self._shard_test_function = (
lambda *args: self._cluster_coordinator.schedule(
shard_test_function,
args=args,
)
)
return self._shard_test_function
def make_test_function(self, force=False):
"""Creates a function that executes one step of evaluation.
This method can be overridden to support custom evaluation logic.
This method is called by `Model.evaluate` and `Model.test_on_batch`.
Typically, this method directly controls `tf.function` and
`tf.distribute.Strategy` settings, and delegates the actual evaluation
logic to `Model.test_step`.
This function is cached the first time `Model.evaluate` or
`Model.test_on_batch` is called. The cache is cleared whenever
`Model.compile` is called. You can skip the cache and generate again the
function with `force=True`.
Args:
force: Whether to regenerate the test function and skip the cached
function if available.
Returns:
Function. The function created by this method should accept a
`tf.data.Iterator`, and return a `dict` containing values that will
be passed to `tf.keras.Callbacks.on_test_batch_end`.
"""
if self.test_function is not None and not force:
return self.test_function
def step_function(model, iterator):
"""Runs a single evaluation step."""
def run_step(data):
outputs = model.test_step(data)
# Ensure counter is updated only if `test_step` succeeds.
with tf.control_dependencies(_minimum_control_deps(outputs)):
model._test_counter.assign_add(1)
return outputs
if self.jit_compile:
run_step = tf.function(
run_step, jit_compile=True, reduce_retracing=True
)
data = next(iterator)
outputs = model.distribute_strategy.run(run_step, args=(data,))
outputs = reduce_per_replica(
outputs,
self.distribute_strategy,
reduction=self.distribute_reduction_method,
)
return outputs
# Special case if steps_per_execution is one.
if (
self._steps_per_execution is None
or self._steps_per_execution.numpy().item() == 1
and not self.autotune_steps_per_execution
):
def test_function(iterator):
"""Runs a test execution with a single step."""
return step_function(self, iterator)
if not self.run_eagerly:
test_function = tf.function(
test_function, reduce_retracing=True
)
if self._cluster_coordinator:
self.test_function = (
lambda it: self._cluster_coordinator.schedule(
test_function, args=(it,)
)
)
else:
self.test_function = test_function
# If we're using a coordinator, use the value of
# self._steps_per_execution at the time the function is
# called/scheduled, and not when it is actually executed.
elif self._cluster_coordinator:
def test_function(iterator, steps_per_execution):
"""Runs a test execution with multiple steps."""
for _ in tf.range(steps_per_execution):
outputs = step_function(self, iterator)
return outputs
if not self.run_eagerly:
test_function = tf.function(
test_function, reduce_retracing=True
)
self.test_function = lambda it: self._cluster_coordinator.schedule(
test_function, args=(it, self._steps_per_execution.value())
)
else:
def test_function(iterator):
"""Runs a test execution with multiple steps."""
for _ in tf.range(self._steps_per_execution):
outputs = step_function(self, iterator)
return outputs
if not self.run_eagerly:
test_function = tf.function(
test_function, reduce_retracing=True
)
self.test_function = test_function
return self.test_function
@traceback_utils.filter_traceback
def evaluate(
self,
x=None,
y=None,
batch_size=None,
verbose="auto",
sample_weight=None,
steps=None,
callbacks=None,
max_queue_size=10,
workers=1,
use_multiprocessing=False,
return_dict=False,
**kwargs,
):
"""Returns the loss value & metrics values for the model in test mode.
Computation is done in batches (see the `batch_size` arg.)
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"` becomes 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). Defaults to 'auto'.
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](https://www.tensorflow.org/api_docs/python/tf/tf_keras/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-pickleable 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.
See the discussion of `Unpacking behavior for iterator-like inputs` for
`Model.fit`.
Returns:
Scalar test loss (if the model has a single output and no metrics)
or list of scalars (if the model has multiple outputs
and/or metrics). The attribute `model.metrics_names` will give you
the display labels for the scalar outputs.
Raises:
RuntimeError: If `model.evaluate` is wrapped in a `tf.function`.
"""
version_utils.disallow_legacy_graph("Model", "evaluate")
self._assert_compile_was_called()
self._check_call_args("evaluate")
self._check_sample_weight_warning(x, sample_weight)
_disallow_inside_tf_function("evaluate")
use_cached_eval_dataset = kwargs.pop("_use_cached_eval_dataset", False)
if kwargs:
raise TypeError(f"Invalid keyword arguments: {list(kwargs.keys())}")
if self.distribute_strategy._should_use_with_coordinator:
self._cluster_coordinator = (
tf.distribute.experimental.coordinator.ClusterCoordinator(
self.distribute_strategy
)
)
verbose = _get_verbosity(verbose, self.distribute_strategy)
if self._pss_evaluation_shards:
self._disallow_exact_eval_with_add_metrics()
with self.distribute_strategy.scope():
# Use cached evaluation data only when it's called in `Model.fit`
if (
use_cached_eval_dataset
and getattr(self, "_eval_data_handler", None) is not None
):
data_handler = self._eval_data_handler
else:
# Creates a `tf.data.Dataset` and handles batch and epoch
# iteration.
data_handler = data_adapter.get_data_handler(
x=x,
y=y,
sample_weight=sample_weight,
batch_size=batch_size,
steps_per_epoch=steps,
initial_epoch=0,
epochs=1,
max_queue_size=max_queue_size,
workers=workers,
use_multiprocessing=use_multiprocessing,
model=self,
steps_per_execution=self._steps_per_execution,
pss_evaluation_shards=self._pss_evaluation_shards,
)
# Container that configures and calls `tf.keras.Callback`s.
if not isinstance(callbacks, callbacks_module.CallbackList):
callbacks = callbacks_module.CallbackList(
callbacks,
add_history=True,
add_progbar=verbose != 0,
model=self,
verbose=verbose,
epochs=1,
steps=data_handler.inferred_steps,
)
# Initialize to prevent errors if 0 epochs are evaluated.
logs = {}
test_function_runner = self._get_test_function_runner(callbacks)
self._test_counter.assign(0)
callbacks.on_test_begin()
if self.autotune_steps_per_execution:
self._steps_per_execution_tuner.start()
for (
_,
dataset_or_iterator,
) in data_handler.enumerate_epochs(): # Single epoch.
self.reset_metrics()
with data_handler.catch_stop_iteration():
for step in data_handler.steps():
with tf.profiler.experimental.Trace(
"test", step_num=step, _r=1
):
callbacks.on_test_batch_begin(step)
logs = test_function_runner.run_step(
dataset_or_iterator,
data_handler,
step,
self._pss_evaluation_shards,
)
logs = tf_utils.sync_to_numpy_or_python_type(logs)
# Override with model metrics instead of last step logs
if self._pss_evaluation_shards:
logs = self._aggregate_exact_metrics(logs)
else:
logs = self._validate_and_get_metrics_result(logs)
if self.autotune_steps_per_execution:
self._steps_per_execution_tuner.stop()
callbacks.on_test_end(logs=logs)
if return_dict:
return logs
else:
return flatten_metrics_in_order(logs, self.metrics_names)
def _disallow_exact_eval_with_add_metrics(self):
metrics_from_add_metric = [
metric
for layer in self._flatten_layers()
for metric in layer._metrics
]
compiled_metrics = self.compiled_metrics.metrics
if any(
[
metric not in compiled_metrics
for metric in metrics_from_add_metric
]
):
raise ValueError(
"Detected that a metric was added to this model "
"via `Model.add_metric`. This is not currently "
"supported when using exact evaluation with "
"`tf.distribute.ParameterServerStrategy`."
)
def _infer_exact_eval_shards(self, pss_evaluation_shards):
if not self.distribute_strategy._should_use_with_coordinator:
return 0
if pss_evaluation_shards == "auto":
# TODO(b/264265138) evaluate and improve this heuristic
return self.distribute_strategy._num_workers * 5
return pss_evaluation_shards
def _get_test_function_runner(self, callbacks):
if (
self._pss_evaluation_shards
and self.distribute_strategy._should_use_with_coordinator
):
self.test_function = self._make_test_function_exact()
test_function_runner = _ExactTestFunction(
self.test_function, callbacks
)
else:
self.test_function = self.make_test_function()
test_function_runner = _TestFunction(self.test_function, callbacks)
return test_function_runner
def predict_step(self, data):
"""The logic for one inference step.
This method can be overridden to support custom inference logic.
This method is called by `Model.make_predict_function`.
This method should contain the mathematical logic for one step of
inference. This typically includes the forward pass.
Configuration details for *how* this logic is run (e.g. `tf.function`
and `tf.distribute.Strategy` settings), should be left to
`Model.make_predict_function`, which can also be overridden.
Args:
data: A nested structure of `Tensor`s.
Returns:
The result of one inference step, typically the output of calling the
`Model` on data.
"""
x, _, _ = data_adapter.unpack_x_y_sample_weight(data)
return self(x, training=False)
def make_predict_function(self, force=False):
"""Creates a function that executes one step of inference.
This method can be overridden to support custom inference logic.
This method is called by `Model.predict` and `Model.predict_on_batch`.
Typically, this method directly controls `tf.function` and
`tf.distribute.Strategy` settings, and delegates the actual evaluation
logic to `Model.predict_step`.
This function is cached the first time `Model.predict` or
`Model.predict_on_batch` is called. The cache is cleared whenever
`Model.compile` is called. You can skip the cache and generate again the
function with `force=True`.
Args:
force: Whether to regenerate the predict function and skip the cached
function if available.
Returns:
Function. The function created by this method should accept a
`tf.data.Iterator`, and return the outputs of the `Model`.
"""
if self.predict_function is not None and not force:
return self.predict_function
def step_function(model, iterator):
"""Runs a single evaluation step."""
def run_step(data):
outputs = model.predict_step(data)
# Ensure counter is updated only if `test_step` succeeds.
with tf.control_dependencies(_minimum_control_deps(outputs)):
model._predict_counter.assign_add(1)
return outputs
if self.jit_compile:
run_step = tf.function(
run_step, jit_compile=True, reduce_retracing=True
)
data = next(iterator)
outputs = model.distribute_strategy.run(run_step, args=(data,))
outputs = reduce_per_replica(
outputs, self.distribute_strategy, reduction="concat"
)
return outputs
# Special case if steps_per_execution is one.
if (
self._steps_per_execution is None
or self._steps_per_execution.numpy().item() == 1
and not self.autotune_steps_per_execution
):
def predict_function(iterator):
"""Runs an evaluation execution with a single step."""
return step_function(self, iterator)
else:
def predict_function(iterator):
"""Runs an evaluation execution with multiple steps."""
outputs = step_function(self, iterator)
for _ in tf.range(self._steps_per_execution - 1):
tf.autograph.experimental.set_loop_options(
shape_invariants=[
(
outputs,
tf.nest.map_structure(
lambda t: tf_utils.get_tensor_spec(
t, dynamic_batch=True
).shape,
outputs,
),
)
]
)
step_outputs = step_function(self, iterator)
outputs = tf.nest.map_structure(
lambda t1, t2: concat([t1, t2]), outputs, step_outputs
)
return outputs
if not self.run_eagerly:
predict_function = tf.function(
predict_function, reduce_retracing=True
)
self.predict_function = predict_function
return self.predict_function
@traceback_utils.filter_traceback
def predict(
self,
x,
batch_size=None,
verbose="auto",
steps=None,
callbacks=None,
max_queue_size=10,
workers=1,
use_multiprocessing=False,
):
"""Generates output predictions for the input samples.
Computation is done in batches. This method is designed for batch
processing of large numbers of inputs. It is not intended for use inside
of loops that iterate over your data and process small numbers of inputs
at a time.
For small numbers of inputs that fit in one batch,
directly use `__call__()` for faster execution, e.g.,
`model(x)`, or `model(x, training=False)` if you have layers such as
`tf.keras.layers.BatchNormalization` that behave differently during
inference. You may pair the individual model call with a `tf.function`
for additional performance inside your inner loop.
If you need access to numpy array values instead of tensors after your
model call, you can use `tensor.numpy()` to get the numpy array value of
an eager tensor.
Also, note the fact that test loss is not affected by
regularization layers like noise and dropout.
Note: See [this FAQ entry](
https://keras.io/getting_started/faq/#whats-the-difference-between-model-methods-predict-and-call)
for more details about the difference between `Model` methods
`predict()` and `__call__()`.
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"` becomes 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). Defaults to 'auto'.
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](
https://www.tensorflow.org/api_docs/python/tf/tf_keras/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-pickleable arguments to
the generator as they can't be passed easily to children
processes.
See the discussion of `Unpacking behavior for iterator-like inputs` for
`Model.fit`. Note that Model.predict uses the same interpretation rules
as `Model.fit` and `Model.evaluate`, so inputs must be unambiguous for
all three methods.
Returns:
Numpy array(s) of predictions.
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.
"""
version_utils.disallow_legacy_graph("Model", "predict")
self._check_call_args("predict")
_disallow_inside_tf_function("predict")
# TODO(yashkatariya): Cache model on the coordinator for faster
# prediction. If running under PSS, then swap it with OneDeviceStrategy
# so that execution will run on the coordinator.
original_pss_strategy = None
if self.distribute_strategy._should_use_with_coordinator:
original_pss_strategy = self.distribute_strategy
self._distribution_strategy = None
# Cluster coordinator is set by `.fit()` and `.evaluate()` which is not
# needed in `.predict()` because all the predictions happen on the
# coordinator/locally.
if self._cluster_coordinator:
self._cluster_coordinator = None
verbose = _get_verbosity(verbose, self.distribute_strategy)
outputs = None
with self.distribute_strategy.scope():
# Creates a `tf.data.Dataset` and handles batch and epoch iteration.
dataset_types = (tf.compat.v1.data.Dataset, tf.data.Dataset)
if (
self._in_multi_worker_mode()
or _is_tpu_multi_host(self.distribute_strategy)
) and isinstance(x, dataset_types):
try:
options = tf.data.Options()
data_option = tf.data.experimental.AutoShardPolicy.DATA
options.experimental_distribute.auto_shard_policy = (
data_option
)
x = x.with_options(options)
except ValueError:
warnings.warn(
"Using Model.predict with MultiWorkerMirroredStrategy "
"or TPUStrategy and AutoShardPolicy.FILE might lead to "
"out-of-order result. Consider setting it to "
"AutoShardPolicy.DATA.",
stacklevel=2,
)
data_handler = data_adapter.get_data_handler(
x=x,
batch_size=batch_size,
steps_per_epoch=steps,
initial_epoch=0,
epochs=1,
max_queue_size=max_queue_size,
workers=workers,
use_multiprocessing=use_multiprocessing,
model=self,
steps_per_execution=self._steps_per_execution,
)
# Container that configures and calls `tf.keras.Callback`s.
if not isinstance(callbacks, callbacks_module.CallbackList):
callbacks = callbacks_module.CallbackList(
callbacks,
add_history=True,
add_progbar=verbose != 0,
model=self,
verbose=verbose,
epochs=1,
steps=data_handler.inferred_steps,
)
self.predict_function = self.make_predict_function()
self._predict_counter.assign(0)
callbacks.on_predict_begin()
if self.autotune_steps_per_execution:
self._steps_per_execution_tuner.start()
batch_outputs = None
for _, iterator in data_handler.enumerate_epochs(): # Single epoch.
with data_handler.catch_stop_iteration():
for step in data_handler.steps():
callbacks.on_predict_batch_begin(step)
tmp_batch_outputs = self.predict_function(iterator)
if data_handler.should_sync:
context.async_wait()
batch_outputs = (
tmp_batch_outputs # No error, now safe to assign.
)
if outputs is None:
outputs = tf.nest.map_structure(
lambda batch_output: [batch_output],
batch_outputs,
)
else:
tf.__internal__.nest.map_structure_up_to(
batch_outputs,
lambda output, batch_output: output.append(
batch_output
),
outputs,
batch_outputs,
)
end_step = step + data_handler.step_increment
callbacks.on_predict_batch_end(
end_step, {"outputs": batch_outputs}
)
if batch_outputs is None:
raise ValueError(
"Unexpected result of `predict_function` "
"(Empty batch_outputs). Please use "
"`Model.compile(..., run_eagerly=True)`, or "
"`tf.config.run_functions_eagerly(True)` for more "
"information of where went wrong, or file a "
"issue/bug to `tf.keras`."
)
if self.autotune_steps_per_execution:
self._steps_per_execution_tuner.stop()
callbacks.on_predict_end()
all_outputs = tf.__internal__.nest.map_structure_up_to(
batch_outputs, potentially_ragged_concat, outputs
)
# If originally PSS strategy was used, then replace it back since
# predict is running under `OneDeviceStrategy` after the swap and once
# its done we need to replace it back to PSS again.
if original_pss_strategy is not None:
self._distribution_strategy = original_pss_strategy
return tf_utils.sync_to_numpy_or_python_type(all_outputs)
def reset_metrics(self):
"""Resets the state of all the metrics in the model.
Examples:
>>> 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"])
>>> x = np.random.random((2, 3))
>>> y = np.random.randint(0, 2, (2, 2))
>>> _ = model.fit(x, y, verbose=0)
>>> assert all(float(m.result()) for m in model.metrics)
>>> model.reset_metrics()
>>> assert all(float(m.result()) == 0 for m in model.metrics)
"""
for m in self.metrics:
m.reset_state()
def train_on_batch(
self,
x,
y=None,
sample_weight=None,
class_weight=None,
reset_metrics=True,
return_dict=False,
):
"""Runs a single gradient update on a single batch of data.
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.
y: Target data. Like the input data `x`, it could be either Numpy
array(s) or TensorFlow tensor(s).
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.
class_weight: Optional dictionary mapping class indices (integers)
to a weight (float) to apply to the model's loss for the samples
from this class during training. This can be useful to tell the
model to "pay more attention" to samples from an under-represented
class. When `class_weight` is specified and targets have a rank of
2 or greater, either `y` must be one-hot encoded, or an explicit
final dimension of `1` must be included for sparse class labels.
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.
Returns:
Scalar training loss
(if the model has a single output and no metrics)
or list of scalars (if the model has multiple outputs
and/or metrics). The attribute `model.metrics_names` will give you
the display labels for the scalar outputs.
Raises:
RuntimeError: If `model.train_on_batch` is wrapped in a `tf.function`.
"""
self._assert_compile_was_called()
self._check_call_args("train_on_batch")
_disallow_inside_tf_function("train_on_batch")
if reset_metrics:
self.reset_metrics()
with self.distribute_strategy.scope(), training_utils.RespectCompiledTrainableState( # noqa: E501
self
):
iterator = data_adapter.single_batch_iterator(
self.distribute_strategy, x, y, sample_weight, class_weight
)
self.train_function = self.make_train_function()
logs = self.train_function(iterator)
logs = tf_utils.sync_to_numpy_or_python_type(logs)
if return_dict:
return logs
else:
return flatten_metrics_in_order(logs, self.metrics_names)
def test_on_batch(
self,
x,
y=None,
sample_weight=None,
reset_metrics=True,
return_dict=False,
):
"""Test the model on a single batch of samples.
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.
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.
Returns:
Scalar test loss (if the model has a single output and no metrics)
or list of scalars (if the model has multiple outputs
and/or metrics). The attribute `model.metrics_names` will give you
the display labels for the scalar outputs.
Raises:
RuntimeError: If `model.test_on_batch` is wrapped in a
`tf.function`.
"""
self._assert_compile_was_called()
self._check_call_args("test_on_batch")
_disallow_inside_tf_function("test_on_batch")
if reset_metrics:
self.reset_metrics()
with self.distribute_strategy.scope():
iterator = data_adapter.single_batch_iterator(
self.distribute_strategy, x, y, sample_weight
)
self.test_function = self.make_test_function()
logs = self.test_function(iterator)
logs = tf_utils.sync_to_numpy_or_python_type(logs)
if return_dict:
return logs
else:
return flatten_metrics_in_order(logs, self.metrics_names)
def predict_on_batch(self, x):
"""Returns predictions for a single batch of samples.
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).
Returns:
Numpy array(s) of predictions.
Raises:
RuntimeError: If `model.predict_on_batch` is wrapped in a
`tf.function`.
"""
self._check_call_args("predict_on_batch")
_disallow_inside_tf_function("predict_on_batch")
with self.distribute_strategy.scope():
iterator = data_adapter.single_batch_iterator(
self.distribute_strategy, x
)
self.predict_function = self.make_predict_function()
outputs = self.predict_function(iterator)
return tf_utils.sync_to_numpy_or_python_type(outputs)
@doc_controls.do_not_generate_docs
def fit_generator(
self,
generator,
steps_per_epoch=None,
epochs=1,
verbose=1,
callbacks=None,
validation_data=None,
validation_steps=None,
validation_freq=1,
class_weight=None,
max_queue_size=10,
workers=1,
use_multiprocessing=False,
shuffle=True,
initial_epoch=0,
):
"""Fits the model on data yielded batch-by-batch by a Python generator.
DEPRECATED:
`Model.fit` now supports generators, so there is no longer any need to
use this endpoint.
"""
warnings.warn(
"`Model.fit_generator` is deprecated and "
"will be removed in a future version. "
"Please use `Model.fit`, which supports generators.",
stacklevel=2,
)
return self.fit(
generator,
steps_per_epoch=steps_per_epoch,
epochs=epochs,
verbose=verbose,
callbacks=callbacks,
validation_data=validation_data,
validation_steps=validation_steps,
validation_freq=validation_freq,
class_weight=class_weight,
max_queue_size=max_queue_size,
workers=workers,
use_multiprocessing=use_multiprocessing,
shuffle=shuffle,
initial_epoch=initial_epoch,
)
@doc_controls.do_not_generate_docs
def evaluate_generator(
self,
generator,
steps=None,
callbacks=None,
max_queue_size=10,
workers=1,
use_multiprocessing=False,
verbose=0,
):
"""Evaluates the model on a data generator.
DEPRECATED:
`Model.evaluate` now supports generators, so there is no longer any
need to use this endpoint.
"""
warnings.warn(
"`Model.evaluate_generator` is deprecated and "
"will be removed in a future version. "
"Please use `Model.evaluate`, which supports generators.",
stacklevel=2,
)
self._check_call_args("evaluate_generator")
return self.evaluate(
generator,
steps=steps,
max_queue_size=max_queue_size,
workers=workers,
use_multiprocessing=use_multiprocessing,
verbose=verbose,
callbacks=callbacks,
)
@doc_controls.do_not_generate_docs
def predict_generator(
self,
generator,
steps=None,
callbacks=None,
max_queue_size=10,
workers=1,
use_multiprocessing=False,
verbose=0,
):
"""Generates predictions for the input samples from a data generator.
DEPRECATED:
`Model.predict` now supports generators, so there is no longer any
need to use this endpoint.
"""
warnings.warn(
"`Model.predict_generator` is deprecated and "
"will be removed in a future version. "
"Please use `Model.predict`, which supports generators.",
stacklevel=2,
)
return self.predict(
generator,
steps=steps,
max_queue_size=max_queue_size,
workers=workers,
use_multiprocessing=use_multiprocessing,
verbose=verbose,
callbacks=callbacks,
)
######################################################################
# Functions below are not training related. They are for model weights
# tracking, save/load, serialization, etc.
######################################################################
@property
def trainable_weights(self):
self._assert_weights_created()
if not self._trainable:
return []
trainable_variables = []
for trackable_obj in self._self_tracked_trackables:
trainable_variables += trackable_obj.trainable_variables
trainable_variables += self._trainable_weights
return self._dedup_weights(trainable_variables)
@property
def non_trainable_weights(self):
self._assert_weights_created()
non_trainable_variables = []
for trackable_obj in self._self_tracked_trackables:
non_trainable_variables += trackable_obj.non_trainable_variables
if not self._trainable:
# Return order is all trainable vars, then all non-trainable vars.
trainable_variables = []
for trackable_obj in self._self_tracked_trackables:
trainable_variables += trackable_obj.trainable_variables
non_trainable_variables = (
trainable_variables
+ self._trainable_weights
+ non_trainable_variables
+ self._non_trainable_weights
)
else:
non_trainable_variables = (
non_trainable_variables + self._non_trainable_weights
)
return self._dedup_weights(non_trainable_variables)
def get_weights(self):
"""Retrieves the weights of the model.
Returns:
A flat list of Numpy arrays.
"""
with self.distribute_strategy.scope():
return super().get_weights()
@traceback_utils.filter_traceback
def save(self, filepath, overwrite=True, save_format=None, **kwargs):
"""Saves a model as a TensorFlow SavedModel or HDF5 file.
See the [Serialization and Saving guide](
https://keras.io/guides/serialization_and_saving/) for details.
Args:
model: TF-Keras model instance to be saved.
filepath: `str` or `pathlib.Path` object. Path where to save the
model.
overwrite: Whether we should overwrite any existing model at the
target location, or instead ask the user via an interactive
prompt.
save_format: Either `"keras"`, `"tf"`, `"h5"`,
indicating whether to save the model
in the native TF-Keras format (`.keras`),
in the TensorFlow SavedModel format
(referred to as "SavedModel" below),
or in the legacy HDF5 format (`.h5`).
Defaults to `"tf"` in TF 2.X, and `"h5"` in TF 1.X.
SavedModel format arguments:
include_optimizer: Only applied to SavedModel and legacy HDF5
formats. If False, do not save the optimizer state.
Defaults to `True`.
signatures: Only applies to SavedModel format. Signatures to save
with the SavedModel. See the `signatures` argument in
`tf.saved_model.save` for details.
options: Only applies to SavedModel format.
`tf.saved_model.SaveOptions` object that specifies SavedModel
saving options.
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.
Example:
```python
model = tf.keras.Sequential([
tf.keras.layers.Dense(5, input_shape=(3,)),
tf.keras.layers.Softmax()])
model.save("model.keras")
loaded_model = tf.keras.models.load_model("model.keras")
x = tf.random.uniform((10, 3))
assert np.allclose(model.predict(x), loaded_model.predict(x))
```
Note that `model.save()` is an alias for `tf.keras.models.save_model()`.
"""
saving_api.save_model(
self,
filepath=filepath,
overwrite=overwrite,
save_format=save_format,
**kwargs,
)
@traceback_utils.filter_traceback
def save_weights(
self, filepath, overwrite=True, save_format=None, options=None
):
"""Saves all layer weights.
Either saves in HDF5 or in TensorFlow format based on the `save_format`
argument.
When saving in HDF5 format, the weight file has:
- `layer_names` (attribute), a list of strings
(ordered names of model layers).
- For every layer, a `group` named `layer.name`
- For every such layer group, a group attribute `weight_names`,
a list of strings
(ordered names of weights tensor of the layer).
- For every weight in the layer, a dataset
storing the weight value, named after the weight tensor.
When saving in TensorFlow format, all objects referenced by the network
are saved in the same format as `tf.train.Checkpoint`, including any
`Layer` instances or `Optimizer` instances assigned to object
attributes. For networks constructed from inputs and outputs using
`tf.keras.Model(inputs, outputs)`, `Layer` instances used by the network
are tracked/saved automatically. For user-defined classes which inherit
from `tf.keras.Model`, `Layer` instances must be assigned to object
attributes, typically in the constructor. See the documentation of
`tf.train.Checkpoint` and `tf.keras.Model` for details.
While the formats are the same, do not mix `save_weights` and
`tf.train.Checkpoint`. Checkpoints saved by `Model.save_weights` should
be loaded using `Model.load_weights`. Checkpoints saved using
`tf.train.Checkpoint.save` should be restored using the corresponding
`tf.train.Checkpoint.restore`. Prefer `tf.train.Checkpoint` over
`save_weights` for training checkpoints.
The TensorFlow format matches objects and variables by starting at a
root object, `self` for `save_weights`, and greedily matching attribute
names. For `Model.save` this is the `Model`, and for `Checkpoint.save`
this is the `Checkpoint` even if the `Checkpoint` has a model attached.
This means saving a `tf.keras.Model` using `save_weights` and loading
into a `tf.train.Checkpoint` with a `Model` attached (or vice versa)
will not match the `Model`'s variables. See the
[guide to training checkpoints](
https://www.tensorflow.org/guide/checkpoint) for details on
the TensorFlow format.
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` becomes 'tf'. Defaults to `None`.
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.
"""
saving_api.save_weights(
self,
filepath=filepath,
overwrite=overwrite,
save_format=save_format,
options=options,
)
@traceback_utils.filter_traceback
def load_weights(
self, filepath, skip_mismatch=False, by_name=False, options=None
):
"""Loads all layer weights from a saved files.
The saved file could be a SavedModel file, a `.keras` file (v3 saving
format), or a file created via `model.save_weights()`.
By default, weights are loaded based on the network's
topology. This means the architecture should be the same as when the
weights were saved. Note that layers that don't have weights are not
taken into account in the topological ordering, so adding or removing
layers is fine as long as they don't have weights.
**Partial weight loading**
If you have modified your model, for instance by adding a new layer
(with weights) or by changing the shape of the weights of a layer,
you can choose to ignore errors and continue loading
by setting `skip_mismatch=True`. In this case any layer with
mismatching weights will be skipped. A warning will be displayed
for each skipped layer.
**Weight loading by name**
If your weights are saved as a `.h5` file created
via `model.save_weights()`, you can use the argument `by_name=True`.
In this case, weights are loaded into layers only if they share
the same name. This is useful for fine-tuning or transfer-learning
models where some of the layers have changed.
Note that only topological loading (`by_name=False`) is supported when
loading weights from the `.keras` v3 format or from the TensorFlow
SavedModel format.
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 or a `.keras` file (v3 saving format) saved
via `model.save()`.
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 weights.
by_name: Boolean, whether to load weights by name or by topological
order. Only topological loading is supported for weight files in
the `.keras` v3 format or in the TensorFlow SavedModel format.
options: Optional `tf.train.CheckpointOptions` object that specifies
options for loading weights (only valid for a SavedModel file).
"""
return saving_api.load_weights(
self,
filepath=filepath,
by_name=by_name,
skip_mismatch=skip_mismatch,
options=options,
)
def _updated_config(self):
"""Util shared between different serialization methods.
Returns:
Model config with TF-Keras version information added.
"""
from tf_keras.src import __version__ as keras_version
config = self.get_config()
model_config = {
"class_name": self.__class__.__name__,
"config": config,
"keras_version": keras_version,
"backend": backend.backend(),
}
return model_config
@generic_utils.default
def get_config(self):
"""Returns the config of the `Model`.
Config is a Python dictionary (serializable) containing the
configuration of an object, which in this case is a `Model`. This allows
the `Model` to be be reinstantiated later (without its trained weights)
from this configuration.
Note that `get_config()` does not guarantee to return a fresh copy of
dict every time it is called. The callers should make a copy of the
returned dict if they want to modify it.
Developers of subclassed `Model` are advised to override this method,
and continue to update the dict from `super(MyModel, self).get_config()`
to provide the proper configuration of this `Model`. The default config
will return config dict for init parameters if they are basic types.
Raises `NotImplementedError` when in cases where a custom
`get_config()` implementation is required for the subclassed model.
Returns:
Python dictionary containing the configuration of this `Model`.
"""
# If sublcass doesn't implement `get_config()` parse from init args
# otherwise default to empty dict
if generic_utils.is_default(self.get_config):
try:
config = base_layer.Layer.get_config(self)
except NotImplementedError:
config = {}
logging.warning(
"Model's `__init__()` arguments contain non-serializable "
"objects. Please implement a `get_config()` method in the "
"subclassed Model for proper saving and loading. "
"Defaulting to empty config."
)
else:
config = {}
return config
@classmethod
def from_config(cls, config, custom_objects=None):
# `from_config` assumes `cls` is either `Functional` or a child class of
# `Functional`. In the case that `cls` is meant to behave like a child
# class of `Functional` but only inherits from the `Model` class, we
# have to call `cls(...)` instead of `Functional.from_config`.
from tf_keras.src.engine import functional
with serialization.SharedObjectLoadingScope():
functional_config_keys = [
"name",
"layers",
"input_layers",
"output_layers",
]
is_functional_config = all(
key in config for key in functional_config_keys
)
argspec = tf_inspect.getfullargspec(cls.__init__)
functional_init_args = tf_inspect.getfullargspec(
functional.Functional.__init__
).args[1:]
revivable_as_functional = (
cls in {functional.Functional, Model}
or argspec.args[1:] == functional_init_args
or (argspec.varargs == "args" and argspec.varkw == "kwargs")
)
if is_functional_config and revivable_as_functional:
# Revive Functional model
# (but not Functional subclasses with a custom __init__)
inputs, outputs, layers = functional.reconstruct_from_config(
config, custom_objects
)
model = cls(
inputs=inputs, outputs=outputs, name=config.get("name")
)
functional.connect_ancillary_layers(model, layers)
else:
# Either the model has a custom __init__, or the config
# does not contain all the information necessary to
# revive a Functional model. This happens when the user creates
# subclassed models where `get_config()` is returning
# insufficient information to be considered a Functional model.
# In this case, we fall back to provide all config into the
# constructor of the class.
try:
model = cls(**config)
except TypeError as e:
raise TypeError(
"Unable to revive model from config. When overriding "
"the `get_config()` method, make sure that the "
"returned config contains all items used as arguments "
f"in the constructor to {cls}, "
"which is the default behavior. "
"You can override this default behavior by defining a "
"`from_config(cls, config)` class method to specify "
"how to create an "
f"instance of {cls.__name__} from its config.\n\n"
f"Received config={config}\n\n"
f"Error encountered during deserialization: {e}"
)
return model
def to_json(self, **kwargs):
"""Returns a JSON string containing the network configuration.
To load a network from a JSON save file, use
`keras.models.model_from_json(json_string, custom_objects={})`.
Args:
**kwargs: Additional keyword arguments to be passed to
*`json.dumps()`.
Returns:
A JSON string.
"""
model_config = self._updated_config()
return json.dumps(
model_config, default=json_utils.get_json_type, **kwargs
)
def to_yaml(self, **kwargs):
"""Returns a yaml string containing the network configuration.
Note: Since TF 2.6, this method is no longer supported and will raise a
RuntimeError.
To load a network from a yaml save file, use
`keras.models.model_from_yaml(yaml_string, custom_objects={})`.
`custom_objects` should be a dictionary mapping
the names of custom losses / layers / etc to the corresponding
functions / classes.
Args:
**kwargs: Additional keyword arguments
to be passed to `yaml.dump()`.
Returns:
A YAML string.
Raises:
RuntimeError: announces that the method poses a security risk
"""
raise RuntimeError(
"Method `model.to_yaml()` has been removed due to security risk of "
"arbitrary code execution. Please use `model.to_json()` instead."
)
def reset_states(self):
for layer in self.layers:
if hasattr(layer, "reset_states") and getattr(
layer, "stateful", False
):
layer.reset_states()
@property
@doc_controls.do_not_generate_docs
def state_updates(self):
"""Deprecated, do NOT use!
Returns the `updates` from all layers that are stateful.
This is useful for separating training updates and
state updates, e.g. when we need to update a layer's internal state
during prediction.
Returns:
A list of update ops.
"""
warnings.warn(
"`Model.state_updates` will be removed in a future version. "
"This property should not be used in TensorFlow 2.0, "
"as `updates` are applied automatically.",
stacklevel=2,
)
state_updates = []
for layer in self.layers:
if getattr(layer, "stateful", False):
if hasattr(layer, "updates"):
state_updates += layer.updates
return state_updates
@property
def weights(self):
"""Returns the list of all layer variables/weights.
Note: This will not track the weights of nested `tf.Modules` that are
not themselves TF-Keras layers.
Returns:
A list of variables.
"""
return self._dedup_weights(self._undeduplicated_weights)
@property
def _undeduplicated_weights(self):
"""Returns the undeduplicated list of all layer variables/weights."""
self._assert_weights_created()
weights = []
for layer in self._self_tracked_trackables:
weights += layer.variables
weights += self._trainable_weights + self._non_trainable_weights
return weights
def summary(
self,
line_length=None,
positions=None,
print_fn=None,
expand_nested=False,
show_trainable=False,
layer_range=None,
):
"""Prints a string summary of the network.
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, becomes
`[0.3, 0.6, 0.70, 1.]`. Defaults to `None`.
print_fn: Print function to use. By default, prints to `stdout`.
If `stdout` doesn't work in your environment, change 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.
Defaults to `False`.
show_trainable: Whether to show if a layer is trainable.
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.
Raises:
ValueError: if `summary()` is called before the model is built.
"""
if not self.built:
raise ValueError(
"This model has not yet been built. "
"Build the model first by calling `build()` or by calling "
"the model on a batch of data."
)
layer_utils.print_summary(
self,
line_length=line_length,
positions=positions,
print_fn=print_fn,
expand_nested=expand_nested,
show_trainable=show_trainable,
layer_range=layer_range,
)
@property
def layers(self):
return list(self._flatten_layers(include_self=False, recursive=False))
@layers.setter
def layers(self, _):
raise AttributeError(
"`Model.layers` attribute is reserved and should not be used. "
"Please use another name."
)
def get_layer(self, name=None, index=None):
"""Retrieves a layer based on either its name (unique) or index.
If `name` and `index` are both provided, `index` will take precedence.
Indices are based on order of horizontal graph traversal (bottom-up).
Args:
name: String, name of layer.
index: Integer, index of layer.
Returns:
A layer instance.
"""
# TODO(fchollet): We could build a dictionary based on layer names
# since they are constant, but we have not done that yet.
if index is not None and name is not None:
raise ValueError(
"Provide only a layer name or a layer index. Received: "
f"index={index}, name={name}."
)
if index is not None:
if len(self.layers) <= index:
raise ValueError(
f"Was asked to retrieve layer at index {index}"
f" but model only has {len(self.layers)}"
" layers."
)
else:
return self.layers[index]
if name is not None:
for layer in self.layers:
if layer.name == name:
return layer
raise ValueError(
f"No such layer: {name}. Existing layers are: "
f"{list(layer.name for layer in self.layers)}."
)
raise ValueError(
"Provide either a layer name or layer index at `get_layer`."
)
def get_weight_paths(self):
"""Retrieve all the variables and their paths for the model.
The variable path (string) is a stable key to identify a `tf.Variable`
instance owned by the model. It can be used to specify variable-specific
configurations (e.g. DTensor, quantization) from a global view.
This method returns a dict with weight object paths as keys
and the corresponding `tf.Variable` instances as values.
Note that if the model is a subclassed model and the weights haven't
been initialized, an empty dict will be returned.
Returns:
A dict where keys are variable paths and values are `tf.Variable`
instances.
Example:
```python
class SubclassModel(tf.keras.Model):
def __init__(self, name=None):
super().__init__(name=name)
self.d1 = tf.keras.layers.Dense(10)
self.d2 = tf.keras.layers.Dense(20)
def call(self, inputs):
x = self.d1(inputs)
return self.d2(x)
model = SubclassModel()
model(tf.zeros((10, 10)))
weight_paths = model.get_weight_paths()
# weight_paths:
# {
# 'd1.kernel': model.d1.kernel,
# 'd1.bias': model.d1.bias,
# 'd2.kernel': model.d2.kernel,
# 'd2.bias': model.d2.bias,
# }
# Functional model
inputs = tf.keras.Input((10,), batch_size=10)
x = tf.keras.layers.Dense(20, name='d1')(inputs)
output = tf.keras.layers.Dense(30, name='d2')(x)
model = tf.keras.Model(inputs, output)
d1 = model.layers[1]
d2 = model.layers[2]
weight_paths = model.get_weight_paths()
# weight_paths:
# {
# 'd1.kernel': d1.kernel,
# 'd1.bias': d1.bias,
# 'd2.kernel': d2.kernel,
# 'd2.bias': d2.bias,
# }
```
"""
result = {}
(
descendants,
object_paths_dict,
) = tf.__internal__.tracking.ObjectGraphView(
self
).breadth_first_traversal()
for descendant in descendants:
if isinstance(descendant, tf.Variable):
trackable_references = object_paths_dict[descendant]
object_path = ".".join([t.name for t in trackable_references])
result[object_path] = descendant
return result
def get_compile_config(self):
"""Returns a serialized config with information for compiling the model.
This method returns a config dictionary containing all the information
(optimizer, loss, metrics, etc.) with which the model was compiled.
Returns:
A dict containing information for compiling the model.
"""
if self._is_compiled and hasattr(self, "_compile_config"):
return self._compile_config.serialize()
def compile_from_config(self, config):
"""Compiles the model with the information given in config.
This method uses the information in the config (optimizer, loss,
metrics, etc.) to compile the model.
Args:
config: Dict containing information for compiling the model.
"""
has_overridden_compile = self.__class__.compile != Model.compile
if has_overridden_compile:
logging.warning(
"`compile()` was not called as part of model loading "
"because the model's `compile()` method is custom. "
"All subclassed Models that have `compile()` "
"overridden should also override "
"`get_compile_config()` and `compile_from_config(config)`. "
"Alternatively, you can "
"call `compile()` manually after loading."
)
return
config = saving_lib.deserialize_keras_object(config)
self.compile(**config)
if (
hasattr(self, "optimizer")
# Exempt legacy optimizers.
and isinstance(self.optimizer, optimizer.Optimizer)
and self.built
):
# Create optimizer variables.
self.optimizer.build(self.trainable_variables)
def export(self, filepath):
"""Create a SavedModel artifact for inference (e.g. via TF-Serving).
This method lets you export a model to a lightweight SavedModel artifact
that contains the model's forward pass only (its `call()` method)
and can be served via e.g. TF-Serving. The forward pass is registered
under the name `serve()` (see example below).
The original code of the model (including any custom layers you may
have used) is *no longer* necessary to reload the artifact -- it is
entirely standalone.
Args:
filepath: `str` or `pathlib.Path` object. Path where to save
the artifact.
Example:
```python
# Create the artifact
model.export("path/to/location")
# Later, in a different process / environment...
reloaded_artifact = tf.saved_model.load("path/to/location")
predictions = reloaded_artifact.serve(input_data)
```
If you would like to customize your serving endpoints, you can
use the lower-level `keras.export.ExportArchive` class. The `export()`
method relies on `ExportArchive` internally.
"""
from tf_keras.src.export import export_lib
export_lib.export_model(self, filepath)
@tf.__internal__.tracking.no_automatic_dependency_tracking
def _set_save_spec(self, inputs, args=None, kwargs=None):
"""Defines the save spec so that serialization can trace `call()`.
The TensorSpecs of the call function `inputs`, `args`, and `kwargs` are
saved into a tuple of `([inputs] + args, kwargs)`. The input
`TensorSpec` names are updated to match the built `input_names`.
The specs can be retrieved with the `save_spec` property.
Args:
inputs: possibly nested inputs passed into the call function.
args: a list of positional arguments passed into call.
kwargs: a dictionary of keyword arguments passed into call.
"""
if self._saved_model_inputs_spec is not None:
return # Already set.
args = args or []
kwargs = kwargs or {}
input_names = self.input_names
if not input_names:
input_names = compile_utils.create_pseudo_input_names(inputs)
flat_inputs = tf.nest.flatten(inputs)
inputs_spec = []
for name, tensor in zip(input_names, flat_inputs):
inputs_spec.append(
tf_utils.get_tensor_spec(tensor, dynamic_batch=False, name=name)
)
inputs_spec = tf.nest.pack_sequence_as(inputs, inputs_spec)
super()._set_save_spec(inputs_spec, args, kwargs)
# Store the input shapes
if (
self.__class__.__name__ == "Sequential"
and self._build_input_shape is None
):
self._build_input_shape = tf.nest.map_structure(
lambda x: None if x is None else x.shape, inputs_spec
)
def save_spec(self, dynamic_batch=True):
"""Returns the `tf.TensorSpec` of call args as a tuple `(args, kwargs)`.
This value is automatically defined after calling the model for the
first time. Afterwards, you can use it when exporting the model for
serving:
```python
model = tf.keras.Model(...)
@tf.function
def serve(*args, **kwargs):
outputs = model(*args, **kwargs)
# Apply postprocessing steps, or add additional outputs.
...
return outputs
# arg_specs is `[tf.TensorSpec(...), ...]`. kwarg_specs, in this
# example, is an empty dict since functional models do not use keyword
# arguments.
arg_specs, kwarg_specs = model.save_spec()
model.save(path, signatures={
'serving_default': serve.get_concrete_function(*arg_specs,
**kwarg_specs)
})
```
Args:
dynamic_batch: Whether to set the batch sizes of all the returned
`tf.TensorSpec` to `None`. (Note that when defining functional or
Sequential models with `tf.keras.Input([...], batch_size=X)`, the
batch size will always be preserved). Defaults to `True`.
Returns:
If the model inputs are defined, returns a tuple `(args, kwargs)`. All
elements in `args` and `kwargs` are `tf.TensorSpec`.
If the model inputs are not defined, returns `None`.
The model inputs are automatically set when calling the model,
`model.fit`, `model.evaluate` or `model.predict`.
"""
return self._get_save_spec(dynamic_batch, inputs_only=False)
def _assert_weights_created(self):
"""Asserts that all the weights for the model have been created.
For a non-dynamic model, the weights must already be created after the
layer has been called. For a dynamic model, the exact list of weights
can never be known for certain since it may change at any time during
execution.
We run this check right before accessing weights or getting the Numpy
value for the current weights. Otherwise, if the layer has never been
called, the user would just get an empty list, which is misleading.
Raises:
ValueError: if the weights of the network have not yet been created.
"""
if self.dynamic:
return
if (
"build" in self.__class__.__dict__
and self.__class__ != Model
and not self.built
):
# For any model that has customized build() method but hasn't been
# invoked yet, this will cover both sequential and subclass model.
# Also make sure to exclude Model class itself which has build()
# defined.
raise ValueError(
f"Weights for model '{self.name}' have not yet been "
"created. "
"Weights are created when the model is first called on "
"inputs or `build()` is called with an `input_shape`."
)
def _check_call_args(self, method_name):
"""Check that `call()` has only one positional arg."""
# Always allow first arg, regardless of arg name.
fullargspec = self._call_spec.full_argspec
if fullargspec.defaults:
positional_args = fullargspec.args[: -len(fullargspec.defaults)]
else:
positional_args = fullargspec.args
if "training" in positional_args:
positional_args.remove("training")
# self and first arg can be positional.
if len(positional_args) > 2:
extra_args = positional_args[2:]
raise ValueError(
f"Models passed to `{method_name}` can only have `training` "
"and the first argument in `call()` as positional arguments, "
f"found: {extra_args}."
)
def _validate_compile(self, optimizer, metrics, **kwargs):
"""Performs validation checks for the default `compile()`."""
if any(
isinstance(opt, optimizer_v1.Optimizer)
for opt in tf.nest.flatten(optimizer)
):
raise ValueError(
f"`tf.compat.v1.keras` Optimizer ({optimizer}) is "
"not supported when eager execution is enabled. Use a "
"`tf.keras` Optimizer instead, or disable eager "
"execution."
)
kwargs.pop("cloning", None) # Legacy DistStrat argument, never used.
kwargs.pop("experimental_run_tf_function", None) # Always `True`.
distribute_arg = kwargs.pop("distribute", None)
if distribute_arg is not None:
raise ValueError(
"`distribute` argument in compile is not available in TF 2.0. "
"Please create the model under the `strategy.scope()`. "
f"Received: {distribute_arg}."
)
target_tensor_arg = kwargs.pop("target_tensors", None)
if target_tensor_arg is not None:
raise ValueError(
"`target_tensors` argument is not supported when executing "
f"eagerly. Received: {target_tensor_arg}."
)
invalid_kwargs = set(kwargs) - {"sample_weight_mode"}
if invalid_kwargs:
raise TypeError(
"Invalid keyword argument(s) in `compile()`: "
f"{(invalid_kwargs,)}. Valid keyword arguments include "
'"cloning", "experimental_run_tf_function", "distribute",'
' "target_tensors", or "sample_weight_mode".'
)
# Model must be created and compiled with the same DistStrat.
if self.built and tf.distribute.has_strategy():
strategy = tf.distribute.get_strategy()
for v in self.variables:
if not strategy.extended.variable_created_in_scope(v):
raise ValueError(
f"Variable ({v}) was not created in the distribution "
f"strategy scope of ({strategy}). It is most likely "
"because some layers, model, or optimizer was being "
"created outside the distribution strategy scope. Try "
"to make sure your code looks similar "
"to the following.\nwith strategy.scope():\n"
" model=_create_model()\n"
" model.compile(...)"
)
# Model metrics must be created in the same distribution strategy scope
# as the model.
strategy = self.distribute_strategy
for metric in tf.nest.flatten(metrics):
for v in getattr(metric, "variables", []):
if not strategy.extended.variable_created_in_scope(v):
raise ValueError(
f"Metric ({metric}) passed to `model.compile` was "
"created inside a different distribution strategy "
"scope than the model. All metrics must be created "
"in the same distribution strategy "
f"scope as the model (in this case {strategy}). "
"If you pass in a string identifier for a metric to "
"compile, the metric will automatically be created "
"in the correct distribution strategy scope."
)
# Model metrics must be created in the same distribution strategy scope
# as the model.
for opt in tf.nest.flatten(optimizer):
for v in getattr(opt, "_weights", []):
if not strategy.extended.variable_created_in_scope(v):
raise ValueError(
f"Optimizer ({optimizer}) passed to `model.compile` "
"was created inside a different distribution strategy "
"scope than the model. All optimizers must be created "
"in the same distribution strategy scope as the model "
f"(in this case {strategy}). If you pass in a string "
"identifier for an optimizer to compile, the optimizer "
"will automatically be created in the correct "
"distribution strategy scope."
)
def _maybe_load_initial_counters_from_ckpt(
self, steps_per_epoch, initial_epoch
):
"""Maybe load initial epoch from ckpt, considering worker recovery.
Refer to tensorflow/python/tf_keras/distribute/worker_training_state.py
for more information.
Args:
steps_per_epoch: The number of step per epoch.
initial_epoch: The original initial_epoch user passes in `fit()`.
mode: The mode for running `model.fit()`.
Returns:
If the training is recovering from previous failure under multi-worker
training setting, return the (epoch, step) the training is supposed to
continue at. Otherwise, return the `initial_epoch, initial_step` the
user passes in.
"""
initial_step = 0
if self._training_state is not None:
return self._training_state.maybe_load_initial_counters_from_ckpt(
steps_per_epoch, initial_epoch, mode=ModeKeys.TRAIN
)
return (initial_epoch, initial_step)
def _assert_compile_was_called(self):
# Checks whether `compile` has been called. If it has been called,
# then the optimizer is set. This is different from whether the
# model is compiled
# (i.e. whether the model is built and its inputs/outputs are set).
if not self._is_compiled:
raise RuntimeError(
"You must compile your model before "
"training/testing. "
"Use `model.compile(optimizer, loss)`."
)
def _check_sample_weight_warning(self, x, sample_weight):
# Datasets can include sample weight, by returning a tuple with the
# structure of `(x, y, sample_weight)`.
sample_weight_present = sample_weight is not None or (
isinstance(x, tf.data.Dataset)
and isinstance(x.element_spec, tuple)
and len(x.element_spec) == 3
)
if (
sample_weight_present
and self.compiled_metrics._user_weighted_metrics is None
):
logging.warning(
"`evaluate()` received a value for `sample_weight`, but "
"`weighted_metrics` were not provided. Did you mean to pass "
"metrics to `weighted_metrics` in `compile()`? If this is "
"intentional you can pass `weighted_metrics=[]` to `compile()` "
"in order to silence this warning."
)
def _set_inputs(self, inputs, outputs=None, training=None):
"""This method is for compat with Modelv1. Only inputs are needed
here."""
self._set_save_spec(inputs)
@property
def _trackable_saved_model_saver(self):
return model_serialization.ModelSavedModelSaver(self)
def _trackable_children(self, save_type="checkpoint", **kwargs):
if save_type == "savedmodel":
# SavedModel needs to ignore the execution functions.
train_function = self.train_function
test_function = self.test_function
predict_function = self.predict_function
train_tf_function = self.train_tf_function
self.train_function = None
self.test_function = None
self.predict_function = None
self.train_tf_function = None
children = super()._trackable_children(save_type, **kwargs)
if save_type == "savedmodel":
self.train_function = train_function
self.test_function = test_function
self.predict_function = predict_function
self.train_tf_function = train_tf_function
return children
def _should_eval(self, epoch, validation_freq):
epoch = epoch + 1 # one-index the user-facing epoch.
if isinstance(validation_freq, int):
return epoch % validation_freq == 0
elif isinstance(validation_freq, list):
return epoch in validation_freq
else:
raise ValueError(
"Expected `validation_freq` to be a list or int. "
f"Received: validation_freq={validation_freq} of the "
f"type {type(validation_freq)}."
)
######################################################################
# Functions below exist only as v1 / v2 compatibility shims.
######################################################################
def _get_compile_args(self, user_metrics=True):
"""Used for saving or cloning a Model.
Args:
user_metrics: Whether to return user-supplied metrics or `Metric`
objects. If True, returns the user-supplied metrics.
Defaults to `True`.
Returns:
Dictionary of arguments that were used when compiling the model.
"""
self._assert_compile_was_called()
saved_metrics = self.compiled_metrics._user_metrics
saved_weighted_metrics = self.compiled_metrics._user_weighted_metrics
if not user_metrics:
if saved_metrics is not None:
saved_metrics = self.compiled_metrics._metrics
if saved_weighted_metrics is not None:
saved_weighted_metrics = self.compiled_metrics._weighted_metrics
compile_args = {
"optimizer": self.optimizer,
"loss": self.compiled_loss._user_losses,
"metrics": saved_metrics,
"weighted_metrics": saved_weighted_metrics,
"loss_weights": self.compiled_loss._user_loss_weights,
}
return compile_args
def _get_callback_model(self):
return self
def _in_multi_worker_mode(self):
return self.distribute_strategy.extended._in_multi_worker_mode()
@property
def _compile_was_called(self):
return self._is_compiled
| (self, filepath, overwrite=True, save_format=None, **kwargs) |
725,040 | tf_keras.src.engine.base_layer | save_own_variables | Saves the state of the layer.
You can override this method to take full control of how the state of
the layer is saved upon calling `model.save()`.
Args:
store: Dict where the state of the model will be saved.
| def save_own_variables(self, store):
"""Saves the state of the layer.
You can override this method to take full control of how the state of
the layer is saved upon calling `model.save()`.
Args:
store: Dict where the state of the model will be saved.
"""
all_vars = self._trainable_weights + self._non_trainable_weights
for i, v in enumerate(all_vars):
store[f"{i}"] = v.numpy()
| (self, store) |
725,042 | tf_keras.src.engine.training | save_weights | Saves all layer weights.
Either saves in HDF5 or in TensorFlow format based on the `save_format`
argument.
When saving in HDF5 format, the weight file has:
- `layer_names` (attribute), a list of strings
(ordered names of model layers).
- For every layer, a `group` named `layer.name`
- For every such layer group, a group attribute `weight_names`,
a list of strings
(ordered names of weights tensor of the layer).
- For every weight in the layer, a dataset
storing the weight value, named after the weight tensor.
When saving in TensorFlow format, all objects referenced by the network
are saved in the same format as `tf.train.Checkpoint`, including any
`Layer` instances or `Optimizer` instances assigned to object
attributes. For networks constructed from inputs and outputs using
`tf.keras.Model(inputs, outputs)`, `Layer` instances used by the network
are tracked/saved automatically. For user-defined classes which inherit
from `tf.keras.Model`, `Layer` instances must be assigned to object
attributes, typically in the constructor. See the documentation of
`tf.train.Checkpoint` and `tf.keras.Model` for details.
While the formats are the same, do not mix `save_weights` and
`tf.train.Checkpoint`. Checkpoints saved by `Model.save_weights` should
be loaded using `Model.load_weights`. Checkpoints saved using
`tf.train.Checkpoint.save` should be restored using the corresponding
`tf.train.Checkpoint.restore`. Prefer `tf.train.Checkpoint` over
`save_weights` for training checkpoints.
The TensorFlow format matches objects and variables by starting at a
root object, `self` for `save_weights`, and greedily matching attribute
names. For `Model.save` this is the `Model`, and for `Checkpoint.save`
this is the `Checkpoint` even if the `Checkpoint` has a model attached.
This means saving a `tf.keras.Model` using `save_weights` and loading
into a `tf.train.Checkpoint` with a `Model` attached (or vice versa)
will not match the `Model`'s variables. See the
[guide to training checkpoints](
https://www.tensorflow.org/guide/checkpoint) for details on
the TensorFlow format.
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` becomes 'tf'. Defaults to `None`.
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.
| # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Training-related part of the TF-Keras engine."""
import copy
import itertools
import json
import warnings
import weakref
import numpy as np
import tensorflow.compat.v2 as tf
from tensorflow.python.distribute import distribute_utils
from tensorflow.python.distribute import input_ops
from tensorflow.python.eager import context
from tensorflow.python.platform import tf_logging as logging
from tensorflow.python.util.tf_export import keras_export
from tensorflow.tools.docs import doc_controls
from tf_keras.src import backend
from tf_keras.src import callbacks as callbacks_module
from tf_keras.src import optimizers
from tf_keras.src.dtensor import dtensor_api
from tf_keras.src.dtensor import layout_map as layout_map_lib
from tf_keras.src.engine import base_layer
from tf_keras.src.engine import base_layer_utils
from tf_keras.src.engine import compile_utils
from tf_keras.src.engine import data_adapter
from tf_keras.src.engine import input_layer as input_layer_module
from tf_keras.src.engine import training_utils
from tf_keras.src.metrics import base_metric
from tf_keras.src.mixed_precision import loss_scale_optimizer as lso
from tf_keras.src.optimizers import optimizer
from tf_keras.src.optimizers import optimizer_v1
from tf_keras.src.saving import pickle_utils
from tf_keras.src.saving import saving_api
from tf_keras.src.saving import saving_lib
from tf_keras.src.saving import serialization_lib
from tf_keras.src.saving.legacy import serialization
from tf_keras.src.saving.legacy.saved_model import json_utils
from tf_keras.src.saving.legacy.saved_model import model_serialization
from tf_keras.src.utils import generic_utils
from tf_keras.src.utils import io_utils
from tf_keras.src.utils import layer_utils
from tf_keras.src.utils import steps_per_execution_tuning
from tf_keras.src.utils import tf_inspect
from tf_keras.src.utils import tf_utils
from tf_keras.src.utils import traceback_utils
from tf_keras.src.utils import version_utils
from tf_keras.src.utils.mode_keys import ModeKeys
try:
import h5py
except ImportError:
h5py = None
@keras_export("keras.Model", "keras.models.Model")
class Model(base_layer.Layer, version_utils.ModelVersionSelector):
"""A model grouping layers into an object with training/inference features.
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:
```python
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)
```
Note: Only dicts, lists, and tuples of input tensors are supported. Nested
inputs are not supported (e.g. lists of list or dicts of dict).
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:
```python
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()`.
```python
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:
```python
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()`.
"""
_TF_MODULE_IGNORED_PROPERTIES = frozenset(
itertools.chain(
(
"_train_counter",
"_test_counter",
"_predict_counter",
"_steps_per_execution",
"_compiled_trainable_state",
),
base_layer.Layer._TF_MODULE_IGNORED_PROPERTIES,
)
)
_SCALAR_UPRANKING_ON = False
def __new__(cls, *args, **kwargs):
# Signature detection
if is_functional_model_init_params(args, kwargs) and cls == Model:
# Functional model
from tf_keras.src.engine import functional
return functional.Functional(skip_init=True, *args, **kwargs)
else:
return super(Model, cls).__new__(cls, *args, **kwargs)
@tf.__internal__.tracking.no_automatic_dependency_tracking
@traceback_utils.filter_traceback
def __init__(self, *args, **kwargs):
self._is_model_for_instrumentation = True
# Special case for Subclassed Functional Model, which we couldn't detect
# when __new__ is called. We only realize it is a functional model when
# it calls super.__init__ with input and output tensor.
from tf_keras.src.engine import functional
if is_functional_model_init_params(args, kwargs) and not isinstance(
self, functional.Functional
):
# Filter the kwargs for multiple inheritance.
supported_kwargs = [
"inputs",
"outputs",
"name",
"trainable",
"skip_init",
]
model_kwargs = {
k: kwargs[k] for k in kwargs if k in supported_kwargs
}
other_kwargs = {
k: kwargs[k] for k in kwargs if k not in supported_kwargs
}
inject_functional_model_class(self.__class__)
functional.Functional.__init__(self, *args, **model_kwargs)
# In case there is any multiple inheritance here, we need to call
# the __init__ for any class that appears after the Functional
# class.
clz_to_init = []
found_functional_class = False
for clz in self.__class__.__bases__:
if issubclass(clz, functional.Functional):
found_functional_class = True
continue
if found_functional_class:
clz_to_init.append(clz)
if clz_to_init:
for clz in clz_to_init:
clz.__init__(self, *args, **other_kwargs)
elif other_kwargs:
# In case there are unused kwargs, we should raise an error to
# user, in case they have a typo in the param name.
raise TypeError(
"The following keyword arguments passed to `Model` aren't "
"supported: {}.".format(other_kwargs)
)
return
# The following are implemented as property functions:
# self.trainable_weights
# self.non_trainable_weights
# `inputs` / `outputs` will only appear in kwargs if either are
# misspelled.
generic_utils.validate_kwargs(
kwargs,
{
"trainable",
"dtype",
"dynamic",
"name",
"autocast",
"inputs",
"outputs",
},
)
super().__init__(**kwargs)
# By default, Model is a subclass model, which is not in graph network.
self._is_graph_network = False
self.inputs = None
self.outputs = None
self.input_names = None
self.output_names = None
# stop_training is used by callback to stop training when error happens
self.stop_training = False
self.history = None
# These objects are used in the default `Model.compile`. They are not
# guaranteed to be set after `Model.compile` is called, as users can
# override compile with custom logic.
self.compiled_loss = None
self.compiled_metrics = None
# This is True for Sequential networks and Functional networks.
self._compute_output_and_mask_jointly = False
# Don't reset compilation if already done. This may occur if calling
# `__init__` (or `_init_graph_network`) on an already-compiled model
# such as a Sequential model. Sequential models may need to rebuild
# themselves after compilation.
self._maybe_create_attribute("_is_compiled", False)
self._maybe_create_attribute("optimizer", None)
# Model must be created under scope of DistStrat it will be trained
# with.
if tf.distribute.has_strategy():
self._distribution_strategy = tf.distribute.get_strategy()
else:
self._distribution_strategy = None
self._distribute_reduction_method = None
self._cluster_coordinator = None
# Defaults to value of `tf.config.experimental_functions_run_eagerly`.
self._run_eagerly = None
# Initialize cache attrs.
self._reset_compile_cache()
# Fault-tolerance handler. Set in `ModelCheckpoint`.
self._training_state = None
self._saved_model_inputs_spec = None
self._saved_model_arg_spec = None
self._checkpoint = tf.train.Checkpoint(root=weakref.ref(self))
self._steps_per_execution = None
self._steps_per_execution_tuner = None
self._autotune_steps_per_execution = False
self._layout_map = layout_map_lib.get_current_layout_map()
self._init_batch_counters()
self._base_model_initialized = True
# `jit_compile` starts off with None as default and gets overwritten by
# the value specified in `Model.compile`, and this is effective for
# `fit`, `evaluate`, and `predict`.
self._jit_compile = None
def _create_counter_variable(self, init_value):
"""Helper function for counter variable creation.
For the DTensor use case with layout map, since the variable are not
tracked by model, they can't be visited by the layout map, and need to
be properly initialized as DVariable.
"""
# This function should be removed after we move to the strategy based
# implementation for DTensor.
if self._layout_map is None:
agg = tf.VariableAggregation.ONLY_FIRST_REPLICA
return tf.Variable(init_value, dtype="int64", aggregation=agg)
else:
layout = dtensor_api.Layout.replicated(
mesh=self._layout_map.get_default_mesh(), rank=0
)
return dtensor_api.DVariable(
init_value, dtype="int64", layout=layout
)
@tf.__internal__.tracking.no_automatic_dependency_tracking
def _init_batch_counters(self):
# Untracked Variables, used to keep track of mini-batches seen in `fit`,
# `evaluate`, and `predict`.
if not tf.inside_function():
# Creating variables inside tf.function is not allowed, hence
# these would otherwise prevent users from creating TF-Keras layers
# inside tf.function.
# These variables are not connected to outputs so they have no
# effect on graph generation anyway.
self._train_counter = self._create_counter_variable(0)
self._test_counter = self._create_counter_variable(0)
self._predict_counter = self._create_counter_variable(0)
def __setattr__(self, name, value):
if not getattr(self, "_self_setattr_tracking", True):
super().__setattr__(name, value)
return
if all(
isinstance(v, (base_layer.Layer, tf.Variable))
or base_layer_utils.has_weights(v)
for v in tf.nest.flatten(value)
):
try:
self._base_model_initialized
except AttributeError:
raise RuntimeError(
"It looks like you are subclassing `Model` and you "
"forgot to call `super().__init__()`."
" Always start with this line."
)
super().__setattr__(name, value)
def __reduce__(self):
if self.built:
return (
pickle_utils.deserialize_model_from_bytecode,
(pickle_utils.serialize_model_as_bytecode(self),),
)
else:
# SavedModel (and hence serialize_model_as_bytecode) only support
# built models, but if the model is not built,
# it may be possible to serialize as a plain Python object,
# as long as the constituent parts (layers, optimizers, losses,
# etc.) can be serialized as plain Python objects. Thus we call up
# the superclass hierarchy to get an implementation of __reduce__
# that can pickle this Model as a plain Python object.
return super().__reduce__()
def __deepcopy__(self, memo):
if self.built:
new = pickle_utils.deserialize_model_from_bytecode(
pickle_utils.serialize_model_as_bytecode(self)
)
memo[id(self)] = new
else:
# See comment in __reduce__ for explanation
deserializer, serialized, *rest = super().__reduce__()
new = deserializer(*serialized)
memo[id(self)] = new
if rest:
state = copy.deepcopy(rest[0], memo=memo)
new.__setstate__(state)
return new
def __copy__(self):
return self.__deepcopy__({})
@generic_utils.default
def build(self, input_shape):
"""Builds the model based on input shapes received.
This is to be used for subclassed models, which do not know at
instantiation time what their inputs look like.
This method only exists for users who want to call `model.build()` in a
standalone way (as a substitute for calling the model on real data to
build it). It will never be called by the framework (and thus it will
never throw unexpected errors in an unrelated workflow).
Args:
input_shape: Single tuple, `TensorShape` instance, or list/dict of
shapes, where shapes are tuples, integers, or `TensorShape`
instances.
Raises:
ValueError:
1. In case of invalid user-provided data (not of type tuple,
list, `TensorShape`, or dict).
2. If the model requires call arguments that are agnostic
to the input shapes (positional or keyword arg in call
signature).
3. If not all layers were properly built.
4. If float type inputs are not supported within the layers.
In each of these cases, the user should build their model by calling
it on real tensor data.
"""
if self._is_graph_network:
super().build(input_shape)
return
if input_shape is None:
raise ValueError(
"Input shape must be defined when calling `build()` on "
"a `Model` subclass."
)
valid_types = (tuple, list, tf.TensorShape, dict)
if not isinstance(input_shape, valid_types):
raise ValueError(
"Specified input shape is not one of the valid types. "
"Please specify a batch input shape of type tuple or "
"list of input shapes. User provided "
"input type: {}.".format(type(input_shape))
)
if input_shape and not self.inputs:
# We create placeholders for the `None`s in the shape and build the
# model in a Graph. Since tf.Variable is compatible with both eager
# execution and graph building, the variables created after building
# the model in a Graph are still valid when executing eagerly.
if tf.executing_eagerly():
graph = tf.__internal__.FuncGraph("build_graph")
else:
graph = backend.get_graph()
with graph.as_default():
if isinstance(input_shape, list) and all(
d is None or isinstance(d, int) for d in input_shape
):
input_shape = tuple(input_shape)
if isinstance(input_shape, list):
x = [
base_layer_utils.generate_placeholders_from_shape(shape)
for shape in input_shape
]
elif isinstance(input_shape, dict):
x = {
k: base_layer_utils.generate_placeholders_from_shape(
shape
)
for k, shape in input_shape.items()
}
else:
x = base_layer_utils.generate_placeholders_from_shape(
input_shape
)
kwargs = {}
call_signature = self._call_spec.full_argspec
call_args = call_signature.args
# Exclude `self`, `inputs`, and any argument with a default
# value.
if len(call_args) > 2:
if call_signature.defaults:
call_args = call_args[2 : -len(call_signature.defaults)]
else:
call_args = call_args[2:]
for arg in call_args:
if arg == "training":
# Case where `training` is a positional arg with no
# default.
kwargs["training"] = False
else:
# Has invalid call signature with unknown positional
# arguments.
raise ValueError(
"Currently, you cannot build your model if it "
"has positional or keyword arguments that are "
"not inputs to the model, but are required for "
"its `call()` method. Instead, in order to "
"instantiate and build your model, `call()` "
"your model on real tensor data with all "
"expected call arguments. The argument "
"for `call()` can be a single list/tuple that "
"contains multiple inputs."
)
elif len(call_args) < 2:
# Signature without `inputs`.
raise ValueError(
"You can only call `build()` on a model if its "
"`call()` method accepts an `inputs` argument."
)
try:
self.call(x, **kwargs)
except (tf.errors.InvalidArgumentError, TypeError) as e:
raise ValueError(
"You cannot build your model by calling `build` "
"if your layers do not support float type inputs. "
"Instead, in order to instantiate and build your "
"model, call your model on real tensor data (of "
"the correct dtype).\n\nThe actual error from "
f"`call` is: {e}."
)
super().build(input_shape)
@traceback_utils.filter_traceback
def __call__(self, *args, **kwargs):
if self._layout_map is not None and not self.built:
# Note that this method is only overridden for DTensor and layout
# injection purpose.
# Capture the inputs and create graph input as replacement for model
# to initialize its weights first.
copied_args = copy.copy(args)
copied_kwargs = copy.copy(kwargs)
(
inputs,
copied_args,
copied_kwargs,
) = self._call_spec.split_out_first_arg(copied_args, copied_kwargs)
def _convert_to_graph_inputs(x):
if isinstance(x, (tf.Tensor, np.ndarray, float, int)):
x = tf.convert_to_tensor(x)
return input_layer_module.Input(x.shape)
# TODO(scottzhu): maybe better handle mask and training flag.
inputs = tf.nest.map_structure(_convert_to_graph_inputs, inputs)
copied_args = tf.nest.map_structure(
_convert_to_graph_inputs, copied_args
)
copied_kwargs = tf.nest.map_structure(
_convert_to_graph_inputs, copied_kwargs
)
with layout_map_lib.layout_map_scope(self._layout_map):
# We ignore the result here.
super().__call__(inputs, *copied_args, **copied_kwargs)
layout_map_lib._map_subclass_model_variable(self, self._layout_map)
return super().__call__(*args, **kwargs)
@doc_controls.doc_in_current_and_subclasses
def call(self, inputs, training=None, mask=None):
"""Calls the model on new inputs and returns the outputs as tensors.
In this case `call()` just reapplies
all ops in the graph to the new inputs
(e.g. build a new computational graph from the provided inputs).
Note: This method should not be called directly. It is only meant to be
overridden when subclassing `tf.keras.Model`.
To call a model on an input, always use the `__call__()` method,
i.e. `model(inputs)`, which relies on the underlying `call()` method.
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](https://www.tensorflow.org/guide/keras/masking_and_padding).
Returns:
A tensor if there is a single output, or
a list of tensors if there are more than one outputs.
"""
raise NotImplementedError(
"Unimplemented `tf.keras.Model.call()`: if you "
"intend to create a `Model` with the Functional "
"API, please provide `inputs` and `outputs` "
"arguments. Otherwise, subclass `Model` with an "
"overridden `call()` method."
)
@traceback_utils.filter_traceback
def compile(
self,
optimizer="rmsprop",
loss=None,
metrics=None,
loss_weights=None,
weighted_metrics=None,
run_eagerly=None,
steps_per_execution=None,
jit_compile=None,
pss_evaluation_shards=0,
**kwargs,
):
"""Configures the model for training.
Example:
```python
model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=1e-3),
loss=tf.keras.losses.BinaryCrossentropy(),
metrics=[tf.keras.metrics.BinaryAccuracy(),
tf.keras.metrics.FalseNegatives()])
```
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. 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`. Defaults to
`False`.
steps_per_execution: Int or `'auto'`. The number of batches to
run during each `tf.function` call. If set to "auto", keras will
automatically tune `steps_per_execution` during runtime. Running
multiple batches inside a single `tf.function` call can greatly
improve performance on TPUs, when used with distributed strategies
such as `ParameterServerStrategy`, or with 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). Defaults to `1`.
jit_compile: If `True`, compile the model training step with XLA.
[XLA](https://www.tensorflow.org/xla) is an optimizing compiler
for machine learning.
`jit_compile` is not enabled for by default.
Note that `jit_compile=True`
may not necessarily work for all models.
For more information on supported operations please refer to the
[XLA documentation](https://www.tensorflow.org/xla).
Also refer to
[known XLA issues](https://www.tensorflow.org/xla/known_issues)
for more details.
pss_evaluation_shards: Integer or 'auto'. Used for
`tf.distribute.ParameterServerStrategy` training only. This arg
sets the number of shards to split the dataset into, to enable an
exact visitation guarantee for evaluation, meaning the model will
be applied to each dataset element exactly once, even if workers
fail. The dataset must be sharded to ensure separate workers do
not process the same data. The number of shards should be at least
the number of workers for good performance. A value of 'auto'
turns on exact evaluation and uses a heuristic for the number of
shards based on the number of workers. 0, meaning no
visitation guarantee is provided. NOTE: Custom implementations of
`Model.test_step` will be ignored when doing exact evaluation.
Defaults to `0`.
**kwargs: Arguments supported for backwards compatibility only.
"""
if jit_compile and not tf_utils.can_jit_compile(warn=True):
jit_compile = False
self._compile_config = serialization_lib.Config(
optimizer=optimizer,
loss=loss,
metrics=metrics,
loss_weights=loss_weights,
weighted_metrics=weighted_metrics,
run_eagerly=run_eagerly,
steps_per_execution=steps_per_execution,
jit_compile=jit_compile,
)
with self.distribute_strategy.scope():
if "experimental_steps_per_execution" in kwargs:
logging.warning(
"The argument `steps_per_execution` is no longer "
"experimental. Pass `steps_per_execution` instead of "
"`experimental_steps_per_execution`."
)
if not steps_per_execution:
steps_per_execution = kwargs.pop(
"experimental_steps_per_execution"
)
# When compiling from an already-serialized model, we do not want to
# reapply some processing steps (e.g. metric renaming for
# multi-output models, which have prefixes added for each
# corresponding output name).
from_serialized = kwargs.pop("from_serialized", False)
self._validate_compile(optimizer, metrics, **kwargs)
self._run_eagerly = run_eagerly
self.optimizer = self._get_optimizer(optimizer)
mesh = None
if self._layout_map is not None:
mesh = self._layout_map.get_default_mesh()
if isinstance(loss, compile_utils.LossesContainer):
self.compiled_loss = loss
else:
self.compiled_loss = compile_utils.LossesContainer(
loss,
loss_weights,
output_names=self.output_names,
mesh=mesh,
)
self.compiled_metrics = compile_utils.MetricsContainer(
metrics,
weighted_metrics,
output_names=self.output_names,
from_serialized=from_serialized,
mesh=mesh,
)
if steps_per_execution == "auto":
if self._steps_per_execution is None:
self._configure_steps_per_execution(1)
self._steps_per_execution_tuner = (
steps_per_execution_tuning.StepsPerExecutionTuner(
self.optimizer, self._steps_per_execution
)
)
self._autotune_steps_per_execution = True
else:
self._configure_steps_per_execution(steps_per_execution or 1)
self._pss_evaluation_shards = self._infer_exact_eval_shards(
pss_evaluation_shards
)
# Initializes attrs that are reset each time `compile` is called.
self._reset_compile_cache()
self._is_compiled = True
self.loss = loss or {}
if (self._run_eagerly or self.dynamic) and jit_compile:
raise ValueError(
"You cannot enable `run_eagerly` and `jit_compile` "
"at the same time."
)
else:
self._jit_compile = jit_compile
def _get_optimizer(self, optimizer):
"""Wraps `optimizer` in `LossScaleOptimizer` if necessary."""
def _get_single_optimizer(opt):
opt = optimizers.get(opt)
if self.dtype_policy.name == "mixed_float16" and not isinstance(
opt, lso.BaseLossScaleOptimizer
):
# Loss scaling is necessary with mixed_float16 for models to
# converge to the same accuracy as with float32.
opt = lso.BaseLossScaleOptimizer(opt)
return opt
return tf.nest.map_structure(_get_single_optimizer, optimizer)
@tf.__internal__.tracking.no_automatic_dependency_tracking
def _reset_compile_cache(self):
self.train_function = None
self.test_function = None
self.predict_function = None
# Used to cache the `tf.function`'ed `train_function` to be logged in
# TensorBoard, since the original `train_function` is not necessarily
# a `tf.function` (e.g., with ParameterServerStrategy, the
# `train_function` is a scheduling of the actual training function to a
# remote worker).
self.train_tf_function = None
# Used to cache `trainable` attr of `Layer`s for `fit`.
self._compiled_trainable_state = self._get_trainable_state()
@tf.__internal__.tracking.no_automatic_dependency_tracking
def _configure_steps_per_execution(self, steps_per_execution):
self._steps_per_execution = self._create_counter_variable(
steps_per_execution
)
@property
def _should_compute_mask(self):
return False
@property
def metrics(self):
"""Return metrics added using `compile()` or `add_metric()`.
Note: Metrics passed to `compile()` are available only after a
`keras.Model` has been trained/evaluated on actual data.
Examples:
>>> 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"])
>>> [m.name for m in model.metrics]
[]
>>> x = np.random.random((2, 3))
>>> y = np.random.randint(0, 2, (2, 2))
>>> model.fit(x, y)
>>> [m.name for m in model.metrics]
['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.add_metric(
... tf.reduce_sum(output_2), name='mean', aggregation='mean')
>>> model.compile(optimizer="Adam", loss="mse", metrics=["mae", "acc"])
>>> model.fit(x, (y, y))
>>> [m.name for m in model.metrics]
['loss', 'out_loss', 'out_1_loss', 'out_mae', 'out_acc', 'out_1_mae',
'out_1_acc', 'mean']
"""
metrics = []
if self._is_compiled:
if self.compiled_loss is not None:
metrics += self.compiled_loss.metrics
if self.compiled_metrics is not None:
metrics += self.compiled_metrics.metrics
for l in self._flatten_layers():
metrics.extend(l._metrics)
return metrics
@property
def metrics_names(self):
"""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.
Examples:
>>> 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']
"""
# This property includes all output names including `loss` and
# per-output losses for backward compatibility.
return [m.name for m in self.metrics]
@property
def distribute_strategy(self):
"""The `tf.distribute.Strategy` this model was created under."""
return self._distribution_strategy or tf.distribute.get_strategy()
@property
def run_eagerly(self):
"""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.
Returns:
Boolean, whether the model should run eagerly.
"""
if self.dynamic and self._run_eagerly == False:
# TODO(fchollet): consider using py_func to enable this.
raise ValueError(
"Your model contains layers that can only be "
"successfully run in eager execution (layers "
"constructed with `dynamic=True`). "
"You cannot set `run_eagerly=False`."
)
if self._cluster_coordinator and self._run_eagerly:
raise ValueError(
"When using `Model` with `ParameterServerStrategy`, "
"`run_eagerly` is not supported."
)
# Run eagerly logic, by priority:
# (1) Dynamic models must be run eagerly.
# (2) Explicitly setting run_eagerly causes a Model to be run eagerly.
# (3) Not explicitly setting run_eagerly defaults to TF's global
# setting.
return (
self.dynamic
or self._run_eagerly
or (tf.config.functions_run_eagerly() and self._run_eagerly is None)
)
@run_eagerly.setter
def run_eagerly(self, value):
self._run_eagerly = value
@property
def autotune_steps_per_execution(self):
"""Settable property to enable tuning for steps_per_execution"""
return self._autotune_steps_per_execution
@autotune_steps_per_execution.setter
def autotune_steps_per_execution(self, value):
self._autotune_steps_per_execution = value
if value and self._steps_per_execution_tuner is None:
if self._steps_per_execution is None:
self._configure_steps_per_execution(1)
self._steps_per_execution_tuner = (
steps_per_execution_tuning.StepsPerExecutionTuner(
self.optimizer, self._steps_per_execution
)
)
@property
def steps_per_execution(self):
"""Settable `steps_per_execution variable. Requires a compiled model."""
return self._steps_per_execution
@steps_per_execution.setter
def steps_per_execution(self, value):
if self._steps_per_execution is None:
self._configure_steps_per_execution(value)
else:
self._steps_per_execution.assign(value)
@property
def jit_compile(self):
"""Specify whether to compile the model with XLA.
[XLA](https://www.tensorflow.org/xla) is an optimizing compiler
for machine learning. `jit_compile` is not enabled by default.
Note that `jit_compile=True` may not necessarily work for all models.
For more information on supported operations please refer to the
[XLA documentation](https://www.tensorflow.org/xla). Also refer to
[known XLA issues](https://www.tensorflow.org/xla/known_issues)
for more details.
"""
return self._jit_compile
@jit_compile.setter
def jit_compile(self, value):
# Function remains cached with previous jit_compile settings
if self._jit_compile == value:
# Avoid resetting compiler cache if possible if the value is the
# same
return
# Check if TensorFlow is compiled with XLA before setting the value
if value and not tf_utils.can_jit_compile(warn=True):
self._jit_compile = False
return
self._jit_compile = value
# Setting `jit_compile` should invalidate previously cached functions.
self._reset_compile_cache()
@property
def distribute_reduction_method(self):
"""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.
"""
return self._distribute_reduction_method or "auto"
@distribute_reduction_method.setter
def distribute_reduction_method(self, value):
self._distribute_reduction_method = value
def _validate_target_and_loss(self, y, loss):
"""Raises error if target or loss is not found.
This method verifies that the target and loss are properly populated
when applicable, or raises errors.
Args:
y: the target for training.
loss: the total loss tensor including loss added via `compile` and
`add_loss`.
"""
# `self.loss` references the loss added via `compile` call. If users
# have provided such, the target must be provided; otherwise it's a user
# error. Note that `self.loss` does not include losses added via
# `add_loss`, and it is a valid use when such loss from `add_loss`
# exists and target does not.
if self.loss and y is None:
raise ValueError(
"Target data is missing. Your model was compiled with "
f"loss={self.loss}, "
"and therefore expects target data to be provided in `fit()`."
)
# For training, there must be compiled loss or regularization loss to
# exist in order to apply the gradients. If one is not found, it means
# no loss was supplied via `compile` or `add_loss`.
elif loss is None:
raise ValueError(
"No loss found. You may have forgotten to provide a `loss` "
"argument in the `compile()` method."
)
def train_step(self, data):
"""The logic for one training step.
This method can be overridden to support custom training logic.
For concrete examples of how to override this method see
[Customizing what happens in fit](
https://www.tensorflow.org/guide/keras/customizing_what_happens_in_fit).
This method is called by `Model.make_train_function`.
This method should contain the mathematical logic for one step of
training. This typically includes the forward pass, loss calculation,
backpropagation, and metric updates.
Configuration details for *how* this logic is run (e.g. `tf.function`
and `tf.distribute.Strategy` settings), should be left to
`Model.make_train_function`, which can also be overridden.
Args:
data: A nested structure of `Tensor`s.
Returns:
A `dict` containing values that will be passed to
`tf.keras.callbacks.CallbackList.on_train_batch_end`. Typically, the
values of the `Model`'s metrics are returned. Example:
`{'loss': 0.2, 'accuracy': 0.7}`.
"""
x, y, sample_weight = data_adapter.unpack_x_y_sample_weight(data)
# Run forward pass.
with tf.GradientTape() as tape:
y_pred = self(x, training=True)
loss = self.compute_loss(x, y, y_pred, sample_weight)
self._validate_target_and_loss(y, loss)
# Run backwards pass.
self.optimizer.minimize(loss, self.trainable_variables, tape=tape)
return self.compute_metrics(x, y, y_pred, sample_weight)
def compute_loss(self, x=None, y=None, y_pred=None, sample_weight=None):
"""Compute the total loss, validate it, and return it.
Subclasses can optionally override this method to provide custom loss
computation logic.
Example:
```python
class MyModel(tf.keras.Model):
def __init__(self, *args, **kwargs):
super(MyModel, self).__init__(*args, **kwargs)
self.loss_tracker = tf.keras.metrics.Mean(name='loss')
def compute_loss(self, x, y, y_pred, sample_weight):
loss = tf.reduce_mean(tf.math.squared_difference(y_pred, y))
loss += tf.add_n(self.losses)
self.loss_tracker.update_state(loss)
return loss
def reset_metrics(self):
self.loss_tracker.reset_states()
@property
def metrics(self):
return [self.loss_tracker]
tensors = tf.random.uniform((10, 10)), tf.random.uniform((10,))
dataset = tf.data.Dataset.from_tensor_slices(tensors).repeat().batch(1)
inputs = tf.keras.layers.Input(shape=(10,), name='my_input')
outputs = tf.keras.layers.Dense(10)(inputs)
model = MyModel(inputs, outputs)
model.add_loss(tf.reduce_sum(outputs))
optimizer = tf.keras.optimizers.SGD()
model.compile(optimizer, loss='mse', steps_per_execution=10)
model.fit(dataset, epochs=2, steps_per_epoch=10)
print('My custom loss: ', model.loss_tracker.result().numpy())
```
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.
Returns:
The total loss as a `tf.Tensor`, or `None` if no loss results (which
is the case when called by `Model.test_step`).
"""
del x # The default implementation does not use `x`.
return self.compiled_loss(
y, y_pred, sample_weight, regularization_losses=self.losses
)
def compute_metrics(self, x, y, y_pred, sample_weight):
"""Update metric states and collect all metrics to be returned.
Subclasses can optionally override this method to provide custom metric
updating and collection logic.
Example:
```python
class MyModel(tf.keras.Sequential):
def compute_metrics(self, x, y, y_pred, sample_weight):
# This super call updates `self.compiled_metrics` and returns
# results for all metrics listed in `self.metrics`.
metric_results = super(MyModel, self).compute_metrics(
x, y, y_pred, sample_weight)
# Note that `self.custom_metric` is not listed in `self.metrics`.
self.custom_metric.update_state(x, y, y_pred, sample_weight)
metric_results['custom_metric_name'] = self.custom_metric.result()
return metric_results
```
Args:
x: Input data.
y: Target data.
y_pred: Predictions returned by the model (output of `model.call(x)`)
sample_weight: Sample weights for weighting the loss function.
Returns:
A `dict` containing values that will be passed to
`tf.keras.callbacks.CallbackList.on_train_batch_end()`. Typically, the
values of the metrics listed in `self.metrics` are returned. Example:
`{'loss': 0.2, 'accuracy': 0.7}`.
"""
del x # The default implementation does not use `x`.
self.compiled_metrics.update_state(y, y_pred, sample_weight)
return self.get_metrics_result()
def get_metrics_result(self):
"""Returns the model's metrics values as a dict.
If any of the metric result is a dict (containing multiple metrics),
each of them gets added to the top level returned dict of this method.
Returns:
A `dict` containing values of the metrics listed in `self.metrics`.
Example:
`{'loss': 0.2, 'accuracy': 0.7}`.
"""
# Collect metrics to return
return_metrics = {}
for metric in self.metrics:
result = metric.result()
if isinstance(result, dict):
return_metrics.update(result)
else:
return_metrics[metric.name] = result
return return_metrics
def _validate_and_get_metrics_result(self, logs):
"""Returns model metrics as a dict if the keys match with input logs.
When the training / evalution is performed with asynchronous steps, such
as the case with `tf.distribute.ParameterServerStrategy`, the last
scheduled `train / test_step` may not give the latest metrics because it
is not guaranteed to be executed the last. This method gets metrics from
the model directly instead of relying on the return from last step
function.
It logs a warning if the metric results could not be overridden when
used with `tf.distribute.ParameterServerStrategy`.
When the user has custom train / test step functions, the metrics
returned may be different from `Model.metrics`. In those instances,
this function will be no-op and return the logs.
Args:
logs: A `dict` of metrics returned by train / test step function.
Returns:
A `dict` containing values of the metrics listed in `self.metrics`
when logs and model metrics keys match. Otherwise it returns input
`logs`.
"""
PSS_WARN_MSG = "Could not get Model metric results. \
Using the results of last step function could lead to incorrect \
results when used with ParameterServerStrategy"
try:
metric_logs = self.get_metrics_result()
except TypeError:
if self._cluster_coordinator:
logging.warning(PSS_WARN_MSG)
else:
# Verify that train / test step logs passed and metric logs have
# matching keys. Could be different when using custom step functions
if isinstance(logs, dict) and set(logs.keys()) == set(
metric_logs.keys()
):
logs = tf_utils.sync_to_numpy_or_python_type(metric_logs)
elif self._cluster_coordinator:
logging.warning(PSS_WARN_MSG)
return logs
def _aggregate_exact_metrics(self, logs):
# When doing exact evaluation, `logs` is a list of each data shard's
# metric variables, which will be used to update the metrics.
for shard_result in logs:
for metric in self.metrics:
if metric.name not in shard_result.keys():
logging.log_first_n(
logging.WARN,
f"No matching result found for metric {metric.name}. "
"This metric's computed result may be incorrect.",
3,
)
continue
metric_result = shard_result[metric.name]
if len(metric_result) != len(metric.weights):
raise ValueError(
f"Expected {len(metric.weights)} variables in result "
f"for metric {metric.name}, but found "
f"{len(metric_result)}."
)
for weight, val in zip(metric.weights, metric_result):
weight.assign_add(val)
return self.get_metrics_result()
def make_train_function(self, force=False):
"""Creates a function that executes one step of training.
This method can be overridden to support custom training logic.
This method is called by `Model.fit` and `Model.train_on_batch`.
Typically, this method directly controls `tf.function` and
`tf.distribute.Strategy` settings, and delegates the actual training
logic to `Model.train_step`.
This function is cached the first time `Model.fit` or
`Model.train_on_batch` is called. The cache is cleared whenever
`Model.compile` is called. You can skip the cache and generate again the
function with `force=True`.
Args:
force: Whether to regenerate the train function and skip the cached
function if available.
Returns:
Function. The function created by this method should accept a
`tf.data.Iterator`, and return a `dict` containing values that will
be passed to `tf.keras.Callbacks.on_train_batch_end`, such as
`{'loss': 0.2, 'accuracy': 0.7}`.
"""
if self.train_function is not None and not force:
return self.train_function
def step_function(model, iterator):
"""Runs a single training step."""
def run_step(data):
outputs = model.train_step(data)
# Ensure counter is updated only if `train_step` succeeds.
with tf.control_dependencies(_minimum_control_deps(outputs)):
model._train_counter.assign_add(1)
return outputs
if self.jit_compile:
run_step = tf.function(
run_step, jit_compile=True, reduce_retracing=True
)
data = next(iterator)
outputs = model.distribute_strategy.run(run_step, args=(data,))
outputs = reduce_per_replica(
outputs,
self.distribute_strategy,
reduction=self.distribute_reduction_method,
)
return outputs
# Special case if steps_per_execution is one.
if (
self._steps_per_execution is None
or self._steps_per_execution.numpy().item() == 1
and not self.autotune_steps_per_execution
):
def train_function(iterator):
"""Runs a training execution with a single step."""
return step_function(self, iterator)
if not self.run_eagerly:
train_function = tf.function(
train_function, reduce_retracing=True
)
self.train_tf_function = train_function
if self._cluster_coordinator:
self.train_function = (
lambda it: self._cluster_coordinator.schedule(
train_function, args=(it,)
)
)
else:
self.train_function = train_function
# If we're using a coordinator, use the value of
# self._steps_per_execution at the time the function is
# called/scheduled, and not when it is actually executed.
elif self._cluster_coordinator:
def train_function(iterator, steps_per_execution):
"""Runs a training execution with multiple steps."""
for _ in tf.range(steps_per_execution):
outputs = step_function(self, iterator)
return outputs
if not self.run_eagerly:
train_function = tf.function(
train_function, reduce_retracing=True
)
self.train_tf_function = train_function
self.train_function = lambda it: self._cluster_coordinator.schedule(
train_function, args=(it, self._steps_per_execution.value())
)
else:
def train_function(iterator):
"""Runs a training execution with multiple steps."""
for _ in tf.range(self._steps_per_execution):
outputs = step_function(self, iterator)
return outputs
if not self.run_eagerly:
train_function = tf.function(
train_function, reduce_retracing=True
)
self.train_tf_function = train_function
self.train_function = train_function
return self.train_function
@traceback_utils.filter_traceback
def fit(
self,
x=None,
y=None,
batch_size=None,
epochs=1,
verbose="auto",
callbacks=None,
validation_split=0.0,
validation_data=None,
shuffle=True,
class_weight=None,
sample_weight=None,
initial_epoch=0,
steps_per_epoch=None,
validation_steps=None,
validation_batch_size=None,
validation_freq=1,
max_queue_size=10,
workers=1,
use_multiprocessing=False,
):
"""Trains the model for a fixed number of epochs (dataset iterations).
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 `tf.keras.utils.experimental.DatasetCreator`, which wraps a
callable that takes a single argument of type
`tf.distribute.InputContext`, and returns a `tf.data.Dataset`.
`DatasetCreator` should be used when users prefer to specify the
per-replica batching and sharding logic for the `Dataset`.
See `tf.keras.utils.experimental.DatasetCreator` doc for more
information.
A more detailed description of unpacking behavior for iterator
types (Dataset, generator, Sequence) is given below. If these
include `sample_weights` as a third component, note that sample
weighting applies to the `weighted_metrics` argument but not the
`metrics` argument in `compile()`. If using
`tf.distribute.experimental.ParameterServerStrategy`, only
`DatasetCreator` type is supported for `x`.
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 `x`).
batch_size: Integer or `None`.
Number of samples per gradient update.
If unspecified, `batch_size` will default to 32.
Do not specify the `batch_size` if your data is in the
form of datasets, generators, or `keras.utils.Sequence`
instances (since they generate batches).
epochs: Integer. Number of epochs to train the model.
An epoch is an iteration over the entire `x` and `y`
data provided
(unless the `steps_per_epoch` flag is set to
something other than None).
Note that in conjunction with `initial_epoch`,
`epochs` is to be understood as "final epoch".
The model is not trained for a number of iterations
given by `epochs`, but merely until the epoch
of index `epochs` is reached.
verbose: 'auto', 0, 1, or 2. Verbosity mode.
0 = silent, 1 = progress bar, 2 = one line per epoch.
'auto' becomes 1 for most cases, but 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 (eg, in a production
environment). Defaults to 'auto'.
callbacks: List of `keras.callbacks.Callback` instances.
List of callbacks to apply during training.
See `tf.keras.callbacks`. Note
`tf.keras.callbacks.ProgbarLogger` and
`tf.keras.callbacks.History` callbacks are created automatically
and need not be passed into `model.fit`.
`tf.keras.callbacks.ProgbarLogger` is created or not based on
`verbose` argument to `model.fit`.
Callbacks with batch-level calls are currently unsupported with
`tf.distribute.experimental.ParameterServerStrategy`, and users
are advised to implement epoch-level calls instead with an
appropriate `steps_per_epoch` value.
validation_split: Float between 0 and 1.
Fraction of the training data to be used as validation data.
The model will set apart this fraction of the training data,
will not train on it, and will evaluate
the loss and any model metrics
on this data at the end of each epoch.
The validation data is selected from the last samples
in the `x` and `y` data provided, before shuffling. This
argument is not supported when `x` is a dataset, generator or
`keras.utils.Sequence` instance.
If both `validation_data` and `validation_split` are provided,
`validation_data` will override `validation_split`.
`validation_split` is not yet supported with
`tf.distribute.experimental.ParameterServerStrategy`.
validation_data: Data on which to evaluate
the loss and any model metrics at the end of each epoch.
The model will not be trained on this data. Thus, note the fact
that the validation loss of data provided using
`validation_split` or `validation_data` is not affected by
regularization layers like noise and dropout.
`validation_data` will override `validation_split`.
`validation_data` could be:
- A tuple `(x_val, y_val)` of Numpy arrays or tensors.
- A tuple `(x_val, y_val, val_sample_weights)` of NumPy
arrays.
- A `tf.data.Dataset`.
- A Python generator or `keras.utils.Sequence` returning
`(inputs, targets)` or `(inputs, targets, sample_weights)`.
`validation_data` is not yet supported with
`tf.distribute.experimental.ParameterServerStrategy`.
shuffle: Boolean (whether to shuffle the training data
before each epoch) or str (for 'batch'). This argument is
ignored when `x` is a generator or an object of tf.data.Dataset.
'batch' is a special option for dealing
with the limitations of HDF5 data; it shuffles in batch-sized
chunks. Has no effect when `steps_per_epoch` is not `None`.
class_weight: Optional dictionary mapping class indices (integers)
to a weight (float) value, used for weighting the loss function
(during training only).
This can be useful to tell the model to
"pay more attention" to samples from
an under-represented class. When `class_weight` is specified
and targets have a rank of 2 or greater, either `y` must be
one-hot encoded, or an explicit final dimension of `1` must
be included for sparse class labels.
sample_weight: Optional Numpy array of weights for
the training samples, used for weighting the loss function
(during training only). 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, generator,
or `keras.utils.Sequence` instance, instead provide the
sample_weights as the third element of `x`.
Note that sample weighting does not apply to metrics specified
via the `metrics` argument in `compile()`. To apply sample
weighting to your metrics, you can specify them via the
`weighted_metrics` in `compile()` instead.
initial_epoch: Integer.
Epoch at which to start training
(useful for resuming a previous training run).
steps_per_epoch: Integer or `None`.
Total number of steps (batches of samples)
before declaring one epoch finished and starting the
next epoch. When training with input tensors such as
TensorFlow data tensors, the default `None` is equal to
the number of samples in your dataset divided by
the batch size, or 1 if that cannot be determined. If x is a
`tf.data` dataset, and 'steps_per_epoch'
is None, the epoch will run until the input dataset is
exhausted. When passing an infinitely repeating dataset, you
must specify the `steps_per_epoch` argument. If
`steps_per_epoch=-1` the training will run indefinitely with an
infinitely repeating dataset. This argument is not supported
with array inputs.
When using `tf.distribute.experimental.ParameterServerStrategy`:
* `steps_per_epoch=None` is not supported.
validation_steps: Only relevant if `validation_data` is provided and
is a `tf.data` dataset. Total number of steps (batches of
samples) to draw before stopping when performing validation
at the end of every epoch. If 'validation_steps' is None,
validation will run until the `validation_data` dataset is
exhausted. In the case of an infinitely repeated dataset, it
will run into an infinite loop. If 'validation_steps' is
specified and only part of the dataset will be consumed, the
evaluation will start from the beginning of the dataset at each
epoch. This ensures that the same validation samples are used
every time.
validation_batch_size: Integer or `None`.
Number of samples per validation batch.
If unspecified, will default to `batch_size`.
Do not specify the `validation_batch_size` if your data is in
the form of datasets, generators, or `keras.utils.Sequence`
instances (since they generate batches).
validation_freq: Only relevant if validation data is provided.
Integer or `collections.abc.Container` instance (e.g. list, tuple,
etc.). If an integer, specifies how many training epochs to run
before a new validation run is performed, e.g. `validation_freq=2`
runs validation every 2 epochs. If a Container, specifies the
epochs on which to run validation, e.g.
`validation_freq=[1, 2, 10]` runs validation at the end of the
1st, 2nd, and 10th epochs.
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-pickleable arguments to
the generator as they can't be passed easily to children
processes.
Unpacking behavior for iterator-like inputs:
A common pattern is to pass a tf.data.Dataset, generator, or
tf.keras.utils.Sequence to the `x` argument of fit, which will in fact
yield not only features (x) but optionally targets (y) and sample
weights. TF-Keras requires that the output of such iterator-likes be
unambiguous. The iterator should return a tuple of length 1, 2, or 3,
where the optional second and third elements will be used for y and
sample_weight respectively. Any other type provided will be wrapped in
a length one tuple, effectively treating everything as 'x'. When
yielding dicts, they should still adhere to the top-level tuple
structure.
e.g. `({"x0": x0, "x1": x1}, y)`. TF-Keras will not attempt to
separate features, targets, and weights from the keys of a single
dict.
A notable unsupported data type is the namedtuple. The reason is
that it behaves like both an ordered datatype (tuple) and a mapping
datatype (dict). So given a namedtuple of the form:
`namedtuple("example_tuple", ["y", "x"])`
it is ambiguous whether to reverse the order of the elements when
interpreting the value. Even worse is a tuple of the form:
`namedtuple("other_tuple", ["x", "y", "z"])`
where it is unclear if the tuple was intended to be unpacked into x,
y, and sample_weight or passed through as a single element to `x`. As
a result the data processing code will simply raise a ValueError if it
encounters a namedtuple. (Along with instructions to remedy the
issue.)
Returns:
A `History` object. Its `History.history` attribute is
a record of training loss values and metrics values
at successive epochs, as well as validation loss values
and validation metrics values (if applicable).
Raises:
RuntimeError: 1. If the model was never compiled or,
2. If `model.fit` is wrapped in `tf.function`.
ValueError: In case of mismatch between the provided input data
and what the model expects or when the input data is empty.
"""
# Legacy graph support is contained in `training_v1.Model`.
version_utils.disallow_legacy_graph("Model", "fit")
self._assert_compile_was_called()
self._check_call_args("fit")
_disallow_inside_tf_function("fit")
verbose = _get_verbosity(verbose, self.distribute_strategy)
if validation_split and validation_data is None:
# Create the validation data using the training data. Only supported
# for `Tensor` and `NumPy` input.
(
x,
y,
sample_weight,
), validation_data = data_adapter.train_validation_split(
(x, y, sample_weight), validation_split=validation_split
)
if validation_data:
(
val_x,
val_y,
val_sample_weight,
) = data_adapter.unpack_x_y_sample_weight(validation_data)
if self.distribute_strategy._should_use_with_coordinator:
self._cluster_coordinator = (
tf.distribute.experimental.coordinator.ClusterCoordinator(
self.distribute_strategy
)
)
with self.distribute_strategy.scope(), training_utils.RespectCompiledTrainableState( # noqa: E501
self
):
# Creates a `tf.data.Dataset` and handles batch and epoch iteration.
data_handler = data_adapter.get_data_handler(
x=x,
y=y,
sample_weight=sample_weight,
batch_size=batch_size,
steps_per_epoch=steps_per_epoch,
initial_epoch=initial_epoch,
epochs=epochs,
shuffle=shuffle,
class_weight=class_weight,
max_queue_size=max_queue_size,
workers=workers,
use_multiprocessing=use_multiprocessing,
model=self,
steps_per_execution=self._steps_per_execution,
)
# Container that configures and calls `tf.keras.Callback`s.
if not isinstance(callbacks, callbacks_module.CallbackList):
callbacks = callbacks_module.CallbackList(
callbacks,
add_history=True,
add_progbar=verbose != 0,
model=self,
verbose=verbose,
epochs=epochs,
steps=data_handler.inferred_steps,
)
self.stop_training = False
self.train_function = self.make_train_function()
self._train_counter.assign(0)
callbacks.on_train_begin()
training_logs = None
if self.autotune_steps_per_execution:
self._steps_per_execution_tuner.start()
# Handle fault-tolerance for multi-worker.
# TODO(omalleyt): Fix the ordering issues that mean this has to
# happen after `callbacks.on_train_begin`.
steps_per_epoch_inferred = (
steps_per_epoch or data_handler.inferred_steps
)
(
data_handler._initial_epoch,
data_handler._initial_step,
) = self._maybe_load_initial_counters_from_ckpt(
steps_per_epoch_inferred, initial_epoch
)
logs = None
for epoch, iterator in data_handler.enumerate_epochs():
self.reset_metrics()
callbacks.on_epoch_begin(epoch)
with data_handler.catch_stop_iteration():
for step in data_handler.steps():
with tf.profiler.experimental.Trace(
"train",
epoch_num=epoch,
step_num=step,
batch_size=batch_size,
_r=1,
):
callbacks.on_train_batch_begin(step)
tmp_logs = self.train_function(iterator)
if data_handler.should_sync:
context.async_wait()
# No error, now safe to assign to logs.
logs = tmp_logs
end_step = step + data_handler.step_increment
callbacks.on_train_batch_end(end_step, logs)
if self.stop_training:
break
logs = tf_utils.sync_to_numpy_or_python_type(logs)
if logs is None:
raise ValueError(
"Unexpected result of `train_function` "
"(Empty logs). This could be due to issues in input "
"pipeline that resulted in an empty dataset. "
"Otherwise, please use "
"`Model.compile(..., run_eagerly=True)`, or "
"`tf.config.run_functions_eagerly(True)` for more "
"information of where went wrong, or file a "
"issue/bug to `tf.keras`."
)
# Override with model metrics instead of last step logs
logs = self._validate_and_get_metrics_result(logs)
epoch_logs = copy.copy(logs)
# Run validation.
if validation_data and self._should_eval(
epoch, validation_freq
):
if self._pss_evaluation_shards:
self._disallow_exact_eval_with_add_metrics()
# Create data_handler for evaluation and cache it.
if getattr(self, "_eval_data_handler", None) is None:
self._eval_data_handler = data_adapter.get_data_handler(
x=val_x,
y=val_y,
sample_weight=val_sample_weight,
batch_size=validation_batch_size or batch_size,
steps_per_epoch=validation_steps,
initial_epoch=0,
epochs=1,
max_queue_size=max_queue_size,
workers=workers,
use_multiprocessing=use_multiprocessing,
model=self,
steps_per_execution=self._steps_per_execution,
pss_evaluation_shards=self._pss_evaluation_shards,
)
val_logs = self.evaluate(
x=val_x,
y=val_y,
sample_weight=val_sample_weight,
batch_size=validation_batch_size or batch_size,
steps=validation_steps,
callbacks=callbacks,
max_queue_size=max_queue_size,
workers=workers,
use_multiprocessing=use_multiprocessing,
return_dict=True,
_use_cached_eval_dataset=True,
)
val_logs = {
"val_" + name: val for name, val in val_logs.items()
}
epoch_logs.update(val_logs)
callbacks.on_epoch_end(epoch, epoch_logs)
training_logs = epoch_logs
if self.stop_training:
break
if isinstance(self.optimizer, optimizer.Optimizer) and epochs > 0:
self.optimizer.finalize_variable_values(
self.trainable_variables
)
# If eval data_handler exists, delete it after all epochs are done.
if getattr(self, "_eval_data_handler", None) is not None:
del self._eval_data_handler
if self.autotune_steps_per_execution:
self._steps_per_execution_tuner.stop()
callbacks.on_train_end(logs=training_logs)
return self.history
def test_step(self, data):
"""The logic for one evaluation step.
This method can be overridden to support custom evaluation logic.
This method is called by `Model.make_test_function`.
This function should contain the mathematical logic for one step of
evaluation.
This typically includes the forward pass, loss calculation, and metrics
updates.
Configuration details for *how* this logic is run (e.g. `tf.function`
and `tf.distribute.Strategy` settings), should be left to
`Model.make_test_function`, which can also be overridden.
Args:
data: A nested structure of `Tensor`s.
Returns:
A `dict` containing values that will be passed to
`tf.keras.callbacks.CallbackList.on_train_batch_end`. Typically, the
values of the `Model`'s metrics are returned.
"""
x, y, sample_weight = data_adapter.unpack_x_y_sample_weight(data)
y_pred = self(x, training=False)
# Updates stateful loss metrics.
self.compute_loss(x, y, y_pred, sample_weight)
return self.compute_metrics(x, y, y_pred, sample_weight)
def _make_test_function_exact(self):
if getattr(self, "_shard_test_function", None):
return self._shard_test_function
def step_function(batch):
def run_step(data):
# TODO(b/272050910): Use sample_weight for weighted metrics.
x, y, sample_weight = data_adapter.unpack_x_y_sample_weight(
data
)
y_pred = self(x, training=False)
return x, y, y_pred, sample_weight
if self._jit_compile:
run_step = tf.function(
run_step, jit_compile=True, reduce_retracing=True
)
outputs = self.distribute_strategy.run(run_step, args=(batch,))
outputs = reduce_per_replica(
outputs,
self.distribute_strategy,
reduction=self.distribute_reduction_method,
)
return outputs
def shard_test_function(dataset, total_shards, shard_idx):
# Copy loss and metric variables to the worker and work with them
# locally. This ensures each shard function is atomic: if a worker
# is preempted, the intermediate progress is discarded and that
# shard is retried. This in turn guarantees exactly-once visitation.
local_unweighted_metrics, local_weighted_metrics = [], []
with tf_utils.with_metric_local_vars_scope():
# TODO(jmullenbach): implement and use a clone for
# `MetricsContainer` and use its `update_state` method directly.
for metric in self.compiled_metrics.unweighted_metrics:
if metric is not None:
local_unweighted_metrics.append(
base_metric.clone_metric(metric)
)
for metric in self.compiled_metrics.weighted_metrics:
if metric is not None:
local_weighted_metrics.append(
base_metric.clone_metric(metric)
)
local_loss = compile_utils.LossesContainer.from_config(
self.compiled_loss.get_config()
)
dataset = input_ops.auto_shard_dataset(
dataset, total_shards, shard_idx
)
iterator = iter(dataset)
with distribute_utils.cache_variable_reads():
for batch in iterator:
x, y, y_pred, sample_weight = step_function(batch)
for weighted_metric in local_weighted_metrics:
weighted_metric.update_state(y, y_pred, sample_weight)
for unweighted_metric in local_unweighted_metrics:
unweighted_metric.update_state(y, y_pred)
local_loss(y, y_pred, sample_weight)
local_metrics = (
local_unweighted_metrics
+ local_weighted_metrics
+ local_loss.metrics
)
outputs = {metric.name: metric.weights for metric in local_metrics}
with tf.control_dependencies(_minimum_control_deps(outputs)):
self._test_counter.assign_add(1)
return outputs
if not self.run_eagerly:
shard_test_function = tf.function(
shard_test_function, reduce_retracing=True
)
self._shard_test_function = (
lambda *args: self._cluster_coordinator.schedule(
shard_test_function,
args=args,
)
)
return self._shard_test_function
def make_test_function(self, force=False):
"""Creates a function that executes one step of evaluation.
This method can be overridden to support custom evaluation logic.
This method is called by `Model.evaluate` and `Model.test_on_batch`.
Typically, this method directly controls `tf.function` and
`tf.distribute.Strategy` settings, and delegates the actual evaluation
logic to `Model.test_step`.
This function is cached the first time `Model.evaluate` or
`Model.test_on_batch` is called. The cache is cleared whenever
`Model.compile` is called. You can skip the cache and generate again the
function with `force=True`.
Args:
force: Whether to regenerate the test function and skip the cached
function if available.
Returns:
Function. The function created by this method should accept a
`tf.data.Iterator`, and return a `dict` containing values that will
be passed to `tf.keras.Callbacks.on_test_batch_end`.
"""
if self.test_function is not None and not force:
return self.test_function
def step_function(model, iterator):
"""Runs a single evaluation step."""
def run_step(data):
outputs = model.test_step(data)
# Ensure counter is updated only if `test_step` succeeds.
with tf.control_dependencies(_minimum_control_deps(outputs)):
model._test_counter.assign_add(1)
return outputs
if self.jit_compile:
run_step = tf.function(
run_step, jit_compile=True, reduce_retracing=True
)
data = next(iterator)
outputs = model.distribute_strategy.run(run_step, args=(data,))
outputs = reduce_per_replica(
outputs,
self.distribute_strategy,
reduction=self.distribute_reduction_method,
)
return outputs
# Special case if steps_per_execution is one.
if (
self._steps_per_execution is None
or self._steps_per_execution.numpy().item() == 1
and not self.autotune_steps_per_execution
):
def test_function(iterator):
"""Runs a test execution with a single step."""
return step_function(self, iterator)
if not self.run_eagerly:
test_function = tf.function(
test_function, reduce_retracing=True
)
if self._cluster_coordinator:
self.test_function = (
lambda it: self._cluster_coordinator.schedule(
test_function, args=(it,)
)
)
else:
self.test_function = test_function
# If we're using a coordinator, use the value of
# self._steps_per_execution at the time the function is
# called/scheduled, and not when it is actually executed.
elif self._cluster_coordinator:
def test_function(iterator, steps_per_execution):
"""Runs a test execution with multiple steps."""
for _ in tf.range(steps_per_execution):
outputs = step_function(self, iterator)
return outputs
if not self.run_eagerly:
test_function = tf.function(
test_function, reduce_retracing=True
)
self.test_function = lambda it: self._cluster_coordinator.schedule(
test_function, args=(it, self._steps_per_execution.value())
)
else:
def test_function(iterator):
"""Runs a test execution with multiple steps."""
for _ in tf.range(self._steps_per_execution):
outputs = step_function(self, iterator)
return outputs
if not self.run_eagerly:
test_function = tf.function(
test_function, reduce_retracing=True
)
self.test_function = test_function
return self.test_function
@traceback_utils.filter_traceback
def evaluate(
self,
x=None,
y=None,
batch_size=None,
verbose="auto",
sample_weight=None,
steps=None,
callbacks=None,
max_queue_size=10,
workers=1,
use_multiprocessing=False,
return_dict=False,
**kwargs,
):
"""Returns the loss value & metrics values for the model in test mode.
Computation is done in batches (see the `batch_size` arg.)
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"` becomes 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). Defaults to 'auto'.
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](https://www.tensorflow.org/api_docs/python/tf/tf_keras/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-pickleable 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.
See the discussion of `Unpacking behavior for iterator-like inputs` for
`Model.fit`.
Returns:
Scalar test loss (if the model has a single output and no metrics)
or list of scalars (if the model has multiple outputs
and/or metrics). The attribute `model.metrics_names` will give you
the display labels for the scalar outputs.
Raises:
RuntimeError: If `model.evaluate` is wrapped in a `tf.function`.
"""
version_utils.disallow_legacy_graph("Model", "evaluate")
self._assert_compile_was_called()
self._check_call_args("evaluate")
self._check_sample_weight_warning(x, sample_weight)
_disallow_inside_tf_function("evaluate")
use_cached_eval_dataset = kwargs.pop("_use_cached_eval_dataset", False)
if kwargs:
raise TypeError(f"Invalid keyword arguments: {list(kwargs.keys())}")
if self.distribute_strategy._should_use_with_coordinator:
self._cluster_coordinator = (
tf.distribute.experimental.coordinator.ClusterCoordinator(
self.distribute_strategy
)
)
verbose = _get_verbosity(verbose, self.distribute_strategy)
if self._pss_evaluation_shards:
self._disallow_exact_eval_with_add_metrics()
with self.distribute_strategy.scope():
# Use cached evaluation data only when it's called in `Model.fit`
if (
use_cached_eval_dataset
and getattr(self, "_eval_data_handler", None) is not None
):
data_handler = self._eval_data_handler
else:
# Creates a `tf.data.Dataset` and handles batch and epoch
# iteration.
data_handler = data_adapter.get_data_handler(
x=x,
y=y,
sample_weight=sample_weight,
batch_size=batch_size,
steps_per_epoch=steps,
initial_epoch=0,
epochs=1,
max_queue_size=max_queue_size,
workers=workers,
use_multiprocessing=use_multiprocessing,
model=self,
steps_per_execution=self._steps_per_execution,
pss_evaluation_shards=self._pss_evaluation_shards,
)
# Container that configures and calls `tf.keras.Callback`s.
if not isinstance(callbacks, callbacks_module.CallbackList):
callbacks = callbacks_module.CallbackList(
callbacks,
add_history=True,
add_progbar=verbose != 0,
model=self,
verbose=verbose,
epochs=1,
steps=data_handler.inferred_steps,
)
# Initialize to prevent errors if 0 epochs are evaluated.
logs = {}
test_function_runner = self._get_test_function_runner(callbacks)
self._test_counter.assign(0)
callbacks.on_test_begin()
if self.autotune_steps_per_execution:
self._steps_per_execution_tuner.start()
for (
_,
dataset_or_iterator,
) in data_handler.enumerate_epochs(): # Single epoch.
self.reset_metrics()
with data_handler.catch_stop_iteration():
for step in data_handler.steps():
with tf.profiler.experimental.Trace(
"test", step_num=step, _r=1
):
callbacks.on_test_batch_begin(step)
logs = test_function_runner.run_step(
dataset_or_iterator,
data_handler,
step,
self._pss_evaluation_shards,
)
logs = tf_utils.sync_to_numpy_or_python_type(logs)
# Override with model metrics instead of last step logs
if self._pss_evaluation_shards:
logs = self._aggregate_exact_metrics(logs)
else:
logs = self._validate_and_get_metrics_result(logs)
if self.autotune_steps_per_execution:
self._steps_per_execution_tuner.stop()
callbacks.on_test_end(logs=logs)
if return_dict:
return logs
else:
return flatten_metrics_in_order(logs, self.metrics_names)
def _disallow_exact_eval_with_add_metrics(self):
metrics_from_add_metric = [
metric
for layer in self._flatten_layers()
for metric in layer._metrics
]
compiled_metrics = self.compiled_metrics.metrics
if any(
[
metric not in compiled_metrics
for metric in metrics_from_add_metric
]
):
raise ValueError(
"Detected that a metric was added to this model "
"via `Model.add_metric`. This is not currently "
"supported when using exact evaluation with "
"`tf.distribute.ParameterServerStrategy`."
)
def _infer_exact_eval_shards(self, pss_evaluation_shards):
if not self.distribute_strategy._should_use_with_coordinator:
return 0
if pss_evaluation_shards == "auto":
# TODO(b/264265138) evaluate and improve this heuristic
return self.distribute_strategy._num_workers * 5
return pss_evaluation_shards
def _get_test_function_runner(self, callbacks):
if (
self._pss_evaluation_shards
and self.distribute_strategy._should_use_with_coordinator
):
self.test_function = self._make_test_function_exact()
test_function_runner = _ExactTestFunction(
self.test_function, callbacks
)
else:
self.test_function = self.make_test_function()
test_function_runner = _TestFunction(self.test_function, callbacks)
return test_function_runner
def predict_step(self, data):
"""The logic for one inference step.
This method can be overridden to support custom inference logic.
This method is called by `Model.make_predict_function`.
This method should contain the mathematical logic for one step of
inference. This typically includes the forward pass.
Configuration details for *how* this logic is run (e.g. `tf.function`
and `tf.distribute.Strategy` settings), should be left to
`Model.make_predict_function`, which can also be overridden.
Args:
data: A nested structure of `Tensor`s.
Returns:
The result of one inference step, typically the output of calling the
`Model` on data.
"""
x, _, _ = data_adapter.unpack_x_y_sample_weight(data)
return self(x, training=False)
def make_predict_function(self, force=False):
"""Creates a function that executes one step of inference.
This method can be overridden to support custom inference logic.
This method is called by `Model.predict` and `Model.predict_on_batch`.
Typically, this method directly controls `tf.function` and
`tf.distribute.Strategy` settings, and delegates the actual evaluation
logic to `Model.predict_step`.
This function is cached the first time `Model.predict` or
`Model.predict_on_batch` is called. The cache is cleared whenever
`Model.compile` is called. You can skip the cache and generate again the
function with `force=True`.
Args:
force: Whether to regenerate the predict function and skip the cached
function if available.
Returns:
Function. The function created by this method should accept a
`tf.data.Iterator`, and return the outputs of the `Model`.
"""
if self.predict_function is not None and not force:
return self.predict_function
def step_function(model, iterator):
"""Runs a single evaluation step."""
def run_step(data):
outputs = model.predict_step(data)
# Ensure counter is updated only if `test_step` succeeds.
with tf.control_dependencies(_minimum_control_deps(outputs)):
model._predict_counter.assign_add(1)
return outputs
if self.jit_compile:
run_step = tf.function(
run_step, jit_compile=True, reduce_retracing=True
)
data = next(iterator)
outputs = model.distribute_strategy.run(run_step, args=(data,))
outputs = reduce_per_replica(
outputs, self.distribute_strategy, reduction="concat"
)
return outputs
# Special case if steps_per_execution is one.
if (
self._steps_per_execution is None
or self._steps_per_execution.numpy().item() == 1
and not self.autotune_steps_per_execution
):
def predict_function(iterator):
"""Runs an evaluation execution with a single step."""
return step_function(self, iterator)
else:
def predict_function(iterator):
"""Runs an evaluation execution with multiple steps."""
outputs = step_function(self, iterator)
for _ in tf.range(self._steps_per_execution - 1):
tf.autograph.experimental.set_loop_options(
shape_invariants=[
(
outputs,
tf.nest.map_structure(
lambda t: tf_utils.get_tensor_spec(
t, dynamic_batch=True
).shape,
outputs,
),
)
]
)
step_outputs = step_function(self, iterator)
outputs = tf.nest.map_structure(
lambda t1, t2: concat([t1, t2]), outputs, step_outputs
)
return outputs
if not self.run_eagerly:
predict_function = tf.function(
predict_function, reduce_retracing=True
)
self.predict_function = predict_function
return self.predict_function
@traceback_utils.filter_traceback
def predict(
self,
x,
batch_size=None,
verbose="auto",
steps=None,
callbacks=None,
max_queue_size=10,
workers=1,
use_multiprocessing=False,
):
"""Generates output predictions for the input samples.
Computation is done in batches. This method is designed for batch
processing of large numbers of inputs. It is not intended for use inside
of loops that iterate over your data and process small numbers of inputs
at a time.
For small numbers of inputs that fit in one batch,
directly use `__call__()` for faster execution, e.g.,
`model(x)`, or `model(x, training=False)` if you have layers such as
`tf.keras.layers.BatchNormalization` that behave differently during
inference. You may pair the individual model call with a `tf.function`
for additional performance inside your inner loop.
If you need access to numpy array values instead of tensors after your
model call, you can use `tensor.numpy()` to get the numpy array value of
an eager tensor.
Also, note the fact that test loss is not affected by
regularization layers like noise and dropout.
Note: See [this FAQ entry](
https://keras.io/getting_started/faq/#whats-the-difference-between-model-methods-predict-and-call)
for more details about the difference between `Model` methods
`predict()` and `__call__()`.
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"` becomes 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). Defaults to 'auto'.
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](
https://www.tensorflow.org/api_docs/python/tf/tf_keras/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-pickleable arguments to
the generator as they can't be passed easily to children
processes.
See the discussion of `Unpacking behavior for iterator-like inputs` for
`Model.fit`. Note that Model.predict uses the same interpretation rules
as `Model.fit` and `Model.evaluate`, so inputs must be unambiguous for
all three methods.
Returns:
Numpy array(s) of predictions.
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.
"""
version_utils.disallow_legacy_graph("Model", "predict")
self._check_call_args("predict")
_disallow_inside_tf_function("predict")
# TODO(yashkatariya): Cache model on the coordinator for faster
# prediction. If running under PSS, then swap it with OneDeviceStrategy
# so that execution will run on the coordinator.
original_pss_strategy = None
if self.distribute_strategy._should_use_with_coordinator:
original_pss_strategy = self.distribute_strategy
self._distribution_strategy = None
# Cluster coordinator is set by `.fit()` and `.evaluate()` which is not
# needed in `.predict()` because all the predictions happen on the
# coordinator/locally.
if self._cluster_coordinator:
self._cluster_coordinator = None
verbose = _get_verbosity(verbose, self.distribute_strategy)
outputs = None
with self.distribute_strategy.scope():
# Creates a `tf.data.Dataset` and handles batch and epoch iteration.
dataset_types = (tf.compat.v1.data.Dataset, tf.data.Dataset)
if (
self._in_multi_worker_mode()
or _is_tpu_multi_host(self.distribute_strategy)
) and isinstance(x, dataset_types):
try:
options = tf.data.Options()
data_option = tf.data.experimental.AutoShardPolicy.DATA
options.experimental_distribute.auto_shard_policy = (
data_option
)
x = x.with_options(options)
except ValueError:
warnings.warn(
"Using Model.predict with MultiWorkerMirroredStrategy "
"or TPUStrategy and AutoShardPolicy.FILE might lead to "
"out-of-order result. Consider setting it to "
"AutoShardPolicy.DATA.",
stacklevel=2,
)
data_handler = data_adapter.get_data_handler(
x=x,
batch_size=batch_size,
steps_per_epoch=steps,
initial_epoch=0,
epochs=1,
max_queue_size=max_queue_size,
workers=workers,
use_multiprocessing=use_multiprocessing,
model=self,
steps_per_execution=self._steps_per_execution,
)
# Container that configures and calls `tf.keras.Callback`s.
if not isinstance(callbacks, callbacks_module.CallbackList):
callbacks = callbacks_module.CallbackList(
callbacks,
add_history=True,
add_progbar=verbose != 0,
model=self,
verbose=verbose,
epochs=1,
steps=data_handler.inferred_steps,
)
self.predict_function = self.make_predict_function()
self._predict_counter.assign(0)
callbacks.on_predict_begin()
if self.autotune_steps_per_execution:
self._steps_per_execution_tuner.start()
batch_outputs = None
for _, iterator in data_handler.enumerate_epochs(): # Single epoch.
with data_handler.catch_stop_iteration():
for step in data_handler.steps():
callbacks.on_predict_batch_begin(step)
tmp_batch_outputs = self.predict_function(iterator)
if data_handler.should_sync:
context.async_wait()
batch_outputs = (
tmp_batch_outputs # No error, now safe to assign.
)
if outputs is None:
outputs = tf.nest.map_structure(
lambda batch_output: [batch_output],
batch_outputs,
)
else:
tf.__internal__.nest.map_structure_up_to(
batch_outputs,
lambda output, batch_output: output.append(
batch_output
),
outputs,
batch_outputs,
)
end_step = step + data_handler.step_increment
callbacks.on_predict_batch_end(
end_step, {"outputs": batch_outputs}
)
if batch_outputs is None:
raise ValueError(
"Unexpected result of `predict_function` "
"(Empty batch_outputs). Please use "
"`Model.compile(..., run_eagerly=True)`, or "
"`tf.config.run_functions_eagerly(True)` for more "
"information of where went wrong, or file a "
"issue/bug to `tf.keras`."
)
if self.autotune_steps_per_execution:
self._steps_per_execution_tuner.stop()
callbacks.on_predict_end()
all_outputs = tf.__internal__.nest.map_structure_up_to(
batch_outputs, potentially_ragged_concat, outputs
)
# If originally PSS strategy was used, then replace it back since
# predict is running under `OneDeviceStrategy` after the swap and once
# its done we need to replace it back to PSS again.
if original_pss_strategy is not None:
self._distribution_strategy = original_pss_strategy
return tf_utils.sync_to_numpy_or_python_type(all_outputs)
def reset_metrics(self):
"""Resets the state of all the metrics in the model.
Examples:
>>> 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"])
>>> x = np.random.random((2, 3))
>>> y = np.random.randint(0, 2, (2, 2))
>>> _ = model.fit(x, y, verbose=0)
>>> assert all(float(m.result()) for m in model.metrics)
>>> model.reset_metrics()
>>> assert all(float(m.result()) == 0 for m in model.metrics)
"""
for m in self.metrics:
m.reset_state()
def train_on_batch(
self,
x,
y=None,
sample_weight=None,
class_weight=None,
reset_metrics=True,
return_dict=False,
):
"""Runs a single gradient update on a single batch of data.
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.
y: Target data. Like the input data `x`, it could be either Numpy
array(s) or TensorFlow tensor(s).
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.
class_weight: Optional dictionary mapping class indices (integers)
to a weight (float) to apply to the model's loss for the samples
from this class during training. This can be useful to tell the
model to "pay more attention" to samples from an under-represented
class. When `class_weight` is specified and targets have a rank of
2 or greater, either `y` must be one-hot encoded, or an explicit
final dimension of `1` must be included for sparse class labels.
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.
Returns:
Scalar training loss
(if the model has a single output and no metrics)
or list of scalars (if the model has multiple outputs
and/or metrics). The attribute `model.metrics_names` will give you
the display labels for the scalar outputs.
Raises:
RuntimeError: If `model.train_on_batch` is wrapped in a `tf.function`.
"""
self._assert_compile_was_called()
self._check_call_args("train_on_batch")
_disallow_inside_tf_function("train_on_batch")
if reset_metrics:
self.reset_metrics()
with self.distribute_strategy.scope(), training_utils.RespectCompiledTrainableState( # noqa: E501
self
):
iterator = data_adapter.single_batch_iterator(
self.distribute_strategy, x, y, sample_weight, class_weight
)
self.train_function = self.make_train_function()
logs = self.train_function(iterator)
logs = tf_utils.sync_to_numpy_or_python_type(logs)
if return_dict:
return logs
else:
return flatten_metrics_in_order(logs, self.metrics_names)
def test_on_batch(
self,
x,
y=None,
sample_weight=None,
reset_metrics=True,
return_dict=False,
):
"""Test the model on a single batch of samples.
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.
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.
Returns:
Scalar test loss (if the model has a single output and no metrics)
or list of scalars (if the model has multiple outputs
and/or metrics). The attribute `model.metrics_names` will give you
the display labels for the scalar outputs.
Raises:
RuntimeError: If `model.test_on_batch` is wrapped in a
`tf.function`.
"""
self._assert_compile_was_called()
self._check_call_args("test_on_batch")
_disallow_inside_tf_function("test_on_batch")
if reset_metrics:
self.reset_metrics()
with self.distribute_strategy.scope():
iterator = data_adapter.single_batch_iterator(
self.distribute_strategy, x, y, sample_weight
)
self.test_function = self.make_test_function()
logs = self.test_function(iterator)
logs = tf_utils.sync_to_numpy_or_python_type(logs)
if return_dict:
return logs
else:
return flatten_metrics_in_order(logs, self.metrics_names)
def predict_on_batch(self, x):
"""Returns predictions for a single batch of samples.
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).
Returns:
Numpy array(s) of predictions.
Raises:
RuntimeError: If `model.predict_on_batch` is wrapped in a
`tf.function`.
"""
self._check_call_args("predict_on_batch")
_disallow_inside_tf_function("predict_on_batch")
with self.distribute_strategy.scope():
iterator = data_adapter.single_batch_iterator(
self.distribute_strategy, x
)
self.predict_function = self.make_predict_function()
outputs = self.predict_function(iterator)
return tf_utils.sync_to_numpy_or_python_type(outputs)
@doc_controls.do_not_generate_docs
def fit_generator(
self,
generator,
steps_per_epoch=None,
epochs=1,
verbose=1,
callbacks=None,
validation_data=None,
validation_steps=None,
validation_freq=1,
class_weight=None,
max_queue_size=10,
workers=1,
use_multiprocessing=False,
shuffle=True,
initial_epoch=0,
):
"""Fits the model on data yielded batch-by-batch by a Python generator.
DEPRECATED:
`Model.fit` now supports generators, so there is no longer any need to
use this endpoint.
"""
warnings.warn(
"`Model.fit_generator` is deprecated and "
"will be removed in a future version. "
"Please use `Model.fit`, which supports generators.",
stacklevel=2,
)
return self.fit(
generator,
steps_per_epoch=steps_per_epoch,
epochs=epochs,
verbose=verbose,
callbacks=callbacks,
validation_data=validation_data,
validation_steps=validation_steps,
validation_freq=validation_freq,
class_weight=class_weight,
max_queue_size=max_queue_size,
workers=workers,
use_multiprocessing=use_multiprocessing,
shuffle=shuffle,
initial_epoch=initial_epoch,
)
@doc_controls.do_not_generate_docs
def evaluate_generator(
self,
generator,
steps=None,
callbacks=None,
max_queue_size=10,
workers=1,
use_multiprocessing=False,
verbose=0,
):
"""Evaluates the model on a data generator.
DEPRECATED:
`Model.evaluate` now supports generators, so there is no longer any
need to use this endpoint.
"""
warnings.warn(
"`Model.evaluate_generator` is deprecated and "
"will be removed in a future version. "
"Please use `Model.evaluate`, which supports generators.",
stacklevel=2,
)
self._check_call_args("evaluate_generator")
return self.evaluate(
generator,
steps=steps,
max_queue_size=max_queue_size,
workers=workers,
use_multiprocessing=use_multiprocessing,
verbose=verbose,
callbacks=callbacks,
)
@doc_controls.do_not_generate_docs
def predict_generator(
self,
generator,
steps=None,
callbacks=None,
max_queue_size=10,
workers=1,
use_multiprocessing=False,
verbose=0,
):
"""Generates predictions for the input samples from a data generator.
DEPRECATED:
`Model.predict` now supports generators, so there is no longer any
need to use this endpoint.
"""
warnings.warn(
"`Model.predict_generator` is deprecated and "
"will be removed in a future version. "
"Please use `Model.predict`, which supports generators.",
stacklevel=2,
)
return self.predict(
generator,
steps=steps,
max_queue_size=max_queue_size,
workers=workers,
use_multiprocessing=use_multiprocessing,
verbose=verbose,
callbacks=callbacks,
)
######################################################################
# Functions below are not training related. They are for model weights
# tracking, save/load, serialization, etc.
######################################################################
@property
def trainable_weights(self):
self._assert_weights_created()
if not self._trainable:
return []
trainable_variables = []
for trackable_obj in self._self_tracked_trackables:
trainable_variables += trackable_obj.trainable_variables
trainable_variables += self._trainable_weights
return self._dedup_weights(trainable_variables)
@property
def non_trainable_weights(self):
self._assert_weights_created()
non_trainable_variables = []
for trackable_obj in self._self_tracked_trackables:
non_trainable_variables += trackable_obj.non_trainable_variables
if not self._trainable:
# Return order is all trainable vars, then all non-trainable vars.
trainable_variables = []
for trackable_obj in self._self_tracked_trackables:
trainable_variables += trackable_obj.trainable_variables
non_trainable_variables = (
trainable_variables
+ self._trainable_weights
+ non_trainable_variables
+ self._non_trainable_weights
)
else:
non_trainable_variables = (
non_trainable_variables + self._non_trainable_weights
)
return self._dedup_weights(non_trainable_variables)
def get_weights(self):
"""Retrieves the weights of the model.
Returns:
A flat list of Numpy arrays.
"""
with self.distribute_strategy.scope():
return super().get_weights()
@traceback_utils.filter_traceback
def save(self, filepath, overwrite=True, save_format=None, **kwargs):
"""Saves a model as a TensorFlow SavedModel or HDF5 file.
See the [Serialization and Saving guide](
https://keras.io/guides/serialization_and_saving/) for details.
Args:
model: TF-Keras model instance to be saved.
filepath: `str` or `pathlib.Path` object. Path where to save the
model.
overwrite: Whether we should overwrite any existing model at the
target location, or instead ask the user via an interactive
prompt.
save_format: Either `"keras"`, `"tf"`, `"h5"`,
indicating whether to save the model
in the native TF-Keras format (`.keras`),
in the TensorFlow SavedModel format
(referred to as "SavedModel" below),
or in the legacy HDF5 format (`.h5`).
Defaults to `"tf"` in TF 2.X, and `"h5"` in TF 1.X.
SavedModel format arguments:
include_optimizer: Only applied to SavedModel and legacy HDF5
formats. If False, do not save the optimizer state.
Defaults to `True`.
signatures: Only applies to SavedModel format. Signatures to save
with the SavedModel. See the `signatures` argument in
`tf.saved_model.save` for details.
options: Only applies to SavedModel format.
`tf.saved_model.SaveOptions` object that specifies SavedModel
saving options.
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.
Example:
```python
model = tf.keras.Sequential([
tf.keras.layers.Dense(5, input_shape=(3,)),
tf.keras.layers.Softmax()])
model.save("model.keras")
loaded_model = tf.keras.models.load_model("model.keras")
x = tf.random.uniform((10, 3))
assert np.allclose(model.predict(x), loaded_model.predict(x))
```
Note that `model.save()` is an alias for `tf.keras.models.save_model()`.
"""
saving_api.save_model(
self,
filepath=filepath,
overwrite=overwrite,
save_format=save_format,
**kwargs,
)
@traceback_utils.filter_traceback
def save_weights(
self, filepath, overwrite=True, save_format=None, options=None
):
"""Saves all layer weights.
Either saves in HDF5 or in TensorFlow format based on the `save_format`
argument.
When saving in HDF5 format, the weight file has:
- `layer_names` (attribute), a list of strings
(ordered names of model layers).
- For every layer, a `group` named `layer.name`
- For every such layer group, a group attribute `weight_names`,
a list of strings
(ordered names of weights tensor of the layer).
- For every weight in the layer, a dataset
storing the weight value, named after the weight tensor.
When saving in TensorFlow format, all objects referenced by the network
are saved in the same format as `tf.train.Checkpoint`, including any
`Layer` instances or `Optimizer` instances assigned to object
attributes. For networks constructed from inputs and outputs using
`tf.keras.Model(inputs, outputs)`, `Layer` instances used by the network
are tracked/saved automatically. For user-defined classes which inherit
from `tf.keras.Model`, `Layer` instances must be assigned to object
attributes, typically in the constructor. See the documentation of
`tf.train.Checkpoint` and `tf.keras.Model` for details.
While the formats are the same, do not mix `save_weights` and
`tf.train.Checkpoint`. Checkpoints saved by `Model.save_weights` should
be loaded using `Model.load_weights`. Checkpoints saved using
`tf.train.Checkpoint.save` should be restored using the corresponding
`tf.train.Checkpoint.restore`. Prefer `tf.train.Checkpoint` over
`save_weights` for training checkpoints.
The TensorFlow format matches objects and variables by starting at a
root object, `self` for `save_weights`, and greedily matching attribute
names. For `Model.save` this is the `Model`, and for `Checkpoint.save`
this is the `Checkpoint` even if the `Checkpoint` has a model attached.
This means saving a `tf.keras.Model` using `save_weights` and loading
into a `tf.train.Checkpoint` with a `Model` attached (or vice versa)
will not match the `Model`'s variables. See the
[guide to training checkpoints](
https://www.tensorflow.org/guide/checkpoint) for details on
the TensorFlow format.
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` becomes 'tf'. Defaults to `None`.
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.
"""
saving_api.save_weights(
self,
filepath=filepath,
overwrite=overwrite,
save_format=save_format,
options=options,
)
@traceback_utils.filter_traceback
def load_weights(
self, filepath, skip_mismatch=False, by_name=False, options=None
):
"""Loads all layer weights from a saved files.
The saved file could be a SavedModel file, a `.keras` file (v3 saving
format), or a file created via `model.save_weights()`.
By default, weights are loaded based on the network's
topology. This means the architecture should be the same as when the
weights were saved. Note that layers that don't have weights are not
taken into account in the topological ordering, so adding or removing
layers is fine as long as they don't have weights.
**Partial weight loading**
If you have modified your model, for instance by adding a new layer
(with weights) or by changing the shape of the weights of a layer,
you can choose to ignore errors and continue loading
by setting `skip_mismatch=True`. In this case any layer with
mismatching weights will be skipped. A warning will be displayed
for each skipped layer.
**Weight loading by name**
If your weights are saved as a `.h5` file created
via `model.save_weights()`, you can use the argument `by_name=True`.
In this case, weights are loaded into layers only if they share
the same name. This is useful for fine-tuning or transfer-learning
models where some of the layers have changed.
Note that only topological loading (`by_name=False`) is supported when
loading weights from the `.keras` v3 format or from the TensorFlow
SavedModel format.
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 or a `.keras` file (v3 saving format) saved
via `model.save()`.
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 weights.
by_name: Boolean, whether to load weights by name or by topological
order. Only topological loading is supported for weight files in
the `.keras` v3 format or in the TensorFlow SavedModel format.
options: Optional `tf.train.CheckpointOptions` object that specifies
options for loading weights (only valid for a SavedModel file).
"""
return saving_api.load_weights(
self,
filepath=filepath,
by_name=by_name,
skip_mismatch=skip_mismatch,
options=options,
)
def _updated_config(self):
"""Util shared between different serialization methods.
Returns:
Model config with TF-Keras version information added.
"""
from tf_keras.src import __version__ as keras_version
config = self.get_config()
model_config = {
"class_name": self.__class__.__name__,
"config": config,
"keras_version": keras_version,
"backend": backend.backend(),
}
return model_config
@generic_utils.default
def get_config(self):
"""Returns the config of the `Model`.
Config is a Python dictionary (serializable) containing the
configuration of an object, which in this case is a `Model`. This allows
the `Model` to be be reinstantiated later (without its trained weights)
from this configuration.
Note that `get_config()` does not guarantee to return a fresh copy of
dict every time it is called. The callers should make a copy of the
returned dict if they want to modify it.
Developers of subclassed `Model` are advised to override this method,
and continue to update the dict from `super(MyModel, self).get_config()`
to provide the proper configuration of this `Model`. The default config
will return config dict for init parameters if they are basic types.
Raises `NotImplementedError` when in cases where a custom
`get_config()` implementation is required for the subclassed model.
Returns:
Python dictionary containing the configuration of this `Model`.
"""
# If sublcass doesn't implement `get_config()` parse from init args
# otherwise default to empty dict
if generic_utils.is_default(self.get_config):
try:
config = base_layer.Layer.get_config(self)
except NotImplementedError:
config = {}
logging.warning(
"Model's `__init__()` arguments contain non-serializable "
"objects. Please implement a `get_config()` method in the "
"subclassed Model for proper saving and loading. "
"Defaulting to empty config."
)
else:
config = {}
return config
@classmethod
def from_config(cls, config, custom_objects=None):
# `from_config` assumes `cls` is either `Functional` or a child class of
# `Functional`. In the case that `cls` is meant to behave like a child
# class of `Functional` but only inherits from the `Model` class, we
# have to call `cls(...)` instead of `Functional.from_config`.
from tf_keras.src.engine import functional
with serialization.SharedObjectLoadingScope():
functional_config_keys = [
"name",
"layers",
"input_layers",
"output_layers",
]
is_functional_config = all(
key in config for key in functional_config_keys
)
argspec = tf_inspect.getfullargspec(cls.__init__)
functional_init_args = tf_inspect.getfullargspec(
functional.Functional.__init__
).args[1:]
revivable_as_functional = (
cls in {functional.Functional, Model}
or argspec.args[1:] == functional_init_args
or (argspec.varargs == "args" and argspec.varkw == "kwargs")
)
if is_functional_config and revivable_as_functional:
# Revive Functional model
# (but not Functional subclasses with a custom __init__)
inputs, outputs, layers = functional.reconstruct_from_config(
config, custom_objects
)
model = cls(
inputs=inputs, outputs=outputs, name=config.get("name")
)
functional.connect_ancillary_layers(model, layers)
else:
# Either the model has a custom __init__, or the config
# does not contain all the information necessary to
# revive a Functional model. This happens when the user creates
# subclassed models where `get_config()` is returning
# insufficient information to be considered a Functional model.
# In this case, we fall back to provide all config into the
# constructor of the class.
try:
model = cls(**config)
except TypeError as e:
raise TypeError(
"Unable to revive model from config. When overriding "
"the `get_config()` method, make sure that the "
"returned config contains all items used as arguments "
f"in the constructor to {cls}, "
"which is the default behavior. "
"You can override this default behavior by defining a "
"`from_config(cls, config)` class method to specify "
"how to create an "
f"instance of {cls.__name__} from its config.\n\n"
f"Received config={config}\n\n"
f"Error encountered during deserialization: {e}"
)
return model
def to_json(self, **kwargs):
"""Returns a JSON string containing the network configuration.
To load a network from a JSON save file, use
`keras.models.model_from_json(json_string, custom_objects={})`.
Args:
**kwargs: Additional keyword arguments to be passed to
*`json.dumps()`.
Returns:
A JSON string.
"""
model_config = self._updated_config()
return json.dumps(
model_config, default=json_utils.get_json_type, **kwargs
)
def to_yaml(self, **kwargs):
"""Returns a yaml string containing the network configuration.
Note: Since TF 2.6, this method is no longer supported and will raise a
RuntimeError.
To load a network from a yaml save file, use
`keras.models.model_from_yaml(yaml_string, custom_objects={})`.
`custom_objects` should be a dictionary mapping
the names of custom losses / layers / etc to the corresponding
functions / classes.
Args:
**kwargs: Additional keyword arguments
to be passed to `yaml.dump()`.
Returns:
A YAML string.
Raises:
RuntimeError: announces that the method poses a security risk
"""
raise RuntimeError(
"Method `model.to_yaml()` has been removed due to security risk of "
"arbitrary code execution. Please use `model.to_json()` instead."
)
def reset_states(self):
for layer in self.layers:
if hasattr(layer, "reset_states") and getattr(
layer, "stateful", False
):
layer.reset_states()
@property
@doc_controls.do_not_generate_docs
def state_updates(self):
"""Deprecated, do NOT use!
Returns the `updates` from all layers that are stateful.
This is useful for separating training updates and
state updates, e.g. when we need to update a layer's internal state
during prediction.
Returns:
A list of update ops.
"""
warnings.warn(
"`Model.state_updates` will be removed in a future version. "
"This property should not be used in TensorFlow 2.0, "
"as `updates` are applied automatically.",
stacklevel=2,
)
state_updates = []
for layer in self.layers:
if getattr(layer, "stateful", False):
if hasattr(layer, "updates"):
state_updates += layer.updates
return state_updates
@property
def weights(self):
"""Returns the list of all layer variables/weights.
Note: This will not track the weights of nested `tf.Modules` that are
not themselves TF-Keras layers.
Returns:
A list of variables.
"""
return self._dedup_weights(self._undeduplicated_weights)
@property
def _undeduplicated_weights(self):
"""Returns the undeduplicated list of all layer variables/weights."""
self._assert_weights_created()
weights = []
for layer in self._self_tracked_trackables:
weights += layer.variables
weights += self._trainable_weights + self._non_trainable_weights
return weights
def summary(
self,
line_length=None,
positions=None,
print_fn=None,
expand_nested=False,
show_trainable=False,
layer_range=None,
):
"""Prints a string summary of the network.
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, becomes
`[0.3, 0.6, 0.70, 1.]`. Defaults to `None`.
print_fn: Print function to use. By default, prints to `stdout`.
If `stdout` doesn't work in your environment, change 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.
Defaults to `False`.
show_trainable: Whether to show if a layer is trainable.
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.
Raises:
ValueError: if `summary()` is called before the model is built.
"""
if not self.built:
raise ValueError(
"This model has not yet been built. "
"Build the model first by calling `build()` or by calling "
"the model on a batch of data."
)
layer_utils.print_summary(
self,
line_length=line_length,
positions=positions,
print_fn=print_fn,
expand_nested=expand_nested,
show_trainable=show_trainable,
layer_range=layer_range,
)
@property
def layers(self):
return list(self._flatten_layers(include_self=False, recursive=False))
@layers.setter
def layers(self, _):
raise AttributeError(
"`Model.layers` attribute is reserved and should not be used. "
"Please use another name."
)
def get_layer(self, name=None, index=None):
"""Retrieves a layer based on either its name (unique) or index.
If `name` and `index` are both provided, `index` will take precedence.
Indices are based on order of horizontal graph traversal (bottom-up).
Args:
name: String, name of layer.
index: Integer, index of layer.
Returns:
A layer instance.
"""
# TODO(fchollet): We could build a dictionary based on layer names
# since they are constant, but we have not done that yet.
if index is not None and name is not None:
raise ValueError(
"Provide only a layer name or a layer index. Received: "
f"index={index}, name={name}."
)
if index is not None:
if len(self.layers) <= index:
raise ValueError(
f"Was asked to retrieve layer at index {index}"
f" but model only has {len(self.layers)}"
" layers."
)
else:
return self.layers[index]
if name is not None:
for layer in self.layers:
if layer.name == name:
return layer
raise ValueError(
f"No such layer: {name}. Existing layers are: "
f"{list(layer.name for layer in self.layers)}."
)
raise ValueError(
"Provide either a layer name or layer index at `get_layer`."
)
def get_weight_paths(self):
"""Retrieve all the variables and their paths for the model.
The variable path (string) is a stable key to identify a `tf.Variable`
instance owned by the model. It can be used to specify variable-specific
configurations (e.g. DTensor, quantization) from a global view.
This method returns a dict with weight object paths as keys
and the corresponding `tf.Variable` instances as values.
Note that if the model is a subclassed model and the weights haven't
been initialized, an empty dict will be returned.
Returns:
A dict where keys are variable paths and values are `tf.Variable`
instances.
Example:
```python
class SubclassModel(tf.keras.Model):
def __init__(self, name=None):
super().__init__(name=name)
self.d1 = tf.keras.layers.Dense(10)
self.d2 = tf.keras.layers.Dense(20)
def call(self, inputs):
x = self.d1(inputs)
return self.d2(x)
model = SubclassModel()
model(tf.zeros((10, 10)))
weight_paths = model.get_weight_paths()
# weight_paths:
# {
# 'd1.kernel': model.d1.kernel,
# 'd1.bias': model.d1.bias,
# 'd2.kernel': model.d2.kernel,
# 'd2.bias': model.d2.bias,
# }
# Functional model
inputs = tf.keras.Input((10,), batch_size=10)
x = tf.keras.layers.Dense(20, name='d1')(inputs)
output = tf.keras.layers.Dense(30, name='d2')(x)
model = tf.keras.Model(inputs, output)
d1 = model.layers[1]
d2 = model.layers[2]
weight_paths = model.get_weight_paths()
# weight_paths:
# {
# 'd1.kernel': d1.kernel,
# 'd1.bias': d1.bias,
# 'd2.kernel': d2.kernel,
# 'd2.bias': d2.bias,
# }
```
"""
result = {}
(
descendants,
object_paths_dict,
) = tf.__internal__.tracking.ObjectGraphView(
self
).breadth_first_traversal()
for descendant in descendants:
if isinstance(descendant, tf.Variable):
trackable_references = object_paths_dict[descendant]
object_path = ".".join([t.name for t in trackable_references])
result[object_path] = descendant
return result
def get_compile_config(self):
"""Returns a serialized config with information for compiling the model.
This method returns a config dictionary containing all the information
(optimizer, loss, metrics, etc.) with which the model was compiled.
Returns:
A dict containing information for compiling the model.
"""
if self._is_compiled and hasattr(self, "_compile_config"):
return self._compile_config.serialize()
def compile_from_config(self, config):
"""Compiles the model with the information given in config.
This method uses the information in the config (optimizer, loss,
metrics, etc.) to compile the model.
Args:
config: Dict containing information for compiling the model.
"""
has_overridden_compile = self.__class__.compile != Model.compile
if has_overridden_compile:
logging.warning(
"`compile()` was not called as part of model loading "
"because the model's `compile()` method is custom. "
"All subclassed Models that have `compile()` "
"overridden should also override "
"`get_compile_config()` and `compile_from_config(config)`. "
"Alternatively, you can "
"call `compile()` manually after loading."
)
return
config = saving_lib.deserialize_keras_object(config)
self.compile(**config)
if (
hasattr(self, "optimizer")
# Exempt legacy optimizers.
and isinstance(self.optimizer, optimizer.Optimizer)
and self.built
):
# Create optimizer variables.
self.optimizer.build(self.trainable_variables)
def export(self, filepath):
"""Create a SavedModel artifact for inference (e.g. via TF-Serving).
This method lets you export a model to a lightweight SavedModel artifact
that contains the model's forward pass only (its `call()` method)
and can be served via e.g. TF-Serving. The forward pass is registered
under the name `serve()` (see example below).
The original code of the model (including any custom layers you may
have used) is *no longer* necessary to reload the artifact -- it is
entirely standalone.
Args:
filepath: `str` or `pathlib.Path` object. Path where to save
the artifact.
Example:
```python
# Create the artifact
model.export("path/to/location")
# Later, in a different process / environment...
reloaded_artifact = tf.saved_model.load("path/to/location")
predictions = reloaded_artifact.serve(input_data)
```
If you would like to customize your serving endpoints, you can
use the lower-level `keras.export.ExportArchive` class. The `export()`
method relies on `ExportArchive` internally.
"""
from tf_keras.src.export import export_lib
export_lib.export_model(self, filepath)
@tf.__internal__.tracking.no_automatic_dependency_tracking
def _set_save_spec(self, inputs, args=None, kwargs=None):
"""Defines the save spec so that serialization can trace `call()`.
The TensorSpecs of the call function `inputs`, `args`, and `kwargs` are
saved into a tuple of `([inputs] + args, kwargs)`. The input
`TensorSpec` names are updated to match the built `input_names`.
The specs can be retrieved with the `save_spec` property.
Args:
inputs: possibly nested inputs passed into the call function.
args: a list of positional arguments passed into call.
kwargs: a dictionary of keyword arguments passed into call.
"""
if self._saved_model_inputs_spec is not None:
return # Already set.
args = args or []
kwargs = kwargs or {}
input_names = self.input_names
if not input_names:
input_names = compile_utils.create_pseudo_input_names(inputs)
flat_inputs = tf.nest.flatten(inputs)
inputs_spec = []
for name, tensor in zip(input_names, flat_inputs):
inputs_spec.append(
tf_utils.get_tensor_spec(tensor, dynamic_batch=False, name=name)
)
inputs_spec = tf.nest.pack_sequence_as(inputs, inputs_spec)
super()._set_save_spec(inputs_spec, args, kwargs)
# Store the input shapes
if (
self.__class__.__name__ == "Sequential"
and self._build_input_shape is None
):
self._build_input_shape = tf.nest.map_structure(
lambda x: None if x is None else x.shape, inputs_spec
)
def save_spec(self, dynamic_batch=True):
"""Returns the `tf.TensorSpec` of call args as a tuple `(args, kwargs)`.
This value is automatically defined after calling the model for the
first time. Afterwards, you can use it when exporting the model for
serving:
```python
model = tf.keras.Model(...)
@tf.function
def serve(*args, **kwargs):
outputs = model(*args, **kwargs)
# Apply postprocessing steps, or add additional outputs.
...
return outputs
# arg_specs is `[tf.TensorSpec(...), ...]`. kwarg_specs, in this
# example, is an empty dict since functional models do not use keyword
# arguments.
arg_specs, kwarg_specs = model.save_spec()
model.save(path, signatures={
'serving_default': serve.get_concrete_function(*arg_specs,
**kwarg_specs)
})
```
Args:
dynamic_batch: Whether to set the batch sizes of all the returned
`tf.TensorSpec` to `None`. (Note that when defining functional or
Sequential models with `tf.keras.Input([...], batch_size=X)`, the
batch size will always be preserved). Defaults to `True`.
Returns:
If the model inputs are defined, returns a tuple `(args, kwargs)`. All
elements in `args` and `kwargs` are `tf.TensorSpec`.
If the model inputs are not defined, returns `None`.
The model inputs are automatically set when calling the model,
`model.fit`, `model.evaluate` or `model.predict`.
"""
return self._get_save_spec(dynamic_batch, inputs_only=False)
def _assert_weights_created(self):
"""Asserts that all the weights for the model have been created.
For a non-dynamic model, the weights must already be created after the
layer has been called. For a dynamic model, the exact list of weights
can never be known for certain since it may change at any time during
execution.
We run this check right before accessing weights or getting the Numpy
value for the current weights. Otherwise, if the layer has never been
called, the user would just get an empty list, which is misleading.
Raises:
ValueError: if the weights of the network have not yet been created.
"""
if self.dynamic:
return
if (
"build" in self.__class__.__dict__
and self.__class__ != Model
and not self.built
):
# For any model that has customized build() method but hasn't been
# invoked yet, this will cover both sequential and subclass model.
# Also make sure to exclude Model class itself which has build()
# defined.
raise ValueError(
f"Weights for model '{self.name}' have not yet been "
"created. "
"Weights are created when the model is first called on "
"inputs or `build()` is called with an `input_shape`."
)
def _check_call_args(self, method_name):
"""Check that `call()` has only one positional arg."""
# Always allow first arg, regardless of arg name.
fullargspec = self._call_spec.full_argspec
if fullargspec.defaults:
positional_args = fullargspec.args[: -len(fullargspec.defaults)]
else:
positional_args = fullargspec.args
if "training" in positional_args:
positional_args.remove("training")
# self and first arg can be positional.
if len(positional_args) > 2:
extra_args = positional_args[2:]
raise ValueError(
f"Models passed to `{method_name}` can only have `training` "
"and the first argument in `call()` as positional arguments, "
f"found: {extra_args}."
)
def _validate_compile(self, optimizer, metrics, **kwargs):
"""Performs validation checks for the default `compile()`."""
if any(
isinstance(opt, optimizer_v1.Optimizer)
for opt in tf.nest.flatten(optimizer)
):
raise ValueError(
f"`tf.compat.v1.keras` Optimizer ({optimizer}) is "
"not supported when eager execution is enabled. Use a "
"`tf.keras` Optimizer instead, or disable eager "
"execution."
)
kwargs.pop("cloning", None) # Legacy DistStrat argument, never used.
kwargs.pop("experimental_run_tf_function", None) # Always `True`.
distribute_arg = kwargs.pop("distribute", None)
if distribute_arg is not None:
raise ValueError(
"`distribute` argument in compile is not available in TF 2.0. "
"Please create the model under the `strategy.scope()`. "
f"Received: {distribute_arg}."
)
target_tensor_arg = kwargs.pop("target_tensors", None)
if target_tensor_arg is not None:
raise ValueError(
"`target_tensors` argument is not supported when executing "
f"eagerly. Received: {target_tensor_arg}."
)
invalid_kwargs = set(kwargs) - {"sample_weight_mode"}
if invalid_kwargs:
raise TypeError(
"Invalid keyword argument(s) in `compile()`: "
f"{(invalid_kwargs,)}. Valid keyword arguments include "
'"cloning", "experimental_run_tf_function", "distribute",'
' "target_tensors", or "sample_weight_mode".'
)
# Model must be created and compiled with the same DistStrat.
if self.built and tf.distribute.has_strategy():
strategy = tf.distribute.get_strategy()
for v in self.variables:
if not strategy.extended.variable_created_in_scope(v):
raise ValueError(
f"Variable ({v}) was not created in the distribution "
f"strategy scope of ({strategy}). It is most likely "
"because some layers, model, or optimizer was being "
"created outside the distribution strategy scope. Try "
"to make sure your code looks similar "
"to the following.\nwith strategy.scope():\n"
" model=_create_model()\n"
" model.compile(...)"
)
# Model metrics must be created in the same distribution strategy scope
# as the model.
strategy = self.distribute_strategy
for metric in tf.nest.flatten(metrics):
for v in getattr(metric, "variables", []):
if not strategy.extended.variable_created_in_scope(v):
raise ValueError(
f"Metric ({metric}) passed to `model.compile` was "
"created inside a different distribution strategy "
"scope than the model. All metrics must be created "
"in the same distribution strategy "
f"scope as the model (in this case {strategy}). "
"If you pass in a string identifier for a metric to "
"compile, the metric will automatically be created "
"in the correct distribution strategy scope."
)
# Model metrics must be created in the same distribution strategy scope
# as the model.
for opt in tf.nest.flatten(optimizer):
for v in getattr(opt, "_weights", []):
if not strategy.extended.variable_created_in_scope(v):
raise ValueError(
f"Optimizer ({optimizer}) passed to `model.compile` "
"was created inside a different distribution strategy "
"scope than the model. All optimizers must be created "
"in the same distribution strategy scope as the model "
f"(in this case {strategy}). If you pass in a string "
"identifier for an optimizer to compile, the optimizer "
"will automatically be created in the correct "
"distribution strategy scope."
)
def _maybe_load_initial_counters_from_ckpt(
self, steps_per_epoch, initial_epoch
):
"""Maybe load initial epoch from ckpt, considering worker recovery.
Refer to tensorflow/python/tf_keras/distribute/worker_training_state.py
for more information.
Args:
steps_per_epoch: The number of step per epoch.
initial_epoch: The original initial_epoch user passes in `fit()`.
mode: The mode for running `model.fit()`.
Returns:
If the training is recovering from previous failure under multi-worker
training setting, return the (epoch, step) the training is supposed to
continue at. Otherwise, return the `initial_epoch, initial_step` the
user passes in.
"""
initial_step = 0
if self._training_state is not None:
return self._training_state.maybe_load_initial_counters_from_ckpt(
steps_per_epoch, initial_epoch, mode=ModeKeys.TRAIN
)
return (initial_epoch, initial_step)
def _assert_compile_was_called(self):
# Checks whether `compile` has been called. If it has been called,
# then the optimizer is set. This is different from whether the
# model is compiled
# (i.e. whether the model is built and its inputs/outputs are set).
if not self._is_compiled:
raise RuntimeError(
"You must compile your model before "
"training/testing. "
"Use `model.compile(optimizer, loss)`."
)
def _check_sample_weight_warning(self, x, sample_weight):
# Datasets can include sample weight, by returning a tuple with the
# structure of `(x, y, sample_weight)`.
sample_weight_present = sample_weight is not None or (
isinstance(x, tf.data.Dataset)
and isinstance(x.element_spec, tuple)
and len(x.element_spec) == 3
)
if (
sample_weight_present
and self.compiled_metrics._user_weighted_metrics is None
):
logging.warning(
"`evaluate()` received a value for `sample_weight`, but "
"`weighted_metrics` were not provided. Did you mean to pass "
"metrics to `weighted_metrics` in `compile()`? If this is "
"intentional you can pass `weighted_metrics=[]` to `compile()` "
"in order to silence this warning."
)
def _set_inputs(self, inputs, outputs=None, training=None):
"""This method is for compat with Modelv1. Only inputs are needed
here."""
self._set_save_spec(inputs)
@property
def _trackable_saved_model_saver(self):
return model_serialization.ModelSavedModelSaver(self)
def _trackable_children(self, save_type="checkpoint", **kwargs):
if save_type == "savedmodel":
# SavedModel needs to ignore the execution functions.
train_function = self.train_function
test_function = self.test_function
predict_function = self.predict_function
train_tf_function = self.train_tf_function
self.train_function = None
self.test_function = None
self.predict_function = None
self.train_tf_function = None
children = super()._trackable_children(save_type, **kwargs)
if save_type == "savedmodel":
self.train_function = train_function
self.test_function = test_function
self.predict_function = predict_function
self.train_tf_function = train_tf_function
return children
def _should_eval(self, epoch, validation_freq):
epoch = epoch + 1 # one-index the user-facing epoch.
if isinstance(validation_freq, int):
return epoch % validation_freq == 0
elif isinstance(validation_freq, list):
return epoch in validation_freq
else:
raise ValueError(
"Expected `validation_freq` to be a list or int. "
f"Received: validation_freq={validation_freq} of the "
f"type {type(validation_freq)}."
)
######################################################################
# Functions below exist only as v1 / v2 compatibility shims.
######################################################################
def _get_compile_args(self, user_metrics=True):
"""Used for saving or cloning a Model.
Args:
user_metrics: Whether to return user-supplied metrics or `Metric`
objects. If True, returns the user-supplied metrics.
Defaults to `True`.
Returns:
Dictionary of arguments that were used when compiling the model.
"""
self._assert_compile_was_called()
saved_metrics = self.compiled_metrics._user_metrics
saved_weighted_metrics = self.compiled_metrics._user_weighted_metrics
if not user_metrics:
if saved_metrics is not None:
saved_metrics = self.compiled_metrics._metrics
if saved_weighted_metrics is not None:
saved_weighted_metrics = self.compiled_metrics._weighted_metrics
compile_args = {
"optimizer": self.optimizer,
"loss": self.compiled_loss._user_losses,
"metrics": saved_metrics,
"weighted_metrics": saved_weighted_metrics,
"loss_weights": self.compiled_loss._user_loss_weights,
}
return compile_args
def _get_callback_model(self):
return self
def _in_multi_worker_mode(self):
return self.distribute_strategy.extended._in_multi_worker_mode()
@property
def _compile_was_called(self):
return self._is_compiled
| (self, filepath, overwrite=True, save_format=None, options=None) |
725,043 | tf_keras.src.engine.base_layer | set_weights | Sets the weights of the layer, from NumPy arrays.
The weights of a layer represent the state of the layer. This function
sets the weight values from numpy arrays. The weight values should be
passed in the order they are created by the layer. Note that the layer's
weights must be instantiated before calling this function, by calling
the layer.
For example, a `Dense` layer returns a list of two values: the kernel
matrix and the bias vector. These can be used to set the weights of
another `Dense` layer:
>>> layer_a = tf.keras.layers.Dense(1,
... kernel_initializer=tf.constant_initializer(1.))
>>> a_out = layer_a(tf.convert_to_tensor([[1., 2., 3.]]))
>>> layer_a.get_weights()
[array([[1.],
[1.],
[1.]], dtype=float32), array([0.], dtype=float32)]
>>> layer_b = tf.keras.layers.Dense(1,
... kernel_initializer=tf.constant_initializer(2.))
>>> b_out = layer_b(tf.convert_to_tensor([[10., 20., 30.]]))
>>> layer_b.get_weights()
[array([[2.],
[2.],
[2.]], dtype=float32), array([0.], dtype=float32)]
>>> layer_b.set_weights(layer_a.get_weights())
>>> layer_b.get_weights()
[array([[1.],
[1.],
[1.]], dtype=float32), array([0.], dtype=float32)]
Args:
weights: a list of NumPy arrays. The number
of arrays and their shape must match
number of the dimensions of the weights
of the layer (i.e. it should match the
output of `get_weights`).
Raises:
ValueError: If the provided weights list does not match the
layer's specifications.
| def set_weights(self, weights):
"""Sets the weights of the layer, from NumPy arrays.
The weights of a layer represent the state of the layer. This function
sets the weight values from numpy arrays. The weight values should be
passed in the order they are created by the layer. Note that the layer's
weights must be instantiated before calling this function, by calling
the layer.
For example, a `Dense` layer returns a list of two values: the kernel
matrix and the bias vector. These can be used to set the weights of
another `Dense` layer:
>>> layer_a = tf.keras.layers.Dense(1,
... kernel_initializer=tf.constant_initializer(1.))
>>> a_out = layer_a(tf.convert_to_tensor([[1., 2., 3.]]))
>>> layer_a.get_weights()
[array([[1.],
[1.],
[1.]], dtype=float32), array([0.], dtype=float32)]
>>> layer_b = tf.keras.layers.Dense(1,
... kernel_initializer=tf.constant_initializer(2.))
>>> b_out = layer_b(tf.convert_to_tensor([[10., 20., 30.]]))
>>> layer_b.get_weights()
[array([[2.],
[2.],
[2.]], dtype=float32), array([0.], dtype=float32)]
>>> layer_b.set_weights(layer_a.get_weights())
>>> layer_b.get_weights()
[array([[1.],
[1.],
[1.]], dtype=float32), array([0.], dtype=float32)]
Args:
weights: a list of NumPy arrays. The number
of arrays and their shape must match
number of the dimensions of the weights
of the layer (i.e. it should match the
output of `get_weights`).
Raises:
ValueError: If the provided weights list does not match the
layer's specifications.
"""
params = self.weights
expected_num_weights = 0
for param in params:
if isinstance(param, base_layer_utils.TrackableWeightHandler):
expected_num_weights += param.num_tensors
else:
expected_num_weights += 1
if expected_num_weights != len(weights):
raise ValueError(
'You called `set_weights(weights)` on layer "%s" '
"with a weight list of length %s, but the layer was "
"expecting %s weights. Provided weights: %s..."
% (
self.name,
len(weights),
expected_num_weights,
str(weights)[:50],
)
)
weight_index = 0
weight_value_tuples = []
for param in params:
if isinstance(param, base_layer_utils.TrackableWeightHandler):
num_tensors = param.num_tensors
tensors = weights[weight_index : weight_index + num_tensors]
param.set_weights(tensors)
weight_index += num_tensors
else:
weight = weights[weight_index]
weight_shape = weight.shape if hasattr(weight, "shape") else ()
ref_shape = param.shape
if not ref_shape.is_compatible_with(weight_shape):
raise ValueError(
f"Layer {self.name} weight shape {ref_shape} "
"is not compatible with provided weight "
f"shape {weight_shape}."
)
weight_value_tuples.append((param, weight))
weight_index += 1
backend.batch_set_value(weight_value_tuples)
# Perform any layer defined finalization of the layer state.
for layer in self._flatten_layers():
layer.finalize_state()
| (self, weights) |
725,044 | tf_keras.src.engine.training | summary | Prints a string summary of the network.
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, becomes
`[0.3, 0.6, 0.70, 1.]`. Defaults to `None`.
print_fn: Print function to use. By default, prints to `stdout`.
If `stdout` doesn't work in your environment, change 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.
Defaults to `False`.
show_trainable: Whether to show if a layer is trainable.
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.
Raises:
ValueError: if `summary()` is called before the model is built.
| def summary(
self,
line_length=None,
positions=None,
print_fn=None,
expand_nested=False,
show_trainable=False,
layer_range=None,
):
"""Prints a string summary of the network.
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, becomes
`[0.3, 0.6, 0.70, 1.]`. Defaults to `None`.
print_fn: Print function to use. By default, prints to `stdout`.
If `stdout` doesn't work in your environment, change 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.
Defaults to `False`.
show_trainable: Whether to show if a layer is trainable.
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.
Raises:
ValueError: if `summary()` is called before the model is built.
"""
if not self.built:
raise ValueError(
"This model has not yet been built. "
"Build the model first by calling `build()` or by calling "
"the model on a batch of data."
)
layer_utils.print_summary(
self,
line_length=line_length,
positions=positions,
print_fn=print_fn,
expand_nested=expand_nested,
show_trainable=show_trainable,
layer_range=layer_range,
)
| (self, line_length=None, positions=None, print_fn=None, expand_nested=False, show_trainable=False, layer_range=None) |
725,045 | tf_keras.src.engine.training | test_on_batch | Test the model on a single batch of samples.
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.
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.
Returns:
Scalar test loss (if the model has a single output and no metrics)
or list of scalars (if the model has multiple outputs
and/or metrics). The attribute `model.metrics_names` will give you
the display labels for the scalar outputs.
Raises:
RuntimeError: If `model.test_on_batch` is wrapped in a
`tf.function`.
| def test_on_batch(
self,
x,
y=None,
sample_weight=None,
reset_metrics=True,
return_dict=False,
):
"""Test the model on a single batch of samples.
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.
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.
Returns:
Scalar test loss (if the model has a single output and no metrics)
or list of scalars (if the model has multiple outputs
and/or metrics). The attribute `model.metrics_names` will give you
the display labels for the scalar outputs.
Raises:
RuntimeError: If `model.test_on_batch` is wrapped in a
`tf.function`.
"""
self._assert_compile_was_called()
self._check_call_args("test_on_batch")
_disallow_inside_tf_function("test_on_batch")
if reset_metrics:
self.reset_metrics()
with self.distribute_strategy.scope():
iterator = data_adapter.single_batch_iterator(
self.distribute_strategy, x, y, sample_weight
)
self.test_function = self.make_test_function()
logs = self.test_function(iterator)
logs = tf_utils.sync_to_numpy_or_python_type(logs)
if return_dict:
return logs
else:
return flatten_metrics_in_order(logs, self.metrics_names)
| (self, x, y=None, sample_weight=None, reset_metrics=True, return_dict=False) |
725,046 | tf_keras.src.engine.training | test_step | The logic for one evaluation step.
This method can be overridden to support custom evaluation logic.
This method is called by `Model.make_test_function`.
This function should contain the mathematical logic for one step of
evaluation.
This typically includes the forward pass, loss calculation, and metrics
updates.
Configuration details for *how* this logic is run (e.g. `tf.function`
and `tf.distribute.Strategy` settings), should be left to
`Model.make_test_function`, which can also be overridden.
Args:
data: A nested structure of `Tensor`s.
Returns:
A `dict` containing values that will be passed to
`tf.keras.callbacks.CallbackList.on_train_batch_end`. Typically, the
values of the `Model`'s metrics are returned.
| def test_step(self, data):
"""The logic for one evaluation step.
This method can be overridden to support custom evaluation logic.
This method is called by `Model.make_test_function`.
This function should contain the mathematical logic for one step of
evaluation.
This typically includes the forward pass, loss calculation, and metrics
updates.
Configuration details for *how* this logic is run (e.g. `tf.function`
and `tf.distribute.Strategy` settings), should be left to
`Model.make_test_function`, which can also be overridden.
Args:
data: A nested structure of `Tensor`s.
Returns:
A `dict` containing values that will be passed to
`tf.keras.callbacks.CallbackList.on_train_batch_end`. Typically, the
values of the `Model`'s metrics are returned.
"""
x, y, sample_weight = data_adapter.unpack_x_y_sample_weight(data)
y_pred = self(x, training=False)
# Updates stateful loss metrics.
self.compute_loss(x, y, y_pred, sample_weight)
return self.compute_metrics(x, y, y_pred, sample_weight)
| (self, data) |
725,047 | tf_keras.src.engine.training | to_json | Returns a JSON string containing the network configuration.
To load a network from a JSON save file, use
`keras.models.model_from_json(json_string, custom_objects={})`.
Args:
**kwargs: Additional keyword arguments to be passed to
*`json.dumps()`.
Returns:
A JSON string.
| def to_json(self, **kwargs):
"""Returns a JSON string containing the network configuration.
To load a network from a JSON save file, use
`keras.models.model_from_json(json_string, custom_objects={})`.
Args:
**kwargs: Additional keyword arguments to be passed to
*`json.dumps()`.
Returns:
A JSON string.
"""
model_config = self._updated_config()
return json.dumps(
model_config, default=json_utils.get_json_type, **kwargs
)
| (self, **kwargs) |
725,048 | tf_keras.src.engine.training | to_yaml | Returns a yaml string containing the network configuration.
Note: Since TF 2.6, this method is no longer supported and will raise a
RuntimeError.
To load a network from a yaml save file, use
`keras.models.model_from_yaml(yaml_string, custom_objects={})`.
`custom_objects` should be a dictionary mapping
the names of custom losses / layers / etc to the corresponding
functions / classes.
Args:
**kwargs: Additional keyword arguments
to be passed to `yaml.dump()`.
Returns:
A YAML string.
Raises:
RuntimeError: announces that the method poses a security risk
| def to_yaml(self, **kwargs):
"""Returns a yaml string containing the network configuration.
Note: Since TF 2.6, this method is no longer supported and will raise a
RuntimeError.
To load a network from a yaml save file, use
`keras.models.model_from_yaml(yaml_string, custom_objects={})`.
`custom_objects` should be a dictionary mapping
the names of custom losses / layers / etc to the corresponding
functions / classes.
Args:
**kwargs: Additional keyword arguments
to be passed to `yaml.dump()`.
Returns:
A YAML string.
Raises:
RuntimeError: announces that the method poses a security risk
"""
raise RuntimeError(
"Method `model.to_yaml()` has been removed due to security risk of "
"arbitrary code execution. Please use `model.to_json()` instead."
)
| (self, **kwargs) |
725,049 | tf_keras.src.engine.training | train_on_batch | Runs a single gradient update on a single batch of data.
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.
y: Target data. Like the input data `x`, it could be either Numpy
array(s) or TensorFlow tensor(s).
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.
class_weight: Optional dictionary mapping class indices (integers)
to a weight (float) to apply to the model's loss for the samples
from this class during training. This can be useful to tell the
model to "pay more attention" to samples from an under-represented
class. When `class_weight` is specified and targets have a rank of
2 or greater, either `y` must be one-hot encoded, or an explicit
final dimension of `1` must be included for sparse class labels.
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.
Returns:
Scalar training loss
(if the model has a single output and no metrics)
or list of scalars (if the model has multiple outputs
and/or metrics). The attribute `model.metrics_names` will give you
the display labels for the scalar outputs.
Raises:
RuntimeError: If `model.train_on_batch` is wrapped in a `tf.function`.
| def train_on_batch(
self,
x,
y=None,
sample_weight=None,
class_weight=None,
reset_metrics=True,
return_dict=False,
):
"""Runs a single gradient update on a single batch of data.
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.
y: Target data. Like the input data `x`, it could be either Numpy
array(s) or TensorFlow tensor(s).
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.
class_weight: Optional dictionary mapping class indices (integers)
to a weight (float) to apply to the model's loss for the samples
from this class during training. This can be useful to tell the
model to "pay more attention" to samples from an under-represented
class. When `class_weight` is specified and targets have a rank of
2 or greater, either `y` must be one-hot encoded, or an explicit
final dimension of `1` must be included for sparse class labels.
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.
Returns:
Scalar training loss
(if the model has a single output and no metrics)
or list of scalars (if the model has multiple outputs
and/or metrics). The attribute `model.metrics_names` will give you
the display labels for the scalar outputs.
Raises:
RuntimeError: If `model.train_on_batch` is wrapped in a `tf.function`.
"""
self._assert_compile_was_called()
self._check_call_args("train_on_batch")
_disallow_inside_tf_function("train_on_batch")
if reset_metrics:
self.reset_metrics()
with self.distribute_strategy.scope(), training_utils.RespectCompiledTrainableState( # noqa: E501
self
):
iterator = data_adapter.single_batch_iterator(
self.distribute_strategy, x, y, sample_weight, class_weight
)
self.train_function = self.make_train_function()
logs = self.train_function(iterator)
logs = tf_utils.sync_to_numpy_or_python_type(logs)
if return_dict:
return logs
else:
return flatten_metrics_in_order(logs, self.metrics_names)
| (self, x, y=None, sample_weight=None, class_weight=None, reset_metrics=True, return_dict=False) |
725,050 | tf_keras.src.engine.training | train_step | The logic for one training step.
This method can be overridden to support custom training logic.
For concrete examples of how to override this method see
[Customizing what happens in fit](
https://www.tensorflow.org/guide/keras/customizing_what_happens_in_fit).
This method is called by `Model.make_train_function`.
This method should contain the mathematical logic for one step of
training. This typically includes the forward pass, loss calculation,
backpropagation, and metric updates.
Configuration details for *how* this logic is run (e.g. `tf.function`
and `tf.distribute.Strategy` settings), should be left to
`Model.make_train_function`, which can also be overridden.
Args:
data: A nested structure of `Tensor`s.
Returns:
A `dict` containing values that will be passed to
`tf.keras.callbacks.CallbackList.on_train_batch_end`. Typically, the
values of the `Model`'s metrics are returned. Example:
`{'loss': 0.2, 'accuracy': 0.7}`.
| def train_step(self, data):
"""The logic for one training step.
This method can be overridden to support custom training logic.
For concrete examples of how to override this method see
[Customizing what happens in fit](
https://www.tensorflow.org/guide/keras/customizing_what_happens_in_fit).
This method is called by `Model.make_train_function`.
This method should contain the mathematical logic for one step of
training. This typically includes the forward pass, loss calculation,
backpropagation, and metric updates.
Configuration details for *how* this logic is run (e.g. `tf.function`
and `tf.distribute.Strategy` settings), should be left to
`Model.make_train_function`, which can also be overridden.
Args:
data: A nested structure of `Tensor`s.
Returns:
A `dict` containing values that will be passed to
`tf.keras.callbacks.CallbackList.on_train_batch_end`. Typically, the
values of the `Model`'s metrics are returned. Example:
`{'loss': 0.2, 'accuracy': 0.7}`.
"""
x, y, sample_weight = data_adapter.unpack_x_y_sample_weight(data)
# Run forward pass.
with tf.GradientTape() as tape:
y_pred = self(x, training=True)
loss = self.compute_loss(x, y, y_pred, sample_weight)
self._validate_target_and_loss(y, loss)
# Run backwards pass.
self.optimizer.minimize(loss, self.trainable_variables, tape=tape)
return self.compute_metrics(x, y, y_pred, sample_weight)
| (self, data) |
725,051 | tf_keras.src.engine.sequential | Sequential | `Sequential` groups a linear stack of layers into a `tf.keras.Model`.
`Sequential` provides training and inference features on this model.
Examples:
```python
model = tf.keras.Sequential()
model.add(tf.keras.Input(shape=(16,)))
model.add(tf.keras.layers.Dense(8))
# Note that you can also omit the initial `Input`.
# In that case the model doesn't have any weights until the first call
# to a training/evaluation method (since it isn't yet built):
model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(8))
model.add(tf.keras.layers.Dense(4))
# model.weights not created yet
# Whereas if you specify an `Input`, the model gets built
# continuously as you are adding layers:
model = tf.keras.Sequential()
model.add(tf.keras.Input(shape=(16,)))
model.add(tf.keras.layers.Dense(4))
len(model.weights)
# Returns "2"
# When using the delayed-build pattern (no input shape specified), you can
# choose to manually build your model by calling
# `build(batch_input_shape)`:
model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(8))
model.add(tf.keras.layers.Dense(4))
model.build((None, 16))
len(model.weights)
# Returns "4"
# Note that when using the delayed-build pattern (no input shape specified),
# the model gets built the first time you call `fit`, `eval`, or `predict`,
# or the first time you call the model on some input data.
model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(8))
model.add(tf.keras.layers.Dense(1))
model.compile(optimizer='sgd', loss='mse')
# This builds the model for the first time:
model.fit(x, y, batch_size=32, epochs=10)
```
| class Sequential(functional.Functional):
"""`Sequential` groups a linear stack of layers into a `tf.keras.Model`.
`Sequential` provides training and inference features on this model.
Examples:
```python
model = tf.keras.Sequential()
model.add(tf.keras.Input(shape=(16,)))
model.add(tf.keras.layers.Dense(8))
# Note that you can also omit the initial `Input`.
# In that case the model doesn't have any weights until the first call
# to a training/evaluation method (since it isn't yet built):
model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(8))
model.add(tf.keras.layers.Dense(4))
# model.weights not created yet
# Whereas if you specify an `Input`, the model gets built
# continuously as you are adding layers:
model = tf.keras.Sequential()
model.add(tf.keras.Input(shape=(16,)))
model.add(tf.keras.layers.Dense(4))
len(model.weights)
# Returns "2"
# When using the delayed-build pattern (no input shape specified), you can
# choose to manually build your model by calling
# `build(batch_input_shape)`:
model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(8))
model.add(tf.keras.layers.Dense(4))
model.build((None, 16))
len(model.weights)
# Returns "4"
# Note that when using the delayed-build pattern (no input shape specified),
# the model gets built the first time you call `fit`, `eval`, or `predict`,
# or the first time you call the model on some input data.
model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(8))
model.add(tf.keras.layers.Dense(1))
model.compile(optimizer='sgd', loss='mse')
# This builds the model for the first time:
model.fit(x, y, batch_size=32, epochs=10)
```
"""
@tf.__internal__.tracking.no_automatic_dependency_tracking
@traceback_utils.filter_traceback
def __init__(self, layers=None, name=None):
"""Creates a `Sequential` model instance.
Args:
layers: Optional list of layers to add to the model.
name: Optional name for the model.
"""
# Skip the init in FunctionalModel since model doesn't have input/output
# yet
super(functional.Functional, self).__init__(name=name, autocast=False)
self.supports_masking = True
self._compute_output_and_mask_jointly = True
self._auto_track_sub_layers = False
self._inferred_input_shape = None
self._has_explicit_input_shape = False
self._input_dtype = None
self._layer_call_argspecs = {}
self._created_nodes = set()
# Flag that indicate whether the sequential network topology has been
# created. It is false when there isn't any layer, or the layers don't
# have an input shape.
self._graph_initialized = False
# Unfortunately some Sequential models using custom layers or
# FeatureColumn layers have multiple inputs. This is fundamentally
# incompatible with most of the Sequential API, and we have to disable a
# number of features for such models.
self._use_legacy_deferred_behavior = False
# Add to the model any layers passed to the constructor.
if layers:
if not isinstance(layers, (list, tuple)):
layers = [layers]
for layer in layers:
self.add(layer)
@property
def layers(self):
# Historically, `sequential.layers` only returns layers that were added
# via `add`, and omits the auto-generated `InputLayer` that comes at the
# bottom of the stack.
# `Trackable` manages the `_layers` attributes and does filtering
# over it.
layers = super().layers
if layers and isinstance(layers[0], input_layer.InputLayer):
return layers[1:]
return layers[:]
@tf.__internal__.tracking.no_automatic_dependency_tracking
@traceback_utils.filter_traceback
def add(self, layer):
"""Adds a layer instance on top of the layer stack.
Args:
layer: layer instance.
Raises:
TypeError: If `layer` is not a layer instance.
ValueError: In case the `layer` argument does not
know its input shape.
ValueError: In case the `layer` argument has
multiple output tensors, or is already connected
somewhere else (forbidden in `Sequential` models).
"""
# If we are passed a TF-Keras tensor created by keras.Input(), we can
# extract the input layer from its keras history and use that without
# any loss of
# generality.
if hasattr(layer, "_keras_history"):
origin_layer = layer._keras_history[0]
if isinstance(origin_layer, input_layer.InputLayer):
layer = origin_layer
if isinstance(layer, tf.Module):
if not isinstance(layer, base_layer.Layer):
layer = functional.ModuleWrapper(layer)
else:
raise TypeError(
"The added layer must be an instance of class Layer. "
f"Received: layer={layer} of type {type(layer)}."
)
tf_utils.assert_no_legacy_layers([layer])
if not self._is_layer_name_unique(layer):
raise ValueError(
"All layers added to a Sequential model "
f'should have unique names. Name "{layer.name}" is already '
"the name of a layer in this model. Update the `name` argument "
"to pass a unique name."
)
self.built = False
set_inputs = False
self._maybe_create_attribute("_self_tracked_trackables", [])
if not self._self_tracked_trackables:
if isinstance(layer, input_layer.InputLayer):
# Case where the user passes an Input or InputLayer layer via
# `add`.
set_inputs = True
else:
batch_shape, dtype = training_utils.get_input_shape_and_dtype(
layer
)
if batch_shape:
# Instantiate an input layer.
x = input_layer.Input(
batch_shape=batch_shape,
dtype=dtype,
name=layer.name + "_input",
)
# This will build the current layer
# and create the node connecting the current layer
# to the input layer we just created.
layer(x)
set_inputs = True
if set_inputs:
outputs = tf.nest.flatten(layer._inbound_nodes[-1].outputs)
if len(outputs) != 1:
raise ValueError(SINGLE_LAYER_OUTPUT_ERROR_MSG)
self.outputs = outputs
self.inputs = layer_utils.get_source_inputs(self.outputs[0])
self.built = True
self._has_explicit_input_shape = True
elif self.outputs:
# If the model is being built continuously on top of an input layer:
# refresh its output.
output_tensor = layer(self.outputs[0])
if len(tf.nest.flatten(output_tensor)) != 1:
raise ValueError(SINGLE_LAYER_OUTPUT_ERROR_MSG)
self.outputs = [output_tensor]
self.built = True
if set_inputs or self._graph_initialized:
self._init_graph_network(self.inputs, self.outputs)
self._graph_initialized = True
else:
self._self_tracked_trackables.append(layer)
self._handle_deferred_layer_dependencies([layer])
self._layer_call_argspecs[layer] = tf_inspect.getfullargspec(layer.call)
@tf.__internal__.tracking.no_automatic_dependency_tracking
@traceback_utils.filter_traceback
def pop(self):
"""Removes the last layer in the model.
Raises:
TypeError: if there are no layers in the model.
"""
if not self.layers:
raise TypeError("There are no layers in the model.")
layer = self._self_tracked_trackables.pop()
self._layer_call_argspecs.pop(layer)
if not self.layers:
self.outputs = None
self.inputs = None
self.built = False
self._inferred_input_shape = None
self._has_explicit_input_shape = False
self._graph_initialized = False
elif self._graph_initialized:
self.layers[-1]._outbound_nodes = []
self.outputs = [self.layers[-1].output]
self._init_graph_network(self.inputs, self.outputs)
self.built = True
@tf.__internal__.tracking.no_automatic_dependency_tracking
def _build_graph_network_for_inferred_shape(
self, input_shape, input_dtype=None
):
if input_shape is None or not self.layers:
return
if (
not tf.__internal__.tf2.enabled()
or not tf.compat.v1.executing_eagerly_outside_functions()
):
# This behavior is disabled in V1 or when eager execution is
# disabled.
return
if (
not self._has_explicit_input_shape
and not self._use_legacy_deferred_behavior
):
# Determine whether the input shape is novel, i.e. whether the model
# should be rebuilt.
input_shape = tuple(input_shape)
if self._inferred_input_shape is None:
new_shape = input_shape
else:
new_shape = relax_input_shape(
self._inferred_input_shape, input_shape
)
if (
new_shape is not None
and new_shape != self._inferred_input_shape
):
# A novel shape has been received: we need to rebuild the model.
# In case we are inside a graph function, we step out of it.
with tf.init_scope():
inputs = input_layer.Input(
batch_shape=new_shape,
dtype=input_dtype,
name=self.layers[0].name + "_input",
)
layer_input = inputs
created_nodes = set()
for layer in self.layers:
# Clear nodes previously created via this method. This
# prevents node accumulation and ensures that e.g.
# `layer.output` is always connected to `model.inputs`
# (this is important e.g. for the feature extraction use
# case). We don't just do `layer._inbound_nodes = []`
# in order not to break shared layers added to
# Sequential models (which is technically illegal as per
# the `add()` docstring, but wasn't previously
# disabled).
clear_previously_created_nodes(
layer, self._created_nodes
)
try:
# Create Functional API connection by calling the
# current layer
layer_output = layer(layer_input)
except: # noqa: E722
# Functional API calls may fail for a number of
# reasons: 1) The layer may be buggy. In this case
# it will be easier for the user to debug if we fail
# on the first call on concrete data, instead of our
# own call on a symbolic input. 2) The layer is
# dynamic (graph-incompatible) and hasn't overridden
# `compute_output_shape`. In this case, it is
# impossible to build a graph network. 3) The layer
# is otherwise incompatible with the Functional API
# (e.g. this is the case for some probabilistic
# layers that rely on hacks and that do not return
# tensors). In all these cases, we should avoid
# creating a graph network (or we simply can't).
self._use_legacy_deferred_behavior = True
return
if len(tf.nest.flatten(layer_output)) != 1:
raise ValueError(SINGLE_LAYER_OUTPUT_ERROR_MSG)
# Keep track of nodes just created above
track_nodes_created_by_last_call(layer, created_nodes)
layer_input = layer_output
outputs = layer_output
self._created_nodes = created_nodes
try:
# Initialize a graph Network. This call will never fail
# for stack of valid TF-Keras layers. However some users
# have layers that are fundamentally incompatible with
# the Functional API, which do not return tensors. In
# this case, we fall back to the legacy deferred
# behavior.
# TODO(fchollet): consider raising here, as we should
# not be supporting such layers.
self._init_graph_network(inputs, outputs)
self._graph_initialized = True
except: # noqa: E722
self._use_legacy_deferred_behavior = True
self._inferred_input_shape = new_shape
@generic_utils.default
def build(self, input_shape=None):
if self._graph_initialized:
self._init_graph_network(self.inputs, self.outputs)
else:
if input_shape is None:
raise ValueError("You must provide an `input_shape` argument.")
self._build_graph_network_for_inferred_shape(input_shape)
if not self.built:
input_shape = tuple(input_shape)
self._build_input_shape = input_shape
super().build(input_shape)
self.built = True
def call(self, inputs, training=None, mask=None):
# If applicable, update the static input shape of the model.
if not self._has_explicit_input_shape:
if not tf.is_tensor(inputs) and not isinstance(inputs, tf.Tensor):
# This is a Sequential with multiple inputs. This is technically
# an invalid use case of Sequential, but we tolerate it for
# backwards compatibility.
self._use_legacy_deferred_behavior = True
self._build_input_shape = tf.nest.map_structure(
_get_shape_tuple, inputs
)
else:
self._build_graph_network_for_inferred_shape(
inputs.shape, inputs.dtype
)
if self._graph_initialized:
if not self.built:
self._init_graph_network(self.inputs, self.outputs)
return super().call(inputs, training=training, mask=mask)
outputs = inputs # handle the corner case where self.layers is empty
for layer in self.layers:
# During each iteration, `inputs` are the inputs to `layer`, and
# `outputs` are the outputs of `layer` applied to `inputs`. At the
# end of each iteration `inputs` is set to `outputs` to prepare for
# the next layer.
kwargs = {}
argspec = self._layer_call_argspecs[layer].args
if "mask" in argspec:
kwargs["mask"] = mask
if "training" in argspec:
kwargs["training"] = training
outputs = layer(inputs, **kwargs)
inputs = outputs
def _get_mask_from_keras_tensor(kt):
return getattr(kt, "_keras_mask", None)
mask = tf.nest.map_structure(_get_mask_from_keras_tensor, outputs)
return outputs
def compute_output_shape(self, input_shape):
shape = input_shape
for layer in self.layers:
shape = layer.compute_output_shape(shape)
return shape
def compute_mask(self, inputs, mask):
# TODO(omalleyt): b/123540974 This function is not really safe to call
# by itself because it will duplicate any updates and losses in graph
# mode by `call`ing the Layers again.
outputs = self.call(inputs, mask=mask)
return getattr(outputs, "_keras_mask", None)
def get_config(self):
layer_configs = []
serialize_obj_fn = serialization_lib.serialize_keras_object
if getattr(self, "use_legacy_config", None):
serialize_obj_fn = legacy_serialization.serialize_keras_object
for layer in super().layers:
# `super().layers` include the InputLayer if available (it is
# filtered out of `self.layers`). Note that
# `self._self_tracked_trackables` is managed by the tracking
# infrastructure and should not be used.
layer_configs.append(serialize_obj_fn(layer))
config = training.Model.get_config(self)
config["name"] = self.name
config["layers"] = copy.deepcopy(layer_configs)
if not self._is_graph_network and self._build_input_shape is not None:
config["build_input_shape"] = self._build_input_shape
return config
@classmethod
def from_config(cls, config, custom_objects=None):
if "name" in config:
name = config["name"]
build_input_shape = config.get("build_input_shape")
layer_configs = config["layers"]
else:
name = None
layer_configs = config
model = cls(name=name)
for layer_config in layer_configs:
use_legacy_format = "module" not in layer_config
layer = layer_module.deserialize(
layer_config,
custom_objects=custom_objects,
use_legacy_format=use_legacy_format,
)
model.add(layer)
if (
not model.inputs
and build_input_shape
and isinstance(build_input_shape, (tuple, list))
):
model.build(build_input_shape)
return model
@property
def input_spec(self):
if hasattr(self, "_manual_input_spec"):
return self._manual_input_spec
if self._has_explicit_input_shape:
return super().input_spec
return None
@input_spec.setter
def input_spec(self, value):
self._manual_input_spec = value
@property
def _trackable_saved_model_saver(self):
return model_serialization.SequentialSavedModelSaver(self)
def _is_layer_name_unique(self, layer):
for ref_layer in self.layers:
if layer.name == ref_layer.name and ref_layer is not layer:
return False
return True
def _assert_weights_created(self):
if self._graph_initialized:
return
# When the graph has not been initialized, use the Model's
# implementation to to check if the weights has been created.
super(functional.Functional, self)._assert_weights_created()
| (layers=None, name=None) |
725,057 | tf_keras.src.engine.sequential | __init__ | Creates a `Sequential` model instance.
Args:
layers: Optional list of layers to add to the model.
name: Optional name for the model.
| @tf.__internal__.tracking.no_automatic_dependency_tracking
@traceback_utils.filter_traceback
def add(self, layer):
"""Adds a layer instance on top of the layer stack.
Args:
layer: layer instance.
Raises:
TypeError: If `layer` is not a layer instance.
ValueError: In case the `layer` argument does not
know its input shape.
ValueError: In case the `layer` argument has
multiple output tensors, or is already connected
somewhere else (forbidden in `Sequential` models).
"""
# If we are passed a TF-Keras tensor created by keras.Input(), we can
# extract the input layer from its keras history and use that without
# any loss of
# generality.
if hasattr(layer, "_keras_history"):
origin_layer = layer._keras_history[0]
if isinstance(origin_layer, input_layer.InputLayer):
layer = origin_layer
if isinstance(layer, tf.Module):
if not isinstance(layer, base_layer.Layer):
layer = functional.ModuleWrapper(layer)
else:
raise TypeError(
"The added layer must be an instance of class Layer. "
f"Received: layer={layer} of type {type(layer)}."
)
tf_utils.assert_no_legacy_layers([layer])
if not self._is_layer_name_unique(layer):
raise ValueError(
"All layers added to a Sequential model "
f'should have unique names. Name "{layer.name}" is already '
"the name of a layer in this model. Update the `name` argument "
"to pass a unique name."
)
self.built = False
set_inputs = False
self._maybe_create_attribute("_self_tracked_trackables", [])
if not self._self_tracked_trackables:
if isinstance(layer, input_layer.InputLayer):
# Case where the user passes an Input or InputLayer layer via
# `add`.
set_inputs = True
else:
batch_shape, dtype = training_utils.get_input_shape_and_dtype(
layer
)
if batch_shape:
# Instantiate an input layer.
x = input_layer.Input(
batch_shape=batch_shape,
dtype=dtype,
name=layer.name + "_input",
)
# This will build the current layer
# and create the node connecting the current layer
# to the input layer we just created.
layer(x)
set_inputs = True
if set_inputs:
outputs = tf.nest.flatten(layer._inbound_nodes[-1].outputs)
if len(outputs) != 1:
raise ValueError(SINGLE_LAYER_OUTPUT_ERROR_MSG)
self.outputs = outputs
self.inputs = layer_utils.get_source_inputs(self.outputs[0])
self.built = True
self._has_explicit_input_shape = True
elif self.outputs:
# If the model is being built continuously on top of an input layer:
# refresh its output.
output_tensor = layer(self.outputs[0])
if len(tf.nest.flatten(output_tensor)) != 1:
raise ValueError(SINGLE_LAYER_OUTPUT_ERROR_MSG)
self.outputs = [output_tensor]
self.built = True
if set_inputs or self._graph_initialized:
self._init_graph_network(self.inputs, self.outputs)
self._graph_initialized = True
else:
self._self_tracked_trackables.append(layer)
self._handle_deferred_layer_dependencies([layer])
self._layer_call_argspecs[layer] = tf_inspect.getfullargspec(layer.call)
| (self, layers=None, name=None) |
725,067 | tf_keras.src.engine.sequential | _assert_weights_created | null | def _assert_weights_created(self):
if self._graph_initialized:
return
# When the graph has not been initialized, use the Model's
# implementation to to check if the weights has been created.
super(functional.Functional, self)._assert_weights_created()
| (self) |
725,069 | tf_keras.src.engine.sequential | _build_graph_network_for_inferred_shape | @tf.__internal__.tracking.no_automatic_dependency_tracking
@traceback_utils.filter_traceback
def add(self, layer):
"""Adds a layer instance on top of the layer stack.
Args:
layer: layer instance.
Raises:
TypeError: If `layer` is not a layer instance.
ValueError: In case the `layer` argument does not
know its input shape.
ValueError: In case the `layer` argument has
multiple output tensors, or is already connected
somewhere else (forbidden in `Sequential` models).
"""
# If we are passed a TF-Keras tensor created by keras.Input(), we can
# extract the input layer from its keras history and use that without
# any loss of
# generality.
if hasattr(layer, "_keras_history"):
origin_layer = layer._keras_history[0]
if isinstance(origin_layer, input_layer.InputLayer):
layer = origin_layer
if isinstance(layer, tf.Module):
if not isinstance(layer, base_layer.Layer):
layer = functional.ModuleWrapper(layer)
else:
raise TypeError(
"The added layer must be an instance of class Layer. "
f"Received: layer={layer} of type {type(layer)}."
)
tf_utils.assert_no_legacy_layers([layer])
if not self._is_layer_name_unique(layer):
raise ValueError(
"All layers added to a Sequential model "
f'should have unique names. Name "{layer.name}" is already '
"the name of a layer in this model. Update the `name` argument "
"to pass a unique name."
)
self.built = False
set_inputs = False
self._maybe_create_attribute("_self_tracked_trackables", [])
if not self._self_tracked_trackables:
if isinstance(layer, input_layer.InputLayer):
# Case where the user passes an Input or InputLayer layer via
# `add`.
set_inputs = True
else:
batch_shape, dtype = training_utils.get_input_shape_and_dtype(
layer
)
if batch_shape:
# Instantiate an input layer.
x = input_layer.Input(
batch_shape=batch_shape,
dtype=dtype,
name=layer.name + "_input",
)
# This will build the current layer
# and create the node connecting the current layer
# to the input layer we just created.
layer(x)
set_inputs = True
if set_inputs:
outputs = tf.nest.flatten(layer._inbound_nodes[-1].outputs)
if len(outputs) != 1:
raise ValueError(SINGLE_LAYER_OUTPUT_ERROR_MSG)
self.outputs = outputs
self.inputs = layer_utils.get_source_inputs(self.outputs[0])
self.built = True
self._has_explicit_input_shape = True
elif self.outputs:
# If the model is being built continuously on top of an input layer:
# refresh its output.
output_tensor = layer(self.outputs[0])
if len(tf.nest.flatten(output_tensor)) != 1:
raise ValueError(SINGLE_LAYER_OUTPUT_ERROR_MSG)
self.outputs = [output_tensor]
self.built = True
if set_inputs or self._graph_initialized:
self._init_graph_network(self.inputs, self.outputs)
self._graph_initialized = True
else:
self._self_tracked_trackables.append(layer)
self._handle_deferred_layer_dependencies([layer])
self._layer_call_argspecs[layer] = tf_inspect.getfullargspec(layer.call)
| (self, input_shape, input_dtype=None) |
|
725,074 | tf_keras.src.engine.functional | _compute_tensor_usage_count | Compute the #. of tensor usages for all the output tensors of layers.
The computed tensor usage count is saved as `self._tensor_usage_count`.
This is later used for saving memory in eager computation by releasing
no-longer-needed tensors as early as possible.
| def _compute_tensor_usage_count(self):
"""Compute the #. of tensor usages for all the output tensors of layers.
The computed tensor usage count is saved as `self._tensor_usage_count`.
This is later used for saving memory in eager computation by releasing
no-longer-needed tensors as early as possible.
"""
tensor_usage_count = collections.Counter()
available_tensors = set(str(id(tensor)) for tensor in self.inputs)
depth_keys = list(self._nodes_by_depth.keys())
depth_keys.sort(reverse=True)
depth_keys = depth_keys[1:]
for depth in depth_keys:
for node in self._nodes_by_depth[depth]:
input_tensors = {
str(id(tensor))
for tensor in tf.nest.flatten(node.keras_inputs)
}
if input_tensors.issubset(available_tensors):
for tensor in tf.nest.flatten(node.keras_inputs):
tensor_usage_count[str(id(tensor))] += 1
for output_tensor in tf.nest.flatten(node.outputs):
available_tensors.add(str(id(output_tensor)))
for tensor in self.outputs:
tensor_usage_count[str(id(tensor))] += 1
self._tensor_usage_count = tensor_usage_count
| (self) |
725,076 | tf_keras.src.engine.functional | _conform_to_reference_input | Set shape and dtype based on `keras.Input`s. | def _conform_to_reference_input(self, tensor, ref_input):
"""Set shape and dtype based on `keras.Input`s."""
if isinstance(tensor, tf.Tensor):
# Allow (None,) and (None, 1) Tensors to be passed interchangeably.
# Use the shape specified by the `keras.Input`.
t_shape = tensor.shape
t_rank = t_shape.rank
ref_shape = ref_input.shape
ref_rank = ref_shape.rank
keras_history = getattr(tensor, "_keras_history", None)
if t_rank is not None and ref_rank is not None:
# Should squeeze last dimension. True if tensor is (BATCH, ...,
# 1) and reference is (BATCH, ...).
if t_rank == ref_rank + 1 and t_shape[-1] == 1:
tensor = tf.squeeze(tensor, axis=-1)
# Should expand last_dimension. True if tensor is (BATCH, ...)
# and reference is (BATCH, ..., 1).
elif t_rank == ref_rank - 1 and ref_shape[-1] == 1:
tensor = tf.expand_dims(tensor, axis=-1)
if keras_history is not None: # Restore keras history.
tensor._keras_history = keras_history
# Dtype casting.
tensor = tf.cast(tensor, dtype=ref_input.dtype)
elif tf_utils.is_extension_type(tensor):
# Dtype casting (If the extension type has a non-variant dtype and
# supports being cast). Only cast if necessary (since some
# extension types may not implement tf.cast).
tensor_dtype = getattr(tensor, "dtype", None)
ref_input_dtype = getattr(ref_input, "dtype", None)
if (
ref_input_dtype is not None
and tensor_dtype is not None
and tensor_dtype != ref_input_dtype
and ref_input_dtype != tf.variant
):
tensor = tf.cast(tensor, dtype=ref_input_dtype)
return tensor
| (self, tensor, ref_input) |
725,087 | tf_keras.src.engine.functional | _flatten_to_reference_inputs | Maps `tensors` to their respective `keras.Input`. | def _flatten_to_reference_inputs(self, tensors):
"""Maps `tensors` to their respective `keras.Input`."""
if self._enable_dict_to_input_mapping and isinstance(tensors, dict):
ref_inputs = self._nested_inputs
if not tf.nest.is_nested(ref_inputs):
ref_inputs = [self._nested_inputs]
if isinstance(ref_inputs, dict):
# In the case that the graph is constructed with dict input
# tensors, We will use the original dict key to map with the
# keys in the input data. Note that the model.inputs is using
# nest.flatten to process the input tensors, which means the
# dict input tensors are ordered by their keys.
ref_input_names = sorted(ref_inputs.keys())
else:
ref_input_names = [
inp._keras_history.layer.name for inp in ref_inputs
]
# Raise an warning if there are more input data comparing to input
# tensor
if len(tensors) > len(ref_input_names):
warnings.warn(
"Input dict contained keys {} which did not match any "
"model input. They will be ignored by the model.".format(
[n for n in tensors.keys() if n not in ref_input_names]
),
stacklevel=2,
)
try:
# Flatten in the order `Input`s were passed during Model
# construction.
return [tensors[n] for n in ref_input_names]
except KeyError:
# TODO(b/151582614)
return tf.nest.flatten(tensors)
# Otherwise both self.inputs and tensors will already be in same order.
return tf.nest.flatten(tensors)
| (self, tensors) |
725,098 | tf_keras.src.engine.functional | _get_save_spec | null | def _get_save_spec(self, dynamic_batch=True, inputs_only=True):
if getattr(self, "_has_explicit_input_shape", True):
# Functional models and Sequential models that have an explicit
# input shape should use the batch size set by the input layer.
dynamic_batch = False
return super()._get_save_spec(dynamic_batch, inputs_only)
| (self, dynamic_batch=True, inputs_only=True) |
725,102 | tf_keras.src.engine.functional | _graph_network_add_loss | null | def _graph_network_add_loss(self, symbolic_loss):
new_nodes, new_layers = _map_subgraph_network(
self.inputs, [symbolic_loss]
)
# Losses must be keyed on inputs no matter what in order to be supported
# in DistributionStrategy.
add_loss_layer = base_layer.AddLoss(
unconditional=False, dtype=symbolic_loss.dtype
)
add_loss_layer(symbolic_loss)
new_nodes.extend(add_loss_layer.inbound_nodes)
new_layers.append(add_loss_layer)
self._insert_layers(new_layers, new_nodes)
| (self, symbolic_loss) |
725,103 | tf_keras.src.engine.functional | _graph_network_add_metric | null | def _graph_network_add_metric(self, value, aggregation, name):
new_nodes, new_layers = _map_subgraph_network(self.inputs, [value])
add_metric_layer = base_layer.AddMetric(
aggregation, name, dtype=value.dtype
)
add_metric_layer(value)
new_nodes.extend(add_metric_layer.inbound_nodes)
new_layers.append(add_metric_layer)
self._insert_layers(new_layers, new_nodes)
| (self, value, aggregation, name) |
725,106 | tf_keras.src.engine.functional | _handle_deferred_layer_dependencies | Handles layer checkpoint dependencies that are added after init. | def _handle_deferred_layer_dependencies(self, layers):
"""Handles layer checkpoint dependencies that are added after init."""
layer_checkpoint_dependencies = self._layer_checkpoint_dependencies
layer_to_name = {v: k for k, v in layer_checkpoint_dependencies.items()}
for layer in layers:
if layer in layer_to_name:
self._handle_deferred_dependencies(
name=layer_to_name[layer], trackable=layer
)
| (self, layers) |
725,113 | tf_keras.src.engine.functional | _init_graph_network | @tf.__internal__.tracking.no_automatic_dependency_tracking
def _init_graph_network(self, inputs, outputs):
# This method is needed for Sequential to reinitialize graph network
# when layer is added or removed.
self._is_graph_network = True
# Normalize and set self.inputs, self.outputs.
if isinstance(inputs, list) and len(tf.nest.flatten(inputs)) == 1:
inputs = inputs[0]
if isinstance(outputs, list) and len(tf.nest.flatten(outputs)) == 1:
outputs = outputs[0]
self._nested_inputs = inputs
self._nested_outputs = outputs
self.inputs = tf.nest.flatten(inputs)
self.outputs = tf.nest.flatten(outputs)
# Models constructed with a single Tensor or list of Tensors can
# be called with a dict, where the keys of the dict are the names
# of the `Input` objects. Extra keys are ignored with warning.
if not tf.nest.is_nested(self._nested_inputs):
self._enable_dict_to_input_mapping = True
elif isinstance(self._nested_inputs, (list, tuple)) and not any(
tf.nest.is_nested(t) for t in self._nested_inputs
):
self._enable_dict_to_input_mapping = True
elif isinstance(self._nested_inputs, dict) and not any(
tf.nest.is_nested(t) for t in self._nested_inputs.values()
):
self._enable_dict_to_input_mapping = True
else:
self._enable_dict_to_input_mapping = False
if not tf.compat.v1.executing_eagerly_outside_functions():
if any(
not hasattr(tensor, "_keras_history") for tensor in self.outputs
):
base_layer_utils.create_keras_history(self._nested_outputs)
self._validate_graph_inputs_and_outputs()
# A Network does not create weights of its own, thus it is already
# built.
self.built = True
self._build_input_shape = tf.nest.map_structure(
lambda x: x.shape, inputs
)
self._compute_output_and_mask_jointly = True
# `_expects_training_arg` is True since the `training` argument is
# always present in the signature of the `call` method of a graph
# network.
self._call_spec.expects_training_arg = True
self._call_spec.expects_mask_arg = True
# A graph network does not autocast inputs, as its layers will cast them
# instead.
self._autocast = False
self._input_layers = []
self._output_layers = []
self._input_coordinates = []
self._output_coordinates = []
# This is for performance optimization when calling the Network on new
# inputs. Every time the Network is called on a set on input tensors, we
# compute the output tensors, output masks and output shapes in one
# pass, then cache them here. When any of these outputs is queried
# later, we retrieve it from there instead of recomputing it.
self._output_mask_cache = {}
self._output_tensor_cache = {}
self._output_shape_cache = {}
# Build self._output_layers:
for x in self.outputs:
(
layer,
node_index,
tensor_index,
) = x._keras_history
self._output_layers.append(layer)
self._output_coordinates.append((layer, node_index, tensor_index))
# Build self._input_layers:
for x in self.inputs:
(
layer,
node_index,
tensor_index,
) = x._keras_history
# It's supposed to be an input layer, so only one node
# and one tensor output.
assert node_index == 0
assert tensor_index == 0
self._input_layers.append(layer)
self._input_coordinates.append((layer, node_index, tensor_index))
# Keep track of the network's nodes and layers.
nodes, nodes_by_depth, layers, _ = _map_graph_network(
self.inputs, self.outputs
)
self._network_nodes = nodes
self._nodes_by_depth = nodes_by_depth
self._self_tracked_trackables = layers
self._layer_call_argspecs = {}
for layer in self._self_tracked_trackables:
self._layer_call_argspecs[layer] = tf_inspect.getfullargspec(
layer.call
)
# Build self.input_names and self.output_names.
self._set_output_names()
self.input_names = []
self._feed_input_names = []
self._feed_inputs = []
self._feed_input_shapes = []
for layer in self._input_layers:
self.input_names.append(layer.name)
if layer.is_placeholder:
self._feed_input_names.append(layer.name)
# Use batch_input_shape here because non-eager composite tensors
# may not have a shape attribute that's meaningful (sparse, for
# instance, has a tensor that's non-constant and needs to be
# fed). This means that input layers that create placeholders
# will need to have the batch_input_shape attr to allow for
# input shape validation.
self._feed_input_shapes.append(layer._batch_input_shape)
self._feed_inputs.append(layer.input)
self._compute_tensor_usage_count()
self._set_save_spec(self._nested_inputs)
tf_utils.assert_no_legacy_layers(self.layers)
# Note that this method is used by both functional and sequential
# models, so we can't just have this method in functional.__init__,
# which will miss the coverage of sequential model.
if self._layout_map is not None:
layout_map_lib._map_functional_model_variable(
self, self._layout_map
)
| (self, inputs, outputs) |
|
725,114 | tf_keras.src.engine.functional | _init_set_name | null | def _init_set_name(self, name, zero_based=True):
if not name:
cls_name = self.__class__.__name__
if self.__class__ == Functional:
# Hide the functional class name from user, since its not a
# public visible class. Use "Model" instead,
cls_name = "Model"
self._name = backend.unique_object_name(
generic_utils.to_snake_case(cls_name), zero_based=zero_based
)
else:
self._name = name
| (self, name, zero_based=True) |
725,115 | tf_keras.src.engine.functional | _insert_layers | Inserts Layers into the Network after Network creation.
This is only valid for TF-Keras Graph Networks. Layers added via this
function will be included in the `call` computation and `get_config` of
this Network. They will not be added to the Network's outputs.
Args:
layers: Arbitrary nested structure of Layers. Layers must be reachable
from one or more of the `keras.Input` Tensors that correspond to
this Network's inputs.
relevant_nodes: Nodes from the Layers that should be considered part
of this Network. If `None`, all Nodes will be considered part of
this Network.
Raises:
ValueError: If the layers depend on `Input`s not found in this Model.
| def _insert_layers(self, layers, relevant_nodes=None):
"""Inserts Layers into the Network after Network creation.
This is only valid for TF-Keras Graph Networks. Layers added via this
function will be included in the `call` computation and `get_config` of
this Network. They will not be added to the Network's outputs.
Args:
layers: Arbitrary nested structure of Layers. Layers must be reachable
from one or more of the `keras.Input` Tensors that correspond to
this Network's inputs.
relevant_nodes: Nodes from the Layers that should be considered part
of this Network. If `None`, all Nodes will be considered part of
this Network.
Raises:
ValueError: If the layers depend on `Input`s not found in this Model.
"""
layers = tf.nest.flatten(layers)
tf_utils.assert_no_legacy_layers(layers)
node_to_depth = {}
for depth, nodes in self._nodes_by_depth.items():
node_to_depth.update({node: depth for node in nodes})
# The nodes of these Layers that are relevant to this Network. If not
# provided, assume all Nodes are relevant
if not relevant_nodes:
relevant_nodes = tf.nest.flatten(
[layer._inbound_nodes for layer in layers]
)
network_nodes = set(relevant_nodes + list(node_to_depth.keys()))
def _get_min_depth(node):
"""Gets the minimum depth at which node can be computed."""
min_depth = 0
for layer, node_id, _, _ in node.iterate_inbound():
inbound_node = layer._inbound_nodes[node_id]
if inbound_node in node_to_depth:
min_depth = min(min_depth, node_to_depth[inbound_node])
elif inbound_node not in network_nodes:
continue
else:
# Previous relevant nodes haven't been processed yet.
return None
# New node is one shallower than its shallowest input.
return min_depth - 1
# Insert nodes into `_nodes_by_depth` and other node attrs.
unprocessed_nodes = copy.copy(relevant_nodes)
i = 0
while unprocessed_nodes:
i += 1
# Do a sanity check. This can occur if `Input`s from outside this
# Model are being relied on.
if i > 10000:
raise ValueError(
"Layers could not be added due to missing dependencies."
)
node = unprocessed_nodes.pop(0)
depth = _get_min_depth(node)
if depth is None: # Defer until inbound nodes are processed.
unprocessed_nodes.append(node)
continue
node_key = _make_node_key(
node.layer.name, node.layer._inbound_nodes.index(node)
)
if node_key not in self._network_nodes:
node_to_depth[node] = depth
self._network_nodes.add(node_key)
self._nodes_by_depth[depth].append(node)
# Insert layers and update other layer attrs.
layer_set = set(self._self_tracked_trackables)
deferred_layers = []
for layer in layers:
if layer not in layer_set:
self._self_tracked_trackables.append(layer)
deferred_layers.append(layer)
self._layer_call_argspecs[layer] = tf_inspect.getfullargspec(
layer.call
)
layer_set.add(layer)
self._handle_deferred_layer_dependencies(deferred_layers)
self._compute_tensor_usage_count()
| (self, layers, relevant_nodes=None) |
725,118 | tf_keras.src.engine.sequential | _is_layer_name_unique | null | def _is_layer_name_unique(self, layer):
for ref_layer in self.layers:
if layer.name == ref_layer.name and ref_layer is not layer:
return False
return True
| (self, layer) |
725,120 | tf_keras.src.engine.functional | _lookup_dependency | null | def _lookup_dependency(self, name, cached_dependencies=None):
if cached_dependencies:
return cached_dependencies.get(name)
# Fall back to slow lookup (`layer_checkpoint_dependencies` does a
# thorough check of all layer to see if they contain weights.)
layer_dependencies = self._layer_checkpoint_dependencies
if name in layer_dependencies:
return layer_dependencies[name]
return super()._lookup_dependency(name)
| (self, name, cached_dependencies=None) |
725,133 | tf_keras.src.engine.functional | _run_internal_graph | Computes output tensors for new inputs.
# Note:
- Can be run on non-Keras tensors.
Args:
inputs: Tensor or nested structure of Tensors.
training: Boolean learning phase.
mask: (Optional) Tensor or nested structure of Tensors.
Returns:
output_tensors
| def _run_internal_graph(self, inputs, training=None, mask=None):
"""Computes output tensors for new inputs.
# Note:
- Can be run on non-Keras tensors.
Args:
inputs: Tensor or nested structure of Tensors.
training: Boolean learning phase.
mask: (Optional) Tensor or nested structure of Tensors.
Returns:
output_tensors
"""
inputs = self._flatten_to_reference_inputs(inputs)
if mask is None:
masks = [None] * len(inputs)
else:
masks = self._flatten_to_reference_inputs(mask)
for input_t, mask in zip(inputs, masks):
input_t._keras_mask = mask
# Dictionary mapping reference tensors to computed tensors.
tensor_dict = {}
tensor_usage_count = self._tensor_usage_count
for x, y in zip(self.inputs, inputs):
y = self._conform_to_reference_input(y, ref_input=x)
x_id = str(id(x))
tensor_dict[x_id] = [y] * tensor_usage_count[x_id]
nodes_by_depth = self._nodes_by_depth
depth_keys = list(nodes_by_depth.keys())
depth_keys.sort(reverse=True)
for depth in depth_keys:
nodes = nodes_by_depth[depth]
for node in nodes:
if node.is_input:
continue # Input tensors already exist.
if any(t_id not in tensor_dict for t_id in node.flat_input_ids):
continue # Node is not computable, try skipping.
args, kwargs = node.map_arguments(tensor_dict)
outputs = node.layer(*args, **kwargs)
# Update tensor_dict.
for x_id, y in zip(
node.flat_output_ids, tf.nest.flatten(outputs)
):
tensor_dict[x_id] = [y] * tensor_usage_count[x_id]
output_tensors = []
for x in self.outputs:
x_id = str(id(x))
assert x_id in tensor_dict, "Could not compute output " + str(x)
output_tensors.append(tensor_dict[x_id].pop())
return tf.nest.pack_sequence_as(self._nested_outputs, output_tensors)
| (self, inputs, training=None, mask=None) |
725,141 | tf_keras.src.engine.functional | _set_output_names | Assigns unique names to the Network's outputs.
Output layers with multiple output tensors would otherwise lead to
duplicate names in self.output_names.
| def _set_output_names(self):
"""Assigns unique names to the Network's outputs.
Output layers with multiple output tensors would otherwise lead to
duplicate names in self.output_names.
"""
uniquified = []
output_names = set()
prefix_count = {}
for layer in self._output_layers:
proposal = layer.name
while proposal in output_names:
existing_count = prefix_count.get(layer.name, 1)
proposal = f"{layer.name}_{existing_count}"
prefix_count[layer.name] = existing_count + 1
output_names.add(proposal)
uniquified.append(proposal)
self.output_names = uniquified
| (self) |
725,151 | tf_keras.src.engine.functional | _trackable_children | null | def _trackable_children(self, save_type="checkpoint", **kwargs):
dependencies = self._layer_checkpoint_dependencies
dependencies.update(super()._trackable_children(save_type, **kwargs))
return dependencies
| (self, save_type='checkpoint', **kwargs) |
725,156 | tf_keras.src.engine.functional | _validate_graph_inputs_and_outputs | Validates the inputs and outputs of a Graph Network. | def _validate_graph_inputs_and_outputs(self):
"""Validates the inputs and outputs of a Graph Network."""
# Check for redundancy in inputs.
if len({id(i) for i in self.inputs}) != len(self.inputs):
raise ValueError(
"The list of inputs passed to the model "
"contains the same input multiple times. "
"All inputs should only appear once."
f"Received inputs={self.inputs}"
)
for x in self.inputs:
# Check that x has appropriate `_keras_history` metadata.
if not hasattr(x, "_keras_history"):
cls_name = self.__class__.__name__
raise ValueError(
f"Input tensors to a {cls_name} model "
"must come from `tf.keras.Input`. "
f"Received inputs={x} (missing previous layer metadata)."
)
# Check that x is an input tensor.
layer = x._keras_history.layer
if len(layer._inbound_nodes) > 1 or (
layer._inbound_nodes and not layer._inbound_nodes[0].is_input
):
cls_name = self.__class__.__name__
logging.warning(
f"{cls_name} model inputs must come from "
"`tf.keras.Input` (thus holding past layer metadata). "
"They cannot be the output of "
"a previous non-Input layer. "
"Here, a tensor specified as "
f'input to "{self.name}" was not an Input tensor, '
f'it was generated by layer "{layer.name}".\n'
"Note that input tensors are "
"instantiated via `tensor = tf.keras.Input(shape)`.\n"
f"The tensor that caused the issue was: {x}"
)
# Check compatibility of batch sizes of Input Layers.
input_batch_sizes = set(
[
training_utils.get_static_batch_size(x._keras_history.layer)
for x in self.inputs
]
)
input_batch_sizes.discard(None)
if len(input_batch_sizes) > 1:
logging.warning(
"Found incompatible static batch sizes among the "
f"inputs. Batch sizes: {sorted(input_batch_sizes)}"
)
for x in self.outputs:
if not hasattr(x, "_keras_history"):
cls_name = self.__class__.__name__
raise ValueError(
f"Output tensors of a {cls_name} model must be "
"the output of a TensorFlow `Layer` "
f"(thus holding past layer metadata). Found: {x}"
)
| (self) |
725,158 | tf_keras.src.engine.sequential | add | Adds a layer instance on top of the layer stack.
Args:
layer: layer instance.
Raises:
TypeError: If `layer` is not a layer instance.
ValueError: In case the `layer` argument does not
know its input shape.
ValueError: In case the `layer` argument has
multiple output tensors, or is already connected
somewhere else (forbidden in `Sequential` models).
| @tf.__internal__.tracking.no_automatic_dependency_tracking
@traceback_utils.filter_traceback
def add(self, layer):
"""Adds a layer instance on top of the layer stack.
Args:
layer: layer instance.
Raises:
TypeError: If `layer` is not a layer instance.
ValueError: In case the `layer` argument does not
know its input shape.
ValueError: In case the `layer` argument has
multiple output tensors, or is already connected
somewhere else (forbidden in `Sequential` models).
"""
# If we are passed a TF-Keras tensor created by keras.Input(), we can
# extract the input layer from its keras history and use that without
# any loss of
# generality.
if hasattr(layer, "_keras_history"):
origin_layer = layer._keras_history[0]
if isinstance(origin_layer, input_layer.InputLayer):
layer = origin_layer
if isinstance(layer, tf.Module):
if not isinstance(layer, base_layer.Layer):
layer = functional.ModuleWrapper(layer)
else:
raise TypeError(
"The added layer must be an instance of class Layer. "
f"Received: layer={layer} of type {type(layer)}."
)
tf_utils.assert_no_legacy_layers([layer])
if not self._is_layer_name_unique(layer):
raise ValueError(
"All layers added to a Sequential model "
f'should have unique names. Name "{layer.name}" is already '
"the name of a layer in this model. Update the `name` argument "
"to pass a unique name."
)
self.built = False
set_inputs = False
self._maybe_create_attribute("_self_tracked_trackables", [])
if not self._self_tracked_trackables:
if isinstance(layer, input_layer.InputLayer):
# Case where the user passes an Input or InputLayer layer via
# `add`.
set_inputs = True
else:
batch_shape, dtype = training_utils.get_input_shape_and_dtype(
layer
)
if batch_shape:
# Instantiate an input layer.
x = input_layer.Input(
batch_shape=batch_shape,
dtype=dtype,
name=layer.name + "_input",
)
# This will build the current layer
# and create the node connecting the current layer
# to the input layer we just created.
layer(x)
set_inputs = True
if set_inputs:
outputs = tf.nest.flatten(layer._inbound_nodes[-1].outputs)
if len(outputs) != 1:
raise ValueError(SINGLE_LAYER_OUTPUT_ERROR_MSG)
self.outputs = outputs
self.inputs = layer_utils.get_source_inputs(self.outputs[0])
self.built = True
self._has_explicit_input_shape = True
elif self.outputs:
# If the model is being built continuously on top of an input layer:
# refresh its output.
output_tensor = layer(self.outputs[0])
if len(tf.nest.flatten(output_tensor)) != 1:
raise ValueError(SINGLE_LAYER_OUTPUT_ERROR_MSG)
self.outputs = [output_tensor]
self.built = True
if set_inputs or self._graph_initialized:
self._init_graph_network(self.inputs, self.outputs)
self._graph_initialized = True
else:
self._self_tracked_trackables.append(layer)
self._handle_deferred_layer_dependencies([layer])
self._layer_call_argspecs[layer] = tf_inspect.getfullargspec(layer.call)
| (self, layer) |
725,164 | tf_keras.src.engine.sequential | build | null | @generic_utils.default
def build(self, input_shape=None):
if self._graph_initialized:
self._init_graph_network(self.inputs, self.outputs)
else:
if input_shape is None:
raise ValueError("You must provide an `input_shape` argument.")
self._build_graph_network_for_inferred_shape(input_shape)
if not self.built:
input_shape = tuple(input_shape)
self._build_input_shape = input_shape
super().build(input_shape)
self.built = True
| (self, input_shape=None) |
725,166 | tf_keras.src.engine.sequential | call | null | def call(self, inputs, training=None, mask=None):
# If applicable, update the static input shape of the model.
if not self._has_explicit_input_shape:
if not tf.is_tensor(inputs) and not isinstance(inputs, tf.Tensor):
# This is a Sequential with multiple inputs. This is technically
# an invalid use case of Sequential, but we tolerate it for
# backwards compatibility.
self._use_legacy_deferred_behavior = True
self._build_input_shape = tf.nest.map_structure(
_get_shape_tuple, inputs
)
else:
self._build_graph_network_for_inferred_shape(
inputs.shape, inputs.dtype
)
if self._graph_initialized:
if not self.built:
self._init_graph_network(self.inputs, self.outputs)
return super().call(inputs, training=training, mask=mask)
outputs = inputs # handle the corner case where self.layers is empty
for layer in self.layers:
# During each iteration, `inputs` are the inputs to `layer`, and
# `outputs` are the outputs of `layer` applied to `inputs`. At the
# end of each iteration `inputs` is set to `outputs` to prepare for
# the next layer.
kwargs = {}
argspec = self._layer_call_argspecs[layer].args
if "mask" in argspec:
kwargs["mask"] = mask
if "training" in argspec:
kwargs["training"] = training
outputs = layer(inputs, **kwargs)
inputs = outputs
def _get_mask_from_keras_tensor(kt):
return getattr(kt, "_keras_mask", None)
mask = tf.nest.map_structure(_get_mask_from_keras_tensor, outputs)
return outputs
| (self, inputs, training=None, mask=None) |
725,170 | tf_keras.src.engine.sequential | compute_mask | null | def compute_mask(self, inputs, mask):
# TODO(omalleyt): b/123540974 This function is not really safe to call
# by itself because it will duplicate any updates and losses in graph
# mode by `call`ing the Layers again.
outputs = self.call(inputs, mask=mask)
return getattr(outputs, "_keras_mask", None)
| (self, inputs, mask) |
725,172 | tf_keras.src.engine.sequential | compute_output_shape | null | def compute_output_shape(self, input_shape):
shape = input_shape
for layer in self.layers:
shape = layer.compute_output_shape(shape)
return shape
| (self, input_shape) |
725,183 | tf_keras.src.engine.sequential | get_config | null | def get_config(self):
layer_configs = []
serialize_obj_fn = serialization_lib.serialize_keras_object
if getattr(self, "use_legacy_config", None):
serialize_obj_fn = legacy_serialization.serialize_keras_object
for layer in super().layers:
# `super().layers` include the InputLayer if available (it is
# filtered out of `self.layers`). Note that
# `self._self_tracked_trackables` is managed by the tracking
# infrastructure and should not be used.
layer_configs.append(serialize_obj_fn(layer))
config = training.Model.get_config(self)
config["name"] = self.name
config["layers"] = copy.deepcopy(layer_configs)
if not self._is_graph_network and self._build_input_shape is not None:
config["build_input_shape"] = self._build_input_shape
return config
| (self) |
725,192 | tf_keras.src.engine.functional | get_weight_paths | null | def get_weight_paths(self):
result = {}
for layer in self.layers:
(
descendants,
object_paths_dict,
) = tf.__internal__.tracking.ObjectGraphView(
layer
).breadth_first_traversal()
for descendant in descendants:
if isinstance(descendant, tf.Variable):
trackable_references = object_paths_dict[descendant]
object_path = ".".join(
[t.name for t in trackable_references]
)
result[layer.name + "." + object_path] = descendant
return result
| (self) |
725,199 | tf_keras.src.engine.sequential | pop | Removes the last layer in the model.
Raises:
TypeError: if there are no layers in the model.
| @tf.__internal__.tracking.no_automatic_dependency_tracking
@traceback_utils.filter_traceback
def add(self, layer):
"""Adds a layer instance on top of the layer stack.
Args:
layer: layer instance.
Raises:
TypeError: If `layer` is not a layer instance.
ValueError: In case the `layer` argument does not
know its input shape.
ValueError: In case the `layer` argument has
multiple output tensors, or is already connected
somewhere else (forbidden in `Sequential` models).
"""
# If we are passed a TF-Keras tensor created by keras.Input(), we can
# extract the input layer from its keras history and use that without
# any loss of
# generality.
if hasattr(layer, "_keras_history"):
origin_layer = layer._keras_history[0]
if isinstance(origin_layer, input_layer.InputLayer):
layer = origin_layer
if isinstance(layer, tf.Module):
if not isinstance(layer, base_layer.Layer):
layer = functional.ModuleWrapper(layer)
else:
raise TypeError(
"The added layer must be an instance of class Layer. "
f"Received: layer={layer} of type {type(layer)}."
)
tf_utils.assert_no_legacy_layers([layer])
if not self._is_layer_name_unique(layer):
raise ValueError(
"All layers added to a Sequential model "
f'should have unique names. Name "{layer.name}" is already '
"the name of a layer in this model. Update the `name` argument "
"to pass a unique name."
)
self.built = False
set_inputs = False
self._maybe_create_attribute("_self_tracked_trackables", [])
if not self._self_tracked_trackables:
if isinstance(layer, input_layer.InputLayer):
# Case where the user passes an Input or InputLayer layer via
# `add`.
set_inputs = True
else:
batch_shape, dtype = training_utils.get_input_shape_and_dtype(
layer
)
if batch_shape:
# Instantiate an input layer.
x = input_layer.Input(
batch_shape=batch_shape,
dtype=dtype,
name=layer.name + "_input",
)
# This will build the current layer
# and create the node connecting the current layer
# to the input layer we just created.
layer(x)
set_inputs = True
if set_inputs:
outputs = tf.nest.flatten(layer._inbound_nodes[-1].outputs)
if len(outputs) != 1:
raise ValueError(SINGLE_LAYER_OUTPUT_ERROR_MSG)
self.outputs = outputs
self.inputs = layer_utils.get_source_inputs(self.outputs[0])
self.built = True
self._has_explicit_input_shape = True
elif self.outputs:
# If the model is being built continuously on top of an input layer:
# refresh its output.
output_tensor = layer(self.outputs[0])
if len(tf.nest.flatten(output_tensor)) != 1:
raise ValueError(SINGLE_LAYER_OUTPUT_ERROR_MSG)
self.outputs = [output_tensor]
self.built = True
if set_inputs or self._graph_initialized:
self._init_graph_network(self.inputs, self.outputs)
self._graph_initialized = True
else:
self._self_tracked_trackables.append(layer)
self._handle_deferred_layer_dependencies([layer])
self._layer_call_argspecs[layer] = tf_inspect.getfullargspec(layer.call)
| (self) |
725,242 | safetensors_rust | SafetensorError | Custom Python Exception for Safetensor errors. | from builtins import type
| null |
725,244 | builtins | safe_open | Opens a safetensors lazily and returns tensors as asked
Args:
filename (`str`, or `os.PathLike`):
The filename to open
framework (`str`):
The framework you want you tensors in. Supported values:
`pt`, `tf`, `flax`, `numpy`.
device (`str`, defaults to `"cpu"`):
The device on which you want the tensors. | from builtins import safe_open
| (self, filename, framework, device='cpu') |
725,247 | notebook | _jupyter_labextension_paths | null | def _jupyter_labextension_paths() -> list[dict[str, str]]:
return [{"src": "labextension", "dest": "@jupyter-notebook/lab-extension"}]
| () -> list[dict[str, str]] |
725,248 | notebook | _jupyter_server_extension_paths | null | def _jupyter_server_extension_paths() -> list[dict[str, str]]:
return [{"module": "notebook"}]
| () -> list[dict[str, str]] |
725,249 | notebook | _jupyter_server_extension_points | null | def _jupyter_server_extension_points() -> list[dict[str, Any]]:
from .app import JupyterNotebookApp
return [{"module": "notebook", "app": JupyterNotebookApp}]
| () -> list[dict[str, typing.Any]] |
725,251 | dockerfile_parse.parser | DockerfileParser | null | class DockerfileParser(object):
def __init__(self, path=None,
cache_content=False,
env_replace=True,
parent_env=None,
fileobj=None,
build_args=None):
"""
Initialize source of Dockerfile
:param path: path to (directory with) Dockerfile; if not provided,
and fileobj is not provided, the current working
directory will be used
:param cache_content: cache Dockerfile content inside DockerfileParser
:param env_replace: return content with variables replaced
:param parent_env: python dict of inherited env vars from parent image
:param fileobj: seekable file-like object containing Dockerfile content
as bytes (will be truncated on write)
:param build_args: python dict of build args used when building image
"""
self.fileobj = fileobj
if self.fileobj is not None:
if path is not None:
raise ValueError("Parameters path and fileobj cannot be used together.")
else:
self.fileobj.seek(0)
else:
path = path or '.'
if path.endswith(DOCKERFILE_FILENAME):
self.dockerfile_path = path
else:
self.dockerfile_path = os.path.join(path, DOCKERFILE_FILENAME)
self.cache_content = cache_content
self.cached_content = '' # unicode string
if cache_content:
try:
# this will cache the Dockerfile content
self.content
except (IOError, OSError):
# the Dockerfile doesn't exist yet
pass
self.env_replace = env_replace
if parent_env is None:
self.parent_env = {}
else:
assert isinstance(parent_env, dict)
logger.debug("Setting inherited parent image ENV vars: %s", parent_env)
self.parent_env = parent_env
if build_args is None:
self.build_args = {}
else:
assert isinstance(build_args, dict)
logger.debug("Setting build args: %s", build_args)
self.build_args = build_args
@contextmanager
def _open_dockerfile(self, mode):
if self.fileobj is not None:
self.fileobj.seek(0)
if 'w' in mode:
self.fileobj.truncate()
yield self.fileobj
self.fileobj.seek(0)
else:
with open(self.dockerfile_path, mode) as dockerfile:
yield dockerfile
@property
def lines(self):
"""
:return: list containing lines (unicode) from Dockerfile
"""
if self.cache_content and self.cached_content:
return self.cached_content.splitlines(True)
try:
with self._open_dockerfile('rb') as dockerfile:
lines = [b2u(line) for line in dockerfile.readlines()]
if self.cache_content:
self.cached_content = ''.join(lines)
return lines
except (IOError, OSError) as ex:
logger.error("Couldn't retrieve lines from dockerfile: %r", ex)
raise
@lines.setter
def lines(self, lines):
"""
Fill Dockerfile content with specified lines
:param lines: list of lines to be written to Dockerfile
"""
if self.cache_content:
self.cached_content = ''.join(b2u(line) for line in lines)
try:
with self._open_dockerfile('wb') as dockerfile:
dockerfile.writelines(u2b(line) for line in lines)
except (IOError, OSError) as ex:
logger.error("Couldn't write lines to dockerfile: %r", ex)
raise
@property
def content(self):
"""
:return: string (unicode) with Dockerfile content
"""
if self.cache_content and self.cached_content:
return self.cached_content
try:
with self._open_dockerfile('rb') as dockerfile:
content = b2u(dockerfile.read())
if self.cache_content:
self.cached_content = content
return content
except (IOError, OSError) as ex:
logger.error("Couldn't retrieve content of dockerfile: %r", ex)
raise
@content.setter
def content(self, content):
"""
Overwrite Dockerfile with specified content
:param content: string to be written to Dockerfile
"""
if self.cache_content:
self.cached_content = b2u(content)
try:
with self._open_dockerfile('wb') as dockerfile:
dockerfile.write(u2b(content))
except (IOError, OSError) as ex:
logger.error("Couldn't write content to dockerfile: %r", ex)
raise
@property
def structure(self):
"""
Returns a list of dicts describing the commands:
[
{"instruction": "FROM", # always upper-case
"startline": 0, # 0-based
"endline": 0, # 0-based
"content": "From fedora\n",
"value": "fedora"},
{"instruction": "CMD",
"startline": 1,
"endline": 2,
"content": "CMD yum -y update && \\\n yum clean all\n",
"value": "yum -y update && yum clean all"}
]
"""
def _rstrip_eol(text, line_continuation_char='\\'):
text = text.rstrip()
if text.endswith(line_continuation_char):
return text[:-1]
return text
def _create_instruction_dict(instruction=None, value=None):
return {
'instruction': instruction,
'startline': lineno,
'endline': lineno,
'content': line, # pylint: disable=undefined-loop-variable
'value': value
}
def _clean_comment_line(line):
line = re.sub(r'^\s*#\s*', '', line)
line = re.sub(r'\n', '', line)
return line
instructions = []
lineno = -1
line_continuation_char = '\\'
insnre = re.compile(r'^\s*(\S+)\s+(.*)$') # matched group is insn
contre = re.compile(r'^.*\\\s*$') # line continues?
commentre = re.compile(r'^\s*#') # line is a comment?
directive_possible = True
# escape directive regex
escape_directive_re = re.compile(r'^\s*#\s*escape\s*=\s*(\\|`)\s*$', re.I)
# syntax directive regex
syntax_directive_re = re.compile(r'^\s*#\s*syntax\s*=\s*(.*)\s*$', re.I)
in_continuation = False
current_instruction = {}
for line in self.lines:
lineno += 1
if directive_possible:
# once support for python versions before 3.8 is dropped use walrus operator
if escape_directive_re.match(line):
# Do the matching twice if there is a directive to avoid doing the matching
# for other lines
match = escape_directive_re.match(line)
line_continuation_char = match.group(1)
contre = re.compile(r'^.*' + re.escape(match.group(1)) + r'\s*$')
elif syntax_directive_re.match(line):
# Currently no information for the syntax directive is stored it is still
# necessary to detect escape directives after a syntax directive
pass
else:
directive_possible = False
# It is necessary to keep instructions and comment parsing separate,
# as a multi-line instruction can be interjected with comments.
if commentre.match(line):
comment = _create_instruction_dict(
instruction=COMMENT_INSTRUCTION,
value=_clean_comment_line(line)
)
instructions.append(comment)
else:
if not in_continuation:
m = insnre.match(line)
if not m:
continue
current_instruction = _create_instruction_dict(
instruction=m.groups()[0].upper(),
value=_rstrip_eol(m.groups()[1], line_continuation_char)
)
else:
current_instruction['content'] += line
current_instruction['endline'] = lineno
if current_instruction['value']:
current_instruction['value'] += _rstrip_eol(line, line_continuation_char)
else:
current_instruction['value'] = _rstrip_eol(line.lstrip(),
line_continuation_char)
in_continuation = contre.match(line)
if not in_continuation and current_instruction:
instructions.append(current_instruction)
return instructions
@property
def json(self):
"""
:return: JSON formatted string with instructions & values from Dockerfile
"""
insndescs = [{insndesc['instruction']: insndesc['value']} for insndesc in self.structure]
return json.dumps(insndescs)
@property
def parent_images(self):
"""
:return: list of parent images -- one image per each stage's FROM instruction
"""
in_stage = False
top_args = {}
parents = []
for instr in self.structure:
if instr['instruction'] == 'ARG':
if not in_stage:
key_val_list = extract_key_values(
env_replace=False,
args={}, envs={},
instruction_value=instr['value'])
for key, value in key_val_list:
if key in self.build_args:
value = self.build_args[key]
top_args[key] = value
elif instr['instruction'] == 'FROM':
in_stage = True
image, _ = image_from(instr['value'])
if image is not None:
image = WordSplitter(image, args=top_args).dequote()
parents.append(image)
return parents
@parent_images.setter
def parent_images(self, parents):
"""
setter for images in 'FROM' instructions.
Images are updated per build stage with the given parents in the order they appear.
Raises RuntimeError if a different number of parents are given than there are stages
as that is likely to be a mistake.
:param parents: list of image strings
"""
parents = list(parents)
change_instrs = []
for instr in self.structure:
if instr['instruction'] != 'FROM':
continue
old_image, stage = image_from(instr['value'])
if old_image is None:
continue # broken FROM, fixing would just confuse things
if not parents:
raise RuntimeError("not enough parents to match build stages")
image = parents.pop(0)
if image != old_image:
instr['value'] = '{0} AS {1}'.format(image, stage) if stage else image
instr['content'] = 'FROM {0}\n'.format(instr['value'])
change_instrs.append(instr)
if parents:
raise RuntimeError("trying to update too many parents for build stages")
lines = self.lines
for instr in reversed(change_instrs):
lines[instr['startline']:instr['endline']+1] = [instr['content']]
self.lines = lines
@property
def is_multistage(self):
return len(self.parent_images) > 1
@property
def baseimage(self):
"""
:return: base image, i.e. value of final stage FROM instruction
"""
return (self.parent_images or [None])[-1]
@baseimage.setter
def baseimage(self, new_image):
"""
change image of final stage FROM instruction
"""
images = []
for instr in self.structure:
if instr['instruction'] == 'FROM':
image, _ = image_from(instr['value'])
if image is not None:
images.append(image)
if not images:
raise RuntimeError('No stage defined to set base image on')
images[-1] = new_image
self.parent_images = images
@property
def cmd(self):
"""
Determine the final CMD instruction, if any, in the final build stage.
CMDs from earlier stages are ignored.
:return: value of final stage CMD instruction
"""
value = None
for insndesc in self.structure:
if insndesc['instruction'] == 'FROM': # new stage, reset
value = None
elif insndesc['instruction'] == 'CMD':
value = insndesc['value']
return value
@cmd.setter
def cmd(self, value):
"""
setter for final 'CMD' instruction in final build stage
"""
cmd = None
for insndesc in self.structure:
if insndesc['instruction'] == 'FROM': # new stage, reset
cmd = None
elif insndesc['instruction'] == 'CMD':
cmd = insndesc
new_cmd = 'CMD ' + value
if cmd:
self.add_lines_at(cmd, new_cmd, replace=True)
else:
self.add_lines(new_cmd)
@property
def labels(self):
"""
LABELs from Dockerfile
:return: dictionary of label:value (value might be '')
"""
return self._instruction_getter('LABEL', env_replace=self.env_replace)
@property
def envs(self):
"""
ENVs from Dockerfile
:return: dictionary of env_var_name:value (value might be '')
"""
return self._instruction_getter('ENV', env_replace=self.env_replace)
@property
def args(self):
"""
ARGs from Dockerfile
:return: dictionary of arg_var_name:value (value might be '')
"""
return self._instruction_getter('ARG', env_replace=self.env_replace)
def _instruction_getter(self, name, env_replace):
"""
Get LABEL or ENV or ARG instructions with environment replacement
:param name: e.g. 'LABEL' or 'ENV' or 'ARG'
:param env_replace: bool, whether to perform ENV substitution
:return: Labels instance or Envs instance
"""
if name not in ('LABEL', 'ENV', 'ARG'):
raise ValueError("Unsupported instruction '{0}'".format(name))
in_stage = False
top_args = {}
instructions = {}
args = {}
envs = {}
for instruction_desc in self.structure:
this_instruction = instruction_desc['instruction']
if this_instruction == 'FROM':
in_stage = True
instructions.clear()
args = {}
envs = self.parent_env.copy()
elif this_instruction in (name, 'ENV', 'ARG'):
logger.debug("%s value: %r", name.lower(), instruction_desc['value'])
key_val_list = extract_key_values(
env_replace=this_instruction != 'ARG' and env_replace,
args=args, envs=envs,
instruction_value=instruction_desc['value'])
for key, value in key_val_list:
if this_instruction == 'ARG':
if in_stage:
if key in top_args:
value = top_args[key]
elif key in self.build_args:
value = self.build_args[key]
args[key] = value
else:
if key in self.build_args:
value = self.build_args[key]
top_args[key] = value
if this_instruction == name:
instructions[key] = value
logger.debug("new %s %r=%r", name.lower(), key, value)
if this_instruction == 'ENV':
envs[key] = value
logger.debug("instructions: %r", instructions)
if name == 'LABEL':
return Labels(instructions, self)
elif name == 'ENV':
return Envs(instructions, self)
else:
return Args(instructions, self)
@labels.setter
def labels(self, labels):
"""
Setter for LABEL instruction, i.e. sets LABELs per input param.
:param labels: dictionary of label name & value to be set
"""
self._instructions_setter('LABEL', labels)
@envs.setter
def envs(self, envs):
"""
Setter for ENV instruction, i.e. sets ENVs per input param.
:param envs: dictionary of env. var. name & value to be set
"""
self._instructions_setter('ENV', envs)
@args.setter
def args(self, args):
"""
Setter for ARG instruction, i.e. sets ARGs per input param.
:param args: dictionary of arg names & values to be set
"""
self._instructions_setter('ARG', args)
def _instructions_setter(self, name, instructions):
if not isinstance(instructions, dict):
raise TypeError('instructions needs to be a dictionary {name: value}')
if name == 'LABEL':
existing = self.labels
elif name == 'ENV':
existing = self.envs
elif name == 'ARG':
existing = self.args
else:
raise ValueError("Unexpected instruction '%s'" % name)
logger.debug("setting %s instructions: %r", name, instructions)
to_delete = [k for k in existing if k not in instructions]
for key in to_delete:
logger.debug("delete %r", key)
self._modify_instruction_label_env(name, key, None)
to_add = dict((k, v) for (k, v) in instructions.items() if k not in existing)
for k, v in to_add.items():
logger.debug("add %r", k)
self._add_instruction(name, (k, v))
to_change = dict((k, v) for (k, v) in instructions.items()
if (k in existing and v != existing[k]))
for k, v in to_change.items():
logger.debug("modify %r", k)
self._modify_instruction_label_env(name, k, v)
def _modify_instruction_label(self, label_key, instr_value):
self._modify_instruction_label_env('LABEL', label_key, instr_value)
def _modify_instruction_env(self, env_var_key, env_var_value):
self._modify_instruction_label_env('ENV', env_var_key, env_var_value)
def _modify_instruction_arg(self, arg_key, arg_value):
self._modify_instruction_label_env('ARG', arg_key, arg_value)
def _modify_instruction_label_env(self, instruction, instr_key, instr_value):
"""
set <INSTRUCTION> instr_key to instr_value
:param instr_key: str, label key
:param instr_value: str or None, new label/env value or None to remove
"""
if instruction == 'LABEL':
instructions = self.labels
elif instruction == 'ENV':
instructions = self.envs
elif instruction == 'ARG':
instructions = self.args
else:
raise ValueError("Unknown instruction '%s'" % instruction)
if instr_key not in instructions:
raise KeyError('%s not in %ss' % (instr_key, instruction))
# extract target instructions from the final stage only
candidates = []
for insn in self.structure:
if insn['instruction'] == 'FROM':
candidates = []
if insn['instruction'] == instruction:
candidates.append(insn)
# Find where in the file to put the changes
content = startline = endline = None
for candidate in candidates:
words = list(WordSplitter(candidate['value']).split(dequote=False))
# LABEL/ENV/ARG syntax is one of two types:
if '=' not in words[0]: # LABEL/ENV/ARG name value
# Remove quotes from key name and see if it's the one
# we're looking for.
if WordSplitter(words[0]).dequote() == instr_key:
if instr_value is None:
# Delete this line altogether
content = None
else:
# Adjust label/env value
words[1:] = [quote(instr_value)]
# Now reconstruct the line
content = " ".join([instruction] + words) + '\n'
startline = candidate['startline']
endline = candidate['endline']
break
else: # LABEL/ENV/ARG "name"="value"
for index, token in enumerate(words):
key, _ = token.split("=", 1)
if WordSplitter(key).dequote() == instr_key:
if instr_value is None:
# Delete this label
del words[index]
else:
# Adjust label/env value
words[index] = "{0}={1}".format(key,
quote(instr_value))
if len(words) == 0:
# We removed the last label/env, delete the whole line
content = None
else:
# Now reconstruct the line
content = " ".join([instruction] + words) + '\n'
startline = candidate['startline']
endline = candidate['endline']
break
# We know the label/env we're looking for is there
assert startline and endline
# Re-write the Dockerfile
lines = self.lines
del lines[startline:endline + 1]
if content:
lines.insert(startline, content)
self.lines = lines
def _delete_instructions(self, instruction, value=None):
"""
:param instruction: name of instruction to be deleted
:param value: if specified, delete instruction only when it has this value
if instruction is LABEL then value is label name
"""
if instruction == 'LABEL' and value:
self._modify_instruction_label(value, None)
return
if instruction == 'ENV' and value:
self._modify_instruction_env(value, None)
return
if instruction == 'ARG' and value:
self._modify_instruction_arg(value, None)
return
lines = self.lines
deleted = False
for insn in reversed(self.structure):
if insn['instruction'] == instruction:
if value and insn['value'] != value:
continue
deleted = True
del lines[insn['startline']:insn['endline'] + 1]
if deleted:
self.lines = lines
def _add_instruction(self, instruction, value):
"""
:param instruction: instruction name to be added
:param value: instruction value
"""
if instruction in ('LABEL', 'ENV', 'ARG') and len(value) == 2:
new_line = instruction + ' ' + '='.join(map(quote, value)) + '\n'
else:
new_line = '{0} {1}\n'.format(instruction, value)
if new_line:
lines = self.lines
if not lines[len(lines) - 1].endswith('\n'):
new_line = '\n' + new_line
lines += new_line
self.lines = lines
def add_lines(self, *lines, **kwargs):
"""
Add lines to the beginning or end of the build.
:param lines: one or more lines to add to the content, by default at the end.
:param all_stages: bool for whether to add in all stages for a multistage build
or (by default) only the last.
:param at_start: adds at the beginning (after FROM) of the stage(s) instead of the end.
:param skip_scratch: skip stages which use "FROM scratch"
"""
assert len(lines) > 0
lines = [_endline(line) for line in lines]
all_stages = kwargs.pop('all_stages', False)
at_start = kwargs.pop('at_start', False)
skip_scratch = kwargs.pop('skip_scratch', False)
assert not kwargs, "Unknown keyword argument(s): {0}".format(list(kwargs))
froms = [
instr for instr in self.structure
if instr['instruction'] == 'FROM'
] or [{'endline': -1}] # no FROM? fake one before the beginning
if not all_stages: # only modify the last
froms = [froms[-1]]
df_lines = self.lines
# make sure last line has a newline if lines are to be appended
if df_lines and not at_start:
df_lines[-1] = _endline(df_lines[-1])
# iterate through the stages in reverse order
# so adding lines doesn't invalidate line numbers from structure dicts.
# first add a bogus instruction to represent EOF in our iteration.
froms.append({'startline': len(df_lines) + 1})
for stage in range(len(froms)-2, -1, -1): # e.g. 0 for single or 2, 1, 0 for 3 stages
start, finish = froms[stage], froms[stage+1]
linenum = start['endline'] + 1 if at_start else finish['startline']
image, _ = image_from(froms[stage].get('value') or '')
if skip_scratch and image == 'scratch':
continue
df_lines[linenum:linenum] = lines
self.lines = df_lines
def add_lines_at(self, anchor, *lines, **kwargs):
"""
Add lines at a specific location in the file.
:param anchor: structure_dict|line_str|line_num a reference to where adds should occur
:param lines: one or more lines to add to the content
:param replace: if True -- replace the anchor
:param after: if True -- insert after the anchor (conflicts with "replace")
"""
assert len(lines) > 0
replace = kwargs.pop('replace', False)
after = kwargs.pop('after', False)
assert not (after and replace)
assert not kwargs, "Unknown keyword argument(s): {0}".format(list(kwargs))
# find the line number for the insertion
df_lines = self.lines
if isinstance(anchor, int): # line number, just validate
assert 0 <= anchor < len(df_lines)
if replace:
del df_lines[anchor]
elif isinstance(anchor, dict): # structure
assert anchor in self.structure, "Current structure does not match: {0}".format(anchor)
if replace:
df_lines[anchor['startline']:anchor['endline'] + 1] = []
if after:
anchor = anchor['endline']
else:
anchor = anchor['startline']
elif isinstance(anchor, str): # line contents
matches = [index for index, text in enumerate(df_lines) if text == anchor]
if not matches:
raise RuntimeError("Cannot find line in the build file:\n" + anchor)
anchor = matches[-1]
if replace:
del df_lines[anchor]
else:
raise RuntimeError("Unknown anchor type {0}".format(anchor))
if after:
# ensure there's a newline on final line
df_lines[anchor] = _endline(df_lines[anchor])
anchor += 1
df_lines[anchor:anchor] = [_endline(line) for line in lines]
self.lines = df_lines
@property
def context_structure(self):
"""
:return: list of Context objects
(Contains info about build arguments, labels, and environment variables for each line.)
"""
in_stage = False
top_args = {}
instructions = []
last_context = Context()
for instr in self.structure:
instruction_type = instr['instruction']
if instruction_type == "FROM": # reset per stage
in_stage = True
last_context = Context(envs=dict(self.parent_env))
context = Context(args=dict(last_context.args),
envs=dict(last_context.envs),
labels=dict(last_context.labels))
if instruction_type in ('ARG', 'ENV', 'LABEL'):
values = get_key_val_dictionary(
instruction_value=instr['value'],
env_replace=instruction_type != 'ARG' and self.env_replace,
args=last_context.args,
envs=last_context.envs)
if instruction_type == 'ARG' and self.env_replace:
if in_stage:
for key in list(values.keys()):
if key in top_args:
values[key] = top_args[key]
elif key in self.build_args:
values[key] = self.build_args[key]
else:
for key, value in list(values.items()):
if key in self.build_args:
value = self.build_args[key]
top_args[key] = value
values[key] = value
context.set_line_value(context_type=instruction_type, value=values)
instructions.append(context)
last_context = context
return instructions
| (path=None, cache_content=False, env_replace=True, parent_env=None, fileobj=None, build_args=None) |
725,252 | dockerfile_parse.parser | __init__ |
Initialize source of Dockerfile
:param path: path to (directory with) Dockerfile; if not provided,
and fileobj is not provided, the current working
directory will be used
:param cache_content: cache Dockerfile content inside DockerfileParser
:param env_replace: return content with variables replaced
:param parent_env: python dict of inherited env vars from parent image
:param fileobj: seekable file-like object containing Dockerfile content
as bytes (will be truncated on write)
:param build_args: python dict of build args used when building image
| def __init__(self, path=None,
cache_content=False,
env_replace=True,
parent_env=None,
fileobj=None,
build_args=None):
"""
Initialize source of Dockerfile
:param path: path to (directory with) Dockerfile; if not provided,
and fileobj is not provided, the current working
directory will be used
:param cache_content: cache Dockerfile content inside DockerfileParser
:param env_replace: return content with variables replaced
:param parent_env: python dict of inherited env vars from parent image
:param fileobj: seekable file-like object containing Dockerfile content
as bytes (will be truncated on write)
:param build_args: python dict of build args used when building image
"""
self.fileobj = fileobj
if self.fileobj is not None:
if path is not None:
raise ValueError("Parameters path and fileobj cannot be used together.")
else:
self.fileobj.seek(0)
else:
path = path or '.'
if path.endswith(DOCKERFILE_FILENAME):
self.dockerfile_path = path
else:
self.dockerfile_path = os.path.join(path, DOCKERFILE_FILENAME)
self.cache_content = cache_content
self.cached_content = '' # unicode string
if cache_content:
try:
# this will cache the Dockerfile content
self.content
except (IOError, OSError):
# the Dockerfile doesn't exist yet
pass
self.env_replace = env_replace
if parent_env is None:
self.parent_env = {}
else:
assert isinstance(parent_env, dict)
logger.debug("Setting inherited parent image ENV vars: %s", parent_env)
self.parent_env = parent_env
if build_args is None:
self.build_args = {}
else:
assert isinstance(build_args, dict)
logger.debug("Setting build args: %s", build_args)
self.build_args = build_args
| (self, path=None, cache_content=False, env_replace=True, parent_env=None, fileobj=None, build_args=None) |
725,253 | dockerfile_parse.parser | _add_instruction |
:param instruction: instruction name to be added
:param value: instruction value
| def _add_instruction(self, instruction, value):
"""
:param instruction: instruction name to be added
:param value: instruction value
"""
if instruction in ('LABEL', 'ENV', 'ARG') and len(value) == 2:
new_line = instruction + ' ' + '='.join(map(quote, value)) + '\n'
else:
new_line = '{0} {1}\n'.format(instruction, value)
if new_line:
lines = self.lines
if not lines[len(lines) - 1].endswith('\n'):
new_line = '\n' + new_line
lines += new_line
self.lines = lines
| (self, instruction, value) |
725,254 | dockerfile_parse.parser | _delete_instructions |
:param instruction: name of instruction to be deleted
:param value: if specified, delete instruction only when it has this value
if instruction is LABEL then value is label name
| def _delete_instructions(self, instruction, value=None):
"""
:param instruction: name of instruction to be deleted
:param value: if specified, delete instruction only when it has this value
if instruction is LABEL then value is label name
"""
if instruction == 'LABEL' and value:
self._modify_instruction_label(value, None)
return
if instruction == 'ENV' and value:
self._modify_instruction_env(value, None)
return
if instruction == 'ARG' and value:
self._modify_instruction_arg(value, None)
return
lines = self.lines
deleted = False
for insn in reversed(self.structure):
if insn['instruction'] == instruction:
if value and insn['value'] != value:
continue
deleted = True
del lines[insn['startline']:insn['endline'] + 1]
if deleted:
self.lines = lines
| (self, instruction, value=None) |
725,255 | dockerfile_parse.parser | _instruction_getter |
Get LABEL or ENV or ARG instructions with environment replacement
:param name: e.g. 'LABEL' or 'ENV' or 'ARG'
:param env_replace: bool, whether to perform ENV substitution
:return: Labels instance or Envs instance
| def _instruction_getter(self, name, env_replace):
"""
Get LABEL or ENV or ARG instructions with environment replacement
:param name: e.g. 'LABEL' or 'ENV' or 'ARG'
:param env_replace: bool, whether to perform ENV substitution
:return: Labels instance or Envs instance
"""
if name not in ('LABEL', 'ENV', 'ARG'):
raise ValueError("Unsupported instruction '{0}'".format(name))
in_stage = False
top_args = {}
instructions = {}
args = {}
envs = {}
for instruction_desc in self.structure:
this_instruction = instruction_desc['instruction']
if this_instruction == 'FROM':
in_stage = True
instructions.clear()
args = {}
envs = self.parent_env.copy()
elif this_instruction in (name, 'ENV', 'ARG'):
logger.debug("%s value: %r", name.lower(), instruction_desc['value'])
key_val_list = extract_key_values(
env_replace=this_instruction != 'ARG' and env_replace,
args=args, envs=envs,
instruction_value=instruction_desc['value'])
for key, value in key_val_list:
if this_instruction == 'ARG':
if in_stage:
if key in top_args:
value = top_args[key]
elif key in self.build_args:
value = self.build_args[key]
args[key] = value
else:
if key in self.build_args:
value = self.build_args[key]
top_args[key] = value
if this_instruction == name:
instructions[key] = value
logger.debug("new %s %r=%r", name.lower(), key, value)
if this_instruction == 'ENV':
envs[key] = value
logger.debug("instructions: %r", instructions)
if name == 'LABEL':
return Labels(instructions, self)
elif name == 'ENV':
return Envs(instructions, self)
else:
return Args(instructions, self)
| (self, name, env_replace) |
725,256 | dockerfile_parse.parser | _instructions_setter | null | def _instructions_setter(self, name, instructions):
if not isinstance(instructions, dict):
raise TypeError('instructions needs to be a dictionary {name: value}')
if name == 'LABEL':
existing = self.labels
elif name == 'ENV':
existing = self.envs
elif name == 'ARG':
existing = self.args
else:
raise ValueError("Unexpected instruction '%s'" % name)
logger.debug("setting %s instructions: %r", name, instructions)
to_delete = [k for k in existing if k not in instructions]
for key in to_delete:
logger.debug("delete %r", key)
self._modify_instruction_label_env(name, key, None)
to_add = dict((k, v) for (k, v) in instructions.items() if k not in existing)
for k, v in to_add.items():
logger.debug("add %r", k)
self._add_instruction(name, (k, v))
to_change = dict((k, v) for (k, v) in instructions.items()
if (k in existing and v != existing[k]))
for k, v in to_change.items():
logger.debug("modify %r", k)
self._modify_instruction_label_env(name, k, v)
| (self, name, instructions) |
725,257 | dockerfile_parse.parser | _modify_instruction_arg | null | def _modify_instruction_arg(self, arg_key, arg_value):
self._modify_instruction_label_env('ARG', arg_key, arg_value)
| (self, arg_key, arg_value) |
725,258 | dockerfile_parse.parser | _modify_instruction_env | null | def _modify_instruction_env(self, env_var_key, env_var_value):
self._modify_instruction_label_env('ENV', env_var_key, env_var_value)
| (self, env_var_key, env_var_value) |
725,259 | dockerfile_parse.parser | _modify_instruction_label | null | def _modify_instruction_label(self, label_key, instr_value):
self._modify_instruction_label_env('LABEL', label_key, instr_value)
| (self, label_key, instr_value) |
725,260 | dockerfile_parse.parser | _modify_instruction_label_env |
set <INSTRUCTION> instr_key to instr_value
:param instr_key: str, label key
:param instr_value: str or None, new label/env value or None to remove
| def _modify_instruction_label_env(self, instruction, instr_key, instr_value):
"""
set <INSTRUCTION> instr_key to instr_value
:param instr_key: str, label key
:param instr_value: str or None, new label/env value or None to remove
"""
if instruction == 'LABEL':
instructions = self.labels
elif instruction == 'ENV':
instructions = self.envs
elif instruction == 'ARG':
instructions = self.args
else:
raise ValueError("Unknown instruction '%s'" % instruction)
if instr_key not in instructions:
raise KeyError('%s not in %ss' % (instr_key, instruction))
# extract target instructions from the final stage only
candidates = []
for insn in self.structure:
if insn['instruction'] == 'FROM':
candidates = []
if insn['instruction'] == instruction:
candidates.append(insn)
# Find where in the file to put the changes
content = startline = endline = None
for candidate in candidates:
words = list(WordSplitter(candidate['value']).split(dequote=False))
# LABEL/ENV/ARG syntax is one of two types:
if '=' not in words[0]: # LABEL/ENV/ARG name value
# Remove quotes from key name and see if it's the one
# we're looking for.
if WordSplitter(words[0]).dequote() == instr_key:
if instr_value is None:
# Delete this line altogether
content = None
else:
# Adjust label/env value
words[1:] = [quote(instr_value)]
# Now reconstruct the line
content = " ".join([instruction] + words) + '\n'
startline = candidate['startline']
endline = candidate['endline']
break
else: # LABEL/ENV/ARG "name"="value"
for index, token in enumerate(words):
key, _ = token.split("=", 1)
if WordSplitter(key).dequote() == instr_key:
if instr_value is None:
# Delete this label
del words[index]
else:
# Adjust label/env value
words[index] = "{0}={1}".format(key,
quote(instr_value))
if len(words) == 0:
# We removed the last label/env, delete the whole line
content = None
else:
# Now reconstruct the line
content = " ".join([instruction] + words) + '\n'
startline = candidate['startline']
endline = candidate['endline']
break
# We know the label/env we're looking for is there
assert startline and endline
# Re-write the Dockerfile
lines = self.lines
del lines[startline:endline + 1]
if content:
lines.insert(startline, content)
self.lines = lines
| (self, instruction, instr_key, instr_value) |
725,261 | dockerfile_parse.parser | _open_dockerfile | null | @property
def structure(self):
"""
Returns a list of dicts describing the commands:
[
{"instruction": "FROM", # always upper-case
"startline": 0, # 0-based
"endline": 0, # 0-based
"content": "From fedora\n",
"value": "fedora"},
{"instruction": "CMD",
"startline": 1,
"endline": 2,
"content": "CMD yum -y update && \\\n yum clean all\n",
"value": "yum -y update && yum clean all"}
]
"""
def _rstrip_eol(text, line_continuation_char='\\'):
text = text.rstrip()
if text.endswith(line_continuation_char):
return text[:-1]
return text
def _create_instruction_dict(instruction=None, value=None):
return {
'instruction': instruction,
'startline': lineno,
'endline': lineno,
'content': line, # pylint: disable=undefined-loop-variable
'value': value
}
def _clean_comment_line(line):
line = re.sub(r'^\s*#\s*', '', line)
line = re.sub(r'\n', '', line)
return line
instructions = []
lineno = -1
line_continuation_char = '\\'
insnre = re.compile(r'^\s*(\S+)\s+(.*)$') # matched group is insn
contre = re.compile(r'^.*\\\s*$') # line continues?
commentre = re.compile(r'^\s*#') # line is a comment?
directive_possible = True
# escape directive regex
escape_directive_re = re.compile(r'^\s*#\s*escape\s*=\s*(\\|`)\s*$', re.I)
# syntax directive regex
syntax_directive_re = re.compile(r'^\s*#\s*syntax\s*=\s*(.*)\s*$', re.I)
in_continuation = False
current_instruction = {}
for line in self.lines:
lineno += 1
if directive_possible:
# once support for python versions before 3.8 is dropped use walrus operator
if escape_directive_re.match(line):
# Do the matching twice if there is a directive to avoid doing the matching
# for other lines
match = escape_directive_re.match(line)
line_continuation_char = match.group(1)
contre = re.compile(r'^.*' + re.escape(match.group(1)) + r'\s*$')
elif syntax_directive_re.match(line):
# Currently no information for the syntax directive is stored it is still
# necessary to detect escape directives after a syntax directive
pass
else:
directive_possible = False
# It is necessary to keep instructions and comment parsing separate,
# as a multi-line instruction can be interjected with comments.
if commentre.match(line):
comment = _create_instruction_dict(
instruction=COMMENT_INSTRUCTION,
value=_clean_comment_line(line)
)
instructions.append(comment)
else:
if not in_continuation:
m = insnre.match(line)
if not m:
continue
current_instruction = _create_instruction_dict(
instruction=m.groups()[0].upper(),
value=_rstrip_eol(m.groups()[1], line_continuation_char)
)
else:
current_instruction['content'] += line
current_instruction['endline'] = lineno
if current_instruction['value']:
current_instruction['value'] += _rstrip_eol(line, line_continuation_char)
else:
current_instruction['value'] = _rstrip_eol(line.lstrip(),
line_continuation_char)
in_continuation = contre.match(line)
if not in_continuation and current_instruction:
instructions.append(current_instruction)
return instructions
| (self, mode) |
725,262 | dockerfile_parse.parser | add_lines |
Add lines to the beginning or end of the build.
:param lines: one or more lines to add to the content, by default at the end.
:param all_stages: bool for whether to add in all stages for a multistage build
or (by default) only the last.
:param at_start: adds at the beginning (after FROM) of the stage(s) instead of the end.
:param skip_scratch: skip stages which use "FROM scratch"
| def add_lines(self, *lines, **kwargs):
"""
Add lines to the beginning or end of the build.
:param lines: one or more lines to add to the content, by default at the end.
:param all_stages: bool for whether to add in all stages for a multistage build
or (by default) only the last.
:param at_start: adds at the beginning (after FROM) of the stage(s) instead of the end.
:param skip_scratch: skip stages which use "FROM scratch"
"""
assert len(lines) > 0
lines = [_endline(line) for line in lines]
all_stages = kwargs.pop('all_stages', False)
at_start = kwargs.pop('at_start', False)
skip_scratch = kwargs.pop('skip_scratch', False)
assert not kwargs, "Unknown keyword argument(s): {0}".format(list(kwargs))
froms = [
instr for instr in self.structure
if instr['instruction'] == 'FROM'
] or [{'endline': -1}] # no FROM? fake one before the beginning
if not all_stages: # only modify the last
froms = [froms[-1]]
df_lines = self.lines
# make sure last line has a newline if lines are to be appended
if df_lines and not at_start:
df_lines[-1] = _endline(df_lines[-1])
# iterate through the stages in reverse order
# so adding lines doesn't invalidate line numbers from structure dicts.
# first add a bogus instruction to represent EOF in our iteration.
froms.append({'startline': len(df_lines) + 1})
for stage in range(len(froms)-2, -1, -1): # e.g. 0 for single or 2, 1, 0 for 3 stages
start, finish = froms[stage], froms[stage+1]
linenum = start['endline'] + 1 if at_start else finish['startline']
image, _ = image_from(froms[stage].get('value') or '')
if skip_scratch and image == 'scratch':
continue
df_lines[linenum:linenum] = lines
self.lines = df_lines
| (self, *lines, **kwargs) |
725,263 | dockerfile_parse.parser | add_lines_at |
Add lines at a specific location in the file.
:param anchor: structure_dict|line_str|line_num a reference to where adds should occur
:param lines: one or more lines to add to the content
:param replace: if True -- replace the anchor
:param after: if True -- insert after the anchor (conflicts with "replace")
| def add_lines_at(self, anchor, *lines, **kwargs):
"""
Add lines at a specific location in the file.
:param anchor: structure_dict|line_str|line_num a reference to where adds should occur
:param lines: one or more lines to add to the content
:param replace: if True -- replace the anchor
:param after: if True -- insert after the anchor (conflicts with "replace")
"""
assert len(lines) > 0
replace = kwargs.pop('replace', False)
after = kwargs.pop('after', False)
assert not (after and replace)
assert not kwargs, "Unknown keyword argument(s): {0}".format(list(kwargs))
# find the line number for the insertion
df_lines = self.lines
if isinstance(anchor, int): # line number, just validate
assert 0 <= anchor < len(df_lines)
if replace:
del df_lines[anchor]
elif isinstance(anchor, dict): # structure
assert anchor in self.structure, "Current structure does not match: {0}".format(anchor)
if replace:
df_lines[anchor['startline']:anchor['endline'] + 1] = []
if after:
anchor = anchor['endline']
else:
anchor = anchor['startline']
elif isinstance(anchor, str): # line contents
matches = [index for index, text in enumerate(df_lines) if text == anchor]
if not matches:
raise RuntimeError("Cannot find line in the build file:\n" + anchor)
anchor = matches[-1]
if replace:
del df_lines[anchor]
else:
raise RuntimeError("Unknown anchor type {0}".format(anchor))
if after:
# ensure there's a newline on final line
df_lines[anchor] = _endline(df_lines[anchor])
anchor += 1
df_lines[anchor:anchor] = [_endline(line) for line in lines]
self.lines = df_lines
| (self, anchor, *lines, **kwargs) |
725,378 | tushare.pro.data_pro | ht_subs | null | def ht_subs(username, password):
from tushare.subs.ht_subs.subscribe import InsightSubscribe
app = InsightSubscribe(username, password)
return app
| (username, password) |
725,404 | tushare.util.verify_token | wrapper |
沪深京 A 股 all -实时行情
@param src: 数据源 新浪sina |东方财富 dc
@param interval: 分页采集时间间隔（默认3秒翻译一夜）
@param page_count: 限制抓取的页数（仅对新浪有效）
@param proxies: 设置代理 防止被封禁
@return: 按涨跌幅 倒序排序
-------
DataFrame 实时交易数据
东方财富：
2、代码:TS_CODE
3、名称:NAME
4、最新价:PRICE
5、涨跌幅:PCT_CHANGE
6、涨跌额:CHANGE
7、成交量:VOLUME
8、成交额:AMOUNT
9、振幅:SWING
10、最高:HIGH
11、最低:LOW
12、今开:OPEN
13、昨收:CLOSE
14、量比:VOL_RATIO
15、换手率:TURNOVER_RATE
16、市盈率-动态:PE
17、市净率:PB
18、总市值:TOTAL_MV
19、流通市值:FLOAT_MV
20、涨速:RISE
21、5分钟涨跌:5MIN
22、60日涨跌幅:60DAY
23、年初至今涨跌幅:1YEAR
新浪财经：
1、代码:TS_CODE
2、名称:NAME
3、最新价:PRICE
4、涨跌额:CHANGE
5、涨跌幅:PCT_CHANGE
6、买入:BUY
7、卖出:SALE
8、昨收:CLOSE
9、今开:OPEN
10、最高:HIGH
11、最低:LOW
12、成交量:VOLUME
13、成交额:AMOUNT
14、时间戳:TIME
| def require_permission(event_name, event_detail):
def decorator(func):
def wrapper(*args, **kwargs):
# event_name = kwargs["event_name"]
# event_detail = kwargs["event_detail"]
# 检查用户权限
token = get_token()
if token:
try:
r = verify_token(token, event_name, event_detail).json()
except Exception as err:
raise PermissionError(f"验证token出错，{err}")
if r.get("message") == "success":
# 如果有足够权限，调用原始函数
return func(*args, **kwargs)
else:
print(f"验证token出错，{r.text}")
raise PermissionError(f"{r['msg']}")
else:
raise PermissionError(ct.TOKEN_ERR_MSG)
wrapper.__doc__ = func.__doc__
return wrapper
return decorator
| (*args, **kwargs) |
725,405 | tushare.util.verify_token | wrapper |
获取实时交易数据 getting real time quotes data
用于跟踪交易情况（本次执行的结果-上一次执行的数据）
Parameters
------
ts_code : string
src : sina ，dc
return
-------
DataFrame 实时交易数据
属性:0：name，股票名字
1：open，今日开盘价
2：pre_close，昨日收盘价
3：price，当前价格
4：high，今日最高价
5：low，今日最低价
6：bid，竞买价，即“买一”报价
7：ask，竞卖价，即“卖一”报价
8：volumn，成交量 maybe you need do volumn/100
9：amount，成交金额（元 CNY）
10：b1_v，委买一（笔数 bid volume）
11：b1_p，委买一（价格 bid price）
12：b2_v，“买二”
13：b2_p，“买二”
14：b3_v，“买三”
15：b3_p，“买三”
16：b4_v，“买四”
17：b4_p，“买四”
18：b5_v，“买五”
19：b5_p，“买五”
20：a1_v，委卖一（笔数 ask volume）
21：a1_p，委卖一（价格 ask price）
...
30：date，日期；
31：time，时间；
| def require_permission(event_name, event_detail):
def decorator(func):
def wrapper(*args, **kwargs):
# event_name = kwargs["event_name"]
# event_detail = kwargs["event_detail"]
# 检查用户权限
token = get_token()
if token:
try:
r = verify_token(token, event_name, event_detail).json()
except Exception as err:
raise PermissionError(f"验证token出错，{err}")
if r.get("message") == "success":
# 如果有足够权限，调用原始函数
return func(*args, **kwargs)
else:
print(f"验证token出错，{r.text}")
raise PermissionError(f"{r['msg']}")
else:
raise PermissionError(ct.TOKEN_ERR_MSG)
wrapper.__doc__ = func.__doc__
return wrapper
return decorator
| (*args, **kwargs) |
725,406 | tushare.util.verify_token | wrapper |
历史分笔数据
:param ts_code: 股票代码
:type ts_code: str
:param src: 来源 腾讯财经tx 新浪财经sina
:type src: str
:param page_count: 限制页数
:type page_count: str
:return: 历史分笔数据
:rtype: pandas.DataFrame
1、TIME : 成交时间
2、PRICE : 成交价格
3、PCHANGE : 涨跌幅
4、CHANGE : 价格变动
5、VOLUME : 成交量(手)
6、AMOUNT : 成交额(元)
7、TYPE : 性质
| def require_permission(event_name, event_detail):
def decorator(func):
def wrapper(*args, **kwargs):
# event_name = kwargs["event_name"]
# event_detail = kwargs["event_detail"]
# 检查用户权限
token = get_token()
if token:
try:
r = verify_token(token, event_name, event_detail).json()
except Exception as err:
raise PermissionError(f"验证token出错，{err}")
if r.get("message") == "success":
# 如果有足够权限，调用原始函数
return func(*args, **kwargs)
else:
print(f"验证token出错，{r.text}")
raise PermissionError(f"{r['msg']}")
else:
raise PermissionError(ct.TOKEN_ERR_MSG)
wrapper.__doc__ = func.__doc__
return wrapper
return decorator
| (*args, **kwargs) |
725,417 | tushare.pro.data_pro | subs | null | def subs(token=''):
if token == '' or token is None:
token = upass.get_token()
from tushare.subs.ts_subs.subscribe import TsSubscribe
app = TsSubscribe(token=token)
return app
| (token='') |
725,427 | lotkavolterra_simulator.simulator | LVobserver | This class contains observational simulators
for a prey and predator populations.
Attributes
----------
Xtrue : array, double, dimension=n
true number of preys to be observed
Ytrue : array, double, dimension=n
true number of predators to be observed
X0 : double
initial condition: number of preys
Y0 : double
initial condition: number of predators
| class LVobserver(object):
"""This class contains observational simulators
for a prey and predator populations.
Attributes
----------
Xtrue : array, double, dimension=n
true number of preys to be observed
Ytrue : array, double, dimension=n
true number of predators to be observed
X0 : double
initial condition: number of preys
Y0 : double
initial condition: number of predators
"""
def __init__(self, Xtrue, Ytrue, X0, Y0):
self.Xtrue=Xtrue
self.Ytrue=Ytrue
self.X0=X0
self.Y0=Y0
@property
def tmax(self):
"""double: number of timesteps (each of length 1).
"""
return len(self.Xtrue)
@property
def t(self):
"""array, double: timestepping of the problem.
"""
import numpy as np
return np.arange(self.tmax)
def make_signal(self, **metaparams):
"""Simulate the signal.
Parameters
----------
model : int, optional, default=0
0= correct data model; 1=misspecified data model
Xefficiency : array, double, dimension=len(t)
detection efficiency of preys as a function of time
Yefficiency : array, double, dimension=len(t)
detection efficiency of preys as a function of time
P : double
rate of prey misses due to correlation between preys and predators
Q : double
rate of predator misses due to correlation between preys and predators
Returns
-------
Xsignal : array, double, dimension=n
unobserved signal for the number of preys
Ysignal : array, double, dimension=n
unobserved signal for the number of predators
"""
import numpy as np
t=self.t
X0=self.X0
Y0=self.Y0
Xtrue=self.Xtrue
Ytrue=self.Ytrue
Xsignal, Ysignal = self.Xtrue, self.Ytrue
if not "model" in metaparams or metaparams["model"] == 0:
# correct data model: The (unobserved) signal is a retarded and non-linear
# observation of the true underlying functions.
P=metaparams["obsP"]
Q=metaparams["obsQ"]
Xefficiency=metaparams["Xefficiency"]
Yefficiency=metaparams["Yefficiency"]
Xretard = np.roll(Xtrue,1)
Yretard = np.roll(Ytrue,1)
Xsignal = Xretard - P*Xretard*Yretard + Q*Xretard**2
Xsignal *= Xefficiency
Ysignal = Yretard + P*Xretard*Yretard - Q*Yretard**2
Ysignal *= Yefficiency
Xsignal[0] = X0
Ysignal[0] = Y0
elif "model" == 1:
# misspecified data model : consider that the measurement is a direct
# observation of the function.
pass
return Xsignal, Ysignal
def Dnoise_cov(self, **metaparams):
"""Covariance matrix for the demographic noise.
Demographic noise depends only on the observed population.
Parameters
----------
obsR : double
strength of demographic noise
Returns
-------
D : array, double, dimension=(2*n,2*n)
demographic noise covariance matrix
"""
import numpy as np
Xtrue=self.Xtrue
Ytrue=self.Ytrue
obsR=metaparams["obsR"]
D=obsR*np.diag(np.concatenate((Xtrue, Ytrue)))
return D
def make_demographic_noise(self, **metaparams):
"""Simulate demographic noise.
Demographic noise depends only on the observed population.
Parameters
----------
obsR : double
strength of demographic noise
Returns
-------
XDnoise : array, double, dimension=n
demographic noise for preys
YDnoise : array, double, dimension=n
demographic noise for predators
"""
import numpy as np
import scipy.stats as ss
Xtrue=self.Xtrue
Ytrue=self.Ytrue
obsR=metaparams["obsR"]
XDnoise = np.sqrt(obsR*Xtrue) * ss.multivariate_normal(mean=np.zeros_like(Xtrue)).rvs()
YDnoise = np.sqrt(obsR*Ytrue) * ss.multivariate_normal(mean=np.zeros_like(Xtrue)).rvs()
return XDnoise, YDnoise
def Onoise_cov(self, X, Y, **metaparams):
"""Covariance matrix for the observational noise.
Prey and predator populations introduce a noise to the other
population, and there is also a non-diagonal term
proportional to the geometric mean of both populations.
Parameters
----------
obsS : double
overall strength of observational noise
obsT : double
strength of non-diagonal term in observational noise
Returns
-------
O : array, double, dimension=(2*n,2*n)
observational noise covariance matrix
Note
----
Getting a positive semidefinite matrix should be enforced by user parameter choice.
"""
import numpy as np
obsS=metaparams["obsS"]
obsT=metaparams["obsT"]
O00=np.diag(Y)
O01=obsT*np.diag(np.sqrt(X*Y))
O10=obsT*np.diag(np.sqrt(X*Y))
O11=np.diag(X)
O=np.block([ [obsS*O00, obsS*O01], [obsS*O10, obsS*O11] ])
return O
def make_observational_noise(self, Xsignal, Ysignal, **metaparams):
"""Simulate observational noise.
Parameters
----------
obsS : double
overall strength of observational noise
obsT : double
strength of non-diagonal term in observational noise
Returns
-------
XOnoise : array, double, dimension=n
observational noise for preys
YOnoise : array, double, dimension=n
observational noise for predators
"""
import numpy as np
import scipy.stats as ss
from scipy.linalg import sqrtm
tmax=self.tmax
# Writing this in a single call to multivariate_normal causes numerical instabilities
XOnoise = np.zeros(tmax) # Pre-allocate the memory for XOnoise
YOnoise = np.zeros(tmax) # Pre-allocate the memory for YOnoise
for n in range(tmax-1):
O = self.Onoise_cov(np.array([Xsignal[n]]), np.array([Ysignal[n]]), **metaparams)
XOnoise[n], YOnoise[n] = ss.multivariate_normal(mean=[0,0], cov=O).rvs()
return XOnoise, YOnoise
def simulate_obs(self, Xsignal, Ysignal, **metaparams):
"""Simulate the observational process, assuming additive noise, i.e.
data = signal + noise.
Parameters
----------
Xsignal : array, double, dimension=n
unobserved signal for the number of preys
Ysignal : array, double, dimension=n
unobserved signal for the number of predators
model : int, optional, default=0
0= correct data model; 1=misspecified data model
obsR : double
strength of demographic noise
obsS : double
overall strength of observational noise
obsT : double
strength of non-diagonal term in observational noise
"""
import numpy as np
import scipy.stats as ss
tmax=self.tmax
# draw demographic noise
XDnoise, YDnoise = self.make_demographic_noise(**metaparams)
# observational noise
XOnoise, YOnoise = np.zeros_like(XDnoise), np.zeros_like(YDnoise)
if not "model" in metaparams or metaparams["model"] == 0:
# correct data model: draw observational noise
XOnoise, YOnoise = self.make_observational_noise(Xsignal, Ysignal, **metaparams)
elif "model" == 1:
# misspecified data model : only consider demographic noise
pass
# data = signal+noise
self.Xdata = Xsignal+XDnoise+XOnoise
self.Ydata = Ysignal+YDnoise+YOnoise
self.Xobs = np.arange(tmax)
self.Yobs = np.arange(tmax)
return Xsignal, XDnoise, XOnoise, self.Xdata, Ysignal, YDnoise, YOnoise, self.Ydata
def censor(self, **metaparams):
"""Censor part of the data during periods
when preys are not observable.
Parameters
----------
mask : array, double, dimension=n
a mask containing zeros and ones
"""
import numpy as np
mask=metaparams["mask"]
self.Xobs = self.Xobs[np.where(mask==1)]
self.Xdata = self.Xdata[np.where(mask==1)]
def threshold(self, **metaparams):
"""Threshold the data, excluding negative measurements
and measurements above a detection maximum.
Parameters
----------
threshold : double
maximum number of individuals (preys or predators) that can be observed
"""
import numpy as np
if not "model" in metaparams or metaparams["model"] == 0:
# correct data model: threshold data
threshold=metaparams["threshold"]
self.Xdata[np.where(self.Xdata>threshold)]=threshold
self.Ydata[np.where(self.Ydata>threshold)]=threshold
self.Xdata[np.where(self.Xdata<0)]=0
self.Ydata[np.where(self.Ydata<0)]=0
elif "model" == 1:
# misspecified data model : do not threshold data
pass
def observe(self, **metaparams):
"""Simulate the observation process using a given data model.
Parameters
----------
model : int, optional, default=0
0= correct data model; 1=misspecified data model
threshold : double
maximum number of individuals (preys or predators) that can be observed
mask : array, double, dimension=n
a mask containing zeros and ones
P : double
rate of prey misses due to correlation between preys and predators
Q : double
rate of predator misses due to correlation between preys and predators
R : double
strength of demographic noise
S : double
overall strength of observational noise
T : double
strength of non-diagonal term in observational noise
"""
import numpy as np
# Simulate the observation process using a given data model
# signal
Xsignal, Ysignal = self.make_signal(**metaparams)
# simulate observation using correct data model
self.simulate_obs(Xsignal, Ysignal, **metaparams)
# censor and threshold data
self.censor(**metaparams)
self.threshold(**metaparams)
| (Xtrue, Ytrue, X0, Y0) |
725,428 | lotkavolterra_simulator.simulator | Dnoise_cov | Covariance matrix for the demographic noise.
Demographic noise depends only on the observed population.
Parameters
----------
obsR : double
strength of demographic noise
Returns
-------
D : array, double, dimension=(2*n,2*n)
demographic noise covariance matrix
| def Dnoise_cov(self, **metaparams):
"""Covariance matrix for the demographic noise.
Demographic noise depends only on the observed population.
Parameters
----------
obsR : double
strength of demographic noise
Returns
-------
D : array, double, dimension=(2*n,2*n)
demographic noise covariance matrix
"""
import numpy as np
Xtrue=self.Xtrue
Ytrue=self.Ytrue
obsR=metaparams["obsR"]
D=obsR*np.diag(np.concatenate((Xtrue, Ytrue)))
return D
| (self, **metaparams) |
725,429 | lotkavolterra_simulator.simulator | Onoise_cov | Covariance matrix for the observational noise.
Prey and predator populations introduce a noise to the other
population, and there is also a non-diagonal term
proportional to the geometric mean of both populations.
Parameters
----------
obsS : double
overall strength of observational noise
obsT : double
strength of non-diagonal term in observational noise
Returns
-------
O : array, double, dimension=(2*n,2*n)
observational noise covariance matrix
Note
----
Getting a positive semidefinite matrix should be enforced by user parameter choice.
| def Onoise_cov(self, X, Y, **metaparams):
"""Covariance matrix for the observational noise.
Prey and predator populations introduce a noise to the other
population, and there is also a non-diagonal term
proportional to the geometric mean of both populations.
Parameters
----------
obsS : double
overall strength of observational noise
obsT : double
strength of non-diagonal term in observational noise
Returns
-------
O : array, double, dimension=(2*n,2*n)
observational noise covariance matrix
Note
----
Getting a positive semidefinite matrix should be enforced by user parameter choice.
"""
import numpy as np
obsS=metaparams["obsS"]
obsT=metaparams["obsT"]
O00=np.diag(Y)
O01=obsT*np.diag(np.sqrt(X*Y))
O10=obsT*np.diag(np.sqrt(X*Y))
O11=np.diag(X)
O=np.block([ [obsS*O00, obsS*O01], [obsS*O10, obsS*O11] ])
return O
| (self, X, Y, **metaparams) |
725,430 | lotkavolterra_simulator.simulator | __init__ | null | def __init__(self, Xtrue, Ytrue, X0, Y0):
self.Xtrue=Xtrue
self.Ytrue=Ytrue
self.X0=X0
self.Y0=Y0
| (self, Xtrue, Ytrue, X0, Y0) |
725,431 | lotkavolterra_simulator.simulator | censor | Censor part of the data during periods
when preys are not observable.
Parameters
----------
mask : array, double, dimension=n
a mask containing zeros and ones
| def censor(self, **metaparams):
"""Censor part of the data during periods
when preys are not observable.
Parameters
----------
mask : array, double, dimension=n
a mask containing zeros and ones
"""
import numpy as np
mask=metaparams["mask"]
self.Xobs = self.Xobs[np.where(mask==1)]
self.Xdata = self.Xdata[np.where(mask==1)]
| (self, **metaparams) |
725,432 | lotkavolterra_simulator.simulator | make_demographic_noise | Simulate demographic noise.
Demographic noise depends only on the observed population.
Parameters
----------
obsR : double
strength of demographic noise
Returns
-------
XDnoise : array, double, dimension=n
demographic noise for preys
YDnoise : array, double, dimension=n
demographic noise for predators
| def make_demographic_noise(self, **metaparams):
"""Simulate demographic noise.
Demographic noise depends only on the observed population.
Parameters
----------
obsR : double
strength of demographic noise
Returns
-------
XDnoise : array, double, dimension=n
demographic noise for preys
YDnoise : array, double, dimension=n
demographic noise for predators
"""
import numpy as np
import scipy.stats as ss
Xtrue=self.Xtrue
Ytrue=self.Ytrue
obsR=metaparams["obsR"]
XDnoise = np.sqrt(obsR*Xtrue) * ss.multivariate_normal(mean=np.zeros_like(Xtrue)).rvs()
YDnoise = np.sqrt(obsR*Ytrue) * ss.multivariate_normal(mean=np.zeros_like(Xtrue)).rvs()
return XDnoise, YDnoise
| (self, **metaparams) |
725,433 | lotkavolterra_simulator.simulator | make_observational_noise | Simulate observational noise.
Parameters
----------
obsS : double
overall strength of observational noise
obsT : double
strength of non-diagonal term in observational noise
Returns
-------
XOnoise : array, double, dimension=n
observational noise for preys
YOnoise : array, double, dimension=n
observational noise for predators
| def make_observational_noise(self, Xsignal, Ysignal, **metaparams):
"""Simulate observational noise.
Parameters
----------
obsS : double
overall strength of observational noise
obsT : double
strength of non-diagonal term in observational noise
Returns
-------
XOnoise : array, double, dimension=n
observational noise for preys
YOnoise : array, double, dimension=n
observational noise for predators
"""
import numpy as np
import scipy.stats as ss
from scipy.linalg import sqrtm
tmax=self.tmax
# Writing this in a single call to multivariate_normal causes numerical instabilities
XOnoise = np.zeros(tmax) # Pre-allocate the memory for XOnoise
YOnoise = np.zeros(tmax) # Pre-allocate the memory for YOnoise
for n in range(tmax-1):
O = self.Onoise_cov(np.array([Xsignal[n]]), np.array([Ysignal[n]]), **metaparams)
XOnoise[n], YOnoise[n] = ss.multivariate_normal(mean=[0,0], cov=O).rvs()
return XOnoise, YOnoise
| (self, Xsignal, Ysignal, **metaparams) |
725,434 | lotkavolterra_simulator.simulator | make_signal | Simulate the signal.
Parameters
----------
model : int, optional, default=0
0= correct data model; 1=misspecified data model
Xefficiency : array, double, dimension=len(t)
detection efficiency of preys as a function of time
Yefficiency : array, double, dimension=len(t)
detection efficiency of preys as a function of time
P : double
rate of prey misses due to correlation between preys and predators
Q : double
rate of predator misses due to correlation between preys and predators
Returns
-------
Xsignal : array, double, dimension=n
unobserved signal for the number of preys
Ysignal : array, double, dimension=n
unobserved signal for the number of predators
| def make_signal(self, **metaparams):
"""Simulate the signal.
Parameters
----------
model : int, optional, default=0
0= correct data model; 1=misspecified data model
Xefficiency : array, double, dimension=len(t)
detection efficiency of preys as a function of time
Yefficiency : array, double, dimension=len(t)
detection efficiency of preys as a function of time
P : double
rate of prey misses due to correlation between preys and predators
Q : double
rate of predator misses due to correlation between preys and predators
Returns
-------
Xsignal : array, double, dimension=n
unobserved signal for the number of preys
Ysignal : array, double, dimension=n
unobserved signal for the number of predators
"""
import numpy as np
t=self.t
X0=self.X0
Y0=self.Y0
Xtrue=self.Xtrue
Ytrue=self.Ytrue
Xsignal, Ysignal = self.Xtrue, self.Ytrue
if not "model" in metaparams or metaparams["model"] == 0:
# correct data model: The (unobserved) signal is a retarded and non-linear
# observation of the true underlying functions.
P=metaparams["obsP"]
Q=metaparams["obsQ"]
Xefficiency=metaparams["Xefficiency"]
Yefficiency=metaparams["Yefficiency"]
Xretard = np.roll(Xtrue,1)
Yretard = np.roll(Ytrue,1)
Xsignal = Xretard - P*Xretard*Yretard + Q*Xretard**2
Xsignal *= Xefficiency
Ysignal = Yretard + P*Xretard*Yretard - Q*Yretard**2
Ysignal *= Yefficiency
Xsignal[0] = X0
Ysignal[0] = Y0
elif "model" == 1:
# misspecified data model : consider that the measurement is a direct
# observation of the function.
pass
return Xsignal, Ysignal
| (self, **metaparams) |
725,435 | lotkavolterra_simulator.simulator | observe | Simulate the observation process using a given data model.
Parameters
----------
model : int, optional, default=0
0= correct data model; 1=misspecified data model
threshold : double
maximum number of individuals (preys or predators) that can be observed
mask : array, double, dimension=n
a mask containing zeros and ones
P : double
rate of prey misses due to correlation between preys and predators
Q : double
rate of predator misses due to correlation between preys and predators
R : double
strength of demographic noise
S : double
overall strength of observational noise
T : double
strength of non-diagonal term in observational noise
| def observe(self, **metaparams):
"""Simulate the observation process using a given data model.
Parameters
----------
model : int, optional, default=0
0= correct data model; 1=misspecified data model
threshold : double
maximum number of individuals (preys or predators) that can be observed
mask : array, double, dimension=n
a mask containing zeros and ones
P : double
rate of prey misses due to correlation between preys and predators
Q : double
rate of predator misses due to correlation between preys and predators
R : double
strength of demographic noise
S : double
overall strength of observational noise
T : double
strength of non-diagonal term in observational noise
"""
import numpy as np
# Simulate the observation process using a given data model
# signal
Xsignal, Ysignal = self.make_signal(**metaparams)
# simulate observation using correct data model
self.simulate_obs(Xsignal, Ysignal, **metaparams)
# censor and threshold data
self.censor(**metaparams)
self.threshold(**metaparams)
| (self, **metaparams) |
725,436 | lotkavolterra_simulator.simulator | simulate_obs | Simulate the observational process, assuming additive noise, i.e.
data = signal + noise.
Parameters
----------
Xsignal : array, double, dimension=n
unobserved signal for the number of preys
Ysignal : array, double, dimension=n
unobserved signal for the number of predators
model : int, optional, default=0
0= correct data model; 1=misspecified data model
obsR : double
strength of demographic noise
obsS : double
overall strength of observational noise
obsT : double
strength of non-diagonal term in observational noise
| def simulate_obs(self, Xsignal, Ysignal, **metaparams):
"""Simulate the observational process, assuming additive noise, i.e.
data = signal + noise.
Parameters
----------
Xsignal : array, double, dimension=n
unobserved signal for the number of preys
Ysignal : array, double, dimension=n
unobserved signal for the number of predators
model : int, optional, default=0
0= correct data model; 1=misspecified data model
obsR : double
strength of demographic noise
obsS : double
overall strength of observational noise
obsT : double
strength of non-diagonal term in observational noise
"""
import numpy as np
import scipy.stats as ss
tmax=self.tmax
# draw demographic noise
XDnoise, YDnoise = self.make_demographic_noise(**metaparams)
# observational noise
XOnoise, YOnoise = np.zeros_like(XDnoise), np.zeros_like(YDnoise)
if not "model" in metaparams or metaparams["model"] == 0:
# correct data model: draw observational noise
XOnoise, YOnoise = self.make_observational_noise(Xsignal, Ysignal, **metaparams)
elif "model" == 1:
# misspecified data model : only consider demographic noise
pass
# data = signal+noise
self.Xdata = Xsignal+XDnoise+XOnoise
self.Ydata = Ysignal+YDnoise+YOnoise
self.Xobs = np.arange(tmax)
self.Yobs = np.arange(tmax)
return Xsignal, XDnoise, XOnoise, self.Xdata, Ysignal, YDnoise, YOnoise, self.Ydata
| (self, Xsignal, Ysignal, **metaparams) |
725,437 | lotkavolterra_simulator.simulator | threshold | Threshold the data, excluding negative measurements
and measurements above a detection maximum.
Parameters
----------
threshold : double
maximum number of individuals (preys or predators) that can be observed
| def threshold(self, **metaparams):
"""Threshold the data, excluding negative measurements
and measurements above a detection maximum.
Parameters
----------
threshold : double
maximum number of individuals (preys or predators) that can be observed
"""
import numpy as np
if not "model" in metaparams or metaparams["model"] == 0:
# correct data model: threshold data
threshold=metaparams["threshold"]
self.Xdata[np.where(self.Xdata>threshold)]=threshold
self.Ydata[np.where(self.Ydata>threshold)]=threshold
self.Xdata[np.where(self.Xdata<0)]=0
self.Ydata[np.where(self.Ydata<0)]=0
elif "model" == 1:
# misspecified data model : do not threshold data
pass
| (self, **metaparams) |
725,438 | lotkavolterra_simulator.simulator | LVsimulator | This class contains a basic Lotka-Volterra simulator
and the observational simulator.
X0 and Y0 are inputs and are the initial populations of each species
alpha, beta, gamma, delta are inputs and problem parameters
Attributes
----------
X0 : double
initial condition: number of preys
Y0 : double
initial condition: number of predators
alpha : double
intrinsic reproduction rate of preys (independent of the number of predators)
beta : double
prey mortality rate due to predators encountered
gamma : double
predator reproduction rate according to preys encountered and eaten
delta : double
intrinsic predator mortality rate (independent of the number of prey)
| class LVsimulator(object):
"""This class contains a basic Lotka-Volterra simulator
and the observational simulator.
X0 and Y0 are inputs and are the initial populations of each species
alpha, beta, gamma, delta are inputs and problem parameters
Attributes
----------
X0 : double
initial condition: number of preys
Y0 : double
initial condition: number of predators
alpha : double
intrinsic reproduction rate of preys (independent of the number of predators)
beta : double
prey mortality rate due to predators encountered
gamma : double
predator reproduction rate according to preys encountered and eaten
delta : double
intrinsic predator mortality rate (independent of the number of prey)
"""
def __init__(self, X0, Y0, alpha, beta, gamma, delta):
self.X0=X0
self.Y0=Y0
self.alpha=alpha
self.beta=beta
self.gamma=gamma
self.delta=delta
def EEuler(self, t):
"""Solves Lotka-Volterra equations for one prey and one predator species using
the explicit Euler method.
Parameters
----------
t : array, double, dimension=n
array of time values where we approximate X and Y values
timestep at each iteration is given by t[n+1] - t[n].
Returns
-------
X : array, double, dimension=n
number of preys
Y : array, double, dimension=n
number of predators
"""
import numpy as np
X = np.zeros(len(t)) # Pre-allocate the memory for X
Y = np.zeros(len(t)) # Pre-allocate the memory for Y
X[0] = self.X0
Y[0] = self.Y0
for n in range(len(t)-1):
dt = t[n+1] - t[n]
X[n+1] = X[n]*(1 + self.alpha*dt - self.beta*dt*Y[n])
Y[n+1] = Y[n]*(1 - self.gamma*dt + self.delta*dt*X[n])
return X, Y
@property
def omega(self):
"""array, double, dimension=4 : vector of parameters
"""
import numpy as np
return np.array((self.alpha, self.beta, self.gamma, self.delta))
@staticmethod
def get_XY(t_s, tres, Xth, Yth):
"""two array, double, dimension=2*n: subsamples in time to get X and Y.
"""
import numpy as np
X=np.array([Xth[tres*n] for n in range(len(t_s))])
Y=np.array([Yth[tres*n] for n in range(len(t_s))])
return X, Y
@staticmethod
def get_theta(X, Y):
"""array, double, dimension=2*n: concatenates X and Y.
"""
import numpy as np
return np.concatenate((X, Y))
def compute_theta(self, omega, t, t_s, tres):
"""Solves the Lotka-Volterra system of equations and
returns theta, the latent function that is the next layer
of the Bayesian hierarchical model.
Parameters
----------
t : array, double, dimension=n
array of time values where we approximate X and Y values
timestep at each iteration is given by t[n+1] - t[n].
t_s : array, double, dimension=S
array of the support time vales where theta is defined
tres : double
time resolution, defined such that:
t = np.linspace(0,tmax-1,tmax*tres+1)
t_s = np.arange(tmax)
Returns
-------
theta : array, double, dimension=S
vector of values of the latent function at t_s
"""
LV = LVsimulator(self.X0, self.Y0, omega[0], omega[1], omega[2], omega[3])
Xtheory, Ytheory = LV.EEuler(t)
X, Y = LV.get_XY(t_s, tres, Xtheory, Ytheory)
theta = LV.get_theta(X, Y)
return theta
def compute_dtheta_domega(self, t, t_s, tres, Delta_omega):
"""Computes the gradient of the latent function theta with respect to
the parameters omega, using finite differences.
Parameters
----------
t : array, double, dimension=n
array of time values where we approximate X and Y values
timestep at each iteration is given by t[n+1] - t[n].
t_s : array, double, dimension=S
array of the support time vales where theta is defined
tres : double
time resolution, defined such that:
t = np.linspace(0,tmax-1,tmax*tres+1)
t_s = np.arange(tmax)
Delta_omega : double
step size for finite differences
Returns
-------
grad_theta : array, double, dimension=(2*S, 4)
gradient of theta with respect to omega
"""
import numpy as np
omega0 = self.omega
tmax = len(t_s)
grad_theta = np.zeros((2*tmax,4))
theta_0 = self.compute_theta(omega0, t, t_s, tres)
for n in range(4):
omega_p1, omega_p2, omega_p3, omega_m1, omega_m2, omega_m3 = np.copy(omega0), np.copy(omega0), np.copy(omega0), np.copy(omega0), np.copy(omega0), np.copy(omega0)
omega_p1[n] += 1*Delta_omega
omega_p2[n] += 2*Delta_omega
omega_p3[n] += 3*Delta_omega
omega_m1[n] -= 1*Delta_omega
omega_m2[n] -= 2*Delta_omega
omega_m3[n] -= 3*Delta_omega
theta_p1 = self.compute_theta(omega_p1, t, t_s, tres)
theta_p2 = self.compute_theta(omega_p2, t, t_s, tres)
theta_p3 = self.compute_theta(omega_p3, t, t_s, tres)
theta_m1 = self.compute_theta(omega_m1, t, t_s, tres)
theta_m2 = self.compute_theta(omega_m2, t, t_s, tres)
theta_m3 = self.compute_theta(omega_m3, t, t_s, tres)
#grad_theta[:,n]=(theta_p1 - theta_0)/Delta_omega
#grad_theta[:,n]=(-1/2.*theta_m1 + 1/2.*theta_p1)/Delta_omega
#grad_theta[:,n]=(1/12.*theta_m2 - 2/3.*theta_m1 + 2/3.*theta_p1 - 1/12.*theta_p2)/Delta_omega
grad_theta[:,n]=(-1/60.*theta_m3 + 3/20.*theta_m2 - 3/4.*theta_m1 + 3/4.*theta_p1 - 3/20.*theta_p2 + 1/60.*theta_p3)/Delta_omega
return grad_theta
| (X0, Y0, alpha, beta, gamma, delta) |
725,439 | lotkavolterra_simulator.simulator | EEuler | Solves Lotka-Volterra equations for one prey and one predator species using
the explicit Euler method.
Parameters
----------
t : array, double, dimension=n
array of time values where we approximate X and Y values
timestep at each iteration is given by t[n+1] - t[n].
Returns
-------
X : array, double, dimension=n
number of preys
Y : array, double, dimension=n
number of predators
| def EEuler(self, t):
"""Solves Lotka-Volterra equations for one prey and one predator species using
the explicit Euler method.
Parameters
----------
t : array, double, dimension=n
array of time values where we approximate X and Y values
timestep at each iteration is given by t[n+1] - t[n].
Returns
-------
X : array, double, dimension=n
number of preys
Y : array, double, dimension=n
number of predators
"""
import numpy as np
X = np.zeros(len(t)) # Pre-allocate the memory for X
Y = np.zeros(len(t)) # Pre-allocate the memory for Y
X[0] = self.X0
Y[0] = self.Y0
for n in range(len(t)-1):
dt = t[n+1] - t[n]
X[n+1] = X[n]*(1 + self.alpha*dt - self.beta*dt*Y[n])
Y[n+1] = Y[n]*(1 - self.gamma*dt + self.delta*dt*X[n])
return X, Y
| (self, t) |
725,440 | lotkavolterra_simulator.simulator | __init__ | null | def __init__(self, X0, Y0, alpha, beta, gamma, delta):
self.X0=X0
self.Y0=Y0
self.alpha=alpha
self.beta=beta
self.gamma=gamma
self.delta=delta
| (self, X0, Y0, alpha, beta, gamma, delta) |
725,441 | lotkavolterra_simulator.simulator | compute_dtheta_domega | Computes the gradient of the latent function theta with respect to
the parameters omega, using finite differences.
Parameters
----------
t : array, double, dimension=n
array of time values where we approximate X and Y values
timestep at each iteration is given by t[n+1] - t[n].
t_s : array, double, dimension=S
array of the support time vales where theta is defined
tres : double
time resolution, defined such that:
t = np.linspace(0,tmax-1,tmax*tres+1)
t_s = np.arange(tmax)
Delta_omega : double
step size for finite differences
Returns
-------
grad_theta : array, double, dimension=(2*S, 4)
gradient of theta with respect to omega
| def compute_dtheta_domega(self, t, t_s, tres, Delta_omega):
"""Computes the gradient of the latent function theta with respect to
the parameters omega, using finite differences.
Parameters
----------
t : array, double, dimension=n
array of time values where we approximate X and Y values
timestep at each iteration is given by t[n+1] - t[n].
t_s : array, double, dimension=S
array of the support time vales where theta is defined
tres : double
time resolution, defined such that:
t = np.linspace(0,tmax-1,tmax*tres+1)
t_s = np.arange(tmax)
Delta_omega : double
step size for finite differences
Returns
-------
grad_theta : array, double, dimension=(2*S, 4)
gradient of theta with respect to omega
"""
import numpy as np
omega0 = self.omega
tmax = len(t_s)
grad_theta = np.zeros((2*tmax,4))
theta_0 = self.compute_theta(omega0, t, t_s, tres)
for n in range(4):
omega_p1, omega_p2, omega_p3, omega_m1, omega_m2, omega_m3 = np.copy(omega0), np.copy(omega0), np.copy(omega0), np.copy(omega0), np.copy(omega0), np.copy(omega0)
omega_p1[n] += 1*Delta_omega
omega_p2[n] += 2*Delta_omega
omega_p3[n] += 3*Delta_omega
omega_m1[n] -= 1*Delta_omega
omega_m2[n] -= 2*Delta_omega
omega_m3[n] -= 3*Delta_omega
theta_p1 = self.compute_theta(omega_p1, t, t_s, tres)
theta_p2 = self.compute_theta(omega_p2, t, t_s, tres)
theta_p3 = self.compute_theta(omega_p3, t, t_s, tres)
theta_m1 = self.compute_theta(omega_m1, t, t_s, tres)
theta_m2 = self.compute_theta(omega_m2, t, t_s, tres)
theta_m3 = self.compute_theta(omega_m3, t, t_s, tres)
#grad_theta[:,n]=(theta_p1 - theta_0)/Delta_omega
#grad_theta[:,n]=(-1/2.*theta_m1 + 1/2.*theta_p1)/Delta_omega
#grad_theta[:,n]=(1/12.*theta_m2 - 2/3.*theta_m1 + 2/3.*theta_p1 - 1/12.*theta_p2)/Delta_omega
grad_theta[:,n]=(-1/60.*theta_m3 + 3/20.*theta_m2 - 3/4.*theta_m1 + 3/4.*theta_p1 - 3/20.*theta_p2 + 1/60.*theta_p3)/Delta_omega
return grad_theta
| (self, t, t_s, tres, Delta_omega) |
725,442 | lotkavolterra_simulator.simulator | compute_theta | Solves the Lotka-Volterra system of equations and
returns theta, the latent function that is the next layer
of the Bayesian hierarchical model.
Parameters
----------
t : array, double, dimension=n
array of time values where we approximate X and Y values
timestep at each iteration is given by t[n+1] - t[n].
t_s : array, double, dimension=S
array of the support time vales where theta is defined
tres : double
time resolution, defined such that:
t = np.linspace(0,tmax-1,tmax*tres+1)
t_s = np.arange(tmax)
Returns
-------
theta : array, double, dimension=S
vector of values of the latent function at t_s
| def compute_theta(self, omega, t, t_s, tres):
"""Solves the Lotka-Volterra system of equations and
returns theta, the latent function that is the next layer
of the Bayesian hierarchical model.
Parameters
----------
t : array, double, dimension=n
array of time values where we approximate X and Y values
timestep at each iteration is given by t[n+1] - t[n].
t_s : array, double, dimension=S
array of the support time vales where theta is defined
tres : double
time resolution, defined such that:
t = np.linspace(0,tmax-1,tmax*tres+1)
t_s = np.arange(tmax)
Returns
-------
theta : array, double, dimension=S
vector of values of the latent function at t_s
"""
LV = LVsimulator(self.X0, self.Y0, omega[0], omega[1], omega[2], omega[3])
Xtheory, Ytheory = LV.EEuler(t)
X, Y = LV.get_XY(t_s, tres, Xtheory, Ytheory)
theta = LV.get_theta(X, Y)
return theta
| (self, omega, t, t_s, tres) |
725,443 | lotkavolterra_simulator.simulator | get_XY | two array, double, dimension=2*n: subsamples in time to get X and Y.
| @staticmethod
def get_XY(t_s, tres, Xth, Yth):
"""two array, double, dimension=2*n: subsamples in time to get X and Y.
"""
import numpy as np
X=np.array([Xth[tres*n] for n in range(len(t_s))])
Y=np.array([Yth[tres*n] for n in range(len(t_s))])
return X, Y
| (t_s, tres, Xth, Yth) |
725,444 | lotkavolterra_simulator.simulator | get_theta | array, double, dimension=2*n: concatenates X and Y.
| @staticmethod
def get_theta(X, Y):
"""array, double, dimension=2*n: concatenates X and Y.
"""
import numpy as np
return np.concatenate((X, Y))
| (X, Y) |
725,446 | splitutils.core.splitutils | binning |
bins numeric data.
If X is one-dimensional:
binning is done either intrinsically into nbins classes
based on an equidistant percentile split, or extrinsically
by using the lower_boundaries values.
If X is two-dimensional
binning is done by kmeans clustering into nbins clusters
Args:
x: (list, np.array) with numeric data.
nbins: (int) number of bins
lower_boundaries: (list) of lower bin boundaries.
If y is 1-dim and lower_boundaries is provided, nbins will be ignored
and y is binned extrinsically. The first value of lower_boundaries
is always corrected not to be higher than min(y).
seed: (int) random seed for kmeans
Returns:
c: (np.array) integers as bin IDs
| def binning(x: Union[list, np.array],
nbins: int = 2,
lower_boundaries: Union[list, np.array, dict] = None,
seed: int = 42) -> np.array:
'''
bins numeric data.
If X is one-dimensional:
binning is done either intrinsically into nbins classes
based on an equidistant percentile split, or extrinsically
by using the lower_boundaries values.
If X is two-dimensional
binning is done by kmeans clustering into nbins clusters
Args:
x: (list, np.array) with numeric data.
nbins: (int) number of bins
lower_boundaries: (list) of lower bin boundaries.
If y is 1-dim and lower_boundaries is provided, nbins will be ignored
and y is binned extrinsically. The first value of lower_boundaries
is always corrected not to be higher than min(y).
seed: (int) random seed for kmeans
Returns:
c: (np.array) integers as bin IDs
'''
assert ((nbins is not None) or (lower_boundaries is not None)), \
"One of nbins or lower_boundaries must be set."
x = np.array(x, dtype=float)
assert ((nbins is not None) or x.ndim == 1), \
"For 2-dimensional data input nbins must be set for KMeans clustering."
if x.ndim == 1:
# 1-dim array
if lower_boundaries is None:
# intrinsic binning by equidistant percentiles
prct = np.linspace(0, 100, nbins+1)
lower_boundaries = np.percentile(x, prct)
lower_boundaries = lower_boundaries[0:nbins]
else:
# extrinsic binning
# make sure that entire range of x is covered
lower_boundaries[0] = min(lower_boundaries[0], np.min(x))
# binned array
c = np.zeros(len(x), dtype=int)
for i in range(1, len(lower_boundaries)):
c[x >= lower_boundaries[i]] = i
else:
# 2-dim array
# centering+scaling
sca = StandardScaler()
xs = sca.fit_transform(x)
# clustering
mod = KMeans(n_clusters=nbins, init='k-means++', max_iter=300, tol=0.0001,
random_state=seed, algorithm='lloyd', n_init=1)
mod.fit(xs)
c = mod.predict(xs)
return c
| (x: Union[list, <built-in function array>], nbins: int = 2, lower_boundaries: Union[list, <built-in function array>, dict, NoneType] = None, seed: int = 42) -> <built-in function array> |
725,448 | splitutils.core.splitutils | optimize_traindevtest_split | optimize group-disjunct split into training, dev, and test set, which is guided by:
- disjunct split of values in SPLIT_ON
- stratification by all keys in STRATIFY_ON (targets and groupings)
- test set proportion in X should be close to test_size (which is the test
proportion in set(split_on))
Score to be minimized: (sum_v[w(v) * max_irad(v)] + w(d) * max_d) / (sum_v[w(v)] + w(d))
(v: variables to be stratified on
w(v): their weight
max_irad(v): maximum information radius of reference distribution of classes in v and
- dev set distribution,
- test set distribution
N(v): number of stratification variables
max_d: maximum of absolute difference between dev and test sizes of X and set(split_on)
w(d): its weight
Args:
X: (np.array or pd.DataFrame) of features
y: (np.array) of targets of length N
if type(y[0]) in ["str", "int"]: y is assumed to be categorical, so that it is additionally
tested that all partitions cover all classes. Else y is assumed to be numeric and no
coverage test is done.
split_on: (np.array) list of length N with grouping variable (e.g. speaker IDs),
on which the group-disjunct split is to be performed. Must be categorical.
stratify_on: (dict) Dict-keys are variable names (targets and/or further groupings)
the split should be stratified on (groupings could e.g. be sex, age class, etc).
Dict-Values are np.array-s of length N that contain the variable values. All
variables must be categorical.
weight: (dict) weight for each variable in stratify_on. Defines their amount of
contribution to the optimization score. Uniform weighting by default. Additional
key: "size_diff" defines how the corresponding size differences should be weighted.
dev_size: (float) proportion in set(split_on) for dev set, e.g. 10% of speakers
to be held-out
test_size: (float) test proportion in set(split_on) for test set
k: (int) number of different splits to be tried out
seed: (int) random seed
Returns:
train_i: (np.array) train set indices in X
dev_i: (np.array) dev set indices in X
test_i: (np.array) test set indices in X
info: (dict) detail information about reference and achieved prob distributions
"dev_size_in_spliton": intended grouping dev_size
"dev_size_in_X": optimized dev proportion of observations in X
"test_size_in_spliton": intended grouping test_size
"test_size_in_X": optimized test proportion of observations in X
"p_ref_{c}": reference class distribution calculated from stratify_on[c]
"p_dev_{c}": dev set class distribution calculated from stratify_on[c][dev_i]
"p_test_{c}": test set class distribution calculated from stratify_on[c][test_i]
| def optimize_traindevtest_split(
X: Union[np.array, pd.DataFrame],
y: Union[np.array, list],
split_on: Union[np.array, list],
stratify_on: dict,
weight: dict = None,
dev_size: float = .1,
test_size: float = .1,
k: int = 30,
seed: int = 42) -> Tuple[np.array, np.array, np.array, dict]:
''' optimize group-disjunct split into training, dev, and test set, which is guided by:
- disjunct split of values in SPLIT_ON
- stratification by all keys in STRATIFY_ON (targets and groupings)
- test set proportion in X should be close to test_size (which is the test
proportion in set(split_on))
Score to be minimized: (sum_v[w(v) * max_irad(v)] + w(d) * max_d) / (sum_v[w(v)] + w(d))
(v: variables to be stratified on
w(v): their weight
max_irad(v): maximum information radius of reference distribution of classes in v and
- dev set distribution,
- test set distribution
N(v): number of stratification variables
max_d: maximum of absolute difference between dev and test sizes of X and set(split_on)
w(d): its weight
Args:
X: (np.array or pd.DataFrame) of features
y: (np.array) of targets of length N
if type(y[0]) in ["str", "int"]: y is assumed to be categorical, so that it is additionally
tested that all partitions cover all classes. Else y is assumed to be numeric and no
coverage test is done.
split_on: (np.array) list of length N with grouping variable (e.g. speaker IDs),
on which the group-disjunct split is to be performed. Must be categorical.
stratify_on: (dict) Dict-keys are variable names (targets and/or further groupings)
the split should be stratified on (groupings could e.g. be sex, age class, etc).
Dict-Values are np.array-s of length N that contain the variable values. All
variables must be categorical.
weight: (dict) weight for each variable in stratify_on. Defines their amount of
contribution to the optimization score. Uniform weighting by default. Additional
key: "size_diff" defines how the corresponding size differences should be weighted.
dev_size: (float) proportion in set(split_on) for dev set, e.g. 10% of speakers
to be held-out
test_size: (float) test proportion in set(split_on) for test set
k: (int) number of different splits to be tried out
seed: (int) random seed
Returns:
train_i: (np.array) train set indices in X
dev_i: (np.array) dev set indices in X
test_i: (np.array) test set indices in X
info: (dict) detail information about reference and achieved prob distributions
"dev_size_in_spliton": intended grouping dev_size
"dev_size_in_X": optimized dev proportion of observations in X
"test_size_in_spliton": intended grouping test_size
"test_size_in_X": optimized test proportion of observations in X
"p_ref_{c}": reference class distribution calculated from stratify_on[c]
"p_dev_{c}": dev set class distribution calculated from stratify_on[c][dev_i]
"p_test_{c}": test set class distribution calculated from stratify_on[c][test_i]
'''
# data size
N = len(y)
# size checks
assert size_check(stratify_on, N), \
f"all stratify_on arrays must have length {N}"
assert size_check(split_on, N), \
f"split_on array must have length {N}"
# categorical target: get number of classes for coverage test
if is_categorical(y[0]):
nc = len(set(y))
else:
nc = None
# adjusted dev_size after having split off the test set
dev_size_adj = (dev_size * N) / (N - test_size * N)
# split all into train/dev vs test
gss_o = GroupShuffleSplit(n_splits=k, test_size=test_size,
random_state=seed)
# split train/dev into train vs dev
gss_i = GroupShuffleSplit(n_splits=k, test_size=dev_size_adj,
random_state=seed)
# set weight defaults
if weight is None:
weight = {}
for c in stratify_on.keys():
if c not in weight:
weight[c] = 1
if "size_diff" not in weight:
weight["size_diff"] = 1
# stratification reference distributions calculated on stratify_on
p_ref = {}
for c in stratify_on:
p_ref[c] = class_prob(stratify_on[c])
# best train/dev/test indices in X; best associated score
train_i, dev_i, test_i, best_sco = None, None, None, np.inf
# full target coverage in all partitions
full_target_coverage = False
# for appropriate subsetting
xtype = type(X)
# brute-force optimization of SPLIT_ON split
# outer loop *_o: splitting into train/dev and test
# inner loop *_i: spltting into train and dev
for tri_o, tei_o in gss_o.split(X, y, split_on):
# current train/dev partition
if xtype == pd.DataFrame:
X_i = X.iloc[tri_o]
else:
X_i = X[tri_o]
y_i = y[tri_o]
split_on_i = split_on[tri_o]
for tri_i, tei_i in gss_i.split(X_i, y_i, split_on_i):
# all classes maintained in all partitions?
if nc:
nc_train = len(set(y[tri_o[tri_i]]))
nc_dev = len(set(y[tri_o[tei_i]]))
nc_test = len(set(y[tei_o]))
if min(nc_train, nc_dev, nc_test) < nc:
continue
full_target_coverage = True
sco = calc_split_score(test_i=tei_o,
stratify_on=stratify_on,
weight=weight, p_ref=p_ref,
N=N, test_size=test_size,
dev_i=tri_o[tei_i],
dev_size=dev_size_adj)
if sco < best_sco:
best_sco = sco
test_i = tei_o
train_i = tri_o[tri_i]
dev_i = tri_o[tei_i]
if test_i is None:
sys.exit(exit_message(full_target_coverage, "dev and test"))
# matching info
info = {"score": best_sco,
"size_devset_in_spliton": dev_size,
"size_devset_in_X": np.round(len(dev_i) / N, 2),
"size_testset_in_spliton": test_size,
"size_testset_in_X": np.round(len(test_i) / N, 2)}
for c in p_ref:
info[f"p_{c}_ref"] = p_ref[c]
info[f"p_{c}_dev"] = class_prob(stratify_on[c][dev_i])
info[f"p_{c}_test"] = class_prob(stratify_on[c][test_i])
return train_i, dev_i, test_i, info
| (X: Union[<built-in function array>, pandas.core.frame.DataFrame], y: Union[<built-in function array>, list], split_on: Union[<built-in function array>, list], stratify_on: dict, weight: Optional[dict] = None, dev_size: float = 0.1, test_size: float = 0.1, k: int = 30, seed: int = 42) -> Tuple[<built-in function array>, <built-in function array>, <built-in function array>, dict] |
725,449 | splitutils.core.splitutils | optimize_traintest_split | optimize group-disjunct split which is guided by:
- disjunct split of values in SPLIT_ON
- stratification by all keys in STRATIFY_ON (targets and groupings)
- test set proportion in X should be close to test_size (which is the test
proportion in set(split_on))
Score to be minimized: (sum_v[w(v) * irad(v)] + w(d) * d) / (sum_v[w(v)] + w(d))
(v: variables to be stratified on
w(v): their weight
irad(v): information radius between reference distribution of classes in v
and test set distribution
N(v): number of stratification variables
d: absolute difference between test sizes of X and set(split_on)
w(d): its weight
Args:
X: (np.array or pd.DataFrame) of features
y: (np.array) of targets of length N
if type(y[0]) in ["str", "int"]: y is assumed to be categorical, so that it is additionally
tested that all partitions cover all classes. Else y is assumed to be numeric and no
coverage test is done.
split_on: (np.array) list of length N with grouping variable (e.g. speaker IDs),
on which the group-disjunct split is to be performed. Must be categorical.
stratify_on: (dict) Dict-keys are variable names (targets and/or further groupings)
the split should be stratified on (groupings could e.g. be sex, age class, etc).
Dict-Values are np.array-s of length N that contain the variable values. All
variables must be categorical.
weight: (dict) weight for each variable in stratify_on. Defines their amount of
contribution to the optimization score. Uniform weighting by default. Additional
key: "size_diff" defines how test size diff should be weighted.
test_size: (float) test proportion in set(split_on), e.g. 10% of speakers to be held-out
k: (int) number of different splits to be tried out
seed: (int) random seed
Returns:
train_i: (np.array) train set indices in X
test_i: (np.array) test set indices in X
info: (dict) detail information about reference and achieved prob distributions
"size_testset_in_spliton": intended test_size
"size_testset_in_X": optimized test proportion in X
"p_ref_{c}": reference class distribution calculated from stratify_on[c]
"p_test_{c}": test set class distribution calculated from stratify_on[c][test_i]
| def optimize_traintest_split(
X: Union[np.array, pd.DataFrame],
y: Union[np.array, list],
split_on: Union[np.array, list],
stratify_on: dict,
weight: dict = None,
test_size: float = .1,
k: int = 30,
seed: int = 42) -> Tuple[np.array, np.array, dict]:
''' optimize group-disjunct split which is guided by:
- disjunct split of values in SPLIT_ON
- stratification by all keys in STRATIFY_ON (targets and groupings)
- test set proportion in X should be close to test_size (which is the test
proportion in set(split_on))
Score to be minimized: (sum_v[w(v) * irad(v)] + w(d) * d) / (sum_v[w(v)] + w(d))
(v: variables to be stratified on
w(v): their weight
irad(v): information radius between reference distribution of classes in v
and test set distribution
N(v): number of stratification variables
d: absolute difference between test sizes of X and set(split_on)
w(d): its weight
Args:
X: (np.array or pd.DataFrame) of features
y: (np.array) of targets of length N
if type(y[0]) in ["str", "int"]: y is assumed to be categorical, so that it is additionally
tested that all partitions cover all classes. Else y is assumed to be numeric and no
coverage test is done.
split_on: (np.array) list of length N with grouping variable (e.g. speaker IDs),
on which the group-disjunct split is to be performed. Must be categorical.
stratify_on: (dict) Dict-keys are variable names (targets and/or further groupings)
the split should be stratified on (groupings could e.g. be sex, age class, etc).
Dict-Values are np.array-s of length N that contain the variable values. All
variables must be categorical.
weight: (dict) weight for each variable in stratify_on. Defines their amount of
contribution to the optimization score. Uniform weighting by default. Additional
key: "size_diff" defines how test size diff should be weighted.
test_size: (float) test proportion in set(split_on), e.g. 10% of speakers to be held-out
k: (int) number of different splits to be tried out
seed: (int) random seed
Returns:
train_i: (np.array) train set indices in X
test_i: (np.array) test set indices in X
info: (dict) detail information about reference and achieved prob distributions
"size_testset_in_spliton": intended test_size
"size_testset_in_X": optimized test proportion in X
"p_ref_{c}": reference class distribution calculated from stratify_on[c]
"p_test_{c}": test set class distribution calculated from stratify_on[c][test_i]
'''
gss = GroupShuffleSplit(n_splits=k, test_size=test_size,
random_state=seed)
# data size
N = len(y)
# size checks
assert size_check(stratify_on, N), \
f"all stratify_on arrays must have length {N}"
assert size_check(split_on, N), \
f"split_on array must have length {N}"
# set weight defaults
if weight is None:
weight = {}
for c in stratify_on.keys():
if c not in weight:
weight[c] = 1
if "size_diff" not in weight:
weight["size_diff"] = 1
# stratification reference distributions calculated on stratify_on
p_ref = {}
for c in stratify_on:
p_ref[c] = class_prob(stratify_on[c])
# best train and test indices in X; best associated score
train_i, test_i, best_sco = None, None, np.inf
# full target coverage in all partitions
full_target_coverage = False
# categorical target: number of classes for coverage test
if is_categorical(y[0]):
nc = len(set(y))
else:
nc = None
# brute-force optimization of SPLIT_ON split
for tri, tei in gss.split(X, y, split_on):
# all classes maintained in all partitions?
if nc:
nc_train = len(set(y[tri]))
nc_test = len(set(y[tei]))
if min(nc_train, nc_test) < nc:
continue
full_target_coverage = True
sco = calc_split_score(tei, stratify_on, weight, p_ref, N, test_size)
if sco < best_sco:
train_i, test_i, best_sco = tri, tei, sco
if test_i is None:
sys.exit(exit_message(full_target_coverage))
# matching info
info = {"score": best_sco,
"size_testset_in_spliton": test_size,
"size_testset_in_X": np.round(len(test_i) / N, 2)}
for c in p_ref:
info[f"p_{c}_ref"] = p_ref[c]
info[f"p_{c}_test"] = class_prob(stratify_on[c][test_i])
return train_i, test_i, info
| (X: Union[<built-in function array>, pandas.core.frame.DataFrame], y: Union[<built-in function array>, list], split_on: Union[<built-in function array>, list], stratify_on: dict, weight: Optional[dict] = None, test_size: float = 0.1, k: int = 30, seed: int = 42) -> Tuple[<built-in function array>, <built-in function array>, dict] |
725,450 | resfo.format | Format |
The format of an res file, either FORMATTED for ascii
or UNFORMATTED for binary.
| class Format(Enum):
"""
The format of an res file, either FORMATTED for ascii
or UNFORMATTED for binary.
"""
FORMATTED = auto()
UNFORMATTED = auto()
| (value, names=None, *, module=None, qualname=None, type=None, start=1) |
725,451 | resfo.types | MESS |
The MESS value is a sentinell object used to signal that the type of the
array that is to be written should be an empty array of type MESS.
| class MESS:
"""
The MESS value is a sentinell object used to signal that the type of the
array that is to be written should be an empty array of type MESS.
"""
pass
| () |
725,452 | resfo.errors | ResfoParsingError |
Indicates an error occurred during reading of an res file.
| class ResfoParsingError(ValueError):
"""
Indicates an error occurred during reading of an res file.
"""
pass
| null |
725,453 | resfo.errors | ResfoWriteError |
Indicates an error occurred during writing of an res file.
| class ResfoWriteError(ValueError):
"""
Indicates an error occurred during writing of an res file.
"""
pass
| null |
725,459 | resfo.read | lazy_read |
Reads the contents of an res file and generates the entries
of that file. Each entry has a entry.read_keyword() and
entry.read_array() method which will return the corresponding
data, but only upon request. This requires the user to
pay attention to when values are read as it should happen
before the file is closed.
When lazy_read is given a path or filename, the file will be closed once
the generator has ran out of elements.
For greater control, one can pass an opened file so that close
can be called at the correct time.
:param filelike: Either filename, pathlib.Path or stream
to write file to. For fileformat=Format.UNFORMATTED the
stream must be in binary mode and for fileformat=Format.FORMATTED
in text mode.
:param fileformat: Either resfo.Format.FORMATTED for ascii
format, resfo.Format.UNFORMATTED for binary formatted files
or None for guess.
:raises resfo.ResfoParsingError: If the file is not a valid
res file.
.. note::
If given a file to be open (as opposed to a stream), the errors
(various `IOError` s) associated with the default behavior of the
built-in `open()` function may be raised.
When given a stream, the exceptions associated with the stream will
pass through.
| def lazy_read(filelike, fileformat: Optional[Format] = None) -> Iterator[ResArray]:
"""
Reads the contents of an res file and generates the entries
of that file. Each entry has a entry.read_keyword() and
entry.read_array() method which will return the corresponding
data, but only upon request. This requires the user to
pay attention to when values are read as it should happen
before the file is closed.
When lazy_read is given a path or filename, the file will be closed once
the generator has ran out of elements.
For greater control, one can pass an opened file so that close
can be called at the correct time.
:param filelike: Either filename, pathlib.Path or stream
to write file to. For fileformat=Format.UNFORMATTED the
stream must be in binary mode and for fileformat=Format.FORMATTED
in text mode.
:param fileformat: Either resfo.Format.FORMATTED for ascii
format, resfo.Format.UNFORMATTED for binary formatted files
or None for guess.
:raises resfo.ResfoParsingError: If the file is not a valid
res file.
.. note::
If given a file to be open (as opposed to a stream), the errors
(various `IOError` s) associated with the default behavior of the
built-in `open()` function may be raised.
When given a stream, the exceptions associated with the stream will
pass through.
"""
if fileformat is None:
fileformat = guess_format(filelike)
stream, didopen = get_stream(filelike, fileformat)
check_correct_mode(stream, fileformat)
try:
if fileformat == Format.FORMATTED:
yield from FormattedArray.parse(stream)
else:
yield from UnformattedResArray.parse(stream)
finally:
if didopen:
stream.close()
| (filelike, fileformat: Optional[resfo.format.Format] = None) -> Iterator[resfo.array_entry.ResArray] |
725,460 | resfo.read | read |
Read the contents of a res file and return a list of
tuples (keyword, array). Takes the same parameters as
lazy_read, but differs in return type
| def read(*args, **kwargs) -> List[Tuple[str, "ReadArrayValue"]]:
"""
Read the contents of a res file and return a list of
tuples (keyword, array). Takes the same parameters as
lazy_read, but differs in return type
"""
return [
(arr.read_keyword(), arr.read_array()) for arr in lazy_read(*args, **kwargs)
]
| (*args, **kwargs) -> List[Tuple[str, ForwardRef('ReadArrayValue')]] |
725,464 | resfo.write | write |
Write the given contents to the given file in res format.
:param filelike: Either filename, pathlib.Path or stream
to write file to. For fileformat=Format.UNFORMATTED the
stream must be in binary mode and for fileformat=Format.FORMATTED
in text mode.
:param contents: list or iterable of tuples (kw, arr) where keyword
is the keyword, and arr is a numpy arraylike of values. The
keyword must have exactly 8 characters and the type of the array
will be converted according to resfo.types.to_np_type
:param fileformat: Either resfo.Format.FORMATTED for ascii
format or resfo.Format.UNFORMATTED for binary format.
:raises resfo.ResfoWriteError: If the given contents cannot be
written to an res file.
.. note::
If given a file to be open (as opposed to a stream), the errors
(various `IOError` s) associated with the default behavior of the
built-in `open()` function may be raised.
When given a stream, the exceptions associated with the stream will
pass through.
| def write(
filelike,
contents: Union[Sequence[Tuple[str, WriteArrayValue]], Dict[str, WriteArrayValue]],
fileformat: Format = Format.UNFORMATTED,
):
"""
Write the given contents to the given file in res format.
:param filelike: Either filename, pathlib.Path or stream
to write file to. For fileformat=Format.UNFORMATTED the
stream must be in binary mode and for fileformat=Format.FORMATTED
in text mode.
:param contents: list or iterable of tuples (kw, arr) where keyword
is the keyword, and arr is a numpy arraylike of values. The
keyword must have exactly 8 characters and the type of the array
will be converted according to resfo.types.to_np_type
:param fileformat: Either resfo.Format.FORMATTED for ascii
format or resfo.Format.UNFORMATTED for binary format.
:raises resfo.ResfoWriteError: If the given contents cannot be
written to an res file.
.. note::
If given a file to be open (as opposed to a stream), the errors
(various `IOError` s) associated with the default behavior of the
built-in `open()` function may be raised.
When given a stream, the exceptions associated with the stream will
pass through.
"""
stream, didopen = get_stream(filelike, fileformat, mode="w")
check_correct_mode(stream, fileformat)
if fileformat == Format.FORMATTED:
formatted_write(stream, contents)
else:
unformatted_write(stream, contents)
if didopen:
stream.close()
| (filelike, contents: Union[Sequence[Tuple[str, Union[ForwardRef('ArrayLike'), resfo.types.MESS]]], Dict[str, Union[ForwardRef('ArrayLike'), resfo.types.MESS]]], fileformat: resfo.format.Format = <Format.UNFORMATTED: 2>) |
725,465 | pydomainextractor | DomainExtractor |
PyDomainExtractor is a highly optimized Domain Name Extraction library written in Rust
| class DomainExtractor:
'''
PyDomainExtractor is a highly optimized Domain Name Extraction library written in Rust
'''
engine: typing.Optional[pydomainextractor.DomainExtractor] = None
def __new__(
cls,
suffix_list_data: typing.Optional[str] = None,
):
if suffix_list_data is None:
if DomainExtractor.engine is None:
DomainExtractor.engine = pydomainextractor.DomainExtractor()
return DomainExtractor.engine
else:
return pydomainextractor.DomainExtractor(suffix_list_data)
| (suffix_list_data: Optional[str] = None) |
725,466 | pydomainextractor | __new__ | null | def __new__(
cls,
suffix_list_data: typing.Optional[str] = None,
):
if suffix_list_data is None:
if DomainExtractor.engine is None:
DomainExtractor.engine = pydomainextractor.DomainExtractor()
return DomainExtractor.engine
else:
return pydomainextractor.DomainExtractor(suffix_list_data)
| (cls, suffix_list_data: Optional[str] = None) |
725,536 | syne_tune.report | Reporter |
Callback for reporting metric values from a training script back to Syne Tune.
Example:
.. code-block:: python
from syne_tune import Reporter
report = Reporter()
for epoch in range(1, epochs + 1):
# ...
report(epoch=epoch, accuracy=accuracy)
:param add_time: If True (default), the time (in secs) since creation of the
:class:`Reporter` object is reported automatically as
:const:`~syne_tune.constants.ST_WORKER_TIME`
:param add_cost: If True (default), estimated dollar cost since creation of
:class:`Reporter` object is reported automatically as
:const:`~syne_tune.constants.ST_WORKER_COST`. This is available for
SageMaker backend only. Requires ``add_time=True``.
| class Reporter:
"""
Callback for reporting metric values from a training script back to Syne Tune.
Example:
.. code-block:: python
from syne_tune import Reporter
report = Reporter()
for epoch in range(1, epochs + 1):
# ...
report(epoch=epoch, accuracy=accuracy)
:param add_time: If True (default), the time (in secs) since creation of the
:class:`Reporter` object is reported automatically as
:const:`~syne_tune.constants.ST_WORKER_TIME`
:param add_cost: If True (default), estimated dollar cost since creation of
:class:`Reporter` object is reported automatically as
:const:`~syne_tune.constants.ST_WORKER_COST`. This is available for
SageMaker backend only. Requires ``add_time=True``.
"""
add_time: bool = True
add_cost: bool = True
def __post_init__(self):
if self.add_time:
self.start = perf_counter()
self.iter = 0
# TODO dollar-cost computation is not available for file-based backends, what would be
# needed to add support for those backends will be to add a way to access instance-type
# information.
if self.add_cost:
# add instance_type and instance count so that cost can be computed easily
self.instance_type = os.getenv(
f"SM_HP_{ST_INSTANCE_TYPE.upper()}", None
)
self.instance_count = literal_eval(
os.getenv(f"SM_HP_{ST_INSTANCE_COUNT.upper()}", "1")
)
if self.instance_type is not None:
logger.info(
f"detected instance-type/instance-count to {self.instance_type}/{self.instance_count}"
)
instance_infos = InstanceInfos()
if self.instance_type in instance_infos.instances:
cost_per_hour = instance_infos(
instance_type=self.instance_type
).cost_per_hour
self.dollar_cost = cost_per_hour * self.instance_count / 3600
def __call__(self, **kwargs) -> None:
"""Report metric values from training function back to Syne Tune
A time stamp :const:`~syne_tune.constants.ST_WORKER_TIMESTAMP` is added.
See :attr:`add_time`, :attr:`add_cost` comments for other automatically
added metrics.
:param kwargs: Keyword arguments for metrics to be reported, for instance
:code:`report(epoch=1, loss=1.2)`. Values must be serializable with json,
keys should not start with ``st_`` which is a reserved namespace for
Syne Tune internals.
"""
self._check_reported_values(kwargs)
assert not any(key.startswith("st_") for key in kwargs), (
"The metric prefix 'st_' is used by Syne Tune internals, "
"please use a metric name that does not start with 'st_'."
)
kwargs[ST_WORKER_TIMESTAMP] = time()
if self.add_time:
seconds_spent = perf_counter() - self.start
kwargs[ST_WORKER_TIME] = seconds_spent
# second cost will only be there if we were able to properly detect the instance-type and instance-count
# from the environment
if hasattr(self, "dollar_cost"):
kwargs[ST_WORKER_COST] = seconds_spent * self.dollar_cost
kwargs[ST_WORKER_ITER] = self.iter
self.iter += 1
_report_logger(**kwargs)
@staticmethod
def _check_reported_values(kwargs: Dict[str, Any]):
assert all(
v is not None for v in kwargs.values()
), f"Invalid value in report: kwargs = {kwargs}"
| (add_time: bool = True, add_cost: bool = True) -> None |
725,537 | syne_tune.report | __call__ | Report metric values from training function back to Syne Tune
A time stamp :const:`~syne_tune.constants.ST_WORKER_TIMESTAMP` is added.
See :attr:`add_time`, :attr:`add_cost` comments for other automatically
added metrics.
:param kwargs: Keyword arguments for metrics to be reported, for instance
:code:`report(epoch=1, loss=1.2)`. Values must be serializable with json,
keys should not start with ``st_`` which is a reserved namespace for
Syne Tune internals.
| def __call__(self, **kwargs) -> None:
"""Report metric values from training function back to Syne Tune
A time stamp :const:`~syne_tune.constants.ST_WORKER_TIMESTAMP` is added.
See :attr:`add_time`, :attr:`add_cost` comments for other automatically
added metrics.
:param kwargs: Keyword arguments for metrics to be reported, for instance
:code:`report(epoch=1, loss=1.2)`. Values must be serializable with json,
keys should not start with ``st_`` which is a reserved namespace for
Syne Tune internals.
"""
self._check_reported_values(kwargs)
assert not any(key.startswith("st_") for key in kwargs), (
"The metric prefix 'st_' is used by Syne Tune internals, "
"please use a metric name that does not start with 'st_'."
)
kwargs[ST_WORKER_TIMESTAMP] = time()
if self.add_time:
seconds_spent = perf_counter() - self.start
kwargs[ST_WORKER_TIME] = seconds_spent
# second cost will only be there if we were able to properly detect the instance-type and instance-count
# from the environment
if hasattr(self, "dollar_cost"):
kwargs[ST_WORKER_COST] = seconds_spent * self.dollar_cost
kwargs[ST_WORKER_ITER] = self.iter
self.iter += 1
_report_logger(**kwargs)
| (self, **kwargs) -> NoneType |
725,538 | syne_tune.report | __eq__ | null | # Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License").
# You may not use this file except in compliance with the License.
# A copy of the License is located at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# or in the "license" file accompanying this file. This file is distributed
# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
# express or implied. See the License for the specific language governing
# permissions and limitations under the License.
import os
import re
import sys
import json
import logging
from ast import literal_eval
from typing import List, Dict, Any
from time import time, perf_counter
from dataclasses import dataclass
from syne_tune.constants import (
ST_INSTANCE_TYPE,
ST_INSTANCE_COUNT,
ST_WORKER_TIME,
ST_WORKER_COST,
ST_WORKER_TIMESTAMP,
ST_WORKER_ITER,
ST_SAGEMAKER_METRIC_TAG,
)
from syne_tune.util import dump_json_with_numpy
# this is required so that metrics are written
from syne_tune.backend.sagemaker_backend.instance_info import InstanceInfos
logging.basicConfig()
logger = logging.getLogger(__name__)
@dataclass
class Reporter:
"""
Callback for reporting metric values from a training script back to Syne Tune.
Example:
.. code-block:: python
from syne_tune import Reporter
report = Reporter()
for epoch in range(1, epochs + 1):
# ...
report(epoch=epoch, accuracy=accuracy)
:param add_time: If True (default), the time (in secs) since creation of the
:class:`Reporter` object is reported automatically as
:const:`~syne_tune.constants.ST_WORKER_TIME`
:param add_cost: If True (default), estimated dollar cost since creation of
:class:`Reporter` object is reported automatically as
:const:`~syne_tune.constants.ST_WORKER_COST`. This is available for
SageMaker backend only. Requires ``add_time=True``.
"""
add_time: bool = True
add_cost: bool = True
def __post_init__(self):
if self.add_time:
self.start = perf_counter()
self.iter = 0
# TODO dollar-cost computation is not available for file-based backends, what would be
# needed to add support for those backends will be to add a way to access instance-type
# information.
if self.add_cost:
# add instance_type and instance count so that cost can be computed easily
self.instance_type = os.getenv(
f"SM_HP_{ST_INSTANCE_TYPE.upper()}", None
)
self.instance_count = literal_eval(
os.getenv(f"SM_HP_{ST_INSTANCE_COUNT.upper()}", "1")
)
if self.instance_type is not None:
logger.info(
f"detected instance-type/instance-count to {self.instance_type}/{self.instance_count}"
)
instance_infos = InstanceInfos()
if self.instance_type in instance_infos.instances:
cost_per_hour = instance_infos(
instance_type=self.instance_type
).cost_per_hour
self.dollar_cost = cost_per_hour * self.instance_count / 3600
def __call__(self, **kwargs) -> None:
"""Report metric values from training function back to Syne Tune
A time stamp :const:`~syne_tune.constants.ST_WORKER_TIMESTAMP` is added.
See :attr:`add_time`, :attr:`add_cost` comments for other automatically
added metrics.
:param kwargs: Keyword arguments for metrics to be reported, for instance
:code:`report(epoch=1, loss=1.2)`. Values must be serializable with json,
keys should not start with ``st_`` which is a reserved namespace for
Syne Tune internals.
"""
self._check_reported_values(kwargs)
assert not any(key.startswith("st_") for key in kwargs), (
"The metric prefix 'st_' is used by Syne Tune internals, "
"please use a metric name that does not start with 'st_'."
)
kwargs[ST_WORKER_TIMESTAMP] = time()
if self.add_time:
seconds_spent = perf_counter() - self.start
kwargs[ST_WORKER_TIME] = seconds_spent
# second cost will only be there if we were able to properly detect the instance-type and instance-count
# from the environment
if hasattr(self, "dollar_cost"):
kwargs[ST_WORKER_COST] = seconds_spent * self.dollar_cost
kwargs[ST_WORKER_ITER] = self.iter
self.iter += 1
_report_logger(**kwargs)
@staticmethod
def _check_reported_values(kwargs: Dict[str, Any]):
assert all(
v is not None for v in kwargs.values()
), f"Invalid value in report: kwargs = {kwargs}"
| (self, other) |
725,540 | syne_tune.report | __post_init__ | null | def __post_init__(self):
if self.add_time:
self.start = perf_counter()
self.iter = 0
# TODO dollar-cost computation is not available for file-based backends, what would be
# needed to add support for those backends will be to add a way to access instance-type
# information.
if self.add_cost:
# add instance_type and instance count so that cost can be computed easily
self.instance_type = os.getenv(
f"SM_HP_{ST_INSTANCE_TYPE.upper()}", None
)
self.instance_count = literal_eval(
os.getenv(f"SM_HP_{ST_INSTANCE_COUNT.upper()}", "1")
)
if self.instance_type is not None:
logger.info(
f"detected instance-type/instance-count to {self.instance_type}/{self.instance_count}"
)
instance_infos = InstanceInfos()
if self.instance_type in instance_infos.instances:
cost_per_hour = instance_infos(
instance_type=self.instance_type
).cost_per_hour
self.dollar_cost = cost_per_hour * self.instance_count / 3600
| (self) |
725,542 | syne_tune.report | _check_reported_values | null | @staticmethod
def _check_reported_values(kwargs: Dict[str, Any]):
assert all(
v is not None for v in kwargs.values()
), f"Invalid value in report: kwargs = {kwargs}"
| (kwargs: Dict[str, Any]) |
725,543 | syne_tune.stopping_criterion | StoppingCriterion |
Stopping criterion that can be used in a Tuner, for instance
:code:`Tuner(stop_criterion=StoppingCriterion(max_wallclock_time=3600), ...)`.
If several arguments are used, the combined criterion is true whenever
one of the atomic criteria is true.
In principle, ``stop_criterion`` for ``Tuner`` can be any lambda function, but
this class should be used with remote launching in order to ensure
proper serialization.
:param max_wallclock_time: Stop once this wallclock time is reached
:param max_num_evaluations: Stop once more than this number of metric
records have been reported
:param max_num_trials_started: Stop once more than this number of trials
have been started
:param max_num_trials_completed: Stop once more than this number of trials
have been completed. This does not include trials which were stopped
or failed
:param max_cost: Stop once total cost of evaluations larger than this value
:param max_num_trials_finished: Stop once more than this number of trials
have finished (i.e., completed, stopped, failed, or stopping)
:param min_metric_value: Dictionary with thresholds for selected metrics.
Stop once an evaluation reports a metric value below a threshold
:param max_metric_value: Dictionary with thresholds for selected metrics.
Stop once an evaluation reports a metric value above a threshold
| class StoppingCriterion:
"""
Stopping criterion that can be used in a Tuner, for instance
:code:`Tuner(stop_criterion=StoppingCriterion(max_wallclock_time=3600), ...)`.
If several arguments are used, the combined criterion is true whenever
one of the atomic criteria is true.
In principle, ``stop_criterion`` for ``Tuner`` can be any lambda function, but
this class should be used with remote launching in order to ensure
proper serialization.
:param max_wallclock_time: Stop once this wallclock time is reached
:param max_num_evaluations: Stop once more than this number of metric
records have been reported
:param max_num_trials_started: Stop once more than this number of trials
have been started
:param max_num_trials_completed: Stop once more than this number of trials
have been completed. This does not include trials which were stopped
or failed
:param max_cost: Stop once total cost of evaluations larger than this value
:param max_num_trials_finished: Stop once more than this number of trials
have finished (i.e., completed, stopped, failed, or stopping)
:param min_metric_value: Dictionary with thresholds for selected metrics.
Stop once an evaluation reports a metric value below a threshold
:param max_metric_value: Dictionary with thresholds for selected metrics.
Stop once an evaluation reports a metric value above a threshold
"""
max_wallclock_time: float = None
max_num_evaluations: int = None
max_num_trials_started: int = None
max_num_trials_completed: int = None
max_cost: float = None
max_num_trials_finished: int = None
# minimum value for metrics, any value below this threshold will trigger a stop
min_metric_value: Optional[Dict[str, float]] = None
# maximum value for metrics, any value above this threshold will trigger a stop
max_metric_value: Optional[Dict[str, float]] = None
# todo we should have unit-test for all those cases.
def __call__(self, status: TuningStatus) -> bool:
if (
self.max_wallclock_time is not None
and status.wallclock_time > self.max_wallclock_time
):
logger.info(
f"reaching max wallclock time ({self.max_wallclock_time}), stopping there."
)
return True
if (
self.max_num_trials_started is not None
and status.num_trials_started > self.max_num_trials_started
):
logger.info(
f"reaching max number of trials started ({self.max_num_trials_started + 1}), stopping there."
)
return True
if (
self.max_num_trials_completed is not None
and status.num_trials_completed > self.max_num_trials_completed
):
logger.info(
f"reaching max number of trials completed ({self.max_num_trials_completed + 1}), stopping there."
)
return True
if (
self.max_num_trials_finished is not None
and status.num_trials_finished > self.max_num_trials_finished
):
logger.info(
f"reaching max number of trials finished ({self.max_num_trials_finished + 1}), stopping there."
)
return True
if self.max_cost is not None and status.cost > self.max_cost:
logger.info(f"reaching max cost ({self.max_cost}), stopping there.")
return True
if (
self.max_num_evaluations is not None
and status.overall_metric_statistics.count > self.max_num_evaluations
):
logger.info(
f"reaching {status.overall_metric_statistics.count + 1} evaluations, stopping there. "
)
return True
if (
self.max_metric_value is not None
and status.overall_metric_statistics.count > 0
):
max_metrics_observed = status.overall_metric_statistics.max_metrics
for metric, max_metric_accepted in self.max_metric_value.items():
if (
metric in max_metrics_observed
and max_metrics_observed[metric] > max_metric_accepted
):
logger.info(
f"found {metric} with value ({max_metrics_observed[metric]}), "
f"above the provided threshold {max_metric_accepted} stopping there."
)
return True
if (
self.min_metric_value is not None
and status.overall_metric_statistics.count > 0
):
min_metrics_observed = status.overall_metric_statistics.min_metrics
for metric, min_metric_accepted in self.min_metric_value.items():
if (
metric in min_metrics_observed
and min_metrics_observed[metric] < min_metric_accepted
):
logger.info(
f"found {metric} with value ({min_metrics_observed[metric]}), "
f"below the provided threshold {min_metric_accepted} stopping there."
)
return True
return False
| (max_wallclock_time: float = None, max_num_evaluations: int = None, max_num_trials_started: int = None, max_num_trials_completed: int = None, max_cost: float = None, max_num_trials_finished: int = None, min_metric_value: Optional[Dict[str, float]] = None, max_metric_value: Optional[Dict[str, float]] = None) -> None |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.