code: def gradients(
      ys,
      xs,
      grad_ys=None,
      name="gradients",
      colocate_gradients_with_ops=False,
      gate_gradients=False,
      aggregation_method=None,
      stop_gradients=None,
      unconnected_gradients=UnconnectedGradients.NONE,
  ):
      """Constructs 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.
  
      """
      # Creating the gradient graph for control flow mutates Operations.
      # _mutation_lock ensures a Session.run call cannot occur between creating and
      # mutating new ops.
      # pylint: disable=protected-access
      with ops.get_default_graph()._mutation_lock():
          return gradients_util._GradientsHelper(
              ys,
              xs,
              grad_ys,
              name,
              colocate_gradients_with_ops,
              gate_gradients,
              aggregation_method,
              stop_gradients,
              unconnected_gradients,
          )
  
imports: from tensorflow.compiler.jit.ops import xla_ops_grad
  from tensorflow.python.framework import dtypes
  from tensorflow.python.framework import ops
  from tensorflow.python.ops import array_grad
  from tensorflow.python.ops import array_ops
  from tensorflow.python.ops import check_ops
  from tensorflow.python.ops import control_flow_grad
  from tensorflow.python.ops import cudnn_rnn_grad
  from tensorflow.python.ops import gradients_util
  from tensorflow.python.ops import image_grad
  from tensorflow.python.ops import io_ops
  from tensorflow.python.ops import linalg_grad
  from tensorflow.python.ops import linalg_ops
  from tensorflow.python.ops import logging_ops
  from tensorflow.python.ops import lookup_grad
  from tensorflow.python.ops import manip_grad
  from tensorflow.python.ops import math_grad
  from tensorflow.python.ops import math_ops
  from tensorflow.python.ops import nccl_ops
  from tensorflow.python.ops import nn_grad
  from tensorflow.python.ops import optional_grad
  from tensorflow.python.ops import parsing_grad
  from tensorflow.python.ops import proto_ops
  from tensorflow.python.ops import random_grad
  from tensorflow.python.ops import rnn_grad
  from tensorflow.python.ops import sdca_ops
  from tensorflow.python.ops import sets
  from tensorflow.python.ops import sparse_grad
  from tensorflow.python.ops import tensor_array_grad
  from tensorflow.python.ops import tensor_array_ops
  from tensorflow.python.ops import while_loop
  from tensorflow.python.ops.linalg.sparse import sparse_csr_matrix_grad
  from tensorflow.python.ops.signal import fft_ops
  from tensorflow.python.ops.unconnected_gradients import UnconnectedGradients
  from tensorflow.python.training import checkpoint_ops
  from tensorflow.python.util.tf_export import tf_export
label_desc: Use image node_id 1 for calling a global function with example usage: gradients(ys, xs, grad_ys, name, colocate_gradients_with_ops, gate_gradients, aggregation_method, stop_gradients, unconnected_gradients) and returns: gradients_util