code: def compute_gradients(self,
                          loss,
                          var_list,
                          global_step=None,
                          gate_gradients=GATE_OP,
                          aggregation_method=None,
                          colocate_gradients_with_ops=False,
                          name=None,
                          grad_loss=None):
      
      del global_step, name  # Unused for now.
      return self._momentum_optimizer.compute_gradients(
          loss,
          var_list=var_list,
          gate_gradients=gate_gradients,
          aggregation_method=aggregation_method,
          colocate_gradients_with_ops=colocate_gradients_with_ops,
          grad_loss=grad_loss)
docs: Compute gradients through momentum optimizer.
  
      Args:
        loss: A Tensor containing the value to minimize.
        var_list: Optional list or tuple of tf.Variable to update
          to minimize loss. Defaults to the list of variables collected
          in the graph under the key GraphKey.TRAINABLE_VARIABLES.
        global_step: Optional Variable to increment by one after the
          variables have been updated.
        gate_gradients: How to gate the computation of gradients.
          Can be GATE_NONE, GATE_OP, or GATE_GRAPH.
        aggregation_method: Specifies the method used to combine
          gradient terms. Valid values are defined in the class AggregationMethod.
        colocate_gradients_with_ops: If True, try collocating gradients with
          the corresponding op.
        name: Optional name for the returned operation. Default to the name
          passed to the Optimizer constructor.
        grad_loss: Optional. A Tensor holding the gradient computed for loss.
  
      Returns:
        A list of (gradient, variable) pairs. Variable is always present,
          but gradient can be None.