AVhQdZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm Z dd lm Z dd lm Z dd lm Z dd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm!Z!dd lm"Z"dd!l#m$Z$dd"l%m&Z&dd#l'm(Z(dd$l)m*Z*dd%l+m,Z,e,d&g'd(d&d)d)d(d(e(jZfd*Z.e,d&g'd(d&d)d(d(e(jZfd+Z/d,Z0e,d-g' d0d.Z1e,d-g' d1d/Z2y()2z=Implements the graph generation for computation of gradients.) xla_ops_grad)dtypes)ops) array_grad) array_ops) check_ops)control_flow_grad)cudnn_rnn_grad)gradients_util) image_grad)io_ops) linalg_grad) linalg_ops) logging_ops) lookup_grad) manip_grad) math_grad)math_ops)nccl_ops)nn_grad) optional_grad) parsing_grad) proto_ops) random_grad)rnn_grad)sdca_ops)sets) sparse_grad)tensor_array_grad)tensor_array_ops) while_loop)sparse_csr_matrix_grad)fft_ops)UnconnectedGradients)checkpoint_ops) tf_export gradients)v1NFc tjj5tj||||||||| cdddS#1swYyxYw)aConstructs symbolic derivatives of sum of `ys` w.r.t. x in `xs`. `ys` and `xs` are each a `Tensor` or a list of tensors. `grad_ys` is a list of `Tensor`, holding the gradients received by the `ys`. The list must be the same length as `ys`. `gradients()` adds ops to the graph to output the derivatives of `ys` with respect to `xs`. It returns a list of `Tensor` of length `len(xs)` where each tensor is the `sum(dy/dx)` for y in `ys` and for x in `xs`. `grad_ys` is a list of tensors of the same length as `ys` that holds the initial gradients for each y in `ys`. When `grad_ys` is None, we fill in a tensor of '1's of the shape of y for each y in `ys`. A user can provide their own initial `grad_ys` to compute the derivatives using a different initial gradient for each y (e.g., if one wanted to weight the gradient differently for each value in each y). `stop_gradients` is a `Tensor` or a list of tensors to be considered constant with respect to all `xs`. These tensors will not be backpropagated through, as though they had been explicitly disconnected using `stop_gradient`. Among other things, this allows computation of partial derivatives as opposed to total derivatives. For example: ```python a = tf.constant(0.) b = 2 * a g = tf.gradients(a + b, [a, b], stop_gradients=[a, b]) ``` Here the partial derivatives `g` evaluate to `[1.0, 1.0]`, compared to the total derivatives `tf.gradients(a + b, [a, b])`, which take into account the influence of `a` on `b` and evaluate to `[3.0, 1.0]`. Note that the above is equivalent to: ```python a = tf.stop_gradient(tf.constant(0.)) b = tf.stop_gradient(2 * a) g = tf.gradients(a + b, [a, b]) ``` `stop_gradients` provides a way of stopping gradient after the graph has already been constructed, as compared to `tf.stop_gradient` which is used during graph construction. When the two approaches are combined, backpropagation stops at both `tf.stop_gradient` nodes and nodes in `stop_gradients`, whichever is encountered first. All integer tensors are considered constant with respect to all `xs`, as if they were included in `stop_gradients`. `unconnected_gradients` determines the value returned for each x in xs if it is unconnected in the graph to ys. By default this is None to safeguard against errors. Mathematically these gradients are zero which can be requested using the `'zero'` option. `tf.UnconnectedGradients` provides the following options and behaviors: ```python a = tf.ones([1, 2]) b = tf.ones([3, 1]) g1 = tf.gradients([b], [a], unconnected_gradients='none') sess.run(g1) # [None] g2 = tf.gradients([b], [a], unconnected_gradients='zero') sess.run(g2) # [array([[0., 0.]], dtype=float32)] ``` Let us take one practical example which comes during the back propogation phase. This function is used to evaluate the derivatives of the cost function with respect to Weights `Ws` and Biases `bs`. Below sample implementation provides the exaplantion of what it is actually used for : ```python Ws = tf.constant(0.) bs = 2 * Ws cost = Ws + bs # This is just an example. So, please ignore the formulas. g = tf.gradients(cost, [Ws, bs]) dCost_dW, dCost_db = g ``` Args: ys: A `Tensor` or list of tensors to be differentiated. xs: A `Tensor` or list of tensors to be used for differentiation. grad_ys: Optional. A `Tensor` or list of tensors the same size as `ys` and holding the gradients computed for each y in `ys`. name: Optional name to use for grouping all the gradient ops together. defaults to 'gradients'. colocate_gradients_with_ops: If True, try colocating gradients with the corresponding op. gate_gradients: If True, add a tuple around the gradients returned for an operations. This avoids some race conditions. aggregation_method: Specifies the method used to combine gradient terms. Accepted values are constants defined in the class `AggregationMethod`. stop_gradients: Optional. A `Tensor` or list of tensors not to differentiate through. unconnected_gradients: Optional. Specifies the gradient value returned when the given input tensors are unconnected. Accepted values are constants defined in the class `tf.UnconnectedGradients` and the default value is `none`. Returns: A list of `Tensor` of length `len(xs)` where each tensor is the `sum(dy/dx)` for y in `ys` and for x in `xs`. Raises: LookupError: if one of the operations between `x` and `y` does not have a registered gradient function. ValueError: if the arguments are invalid. RuntimeError: if called in Eager mode. Nrget_default_graph_mutation_lockr _GradientsHelper) ysxsgrad_ysnamecolocate_gradients_with_opsgate_gradientsaggregation_methodstop_gradientsunconnected_gradientss T/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/gradients_impl.pyr'r'7sTz --/  * * B:*N  A  Ac tjj5tj||||d|||| cdddS#1swYyxYw)aZConstructs symbolic derivatives of sum of `ys` w.r.t. x in `xs`. `tf.gradients` is only valid in a graph context. In particular, it is valid in the context of a `tf.function` wrapper, where code is executing as a graph. `ys` and `xs` are each a `Tensor` or a list of tensors. `grad_ys` is a list of `Tensor`, holding the gradients received by the `ys`. The list must be the same length as `ys`. `gradients()` adds ops to the graph to output the derivatives of `ys` with respect to `xs`. It returns a list of `Tensor` of length `len(xs)` where each tensor is the `sum(dy/dx)` for y in `ys` and for x in `xs`. `grad_ys` is a list of tensors of the same length as `ys` that holds the initial gradients for each y in `ys`. When `grad_ys` is None, we fill in a tensor of '1's of the shape of y for each y in `ys`. A user can provide their own initial `grad_ys` to compute the derivatives using a different initial gradient for each y (e.g., if one wanted to weight the gradient differently for each value in each y). `stop_gradients` is a `Tensor` or a list of tensors to be considered constant with respect to all `xs`. These tensors will not be backpropagated through, as though they had been explicitly disconnected using `stop_gradient`. Among other things, this allows computation of partial derivatives as opposed to total derivatives. For example: >>> @tf.function ... def example(): ... a = tf.constant(0.) ... b = 2 * a ... return tf.gradients(a + b, [a, b], stop_gradients=[a, b]) >>> example() [, ] Here the partial derivatives `g` evaluate to `[1.0, 1.0]`, compared to the total derivatives `tf.gradients(a + b, [a, b])`, which take into account the influence of `a` on `b` and evaluate to `[3.0, 1.0]`. Note that the above is equivalent to: >>> @tf.function ... def example(): ... a = tf.stop_gradient(tf.constant(0.)) ... b = tf.stop_gradient(2 * a) ... return tf.gradients(a + b, [a, b]) >>> example() [, ] `stop_gradients` provides a way of stopping gradient after the graph has already been constructed, as compared to `tf.stop_gradient` which is used during graph construction. When the two approaches are combined, backpropagation stops at both `tf.stop_gradient` nodes and nodes in `stop_gradients`, whichever is encountered first. All integer tensors are considered constant with respect to all `xs`, as if they were included in `stop_gradients`. `unconnected_gradients` determines the value returned for each x in xs if it is unconnected in the graph to ys. By default this is None to safeguard against errors. Mathematically these gradients are zero which can be requested using the `'zero'` option. `tf.UnconnectedGradients` provides the following options and behaviors: >>> @tf.function ... def example(use_zero): ... a = tf.ones([1, 2]) ... b = tf.ones([3, 1]) ... if use_zero: ... return tf.gradients([b], [a], unconnected_gradients='zero') ... else: ... return tf.gradients([b], [a], unconnected_gradients='none') >>> example(False) [None] >>> example(True) [] Let us take one practical example which comes during the back propogation phase. This function is used to evaluate the derivatives of the cost function with respect to Weights `Ws` and Biases `bs`. Below sample implementation provides the exaplantion of what it is actually used for : >>> @tf.function ... def example(): ... Ws = tf.constant(0.) ... bs = 2 * Ws ... cost = Ws + bs # This is just an example. Please ignore the formulas. ... g = tf.gradients(cost, [Ws, bs]) ... dCost_dW, dCost_db = g ... return dCost_dW, dCost_db >>> example() (, ) Args: ys: A `Tensor` or list of tensors to be differentiated. xs: A `Tensor` or list of tensors to be used for differentiation. grad_ys: Optional. A `Tensor` or list of tensors the same size as `ys` and holding the gradients computed for each y in `ys`. name: Optional name to use for grouping all the gradient ops together. defaults to 'gradients'. gate_gradients: If True, add a tuple around the gradients returned for an operations. This avoids some race conditions. aggregation_method: Specifies the method used to combine gradient terms. Accepted values are constants defined in the class `AggregationMethod`. stop_gradients: Optional. A `Tensor` or list of tensors not to differentiate through. unconnected_gradients: Optional. Specifies the gradient value returned when the given input tensors are unconnected. Accepted values are constants defined in the class `tf.UnconnectedGradients` and the default value is `none`. Returns: A list of `Tensor` of length `len(xs)` where each tensor is the `sum(dy/dx)` for y in `ys` and for x in `xs`. Raises: LookupError: if one of the operations between `x` and `y` does not have a registered gradient function. ValueError: if the arguments are invalid. RuntimeError: if called in Eager mode. TNr*)r.r/r0r1r3r4r5r6s r7 gradients_v2r:sRT --/  * * Bt^N r8c 4t|}t||k7r tdt||}t||k(sJt||Dcgc]0\}}|)t j |t j|2}}}t||Scc}}w)aMultiply the Hessian of `ys` wrt `xs` by `v`. This is an efficient construction that uses a backprop-like approach to compute the product between the Hessian and another vector. The Hessian is usually too large to be explicitly computed or even represented, but this method allows us to at least multiply by it for the same big-O cost as backprop. Implicit Hessian-vector products are the main practical, scalable way of using second derivatives with neural networks. They allow us to do things like construct Krylov subspaces and approximate conjugate gradient descent. Example: if `y` = 1/2 `x`^T A `x`, then `hessian_vector_product(y, x, v)` will return an expression that evaluates to the same values as (A + A.T) `v`. Args: ys: A scalar value, or a tensor or list of tensors to be summed to yield a scalar. xs: A list of tensors that we should construct the Hessian over. v: A list of tensors, with the same shapes as xs, that we want to multiply by the Hessian. Returns: A list of tensors (or if the list would be length 1, a single tensor) containing the product between the Hessian and `v`. Raises: ValueError: `xs` and `v` have different length. z#xs and v must have the same length.)len ValueErrorr'ziprmultiplyr stop_gradient)r.r/vlengthgrads grad_elemv_elemelemwise_productss r7_hessian_vector_productrGOsF r7&Vv : ;; B % Uv   #5!} )V   9#:#:6#BC $b ))s5Bhessianscjtj|}|||d}g}t||fi|}t||D]\t j dgt j t jdtjtjjg} tjfdfd| \} } t j} t j | jt j | | fd} |j#| |S)a:Constructs the Hessian of sum of `ys` with respect to `x` in `xs`. `hessians()` adds ops to the graph to output the Hessian matrix of `ys` with respect to `xs`. It returns a list of `Tensor` of length `len(xs)` where each tensor is the Hessian of `sum(ys)`. The Hessian is a matrix of second-order partial derivatives of a scalar tensor (see https://en.wikipedia.org/wiki/Hessian_matrix for more details). Args: ys: A `Tensor` or list of tensors to be differentiated. xs: A `Tensor` or list of tensors to be used for differentiation. name: Optional name to use for grouping all the gradient ops together. defaults to 'hessians'. colocate_gradients_with_ops: See `gradients()` documentation for details. gate_gradients: See `gradients()` documentation for details. aggregation_method: See `gradients()` documentation for details. Returns: A list of Hessian matrices of `sum(ys)` for each `x` in `xs`. Raises: LookupError: if one of the operations between `xs` and `ys` does not have a registered gradient function. )r2r3r4rc|kS)N)j_ns r7zhessians..s QUcR|dz|j|t|dfS)Nr)writer')rMresultgradientxs r7rPzhessians..s/1q5!<<9Xa[!+DQ+GHJrQ)r _AsListr'r>rreshapesizeconstantrint32r TensorArraydtyper!shapestackconcatappend)r.r/r1r2r3r4kwargsrH _gradients loop_varsrNhessian_shape_reshaped_hessianrVrOrWs @@@r7rHrHs @b!"%@&. & (R*6**R('kh  B40H qA1fll+$$QWWa0I && J JAw__Q F!))'--/*3*:*:FF;KQ*OQ OO%&-'. /rQc$t|||d||S)aConstructs the Hessian of sum of `ys` with respect to `x` in `xs`. `hessians()` adds ops to the graph to output the Hessian matrix of `ys` with respect to `xs`. It returns a list of `Tensor` of length `len(xs)` where each tensor is the Hessian of `sum(ys)`. The Hessian is a matrix of second-order partial derivatives of a scalar tensor (see https://en.wikipedia.org/wiki/Hessian_matrix for more details). Args: ys: A `Tensor` or list of tensors to be differentiated. xs: A `Tensor` or list of tensors to be used for differentiation. gate_gradients: See `gradients()` documentation for details. aggregation_method: See `gradients()` documentation for details. name: Optional name to use for grouping all the gradient ops together. defaults to 'hessians'. Returns: A list of Hessian matrices of `sum(ys)` for each `x` in `xs`. Raises: LookupError: if one of the operations between `xs` and `ys` does not have a registered gradient function. T)r1r2r3r4)rH)r.r/r3r4r1s r7 HessiansV2rjs#<  "&#+  --rQ)rHFFN)FNrH)3__doc__tensorflow.compiler.jit.opsrtensorflow.python.frameworkrrtensorflow.python.opsrrrr r r r r rrrrrrrrrrrrrrrrrrr r!#tensorflow.python.ops.linalg.sparser"tensorflow.python.ops.signalr#+tensorflow.python.ops.unconnected_gradientsr$tensorflow.python.trainingr% tensorflow.python.util.tf_exportr&NONEr'r:rGrHrjrLrQr7rus@D4.+,++300,(-,--,+**)/.+-**&-32,F0L56 {m*/"!%!$8$=$=@@H ;2! %$( $';'@'@MMd2*j zl).! $ ??D :"$"& #-#-rQ