a /Sic% @sdZddlZddlZddlZddlZddlmZddlmZddlm Z ddlm Z ddlm Z ddlm Z dd l mZdd l mZdd l mZdd l mZdd l mZddl mZddl mZddl mZddl mZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddl m!Z!ddl"m#Z$ddl%m&Z&ddl%m'Z'ddl%m(Z(ddl%m)Z)dd l%m*Z*dd!l+m,Z,dd"l-m.Z.e,d#e/d$Z0e,d%e/d&Z1iZ2d'd(Z3d)d*Z4Gd+d,d,e5Z6d-d.Z7e8e7d/d0Z9e.d1gd2d3d4Z:e9e _;e:e _:d5d6ZdZd;d<Z?d=d>Z@d[d?d@ZAd\dBdCZBdDdEZCdFdGZDdHdIZEdJdKZFdLdMZGdNdOZHdPdQZIe jJeFeEeHeIejKejLejMdRZNeOeNdSdTZPdUdVZQe.dWdXdWgd2GdYdWdWe5ZRdS)]z2Code for backpropagation using the tape utilities.N) pywrap_tfe) backprop_util)context)execute)imperative_grad)tape)composite_tensor)composite_tensor_gradient) constant_op)dtypes)indexed_slices)ops) tensor_shape) tensor_util) type_spec) array_ops) check_ops)control_flow_util)default_gradient) gen_array_ops) gen_math_ops)math_ops)resource_variable_ops)UnconnectedGradients) tf_logging) _pywrap_utils)nest) tf_contextlib) tf_inspect)variable_utils) LazyLoader) tf_exportpfor_opsz3tensorflow.python.ops.parallel_for.control_flow_opsfunctionz tensorflow.python.eager.functioncCsRzt||fWSty@ttj}t|||}Yn0|t||f<|SN)_op_attr_type_cacheKeyErrorrensure_initialized_handlerTFE_OpNameGetAttrType)op_type attr_nameh attr_typer.\/var/www/html/django/DPS/env/lib/python3.9/site-packages/tensorflow/python/eager/backprop.py op_attr_typeIs   r0cCs|ttjkrt|S|ttjgkr6dd|DS|ttjkrRt|S|ttjgkrpdd|DSt dd|S)NcSsg|]}t|qSr.)r as_dtype.0vr.r.r/ ^zmake_attr..cSsg|]}t|qSr.)ras_shapeas_protor2r.r.r/r5br6cSst|tr|S|Sr$) isinstancestrencode)r4r.r.r/dr6zmake_attr..) intr TF_ATTR_TYPEr r1 TF_ATTR_SHAPErr7r8r map_structure)r-valuer.r.r/ make_attrTs rBc@s(eZdZdZddZddZddZdS) _MockOpz9Pretends to be a tf.Operation for the gradient functions.cCs"||_||_||_||_||_dSr$)attrsinputsoutputstypeskip_input_indices)selfrDrErFtyprHr.r.r/__init__ks z_MockOp.__init__cCsVt|j|}tdt|jdD]*}|j||krt||j|dSqt|dS)Nr)r0rGrangelenrDrBr&)rIattrrJir.r.r/get_attrrs  z_MockOp.get_attrcCs tddS)Nztf.GradientTape.gradients() does not support graph control flow operations like tf.cond or tf.while at this time. Use tf.gradients() instead. If you need this feature, please file a feature request at https://github.com/tensorflow/tensorflow/issues/new)NotImplementedErrorrIr.r.r/_get_control_flow_contextysz!_MockOp._get_control_flow_contextN)__name__ __module__ __qualname____doc__rKrRrUr.r.r.r/rChsrCc Cst|||||}tj|} | dur.dg|StsDttrd} |rX| |d7} t|  | |g|RWdS1s0Yn| |g|RSdS)aCalls the gradient function of the op. Args: op_name: the name of the op to be differentiated. attr_tuple: the attrs, as a tuple. num_inputs: the number of inputs to the op. inputs: inputs to the original operation. outputs: outputs to the original operation. out_grads: gradients of the operation wrt its outputs. skip_input_indices: a tuple that is passed to the gradient function, indicating which inputs to skip calculating the gradient for forward_pass_name_scope: the namescope of the op in the forward pass. Returns: The gradients with respect to the inputs of the function, as a list. Nzgradient_tape//) rCr _gradient_registrylookup#executing_eagerly_outside_functionsrEnableControlFlowV2get_default_graph name_scope) op_nameZ attr_tuple num_inputsrErFZ out_gradsrHZforward_pass_name_scopeZmock_opgrad_fnZgradient_name_scoper.r.r/_gradient_functions     0rdcCs t Sr$)rTFE_Py_TapeSetIsEmptyr.r.r.r/_must_record_gradientsrfz__internal__.record_gradient)v1cCst||||tdS)aFExplicitly record the gradient for a given op. Args: op_name: The op name as listed in the `OpDef` for the op. inputs: A list of tensor inputs to the op. attrs: The op attributes as a flattened list of alternating attribute names and attribute values. outputs: A list of tensor outputs from the op. N)rTFE_Py_RecordGradientr get_name_scope)rarErDrFr.r.r/record_gradients rjcsfdd}|S)aReturns a function which differentiates f with respect to variables. The wrapped function returns the value and the gradient of f when called with the same arguments. The gradient is with respect to all trainable TFE variables accessed by `f`. This function is useful when the exact set of variables to differentiate with is not known ahead of time. Example: ```python dense_layer = tf.compat.v1.layers.Dense(1) def loss(x, y): return tf.reduce_sum(tf.square(dense_layer(x) - y)) # Obtain the gradient function. val_grad_fn = tfe.implicit_value_and_gradients(loss) # Invoke the gradient function with concrete values of x and y. x = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) y = tf.constant([[10.0], [20.0]]) value, grads_and_vars = val_grad_fn(x, y) print('Value of loss: %s' % value) # Apply the gradients to Variables. optimizer = tf.compat.v1.train.GradientDescentOptimizer(0.1) optimizer.apply_gradients(grads_and_vars) ``` Args: f: function to be differentiated. If `f` returns a scalar, this scalar will be differentiated. If `f` returns a tensor or list of tensors, by default a scalar will be computed by adding all their values to produce a single scalar. Returns: A function which, when called, returns a tuple pair. Its first element is the value to which the function evaluates. Its second element is list of (gradient, variable) pairs. Raises: ValueError: if `f` returns None. c st}z4|i|}|dur0tdjWt|n t|0|}|s^tddd|D}|D]}t|ddrptdqpt|t ||}|t t ||fS) .Computes the gradient of the wrapped function.N\Cannot differentiate a function that returns None; did you forget to return a value from {}?zKNo trainable variables were accessed while the function was being computed.cSsg|] }|jqSr.)handler2r.r.r/r5r6z:implicit_val_and_grad..grad_fn.. is_packedFBGradientTape.gradient is not supported on packed EagerTensors yet.) r push_new_tape ValueErrorformatrVpop_tapewatched_variablesgetattrrrflattenlistzip)argskwds this_tapeZend_node variablessourcessgradfr.r/rcs* z&implicit_val_and_grad..grad_fnr.rrcr.rr/implicit_val_and_grads0 rcsfdd}|S)aReturns a function which differentiates f with respect to variables. The wrapped function returns the gradient of f when called with the same arguments. The gradient is with respect to all trainable TFE variables accessed by `f`. This function is useful when the exact set of variables to differentiate with is not known ahead of time. Example: ```python dense_layer = tf.compat.v1.layers.Dense(1) def loss(x, y): return tf.reduce_sum(tf.square(dense_layer(x) - y)) # Obtain the gradient function. grad_fn = tfe.implicit_gradients(loss) # Invoke the gradient function with concrete values of x and y. x = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) y = tf.constant([[10.0], [20.0]]) grads_and_vars = grad_fn(x, y) # Apply the gradients to Variables. optimizer = tf.compat.v1.train.GradientDescentOptimizer(0.1) optimizer.apply_gradients(grads_and_vars) ``` Args: f: function to be differentiated. If `f` returns a scalar, this scalar will be differentiated. If `f` returns a tensor or list of tensors, by default a scalar will be computed by adding all their values to produce a single scalar. Returns: A function which, when called, returns a list of (gradient, variable) pairs. cst|i|dS)rkrM)r)ryrzrr.r/rc8szimplicit_grad..grad_fnr.rr.rr/ implicit_grads* rc szt|jWnvty}z^|dur@tt|WYd}~Stdd|Drb|WYd}~Std||fWYd}~n d}~00|durʈstt|SddkrttdSttSnHtdd|Drfd d |DStd d|Dr|Std |dS) zHThe positions of the parameters of f to be differentiated in param_args.Ncss|]}t|tVqdSr$r9r=r3xr.r.r/ Gr6z _get_arg_spec..zmEither callable provided is not a function or could not inspect its arguments by name: %s. Original error: %srrIrMcss|]}t|tjVqdSr$)r9six string_typesrr.r.r/rSr6csg|]}|qSr.)index)r3nryr.r/r5Tr6z!_get_arg_spec..css|]}t|tVqdSr$rrr.r.r/rUr6z3params must be all strings or all integers; got %s.)rgetfullargspecry TypeErrorrNrOallrq)rparamsZ param_argser.rr/ _get_arg_spec?s.  rcsfdd}|S)a Returns a function which differentiates f with respect to params. Example: ```python # f(x, y) = (x ^ 3) * y - x * (y ^ 2) # Therefore, the 1st order derivatives are: # df / dx = 3 * (x ^ 2) * y - y ^ 2 # df / dy = x ^ 3 - 2 * x * y # The 2nd order derivatives with respect to x is: # d^2 f / (dx)^2 = 6 * x * y def f(x, y): return x * x * x * y - x * y * y # Obtain a function that returns 1st order gradients. grad_fn = tfe.gradients_function(f) x = 2.0 y = 3.0 # Invoke the 1st order gradient function. x_grad, y_grad = grad_fn(x, y) assert x_grad.numpy() == 3 * (2 ** 2) * 3 - 3 ** 2 assert y_grad.numpy() == (2 ** 3) - 2 * 2 * 3 # Obtain a function that returns the 2nd order gradient with respect to x. gradgrad_fn = tfe.gradients_function(lambda x, y: grad_fn(x, y)[0]) # Invoke the 2nd order gradient function. x_gradgrad = gradgrad_fn(x, y)[0] assert x_gradgrad.numpy() == 6 * 2 * 3 # To obtain a callable that returns the gradient(s) of `f` with respect to a # subset of its inputs, use the `params` keyword argument with # `gradients_function()`. ygrad_fn = tfe.gradients_function(f, params=[1]) (y_grad,) = ygrad_fn(x, y) assert y_grad.numpy() == (2 ** 3) - 2 * 2 * 3 ``` Note that only tensors with real or complex dtypes are differentiable. Args: f: function to be differentiated. If `f` returns a scalar, this scalar will be differentiated. If `f` returns a tensor or list of tensors, by default a scalar will be computed by adding all their values to produce a single scalar. If desired, the tensors can be elementwise multiplied by the tensors passed as the `dy` keyword argument to the returned gradient function. params: list of parameter names of f or list of integers indexing the parameters with respect to which we'll differentiate. Passing None differentiates with respect to all parameters. Returns: function which, when called, returns the value of f and the gradient of `f` with respect to all of `params`. The function takes an extra optional keyword argument `dy`. Setting it allows computation of vector jacobian products for vectors other than the vector of ones. Raises: ValueError: if the params are not all strings or all integers. cstd|i|\}}|S)z0Computes the gradient of the decorated function.)r)val_and_grad_function)ryrz_rrrr.r/ decoratedsz%gradients_function..decoratedr.rrrr.rr/gradients_function\s@rcCsTt}t|D]@\}}||vrt|}||vrDt||||<q||q|S)a.Make each of the parameter_positions in args a unique ops.Tensor object. Ensure that each parameter is treated independently. For example: def f(x, y): return x * y g = gradients_function(f) one = tf.constant(1.) g(one, one) should return [1., 1.] (even though the two arguments are the same Tensor object). Args: parameter_positions: List of indices into args defining the arguments to differentiate against. args: A list of arguments to the function to be differentiated. Returns: args, possibly edited in-place. )set enumerater tensor_idridentityadd)parameter_positionsryr~rQttidr.r.r/_ensure_unique_tensor_objectss  rcsfdd}|S)aMReturns a function that computes f and its derivative w.r.t. params. Example: ```python # f(x, y) = (x ^ 3) * y - x * (y ^ 2) # Therefore, the 1st order derivatives are: # df / dx = 3 * (x ^ 2) * y - y ^ 2 # df / dy = x ^ 3 - 2 * x * y def f(x, y): return x * x * x * y - x * y * y # Obtain a function that returns the function value and the 1st order # gradients. val_grads_fn = tfe.value_and_gradients_function(f) x = 2.0 y = 3.0 # Invoke the value-and-gradients function. f_val, (x_grad, y_grad) = val_grads_fn(x, y) assert f_val.numpy() == (2 ** 3) * 3 - 2 * (3 ** 2) assert x_grad.numpy() == 3 * (2 ** 2) * 3 - 3 ** 2 assert y_grad.numpy() == (2 ** 3) - 2 * 2 * 3 # To obtain a callable that returns the value of `f` and the gradient(s) of # `f` with respect to a subset of its inputs, use the `params` keyword # argument with `value_and_gradients_function()`. val_ygrad_fn = tfe.value_and_gradients_function(f, params=[1]) f_val, (y_grad,) = val_ygrad_fn(x, y) assert f_val.numpy() == (2 ** 3) * 3 - 2 * (3 ** 2) assert y_grad.numpy() == (2 ** 3) - 2 * 2 * 3 ``` Args: f: function to be differentiated. If `f` returns a scalar, this scalar will be differentiated. If `f` returns a tensor or list of tensors, by default a scalar will be computed by adding all their values to produce a single scalar. If desired, the tensors can be elementwise multiplied by the tensors passed as the `dy` keyword argument to the returned gradient function. params: list of parameter names of f or list of integers indexing the parameters with respect to which we'll differentiate. Passing `None` differentiates with respect to all parameters. Returns: function which, when called, returns the value of f and the gradient of f with respect to all of `params`. The function takes an extra optional keyword argument "dy". Setting it allows computation of vector jacobian products for vectors other than the vector of ones. Raises: ValueError: if the params are not all strings or all integers. cs>|dd}|rtdt|i|\}}|||dfS):Computes the value and gradient of the decorated function.dyNz@Functions to be differentiated cannot receive keyword arguments.r)poprqmake_vjp)ryrzrvalvjprr.r/rs  z(val_and_grad_function..decoratedr.rr.rr/rs8 rTcsfdd}|S)aReturns a function that computes f and its vjp w.r.t. params. The term "vjp" here is an abbreviation for vector-jacobian product. Args: f: the function to be differentiated. params: the parameters (numbers or names) to differentiate with respect to. A value of None will differentiate with respect to all parameters. persistent: Boolean controlling whether the VJP function can be re-used. Must be True or False. Returns: A function, which when called, returns a tuple (value, vjp), where: - value is the result of calling f. - vjp is a function, which takes a vector as an argument and returns the product of that vector with the Jacobian of f. Providing no argument to vjp is equivalent to providing a vector of ones. For example, ```python def f(x): return x * x wrapped_fn = tfe.make_vjp(f) result, vjp = wrapped_fn(tf.constant(3.0)) # result is 9.0 vjp() # the vjp function returns 6.0 Raises: ValueError: if `f` returns None. c st||rJdtjdzgfddt|D}t|}D]:}t||ddrjtd||t||qN|durtd j t }d d|D}t |Wtn t0d fd d }|fS)rz3The gradient function can't take keyword arguments.) persistentcs&g|]\}}|vrt|n|qSr.r convert_to_tensor)r3rQarg)rr.r/r54sz/make_vjp..decorated..rnFzAGradientTape.gradient is not supported on packed EagerTensorsyet.NrlcSsg|]}t|qSr.)rrrr.r.r/r5Fr6cs4|durddt|D}tjt|dS)NcSsg|]}t|qSr.rrr.r.r/r5Lr6z.decorated..vjp..)output_gradients)rrvrr)resultr}r{r.r/rJs z(make_vjp..decorated..vjp)N)rrrprrrurqappendwatchrrrVrrvpack_sequence_asrs)ryrzrQ flat_resultrrrr)rrr}r{r/r-s6      zmake_vjp..decoratedr.)rrrrr.rr/r s$%rcCs`t|tjsJt|jtjr"|St|jtjs4Jt|j}t|jt|j |j |j SdSr$) r9r IndexedSlicesvaluesr Tensorflatten_nested_indexed_slicesrgatherindices dense_shape)rgr.r.r/rUs rcCst|dkrdSt|dkr$|dSdd|D}tdd|DrNt|St|}dd|D}ttjd d|Ddd tjd d|Ddd |dj }|S) z1Aggregates gradients containing `IndexedSlices`s.rMNrcSsg|]}|dur|qSr$r.r3rr.r.r/r5fr6z6aggregate_indexed_slices_gradients..css|]}t|tjVqdSr$r9r rrr.r.r/rir6z5aggregate_indexed_slices_gradients..cSsg|] }t|qSr.)rrr.r.r/r5qr6cSsg|] }|jqSr.)rrr.r.r/r5tr6axiscSsg|] }|jqSr.)rrr.r.r/r5ur6) rOanyradd_n_as_indexed_slices_listr rrconcatr)gradsZ concat_gradr.r.r/"aggregate_indexed_slices_gradients`s    rcCs^|s Jdt|dkr |dStdd|Dr.css |]}t|tjtjfVqdSr$)r9r rr rrr.r.r/rsN)rOrrrr) gradientsr.r.r/_aggregate_grads{s    rcCsZt|tjr|}n t|tjr.|j}ntd|dusFd|vrJdSt t j |dS)z,The number of elements in the `grad` tensor.z%`grad` not a Tensor or IndexedSlices.NrrM) r9r r _shape_tupler rrrq functoolsreduceoperatormul)rZ shape_tupler.r.r/ _num_elementss    rcCs"ttj|tjdtj||dS)Ndtype)rfillr constantr int32)rAshaperr.r.r/ _fast_fills rcCs|tjks|tjkrdSt}|s4t||S|j}t |rN| }n|}|||f}| |}|durt |jrd}nd}t|||}| |||S)z>Helper to return (possibly cached) zero tensors in eager mode.NFr)r stringresourcerexecuting_eagerlyrzeros device_namer is_tf_typeref zeros_cachegetr1is_boolrput)rrctxdeviceZ shape_key cache_keycachedrAr.r.r/_zeross$      rcCs^t|}|tjkrdSts,t||S|jr8d}nd}|dkrRtj ||dSt |||S)NTrMr.r) r r1rrrronesrr rr)rrr1rAr.r.r/_oness   r)Znum_elements_fnZ aggregate_fnZzeros_fnZones_fnZ zeros_like_fnZ ones_like_fnZgraph_shape_fncCst|r|jS|S)z3Unwrap resource variable/ndarray to return tensors.)ris_resource_variablerm)rr.r.r/_handle_or_selfs rccsxt|D]h}t|s"t|r*|Vq t|tjrVt | |}t |EdHq t d|dt |jdq dS)z5Extracts tensors and variables from the input object.NzPassed in object z of type z0, not tf.Tensor or tf.Variable or ExtensionType.)rrvrIsTensor IsVariabler9rCompositeTensorrtype_spec_from_value_to_components_extract_tensors_and_variablesrqrGrV)tensorobj componentsr.r.r/rs r GradientTapezautodiff.GradientTapec@seZdZdZdddZddZdd Zd d Zd d Ze j ddZ ddZ e j ddZ ddZddZdejfddZejddfddZejddfddZdS) raRecord operations for automatic differentiation. Operations are recorded if they are executed within this context manager and at least one of their inputs is being "watched". Trainable variables (created by `tf.Variable` or `tf.compat.v1.get_variable`, where `trainable=True` is default in both cases) are automatically watched. Tensors can be manually watched by invoking the `watch` method on this context manager. For example, consider the function `y = x * x`. The gradient at `x = 3.0` can be computed as: >>> x = tf.constant(3.0) >>> with tf.GradientTape() as g: ... g.watch(x) ... y = x * x >>> dy_dx = g.gradient(y, x) >>> print(dy_dx) tf.Tensor(6.0, shape=(), dtype=float32) GradientTapes can be nested to compute higher-order derivatives. For example, >>> x = tf.constant(5.0) >>> with tf.GradientTape() as g: ... g.watch(x) ... with tf.GradientTape() as gg: ... gg.watch(x) ... y = x * x ... dy_dx = gg.gradient(y, x) # dy_dx = 2 * x >>> d2y_dx2 = g.gradient(dy_dx, x) # d2y_dx2 = 2 >>> print(dy_dx) tf.Tensor(10.0, shape=(), dtype=float32) >>> print(d2y_dx2) tf.Tensor(2.0, shape=(), dtype=float32) By default, the resources held by a GradientTape are released as soon as GradientTape.gradient() method is called. To compute multiple gradients over the same computation, create a persistent gradient tape. This allows multiple calls to the gradient() method as resources are released when the tape object is garbage collected. For example: >>> x = tf.constant(3.0) >>> with tf.GradientTape(persistent=True) as g: ... g.watch(x) ... y = x * x ... z = y * y >>> dz_dx = g.gradient(z, x) # (4*x^3 at x = 3) >>> print(dz_dx) tf.Tensor(108.0, shape=(), dtype=float32) >>> dy_dx = g.gradient(y, x) >>> print(dy_dx) tf.Tensor(6.0, shape=(), dtype=float32) By default GradientTape will automatically watch any trainable variables that are accessed inside the context. If you want fine grained control over which variables are watched you can disable automatic tracking by passing `watch_accessed_variables=False` to the tape constructor: >>> x = tf.Variable(2.0) >>> w = tf.Variable(5.0) >>> with tf.GradientTape( ... watch_accessed_variables=False, persistent=True) as tape: ... tape.watch(x) ... y = x ** 2 # Gradients will be available for `x`. ... z = w ** 3 # No gradients will be available as `w` isn't being watched. >>> dy_dx = tape.gradient(y, x) >>> print(dy_dx) tf.Tensor(4.0, shape=(), dtype=float32) >>> # No gradients will be available as `w` isn't being watched. >>> dz_dw = tape.gradient(z, w) >>> print(dz_dw) None Note that when using models you should ensure that your variables exist when using `watch_accessed_variables=False`. Otherwise it's quite easy to make your first iteration not have any gradients: ```python a = tf.keras.layers.Dense(32) b = tf.keras.layers.Dense(32) with tf.GradientTape(watch_accessed_variables=False) as tape: tape.watch(a.variables) # Since `a.build` has not been called at this point # `a.variables` will return an empty list and the # tape will not be watching anything. result = b(a(inputs)) tape.gradient(result, a.variables) # The result of this computation will be # a list of `None`s since a's variables # are not being watched. ``` Note that only tensors with real or complex dtypes are differentiable. FTcCs"d|_||_||_d|_d|_dS)aCreates a new GradientTape. Args: persistent: Boolean controlling whether a persistent gradient tape is created. False by default, which means at most one call can be made to the gradient() method on this object. watch_accessed_variables: Boolean controlling whether the tape will automatically `watch` any (trainable) variables accessed while the tape is active. Defaults to True meaning gradients can be requested from any result computed in the tape derived from reading a trainable `Variable`. If False users must explicitly `watch` any `Variable`s they want to request gradients from. Nr.F)_tape _persistent_watch_accessed_variables_watched_variables _recording)rIrwatch_accessed_variablesr.r.r/rKSs zGradientTape.__init__cCs ||S)zCEnters a context inside which operations are recorded on this tape.) _push_taperTr.r.r/ __enter__gszGradientTape.__enter__cCs|jr|dS)z>Exits the recording context, no further operations are traced.N)r _pop_tape)rIrJrA tracebackr.r.r/__exit__lszGradientTape.__exit__cCsD|jrtd|jdur.tj|j|jd|_n t|jd|_dS)z&Pushes a new tape onto the tape stack.zWTape is still recording, This can happen if you try to re-enter an already-active tape.N)rrT)rrqrrrprr push_taperTr.r.r/rqs   zGradientTape._push_tapecCs$|jstdt|jd|_dS)NzTape is not recording.F)rrqrrsrrTr.r.r/r~s zGradientTape._pop_tapeccs8|js.z|dVW|q4|0ndVdS)z$Ensures that this tape is recording.N)rrrrTr.r.r/_ensure_recordings zGradientTape._ensure_recordingcCsXt|D]J}t|s*ttjdd|jt|drDt |j |qt |j |qdS)zEnsures that `tensor` is being traced by this tape. Args: tensor: a Tensor/Variable or list of Tensors/Variables. Raises: ValueError: if it encounters something that is not a tensor. zJThe dtype of the watched tensor must be floating (e.g. tf.float32), got %rrmN) rr IsTrainablelogging log_first_nWARNrhasattrrwatch_variablerr)rIrrr.r.r/rs   zGradientTape.watchccs<|jdurtd|zdVW|n |0dS)a!Temporarily stops recording operations on this tape. Operations executed while this context manager is active will not be recorded on the tape. This is useful for reducing the memory used by tracing all computations. For example: >>> x = tf.constant(4.0) >>> with tf.GradientTape() as tape: ... with tape.stop_recording(): ... y = x ** 2 >>> dy_dx = tape.gradient(y, x) >>> print(dy_dx) None Yields: None Raises: RuntimeError: if the tape is not currently recording. Nz7Trying to stop recording a tape which is not recording.)r RuntimeErrorrrrTr.r.r/stop_recordings zGradientTape.stop_recordingcCs|d|_|dS)aClears all information stored in this tape. Equivalent to exiting and reentering the tape context manager with a new tape. For example, the two following code blocks are equivalent: ``` with tf.GradientTape() as t: loss = loss_fn() with tf.GradientTape() as t: loss += other_loss_fn() t.gradient(loss, ...) # Only differentiates other_loss_fn, not loss_fn # The following is equivalent to the above with tf.GradientTape() as t: loss = loss_fn() t.reset() loss += other_loss_fn() t.gradient(loss, ...) # Only differentiates other_loss_fn, not loss_fn ``` This is useful if you don't want to exit the context manager for the tape, or can't because the desired reset point is inside a control flow construct: ``` with tf.GradientTape() as t: loss = ... if loss > k: t.reset() ``` N)rrrrTr.r.r/resets zGradientTape.resetcCs|jdur|j|_|jS)z@Returns variables watched by this tape in order of construction.N)rrtrrTr.r.r/rts  zGradientTape.watched_variablesNc Cs||jdurtd|jr8|js(|nttjdd|durHtdg}t |D].}t |svt tjd|j|t|qVt|}t |}g}|D]B}t |st tjd|jt|dd rtd |t|qt|}|dur"t t|}t|}d d |D}tj|j|||||d } |jsT|j|_d|_t t|}t|| } t || } | S)aComputes the gradient using operations recorded in context of this tape. Note: Unless you set `persistent=True` a GradientTape can only be used to compute one set of gradients (or jacobians). In addition to Tensors, gradient also supports RaggedTensors. For example, >>> x = tf.ragged.constant([[1.0, 2.0], [3.0]]) >>> with tf.GradientTape() as g: ... g.watch(x) ... y = x * x >>> g.gradient(y, x) Args: target: a list or nested structure of Tensors or Variables or CompositeTensors to be differentiated. sources: a list or nested structure of Tensors or Variables or CompositeTensors. `target` will be differentiated against elements in `sources`. output_gradients: a list of gradients, one for each differentiable element of target. Defaults to None. unconnected_gradients: a value which can either hold 'none' or 'zero' and alters the value which will be returned if the target and sources are unconnected. The possible values and effects are detailed in 'UnconnectedGradients' and it defaults to 'none'. Returns: a list or nested structure of Tensors (or IndexedSlices, or None, or CompositeTensor), one for each element in `sources`. Returned structure is the same as the structure of `sources`. Raises: RuntimeError: If called on a used, non-persistent tape. RuntimeError: If called inside the context of the tape. TypeError: If the target is a None object. ValueError: If the target is a variable or if unconnected gradients is called with an unknown value. N]A non-persistent GradientTape can only be used to compute one set of gradients (or jacobians)ayCalling GradientTape.gradient on a persistent tape inside its context is significantly less efficient than calling it outside the context (it causes the gradient ops to be recorded on the tape, leading to increased CPU and memory usage). Only call GradientTape.gradient inside the context if you actually want to trace the gradient in order to compute higher order derivatives.rMzArgument `target` should be a list or nested structure of Tensors, Variables or CompositeTensors to be differentiated, but received None.zlThe dtype of the target tensor must be floating (e.g. tf.float32) when calling GradientTape.gradient, got %rzlThe dtype of the source tensor must be floating (e.g. tf.float32) when calling GradientTape.gradient, got %rrnFrocSs"g|]}|durdnt|qSr$rrr.r.r/r5Vsz)GradientTape.gradient..)rZ sources_rawunconnected_gradients)rrrrrrrrrrrvrrvlogrrrr get_flat_tensors_for_gradientsrurqrconvert_variables_to_tensorsrrtrr@"replace_flat_tensors_for_gradientsr) rItargetr}rr Z flat_targetsrZflat_sources_raw flat_sources flat_gradrr.r.r/gradients,           zGradientTape.gradientc sjdurtdt|j}t}tdgWdn1sX0Yfdd}ztjd} Wn t ytd} Yn0|rzt j || |d} WnHt y } z.t t t t| dtd WYd} ~ n d} ~ 00n8tr(js(td t j|jgt| |d} t| D]h\} } | durtj|t| d dgdd }t| |} tr| || j| | | <qNt|| S) aJ Computes the jacobian using operations recorded in context of this tape. Note: Unless you set `persistent=True` a GradientTape can only be used to compute one set of gradients (or jacobians). Note: By default the jacobian implementation uses parallel for (pfor), which creates a tf.function under the hood for each jacobian call. For better performance, and to avoid recompilation and vectorization rewrites on each call, enclose GradientTape code in @tf.function. See[wikipedia article](http://en.wikipedia.org/wiki/jacobian_matrix_and_determinant) for the definition of a Jacobian. Example usage: ```python with tf.GradientTape() as g: x = tf.constant([1.0, 2.0]) g.watch(x) y = x * x jacobian = g.jacobian(y, x) # jacobian value is [[2., 0.], [0., 4.]] ``` Args: target: Tensor to be differentiated. sources: a list or nested structure of Tensors or Variables. `target` will be differentiated against elements in `sources`. unconnected_gradients: a value which can either hold 'none' or 'zero' and alters the value which will be returned if the target and sources are unconnected. The possible values and effects are detailed in 'UnconnectedGradients' and it defaults to 'none'. parallel_iterations: A knob to control how many iterations are dispatched in parallel. This knob can be used to control the total memory usage. experimental_use_pfor: If true, vectorizes the jacobian computation. Else falls back to a sequential while_loop. Vectorization can sometimes fail or lead to excessive memory usage. This option can be used to disable vectorization in such cases. Returns: A list or nested structure of Tensors (or None), one for each element in `sources`. Returned structure is the same as the structure of `sources`. Note if any gradient is sparse (IndexedSlices), jacobian function currently makes it dense and returns a Tensor instead. This may change in the future. Raises: RuntimeError: If called on a used, non-persistent tape. RuntimeError: If called on a non-persistent tape with eager execution enabled and without enabling experimental_use_pfor. ValueError: If vectorization of jacobian computation fails. Nr csDt|}Wdn1s*0Yj|dS)Nr )rrrrrQyrrIrr r.r/loop_fns  *z&GradientTape.jacobian..loop_fnrparallel_iterationsz Encountered an exception while vectorizing the jacobian computation. Vectorization can be disabled by setting experimental_use_pfor to False.rLzGradientTape must be created with persistent=True to compute the jacobian with eager execution enabled and with experimental_use_pfor set to False.rMr)rrrrvrrrreshaper=rr"pforrqrreraiser:sysexc_inforrrfor_looprrOrr set_shape concatenater)rIrr}r rexperimental_use_pforZtarget_static_shape target_shaperZ target_sizeoutputerrrQout new_shaper.rr/jacobianlsV<    ,        zGradientTape.jacobianc sLjdurtdj}|jdur.td}n |jd}|dr^jdr^|jdsrt djjf| rt |d}| |} n t }|d}t |} t } Ztt|| dg t || gWdn1s0YWdn1s(0Ydfdd} |rztj| | d } WnHt y} z.tt t t| d tdWYd} ~ n d} ~ 00n.tr̈jstd tj| j | d } t j!|| d dgdd }| durt "|j } | St | | |dg} t #| gd} t | |} | SdS)aK Computes and stacks per-example jacobians. See [wikipedia article](http://en.wikipedia.org/wiki/jacobian_matrix_and_determinant) for the definition of a Jacobian. This function is essentially an efficient implementation of the following: `tf.stack([self.jacobian(y[i], x[i]) for i in range(x.shape[0])])`. Note that compared to `GradientTape.jacobian` which computes gradient of each output value w.r.t each input value, this function is useful when `target[i,...]` is independent of `source[j,...]` for `j != i`. This assumption allows more efficient computation as compared to `GradientTape.jacobian`. The output, as well as intermediate activations, are lower dimensional and avoid a bunch of redundant zeros which would result in the jacobian computation given the independence assumption. Note: Unless you set `persistent=True` a GradientTape can only be used to compute one set of gradients (or jacobians). Note: By default the batch_jacobian implementation uses parallel for (pfor), which creates a tf.function under the hood for each batch_jacobian call. For better performance, and to avoid recompilation and vectorization rewrites on each call, enclose GradientTape code in @tf.function. Example usage: ```python with tf.GradientTape() as g: x = tf.constant([[1., 2.], [3., 4.]], dtype=tf.float32) g.watch(x) y = x * x batch_jacobian = g.batch_jacobian(y, x) # batch_jacobian is [[[2, 0], [0, 4]], [[6, 0], [0, 8]]] ``` Args: target: A tensor with rank 2 or higher and with shape [b, y1, ..., y_n]. `target[i,...]` should only depend on `source[i,...]`. source: A tensor with rank 2 or higher and with shape [b, x1, ..., x_m]. unconnected_gradients: a value which can either hold 'none' or 'zero' and alters the value which will be returned if the target and sources are unconnected. The possible values and effects are detailed in 'UnconnectedGradients' and it defaults to 'none'. parallel_iterations: A knob to control how many iterations are dispatched in parallel. This knob can be used to control the total memory usage. experimental_use_pfor: If true, uses pfor for computing the Jacobian. Else uses a tf.while_loop. Returns: A tensor `t` with shape [b, y_1, ..., y_n, x1, ..., x_m] where `t[i, ...]` is the jacobian of `target[i, ...]` w.r.t. `source[i, ...]`, i.e. stacked per-example jacobians. Raises: RuntimeError: If called on a used, non-persistent tape. RuntimeError: If called on a non-persistent tape with eager execution enabled and without enabling experimental_use_pfor. ValueError: If vectorization of jacobian computation fails or if first dimension of `target` and `source` do not match. Nz\A non-persistent GradientTape can only be used tocompute one set of gradients (or jacobians)rrLzINeed first dimension of target shape (%s) and source shape (%s) to match.Fcspr$js$durtdntdd tj|dd}Wdn1sV0Yj|dS)NziGradientTape must be created with persistent=True to compute the batch_jacobian with parallel_iterations.zPGradientTape must be created with persistent=True to compute the batch_jacobian.TrMrr)rrrrrrrrrun_oncerIsourcerr r.r/rCs  .z,GradientTape.batch_jacobian..loop_fnrz Encountered an exception while vectorizing the batch_jacobian computation. Vectorization can be disabled by setting experimental_use_pfor to False.zGradientTape must be created with persistent=True to compute the batch_jacobian with eager execution enabled and with experimental_use_pfor set to False.rMrr)rMrrL)$rrrrankr Dimensiondimswith_rank_at_leastis_compatible_withrqis_fully_definedr= num_elementsrsizerr control_dependenciesr assert_equalrr"rrrr:r r!rrrr"rrr transpose)rIrr.r rr%r&dim batch_sizeZtarget_row_sizeZ source_shaperr'r(r*r.r,r/batch_jacobiansxC           P      zGradientTape.batch_jacobian)FT)rVrWrXrYrKrrrrrcontextmanagerrrr r rtrNONErr+r<r.r.r.r/rs0_    $  } w)N)N)NT)SrYrrr rtensorflow.pythonrtensorflow.python.eagerrrrrrtensorflow.python.frameworkrr r r r r rrrtensorflow.python.opsrrrrrrrr+tensorflow.python.ops.unconnected_gradientsrtensorflow.python.platformrrtensorflow.python.utilrrrrr"tensorflow.python.util.lazy_loaderr tensorflow.python.util.tf_exportr!globalsr"r#r%r0rBobjectrCrdTFE_Py_RegisterGradientFunctionrfrjmust_record_gradientrrrrrrrrrrrrrrZVSpace zeros_like ones_likerZ_default_vspaceTFE_Py_RegisterVSpacerrrr.r.r.r/s                                 #   O1 I D L