tf.compat.v1.train.SingularMonitoredSession

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
)

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 handles AbortedError and UnavailableError for distributed settings, but SingularMonitoredSession does not.
• MonitoredSession can be created in chief or worker modes. SingularMonitoredSession is always created as chief.
• You can access the raw tf.compat.v1.Session object used by SingularMonitoredSession, whereas in MonitoredSession the raw session is private. This can be used:
  • To run without hooks.
  • To save and restore.
• 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 the SingularMonitoredSession is used as a context.

Child Classes

class StepContext

Methods

close

View source

close()

raw_session

View source

raw_session()

Returns underlying TensorFlow.Session object.

run

View source

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.

run_step_fn

View source

run_step_fn(
    step_fn
)

Run ops using a step function.

```python
with tf.Graph().as_default():
  c = tf.compat.v1.placeholder(dtypes.float32)
  v = tf.add(c, 4.0)
  w = tf.add(c, 0.5)
  def step_fn(step_context):
    a = step_context.session.run(fetches=v, feed_dict={c: 0.5})
    if a <= 4.5:
      step_context.request_stop()
      return step_context.run_with_hooks(fetches=w,
                                         feed_dict={c: 0.1})

  with tf.MonitoredSession() as session:
    while not session.should_stop():
      a = session.run_step_fn(step_fn)
```
Hooks interact with the `run_with_hooks()` call inside the
     `step_fn` as they do with a `MonitoredSession.run` call.

should_stop

View source

should_stop()

__enter__

View source

__enter__()

__exit__

View source

__exit__(
    exception_type, exception_value, traceback
)