BVh:dZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm Z dd lm Z dd lm Z dd lm Z dd lmZdd lmZddlmZddlmZdZej,ZedgdZedgd dZedgd dZedgd dZedgdZd dZd dZd dZy)!zUtility functions for training.)context)dtypes)graph_io)ops)tensor)cond)init_ops)resource_variable_ops) state_ops)variable_scope) variable_v1) variables) tf_logging) tf_exportglobal_step_read_op_cacheztrain.global_step)v1ctjrt|jSt|j |S)axSmall helper to get the global step. ```python # Create a variable to hold the global_step. global_step_tensor = tf.Variable(10, trainable=False, name='global_step') # Create a session. sess = tf.compat.v1.Session() # Initialize the variable sess.run(global_step_tensor.initializer) # Get the variable value. print('global_step: %s' % tf.compat.v1.train.global_step(sess, global_step_tensor)) global_step: 10 ``` Args: sess: A TensorFlow `Session` object. global_step_tensor: `Tensor` or the `name` of the operation that contains the global step. Returns: The global step value. )rexecuting_eagerlyintnumpyrun)sessglobal_step_tensors X/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/training/training_util.py global_stepr's:4  !'') ** TXX( ) **ztrain.get_global_stepNc>|xstj}d}|jtjj}t |dk(r|d}n+|s |j d}ntjdyt||S#t$rYywxYw)a Get the global step tensor. The global step tensor must be an integer variable. We first try to find it in the collection `GLOBAL_STEP`, or by name `global_step:0`. Args: graph: The graph to find the global step in. If missing, use default graph. Returns: The global step variable, or `None` if none was found. Raises: TypeError: If the global step tensor has a non-integer type, or if it is not a `Variable`. @compatibility(TF2) With the deprecation of global graphs, TF no longer tracks variables in collections. In other words, there are no global variables in TF2. Thus, the global step functions have been removed (`get_or_create_global_step`, `create_global_step`, `get_global_step`) . You have two options for migrating: 1. Create a Keras optimizer, which generates an `iterations` variable. This variable is automatically incremented when calling `apply_gradients`. 2. Manually create and increment a `tf.Variable`. Below is an example of migrating away from using a global step to using a Keras optimizer: Define a dummy model and loss: >>> def compute_loss(x): ... v = tf.Variable(3.0) ... y = x * v ... loss = x * 5 - x * v ... return loss, [v] Before migrating: >>> g = tf.Graph() >>> with g.as_default(): ... x = tf.compat.v1.placeholder(tf.float32, []) ... loss, var_list = compute_loss(x) ... global_step = tf.compat.v1.train.get_or_create_global_step() ... global_init = tf.compat.v1.global_variables_initializer() ... optimizer = tf.compat.v1.train.GradientDescentOptimizer(0.1) ... train_op = optimizer.minimize(loss, global_step, var_list) >>> sess = tf.compat.v1.Session(graph=g) >>> sess.run(global_init) >>> print("before training:", sess.run(global_step)) before training: 0 >>> sess.run(train_op, feed_dict={x: 3}) >>> print("after training:", sess.run(global_step)) after training: 1 Using `get_global_step`: >>> with g.as_default(): ... print(sess.run(tf.compat.v1.train.get_global_step())) 1 Migrating to a Keras optimizer: >>> optimizer = tf.keras.optimizers.SGD(.01) >>> print("before training:", optimizer.iterations.numpy()) before training: 0 >>> with tf.GradientTape() as tape: ... loss, var_list = compute_loss(3) ... grads = tape.gradient(loss, var_list) ... optimizer.apply_gradients(zip(grads, var_list)) >>> print("after training:", optimizer.iterations.numpy()) after training: 1 @end_compatibility Nrz global_step:0z+Multiple tensors in global_step collection.) rget_default_graphget_collection GraphKeys GLOBAL_STEPlenget_tensor_by_nameKeyErrorloggingerrorassert_global_step)graphrglobal_step_tensorss rget_global_stepr+FsX  *3((*%,,S]]-F-FG ",Q/  33OD MM?@ '(   sB BBztrain.create_global_stepc |xstj}t| tdt j rtj d5tjtjjgtjtjdtj j"tjj$tjjgcdddS|j'5}|j)d5tjtjjgtjtjdtj j"tjj$tjjgcdddcdddS#1swYxYw#1swYnxYwdddy#1swYyxYw)aCreate global step tensor in graph. Args: graph: The graph in which to create the global step tensor. If missing, use default graph. Returns: Global step tensor. Raises: ValueError: if global step tensor is already defined. @compatibility(TF2) With the deprecation of global graphs, TF no longer tracks variables in collections. In other words, there are no global variables in TF2. Thus, the global step functions have been removed (`get_or_create_global_step`, `create_global_step`, `get_global_step`) . You have two options for migrating: 1. Create a Keras optimizer, which generates an `iterations` variable. This variable is automatically incremented when calling `apply_gradients`. 2. Manually create and increment a `tf.Variable`. Below is an example of migrating away from using a global step to using a Keras optimizer: Define a dummy model and loss: >>> def compute_loss(x): ... v = tf.Variable(3.0) ... y = x * v ... loss = x * 5 - x * v ... return loss, [v] Before migrating: >>> g = tf.Graph() >>> with g.as_default(): ... x = tf.compat.v1.placeholder(tf.float32, []) ... loss, var_list = compute_loss(x) ... global_step = tf.compat.v1.train.create_global_step() ... global_init = tf.compat.v1.global_variables_initializer() ... optimizer = tf.compat.v1.train.GradientDescentOptimizer(0.1) ... train_op = optimizer.minimize(loss, global_step, var_list) >>> sess = tf.compat.v1.Session(graph=g) >>> sess.run(global_init) >>> print("before training:", sess.run(global_step)) before training: 0 >>> sess.run(train_op, feed_dict={x: 3}) >>> print("after training:", sess.run(global_step)) after training: 1 Migrating to a Keras optimizer: >>> optimizer = tf.keras.optimizers.SGD(.01) >>> print("before training:", optimizer.iterations.numpy()) before training: 0 >>> with tf.GradientTape() as tape: ... loss, var_list = compute_loss(3) ... grads = tape.gradient(loss, var_list) ... optimizer.apply_gradients(zip(grads, var_list)) >>> print("after training:", optimizer.iterations.numpy()) after training: 1 @end_compatibility Nz"global_step" already exists.zcpu:0F)shapedtype initializer trainable aggregation collections)rrr+ ValueErrorrrdevicer get_variabler!r"rint64r zeros_initializerrVariableAggregationONLY_FIRST_REPLICAGLOBAL_VARIABLES as_default name_scope)r)gs rcreate_global_stepr>s{F  *3((*%U' 4 55  G    ( ( -- # # 00233FFmm,,cmm.G.G       QQ T 2Q  & & !!ll..011DD]]33S]]5N5NO QQQQ   QQQQQs2BGG4"BG G4GG( $G44G=ztrain.get_or_create_global_stepcf|xstj}t|}| t|}|S)ajReturns and create (if necessary) the global step tensor. Args: graph: The graph in which to create the global step tensor. If missing, use default graph. Returns: The global step tensor. @compatibility(TF2) With the deprecation of global graphs, TF no longer tracks variables in collections. In other words, there are no global variables in TF2. Thus, the global step functions have been removed (`get_or_create_global_step`, `create_global_step`, `get_global_step`) . You have two options for migrating: 1. Create a Keras optimizer, which generates an `iterations` variable. This variable is automatically incremented when calling `apply_gradients`. 2. Manually create and increment a `tf.Variable`. Below is an example of migrating away from using a global step to using a Keras optimizer: Define a dummy model and loss: >>> def compute_loss(x): ... v = tf.Variable(3.0) ... y = x * v ... loss = x * 5 - x * v ... return loss, [v] Before migrating: >>> g = tf.Graph() >>> with g.as_default(): ... x = tf.compat.v1.placeholder(tf.float32, []) ... loss, var_list = compute_loss(x) ... global_step = tf.compat.v1.train.get_or_create_global_step() ... global_init = tf.compat.v1.global_variables_initializer() ... optimizer = tf.compat.v1.train.GradientDescentOptimizer(0.1) ... train_op = optimizer.minimize(loss, global_step, var_list) >>> sess = tf.compat.v1.Session(graph=g) >>> sess.run(global_init) >>> print("before training:", sess.run(global_step)) before training: 0 >>> sess.run(train_op, feed_dict={x: 3}) >>> print("after training:", sess.run(global_step)) after training: 1 Migrating to a Keras optimizer: >>> optimizer = tf.keras.optimizers.SGD(.01) >>> print("before training:", optimizer.iterations.numpy()) before training: 0 >>> with tf.GradientTape() as tape: ... loss, var_list = compute_loss(3) ... grads = tape.gradient(loss, var_list) ... optimizer.apply_gradients(zip(grads, var_list)) >>> print("after training:", optimizer.iterations.numpy()) after training: 1 @end_compatibility )rrr+r>)r)rs rget_or_create_global_stepr@s:@  *3((*%&u-+E2 rztrain.assert_global_stepct|tjs=t|tjs#t j |std|z|jjjstd|jz|jjdk7r;|jjrtd|jzyy)zzAsserts `global_step_tensor` is a scalar int `Variable` or `Tensor`. Args: global_step_tensor: `Tensor` to test. z8Existing "global_step" must be a Variable or Tensor: %s.z5Existing "global_step" does not have integer type: %srz(Existing "global_step" is not scalar: %sN) isinstancerVariablerTensorr is_resource_variable TypeErrorr. base_dtype is_integer get_shapendimsis_fully_definedrs rr(r(Is ');); < ' 7  4 45G H N&' ((  ! ! , , 7 7 K&,,- ..""$**a/""$557 >&0023 4480rc|xstj}|jt}t |dkDrt dj tt |dk(r|dSy)aGets global step read tensor in graph. Args: graph: The graph in which to create the global step read tensor. If missing, use default graph. Returns: Global step read tensor. Raises: RuntimeError: if multiple items found in collection GLOBAL_STEP_READ_KEY. rzDThere are multiple items in collection {}. There should be only one.rN)rrr GLOBAL_STEP_READ_KEYr# RuntimeErrorformat)r)global_step_read_tensorss r_get_global_step_readrR`st  *3((*%"112FG !"Q& 3396:N3O QQ !"a' #A && rc |xstj}t|}||St|y|j 5}|j d5|j j jdz5ttjr8tjtjjfd}n}|dz}tjt |dddddddddt|S#1swY$xYw#1swY(xYw#1swYt|SxYw)aGets or creates global step read tensor in graph. Args: graph: The graph in which to create the global step read tensor. If missing, use default graph. Returns: Global step read tensor if there is global_step_tensor else return None. N/cjSN) initial_valuerLsrz1_get_or_create_global_step_read..s&44rr)rrrRr+r;r<opnamerBrrCrr is_variable_initialized read_valueadd_to_collectionrN)r)global_step_read_tensorr=global_step_valuers @r_get_or_create_global_step_readr`xs9  *3((*%1%8( ""&u-   KQ T 2 K (++0036 7 K & (:(: ; II  / /0B C  ) ) 46 / 1A 5 02IJ K K K u %% K K K K K u %%s=D1)D%A4D6D%>D1D" D%%D. *D11Ec J|xstj}t|}| tdt |}|j 5}|j d5|j |jjdz5tj|g5tj||cdddcdddcdddcdddS#1swYnxYw dddn #1swYnxYwdddn #1swYnxYwdddy#1swYyxYw)NzdGlobal step tensor should be created by tf.train.get_or_create_global_step before calling increment.rT) rrr+r3r`r;r<rYrZcontrol_dependenciesr assign_add) incrementr)rr^r=s r_increment_global_stepres0  *3((*%&u-  G HHC##$6 BCCCCCCCCCCCCCCCCCCCs` D)DC/C 4 C/= D DC" C/& D/C8 4D; DD DD"rV)__doc__tensorflow.python.eagerrtensorflow.python.frameworkrrrrtensorflow.python.opsrr r r r r rtensorflow.python.platformrr& tensorflow.python.util.tf_exportrrN write_graphrr+r>r@r(rRr`rerrrns&+.0+.&*7+0-+<63""  "#$+%+< &'(Z)Zz )*+ZQ,ZQz 012C3CL )*+4,4,0&D Cr