BVh(dZddlZddlZddlZddlmZddlmZddlm Z ddl m Z ddl m Z ddl m Z dd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlm Z ddl!m"Z"e"dgGddZ#GddejHZ%GddejHZ&GddejHZ'e(e#de#jRe(e#de#jTe(e#d e#jVe(e#d!e#jXe(e#d"e#jZe(e#d#e#j\e(e#d$e#j^e(e#d%e#j`e(e#d&e#jbe(e#d'e#jdy)(z?Training helper that checkpoints models and computes summaries.N)Summary) SessionLog)context)dtypes) meta_graph)ops)control_flow_ops) lookup_ops) variables) tf_logging)summary) coordinatorsaversession_manager) training_util) deprecation) tf_exportztrain.Supervisor)v1c6eZdZdZdZej dddeedededeeeddddd deddfd Zd/d Zd Z eefd Z edfdZ efdZ efdZ efdZefdZedZedZedZedZedZedZedZedZedZedZedZedZedZed Zd!Zd"Z d0d#Z!d/d$Z"d1d%Z# d2d&Z$d/d'Z%d(Z&d)Z'd*Z(d/d+Z)d,Z*d-Z+e,jZ d3d.Z.y)4 SupervisoraA training helper that checkpoints models and computes summaries. This class is deprecated. Please use `tf.compat.v1.train.MonitoredTrainingSession` instead. The Supervisor is a small wrapper around a `Coordinator`, a `Saver`, and a `SessionManager` that takes care of common needs of TensorFlow training programs. #### Use for a single program ```python with tf.Graph().as_default(): ...add operations to the graph... # Create a Supervisor that will checkpoint the model in '/tmp/mydir'. sv = Supervisor(logdir='/tmp/mydir') # Get a TensorFlow session managed by the supervisor. with sv.managed_session(FLAGS.master) as sess: # Use the session to train the graph. while not sv.should_stop(): sess.run() ``` Within the `with sv.managed_session()` block all variables in the graph have been initialized. In addition, a few services have been started to checkpoint the model and add summaries to the event log. If the program crashes and is restarted, the managed session automatically reinitialize variables from the most recent checkpoint. The supervisor is notified of any exception raised by one of the services. After an exception is raised, `should_stop()` returns `True`. In that case the training loop should also stop. This is why the training loop has to check for `sv.should_stop()`. Exceptions that indicate that the training inputs have been exhausted, `tf.errors.OutOfRangeError`, also cause `sv.should_stop()` to return `True` but are not re-raised from the `with` block: they indicate a normal termination. #### Use for multiple replicas To train with replicas you deploy the same program in a `Cluster`. One of the tasks must be identified as the *chief*: the task that handles initialization, checkpoints, summaries, and recovery. The other tasks depend on the *chief* for these services. The only change you have to do to the single program code is to indicate if the program is running as the *chief*. ```python # Choose a task as the chief. This could be based on server_def.task_index, # or job_def.name, or job_def.tasks. It's entirely up to the end user. # But there can be only one *chief*. is_chief = (server_def.task_index == 0) server = tf.distribute.Server(server_def) with tf.Graph().as_default(): ...add operations to the graph... # Create a Supervisor that uses log directory on a shared file system. # Indicate if you are the 'chief' sv = Supervisor(logdir='/shared_directory/...', is_chief=is_chief) # Get a Session in a TensorFlow server on the cluster. with sv.managed_session(server.target) as sess: # Use the session to train the graph. while not sv.should_stop(): sess.run() ``` In the *chief* task, the `Supervisor` works exactly as in the first example above. In the other tasks `sv.managed_session()` waits for the Model to have been initialized before returning a session to the training code. The non-chief tasks depend on the chief task for initializing the model. If one of the tasks crashes and restarts, `managed_session()` checks if the Model is initialized. If yes, it just creates a session and returns it to the training code that proceeds normally. If the model needs to be initialized, the chief task takes care of reinitializing it; the other tasks just wait for the model to have been initialized. NOTE: This modified program still works fine as a single program. The single program marks itself as the chief. #### What `master` string to use Whether you are running on your machine or in the cluster you can use the following values for the --master flag: * Specifying `''` requests an in-process session that does not use RPC. * Specifying `'local'` requests a session that uses the RPC-based "Master interface" to run TensorFlow programs. See `tf.train.Server.create_local_server` for details. * Specifying `'grpc://hostname:port'` requests a session that uses the RPC interface to a specific host, and also allows the in-process master to access remote tensorflow workers. Often, it is appropriate to pass `server.target` (for some `tf.distribute.Server` named `server). #### Advanced use ##### Launching additional services `managed_session()` launches the Checkpoint and Summary services (threads). If you need more services to run you can simply launch them in the block controlled by `managed_session()`. Example: Start a thread to print losses. We want this thread to run every 60 seconds, so we launch it with `sv.loop()`. ```python ... sv = Supervisor(logdir='/tmp/mydir') with sv.managed_session(FLAGS.master) as sess: sv.loop(60, print_loss, (sess, )) while not sv.should_stop(): sess.run(my_train_op) ``` ##### Launching fewer services `managed_session()` launches the "summary" and "checkpoint" threads which use either the optionally `summary_op` and `saver` passed to the constructor, or default ones created automatically by the supervisor. If you want to run your own summary and checkpointing logic, disable these services by passing `None` to the `summary_op` and `saver` parameters. Example: Create summaries manually every 100 steps in the chief. ```python # Create a Supervisor with no automatic summaries. sv = Supervisor(logdir='/tmp/mydir', is_chief=is_chief, summary_op=None) # As summary_op was None, managed_session() does not start the # summary thread. with sv.managed_session(FLAGS.master) as sess: for step in range(1000000): if sv.should_stop(): break if is_chief and step % 100 == 0: # Create the summary every 100 chief steps. sv.summary_computed(sess, sess.run(my_summary_op)) else: # Train normally sess.run(my_train_op) ``` ##### Custom model initialization `managed_session()` only supports initializing the model by running an `init_op` or restoring from the latest checkpoint. If you have special initialization needs, see how to specify a `local_init_op` when creating the supervisor. You can also use the `SessionManager` directly to create a session and check if it could be initialized automatically. rNz2Please switch to tf.train.MonitoredTrainingSessionTxiXz model.ckptctjr td|tj}|j 5|j |||j|||j||j| |j| |j| ddd||_ tj|jd |j r|j j"nd |_||_t)j*|_||_||_||_||_d|_d|_d|_d|_d|_|j&r||_| |_| |_|j6r/t@jBjE|j6||_|tFjHur1|j6r,tKjL|j6|_n||_d |_'|jQ| |jS|jUy#1swYxYw)aCreate a `Supervisor`. Args: graph: A `Graph`. The graph that the model will use. Defaults to the default `Graph`. The supervisor may add operations to the graph before creating a session, but the graph should not be modified by the caller after passing it to the supervisor. ready_op: 1-D string `Tensor`. This tensor is evaluated by supervisors in `prepare_or_wait_for_session()` to check if the model is ready to use. The model is considered ready if it returns an empty array. Defaults to the tensor returned from `tf.compat.v1.report_uninitialized_variables()` If `None`, the model is not checked for readiness. ready_for_local_init_op: 1-D string `Tensor`. This tensor is evaluated by supervisors in `prepare_or_wait_for_session()` to check if the model is ready to run the local_init_op. The model is considered ready if it returns an empty array. Defaults to `None`. If `None`, the model is not checked for readiness before running local_init_op. is_chief: If True, create a chief supervisor in charge of initializing and restoring the model. If False, create a supervisor that relies on a chief supervisor for inits and restore. init_op: `Operation`. Used by chief supervisors to initialize the model when it can not be recovered. Defaults to an `Operation` that initializes all global variables. If `None`, no initialization is done automatically unless you pass a value for `init_fn`, see below. init_feed_dict: A dictionary that maps `Tensor` objects to feed values. This feed dictionary will be used when `init_op` is evaluated. local_init_op: `Operation`. Used by all supervisors to run initializations that should run for every new supervisor instance. By default these are table initializers and initializers for local variables. If `None`, no further per supervisor-instance initialization is done automatically. logdir: A string. Optional path to a directory where to checkpoint the model and log events for the visualizer. Used by chief supervisors. The directory will be created if it does not exist. summary_op: An `Operation` that returns a Summary for the event logs. Used by chief supervisors if a `logdir` was specified. Defaults to the operation returned from summary.merge_all(). If `None`, summaries are not computed automatically. saver: A Saver object. Used by chief supervisors if a `logdir` was specified. Defaults to the saved returned by Saver(). If `None`, the model is not saved automatically. global_step: An integer Tensor of size 1 that counts steps. The value from 'global_step' is used in summaries and checkpoint filenames. Default to the op named 'global_step' in the graph if it exists, is of rank 1, size 1, and of type tf.int32 or tf.int64. If `None` the global step is not recorded in summaries and checkpoint files. Used by chief supervisors if a `logdir` was specified. save_summaries_secs: Number of seconds between the computation of summaries for the event log. Defaults to 120 seconds. Pass 0 to disable summaries. save_model_secs: Number of seconds between the creation of model checkpoints. Defaults to 600 seconds. Pass 0 to disable checkpoints. recovery_wait_secs: Number of seconds between checks that the model is ready. Used by supervisors when waiting for a chief supervisor to initialize or restore the model. Defaults to 30 seconds. stop_grace_secs: Grace period, in seconds, given to running threads to stop when `stop()` is called. Defaults to 120 seconds. checkpoint_basename: The basename for checkpoint saving. session_manager: `SessionManager`, which manages Session creation and recovery. If it is `None`, a default `SessionManager` will be created with the set of arguments passed in for backwards compatibility. summary_writer: `SummaryWriter` to use or `USE_DEFAULT`. Can be `None` to indicate that no summaries should be written. init_fn: Optional callable used to initialize the model. Called after the optional `init_op` is called. The callable must accept one argument, the session being initialized. local_init_run_options: RunOptions to be passed as the SessionManager local_init_run_options parameter. Returns: A `Supervisor`. Raises: RuntimeError: If called with eager execution enabled. @compatibility(eager) `Supervisor`s are not supported when eager execution is enabled. @end_compatibility z2Supervisors are incompatible with eager execution.N)ready_opready_for_local_init_op)init_opinit_feed_dict) local_init_opr) summary_op global_stepT add_shapes) graph_def saver_defFr)+rexecuting_eagerly RuntimeErrorrget_default_graph as_default_init_ready_op _init_init_op_init_local_init_op _init_saver_init_summary_op_init_global_step_graphrcreate_meta_graph_def as_graph_def_saverr'_meta_graph_def _is_chiefr Coordinator_coord_recovery_wait_secs_stop_grace_secs_init_fn_local_init_run_options_logdir_save_summaries_secs_save_model_secs _save_path_summary_writerospathjoinr USE_DEFAULT_summary FileWriter_graph_added_to_summary_init_session_manager _verify_setupfinalize)selfgraphrris_chiefrrr logdirr!rr#save_summaries_secssave_model_secsrecovery_wait_secsstop_grace_secscheckpoint_basenamersummary_writerinit_fnlocal_init_run_optionss U/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/training/supervisor.py__init__zSupervisor.__init__s J  " M NN }##%e    6 5LN H ]; U# z2 56DK%;;$$$5+/;;$++''DBDDN))+DK1D+DDM#9D DL $D DDOD ~~dl"5d-d '',,t||5HI :11 1 <>"&"?"? !55!%!=!= ?d.dc tj|}t|dkDr tjdt|||r|dS y#t $rYywxYw)zReturns the first `Operation` from a collection. Args: key: A string collection key. Returns: The first Op found in a collection, or `None` if the collection is empty. z0Found %d %s operations. Returning the first one.rN)rget_collectionlenlogginginfo LookupError)rMkeyop_lists rY_get_first_op_from_collectionz(Supervisor._get_first_op_from_collectionosi ""3'g W  G\3 ( qz      sA A AAc|tjurm|jtjj }|Bt j}tjtjj |||_ |tjur)|jtjj}||_ y)aInitializes ready_op. Args: ready_op: `Tensor` to check if the model is initialized. If it's set to USE_DEFAULT, creates an op that checks all the variables are initialized. ready_for_local_init_op: `Tensor` to check if the model is ready to run local_init_op. If it's set to USE_DEFAULT, creates an op that checks all the global variables are initialized. N) rrFrlr GraphKeysREADY_OPr report_uninitialized_variablesadd_to_collectionr_READY_FOR_LOCAL_INIT_OPr`)rMrrs rYr,zSupervisor._init_ready_ops:)))33CMM4J4JKh  ;;= cmm44h?DN*"8"88 $ B B -- / /!1$;D!rbc|tjurm|jtjj }|Bt j}tjtjj |||_ ||_ y)aHInitializes init_op. Args: init_op: `Operation` to initialize the variables. If set to USE_DEFAULT, create an op that initializes all variables and tables. init_feed_dict: A dictionary that maps `Tensor` objects to feed values. This feed dictionary will be used when `init_op` is evaluated. N) rrFrlrrnINIT_OPr global_variables_initializerrq_init_op_init_feed_dict)rMrrs rYr-zSupervisor._init_init_opsh*(((223==3H3HIg 88: cmm33W=DM)Drbc`|tjur|jtjj }|jt jtjg}|r@tj|}tjtjj |||_ y)a=Initializes local_init_op. Args: local_init_op: `Operation` run for every new supervisor instance. If set to USE_DEFAULT, use the first op from the GraphKeys.LOCAL_INIT_OP collection. If the collection is empty, create an op that initializes all local variables and all tables. N)rrFrlrrn LOCAL_INIT_OPr local_variables_initializerr tables_initializerr grouprqr^)rMr rks rYr.zSupervisor._init_local_init_ops ...88 -- % %'m    1 1 3  ) ) +  *00':-   ; ;] K'Drbc8|tjur|jtjj }|Vt jrBtj}tjtjj |||_ y)zInitializes saver. Args: saver: A `Saver` object. If set to USE_DEFAULT, create one that saves all the variables. N) rrFrlrrnSAVERSr global_variables saver_modSaverrqr5)rMrs rYr/zSupervisor._init_saversi &&&001E1EFe 9557! cmm22E:DKrbc|tjuro|jtjj }|Dt j}|.tjtjj |||_ y)zInitializes summary_op. Args: summary_op: An Operation that returns a Summary for the event logs. If set to USE_DEFAULT, create an op that merges all the summaries. N) rrFrlrrn SUMMARY_OPrG merge_allrq _summary_op)rMr!s rYr0zSupervisor._init_summary_opshZ+++55cmm6N6NOj  '')  !   8 8* E!Drbc |tjurk|jtjj }|@|j }|.tjtjj |||_y)zInitializes global_step. Args: global_step: An integer Tensor of size 1 that counts steps. If set to USE_DEFAULT, creates global_step tensor. N) rrFrlrrn GLOBAL_STEP_default_global_step_tensorrq _global_step)rMr#s rYr1zSupervisor._init_global_stepskj,,,66 -- # #%k  668  "   9 9; G#Drbc|jS)zKReturn True if this is a chief supervisor. Returns: A bool. )r7rMs rYrOzSupervisor.is_chief >>rbc|jS)zcReturn the SessionManager used by the Supervisor. Returns: A SessionManager object. )rars rYrzSupervisor.session_manager   rbc|jS)zReturn the Coordinator used by the Supervisor. The Coordinator can be useful if you want to run multiple threads during your training. Returns: A Coordinator object. )r9rs rYcoordzSupervisor.coords ;;rbc|jS)zTReturn the Init Op used by the supervisor. Returns: An Op or `None`. )rvrs rYrzSupervisor.init_ops ==rbc|jS)ztReturn the feed dictionary used when evaluating the `init_op`. Returns: A feed dictionary or `None`. )rwrs rYrzSupervisor.init_feed_dict   rbc|jS)zUReturn the Ready Op used by the supervisor. Returns: An Op or `None`. )r_rs rYrzSupervisor.ready_op"rrbc|jSN)r`rs rYrz"Supervisor.ready_for_local_init_op+s  ( ((rbc|jS)z`Return the SummaryWriter used by the chief supervisor. Returns: A SummaryWriter. )rBrs rYrVzSupervisor.summary_writer/rrbc|jS)z{Return the Summary Tensor used by the chief supervisor. Returns: A string Tensor for the summary or `None`. )rrs rYr!zSupervisor.summary_op8s   rbc|jS)zTReturn the delay between summary computations. Returns: A timestamp. )r?rs rYrQzSupervisor.save_summaries_secsAs  $ $$rbc|jS)zuReturn the global_step Tensor used by the supervisor. Returns: An integer Tensor for the global_step. )rrs rYr#zSupervisor.global_stepJs   rbc|jS)zQReturn the Saver used by the supervisor. Returns: A Saver object. )r5rs rYrzSupervisor.saverSs ;;rbc|jS)zKReturn the delay between checkpoints. Returns: A timestamp. )r@rs rYrRzSupervisor.save_model_secs\rrbc|jS)zOReturn the save path used by the supervisor. Returns: A string. )rArs rY save_pathzSupervisor.save_pathes ??rbc|jsJ|jr;tj|jj d|jd|j r_|jsR|j j|j|j j|jd|_yyy)zBWrites graph_def to `logdir` and adds it to summary if applicable.Tr$z graph.pbtxtN) r7r>r write_graphr2r4rBrI add_graphadd_meta_graphr6rs rY _write_graphzSupervisor._write_graphns >>> || ++ " "d " 3T\\  D$@$@ $$T[[1 ))$*>*>?%)d"%Arbc|js td|jstjdy|j `|j rTtj||j }|j jttj|g}|jrZ|j rN|j|jt|||j |jt!|||j"r'|j$r|jt'|||D]}|j)|S)aStart the standard services for 'sess'. This starts services in the background. The services started depend on the parameters to the constructor and may include: - A Summary thread computing summaries every save_summaries_secs. - A Checkpoint thread saving the model every save_model_secs. - A StepCounter thread measure step time. Args: sess: A Session. Returns: A list of threads that are running the standard services. You can use the Supervisor's Coordinator to join these threads with: sv.coord.Join() Raises: RuntimeError: If called with a non-chief Supervisor. ValueError: If not `logdir` was passed to the constructor as the services need a log directory. zcOnly chief supervisor can start standard services. Because only chief supervisors can write events.z>Standard services need a 'logdir' passed to the SessionManagerNstatus)r7r)r>rgwarningrrBrr#add_session_logrSTARTr?rappendSVSummaryThreadSVStepCounterThreadrr@SVTimerCheckpointThreadstart)rMsess current_stepthreadsts rYstart_standard_servicesz"Supervisor.start_standard_serviceszs&. >> L MM << oo56  $)=)=#..tT5F5FGl ** J,, -|=G   T%9%9   %tT23   &*467 zzd++ nn,T489 ggi Nrbc H|jj|jr|jj|jr|j j ||j|j|j||||j|j }|j|rEtjd|j|n|j j!|||}|r&tjd|j#||S)aMake sure the model is ready to be used. Create a session on 'master', recovering or initializing the model as needed, or wait for a session to be ready. If running as the chief and `start_standard_service` is set to True, also call the session manager to start the standard services. Args: master: name of the TensorFlow master to use. See the `tf.compat.v1.Session` constructor for how this is interpreted. config: Optional ConfigProto proto used to configure the session, which is passed as-is to create the session. wait_for_checkpoint: Whether we should wait for the availability of a checkpoint before creating Session. Defaults to False. max_wait_secs: Maximum time to wait for the session to become available. start_standard_services: Whether to start the standard services and the queue runners. Returns: A Session object that can be used to drive the model. )rrcheckpoint_dirwait_for_checkpoint max_wait_secsconfigrrWzStarting standard services.)rrzStarting queue runners.)r9 clear_stoprBreopenr7raprepare_sessionrrr>rwr<rrgrhrwait_for_sessionstart_queue_runners)rMmasterrrrrrs rYprepare_or_wait_for_sessionz&Supervisor.prepare_or_wait_for_sessions< KK  !!# ~~  " " 2 2 ,, 1%----3 !d   23 $$T*  " " 3 3 }4>d ll,- t$ Krbc tjr td|3|jj t j j}g}|D]0}|j|j||jdd2|S)aJStart threads for `QueueRunners`. Note that the queue runners collected in the graph key `QUEUE_RUNNERS` are already started automatically when you create a session with the supervisor, so unless you have non-collected queue runners to start you do not need to call this explicitly. Args: sess: A `Session`. queue_runners: A list of `QueueRunners`. If not specified, we'll use the list of queue runners gathered in the graph under the key `GraphKeys.QUEUE_RUNNERS`. Returns: The list of threads started for the `QueueRunners`. Raises: RuntimeError: If called with eager execution enabled. @compatibility(eager) Queues are not compatible with eager execution. To ingest data when eager execution is enabled, use the `tf.data` API. @end_compatibility z/Queues are not compatible with eager execution.T)rdaemonr) rr(r)r2rerrn QUEUE_RUNNERSextendcreate_threadsr9)rMr queue_runnersrqrs rYrzSupervisor.start_queue_runnerss2  " J KKkk001L1LMmGO nn  D D  MOO Nrbcntj|j||||}|j|S)aStart a LooperThread that calls a function periodically. If `timer_interval_secs` is None the thread calls `target(*args, **kwargs)` repeatedly. Otherwise it calls it every `timer_interval_secs` seconds. The thread terminates when a stop is requested. The started thread is added to the list of threads managed by the supervisor so it does not need to be passed to the `stop()` method. Args: timer_interval_secs: Number. Time boundaries at which to call `target`. target: A callable object. args: Optional arguments to pass to `target` when calling it. kwargs: Optional keyword arguments to pass to `target` when calling it. Returns: The started thread. )targetargskwargs)r LooperThreadr9r)rMtimer_interval_secsrrrloopers rYloopzSupervisor.loop s7& % %   F  LLN Mrbc$|jj |jj||j||rb|jrU|jj t t j|jjd|_ yyy#|rb|jrU|jj t t j|jjd|_ wwwxYw)aStop the services and the coordinator. This does not close the session. Args: threads: Optional list of threads to join with the coordinator. If `None`, defaults to the threads running the standard services, the threads started for `QueueRunners`, and the threads started by the `loop()` method. To wait on additional threads, pass the list in this parameter. close_summary_writer: Whether to close the `summary_writer`. Defaults to `True` if the summary writer was created by the supervisor, `False` otherwise. ignore_live_threads: If `True` ignores threads that remain running after a grace period when joining threads via the coordinator, instead of raising a RuntimeError. )stop_grace_period_secsignore_live_threadsrFN) r9 request_stoprEr;rBrrSTOPcloserI)rMrclose_summary_writerrs rYstopzSupervisor.stop&s* KK- kk !%!6!613 $"6"6 ,,Zz-OP ""$',$ #7  $"6"6 ,,Zz-OP ""$',$ #7 s (B))A&Dc<|jj|y)aERequest that the coordinator stop the threads. See `Coordinator.request_stop()`. Args: ex: Optional `Exception`, or Python `exc_info` tuple as returned by `sys.exc_info()`. If this is the first call to `request_stop()` the corresponding exception is recorded and re-raised from `join()`. )exN)r9r)rMrs rYrzSupervisor.request_stopMs KK#rbc6|jjS)zCheck if the coordinator was told to stop. See `Coordinator.should_stop()`. Returns: True if the coordinator was told to stop, False otherwise. )r9 should_stoprs rYrzSupervisor.should_stopYs ;; " " $$rbc6|jjS)zContext handler to stop the supervisor when an exception is raised. See `Coordinator.stop_on_exception()`. Returns: A context handler. )r9stop_on_exceptionrs rYrzSupervisor.stop_on_exceptioncs ;; ( ( **rbc8|jjy)z*Block waiting for the coordinator to stop.N)r9 wait_for_stoprs rYrzSupervisor.wait_for_stopmsKKrbc|js td|,|j tj||j}|jj ||y)aIndicate that a summary was computed. Args: sess: A `Session` object. summary: A Summary proto, or a string holding a serialized summary proto. global_step: Int. global step this summary is associated with. If `None`, it will try to fetch the current step. Raises: TypeError: if 'summary' is not a Summary proto or a string. RuntimeError: if the Supervisor was created without a `logdir`. z,Writing a summary requires a summary writer.N)rBr)r#r add_summary)rMrr r#s rYsummary_computedzSupervisor.summary_computedqsX    G HHt//;!--dD4D4DEk$$Wk:rbc tjjd}|jjt j t jfvr|Stjd|jy#t$rYywxYw)zlReturns the global_step from the default graph. Returns: The global step `Tensor` or `None`. z global_step:0z*Found 'global_step' is not an int type: %sN) rr*get_tensor_by_namedtype base_dtyperint32int64rgrKeyError)rMgss rYrz&Supervisor._default_global_step_tensorsl   " 5 5o Fb   v|| < < DbhhO  sAA> A>> B  B c|jsI|jjD]+}|jdvs|jrt d|zyy)zUCheck that all is good. Raises: ValueError: If something is not good. )Variable VariableV2zAWhen using replicas, all Variables must have their device set: %sN)r7r2get_operationstypedevice ValueError)rMops rYrKzSupervisor._verify_setupsY >> **,8" 770 024678 88 rbc#K |j|||}| |j| j y#t$r}|j|Yd}~Dd}~wwxYw#t$rYywxYw# j w#t$rYwwxYwxYw# |j| j w#t$rYwwxYw# j w#t$rYwwxYwxYwxYww)aReturns a context manager for a managed session. This context manager creates and automatically recovers a session. It optionally starts the standard services that handle checkpoints and summaries. It monitors exceptions raised from the `with` block or from the services and stops the supervisor as needed. The context manager is typically used as follows: ```python def train(): sv = tf.compat.v1.train.Supervisor(...) with sv.managed_session() as sess: for step in range(..): if sv.should_stop(): break sess.run() ...do other things needed at each training step... ``` An exception raised from the `with` block or one of the service threads is raised again when the block exits. This is done after stopping all threads and closing the session. For example, an `AbortedError` exception, raised in case of preemption of one of the workers in a distributed model, is raised again when the block exits. If you want to retry the training loop in case of preemption you can do it as follows: ```python def main(...): while True try: train() except tf.errors.Aborted: pass ``` As a special case, exceptions used for control flow, such as `OutOfRangeError` which reports that input queues are exhausted, are not raised again from the `with` block: they indicate a clean termination of the training loop and are considered normal termination. Args: master: name of the TensorFlow master to use. See the `tf.compat.v1.Session` constructor for how this is interpreted. config: Optional `ConfigProto` proto used to configure the session. Passed as-is to create the session. start_standard_services: Whether to start the standard services, such as checkpoint, summary and step counter. close_summary_writer: Whether to close the summary writer when closing the session. Defaults to True. Returns: A context manager that yields a `Session` restored from the latest checkpoint or initialized from scratch if not checkpoint exists. The session is closed when the `with` block exits. )rrrN)r)r Exceptionrrr)rMrrrrres rYmanaged_sessionzSupervisor.managed_sessions@  - -"9.;d j '; <   **,        **,    '; <   **,     **,   sC9AA7A(C9 A% A B A%%B( A41C93A44C97B9B  B BBBBC9C6C1CC6 C C6 CC6C3C$#C3$ C0 -C3/C0 0C33C66C9r)NFi T)NN)NTF)rNTT)/__name__ __module__ __qualname____doc__rFr deprecatedrZrJrlr,r-r.r/r0r1propertyrOrrrrrrrVr!rQr#rrRrrrrrrrrrrrrrrK contextlibcontextmanagerrrbrYrr'sc[@+;$NP#'2""(% &#&""$"#/#)&*)TPTl .,*-8<4#.d*"/:(,* )4 "+6$    ! !             ) )       % %     ! !   *2j*,)-6;04:> 7r!F: $$%-N $%+ ;& 8!.2+/ WWrbrc(eZdZdZfdZdZxZS)rz&A thread to save summaries on a timer.crtt| |j|j||_||_y)z\Create a SVSummaryThread. Args: sv: A `Supervisor`. sess: A `Session`. N)superrrZrrQ_sv_sessrMsvr __class__s rYrZzSVSummaryThread.__init__s. /4)"((B4J4JKDHDJrbc|jjI|jj|jj|jjg\}}n1|jj|jj}d}|jj r=t jd||jj j||yy)NzRecording summary at step %s.) rr#rrunr!rVrgrhr)rM summary_strsr#s rYrun_loopzSVSummaryThread.run_loops xx'"&**.. 88   4 4 5#7lKZZ^^DHH$7$78lk xx ll2K@ hh)), DrbrrrrrZr  __classcell__rs@rYrrs.  Erbrc0eZdZdZdfd ZdZdZxZS)rz2Threads to count steps and measure their duration.c tt| |j|j||_||_d|_d|_| |jn|}||_ d|jjjz|_ y)zCreate a `SVStepCounterThread`. Args: sv: A `Supervisor`. sess: A `Session`. step_counter: A `Tensor` holding the step counter. By defaults, it uses sv.global_step. rNz%s/sec)rrrZrrQrr _last_time _last_stepr# _step_counterrname _summary_tag)rMrr step_counterrs rYrZzSVStepCounterThread.__init__st t-bhh8N8NODHDJDODO%1%92>>|L%D 4#5#5#8#8#=#==Drbctj|_tj|j|j |_yr)timerrr#rrrrs rY start_loopzSVStepCounterThread.start_loop/s-iikDO#// D$P'rbrc(eZdZdZfdZdZxZS)rz"A thread to checkpoint on a timer.crtt| |j|j||_||_y)zfCreate a `SVTimerCheckpointThread`. Args: sv: A `Supervisor`. sess: A `Session`. N)rrrZrrRrrrs rYrZz SVTimerCheckpointThread.__init__Ms/ !41"((BrDs]F 95+.2+2,+<929M4.6 !"#SS$SpEk..E4-'+22-'`k666 $j&L&LM ')G)GH +Z-O-OP FJOO, M:#:#:; FJOO, L*"8"89 %z'C'CD M:#;#;< %z'B'BCrb