View source on GitHub |
Session-like object that handles initialization, restoring, and hooks.
tf.compat.v1.train.SingularMonitoredSession(
hooks=None,
scaffold=None,
master='',
config=None,
checkpoint_dir=None,
stop_grace_period_secs=120,
checkpoint_filename_with_path=None
)
Migrate to TF2
This API is not compatible with eager execution and tf.function
. To migrate
to TF2, rewrite the code to be compatible with eager execution. Check the
migration
guide
on replacing Session.run
calls. In Keras, session hooks can be replaced by
Callbacks e.g. logging hook notebook
For more details please read Better
performance with tf.function.
Description
Please note that this utility is not recommended for distributed settings.
For distributed settings, please use tf.compat.v1.train.MonitoredSession
.
The
differences between MonitoredSession
and SingularMonitoredSession
are:
MonitoredSession
handlesAbortedError
andUnavailableError
for distributed settings, butSingularMonitoredSession
does not.MonitoredSession
can be created inchief
orworker
modes.SingularMonitoredSession
is always created aschief
.- You can access the raw
tf.compat.v1.Session
object used bySingularMonitoredSession
, whereas in MonitoredSession the raw session is private. This can be used:- To
run
without hooks. - To save and restore.
- To
- All other functionality is identical.
Example usage:
saver_hook = CheckpointSaverHook(...)
summary_hook = SummarySaverHook(...)
with SingularMonitoredSession(hooks=[saver_hook, summary_hook]) as sess:
while not sess.should_stop():
sess.run(train_op)
Initialization: At creation time the hooked session does following things in given order:
- calls
hook.begin()
for each given hook - finalizes the graph via
scaffold.finalize()
- create session
- initializes the model via initialization ops provided by
Scaffold
- restores variables if a checkpoint exists
- launches queue runners
Run: When run()
is called, the hooked session does following things:
- calls
hook.before_run()
- calls TensorFlow
session.run()
with merged fetches and feed_dict - calls
hook.after_run()
- returns result of
session.run()
asked by user
Exit: At the close()
, the hooked session does following things in order:
- calls
hook.end()
- closes the queue runners and the session
- suppresses
OutOfRange
error which indicates that all inputs have been processed if theSingularMonitoredSession
is used as a context.
Attributes | |
---|---|
graph
|
The graph that was launched in this session. |
Child Classes
Methods
close
close()
raw_session
raw_session()
Returns underlying TensorFlow.Session
object.
run
run(
fetches, feed_dict=None, options=None, run_metadata=None
)
Run ops in the monitored session.
This method is completely compatible with the tf.Session.run()
method.
Args | |
---|---|
fetches
|
Same as tf.Session.run() .
|
feed_dict
|
Same as tf.Session.run() .
|
options
|
Same as tf.Session.run() .
|
run_metadata
|
Same as tf.Session.run() .
|
Returns | |
---|---|
Same as tf.Session.run() .
|
run_step_fn
run_step_fn(
step_fn
)
Run ops using a step function.
Args | |
---|---|
step_fn
|
A function or a method with a single argument of type
StepContext . The function may use methods of the argument to perform
computations with access to a raw session. The returned value of the
step_fn will be returned from run_step_fn , unless a stop is
requested. In that case, the next should_stop call will return True.
Example usage:
|
Returns | |
---|---|
Returns the returned value of step_fn .
|
Raises | |
---|---|
StopIteration
|
if step_fn has called request_stop() . It may be
caught by with tf.MonitoredSession() to close the session.
|
ValueError
|
if step_fn doesn't have a single argument called
step_context . It may also optionally have self for cases when it
belongs to an object.
|
should_stop
should_stop()
__enter__
__enter__()
__exit__
__exit__(
exception_type, exception_value, traceback
)