TensorFlow的自动求导具体是在哪部分代码里实现的？ 第1页

         grads = gradients.gradients(           loss, var_refs, grad_ys=grad_loss,           gate_gradients=(gate_gradients == Optimizer.GATE_OP),           aggregation_method=aggregation_method,           colocate_gradients_with_ops=colocate_gradients_with_ops)     

         @tf_export("gradients")   def gradients(ys,                 xs,                 grad_ys=None,                 name="gradients",                 colocate_gradients_with_ops=False,                 gate_gradients=False,                 aggregation_method=None,                 stop_gradients=None):     # Creating the gradient graph for control flow mutates Operations.     # _mutation_lock ensures a Session.run call cannot occur between creating and     # mutating new ops.     with ops.get_default_graph()._mutation_lock():  # pylint: disable=protected-access       return _GradientsHelper(ys, xs, grad_ys, name, colocate_gradients_with_ops,                               gate_gradients, aggregation_method, stop_gradients)     

         if grad_fn:     # If grad_fn was found, do not use SymbolicGradient even for     # functions.     in_grads = _MaybeCompile(grad_scope, op, func_call,                              lambda: grad_fn(op, *out_grads))   else:     # For function call ops, we add a 'SymbolicGradient'     # node to the graph to compute gradients.     in_grads = _MaybeCompile(grad_scope, op, func_call,                              lambda: _SymGrad(op, out_grads, xs))     

         Optimizer.minimize   |---Optimizer.compute_gradients       |---gradients (gradients_impl.py)           |---_GradientsHelper (gradients_impl.py)     

         @ops.RegisterGradient("Log")   def _LogGrad(op, grad):     """Returns grad * (1/x)."""     x = op.inputs[0]     with ops.control_dependencies([grad]):       x = math_ops.conj(x)       return grad * math_ops.reciprocal(x)     

         @tf.RegisterGradient("Sub")     def _sub_grad(unused_op, grad):       return grad, tf.negative(grad)     

         import tensorflow as tf   tf.enable_eager_execution()   ​   NUM_EXAMPLES = 1000   training_inputs = tf.random_normal([NUM_EXAMPLES])   noise = tf.random_normal([NUM_EXAMPLES])   training_outputs = training_inputs * 3 + 2 + noise   ​   ​   def prediction(x, w, b):       return x * w + b   ​   ​   # A loss function using mean-squared error   def loss(weights, biases):       error = prediction(training_inputs, weights, biases) - training_outputs       return tf.reduce_mean(tf.square(error))   ​   ​   train_steps = 200   learning_rate = 0.1   # Start with arbitrary values for W and B on the same batch of data   weight = tf.Variable(5.)   bias = tf.Variable(10.)   optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)   ​   for i in range(20):       print("Initial loss: {:.3f}".format(loss(weight, bias)))       optimizer.minimize(lambda: loss(weight, bias))   ​   print("Final loss: {:.3f}".format(loss(weight, bias)))   print("W = {}, B = {}".format(weight.numpy(), bias.numpy()))     

         if callable(loss):     with backprop.GradientTape() as tape:       if var_list is not None:         tape.watch(var_list)       loss_value = loss()   ​       # Scale loss if using a "mean" loss reduction and multiple towers.       # Have to be careful to call distribute_lib.get_loss_reduction()       # *after* loss() is evaluated, so we know what loss reduction it uses.       # TODO(josh11b): Test that we handle weight decay in a reasonable way.       if (distribute_lib.get_loss_reduction() ==           variable_scope.VariableAggregation.MEAN):         num_towers = distribution_strategy_context.get_distribution_strategy(         ).num_towers         if num_towers > 1:           loss_value *= (1. / num_towers)                if var_list is None:       var_list = tape.watched_variables()     grads = tape.gradient(loss_value, var_list, grad_loss)     return list(zip(grads, var_list))     

         flat_grad = imperative_grad.imperative_grad(           _default_vspace, self._tape, nest.flatten(target), flat_sources,           output_gradients=output_gradients)     

         template <typename Gradient, typename BackwardFunction, typename TapeTensor>   // 使用了传统C的约定，返回一个状态码，结果保存在result变量里   // 核心思想还是对有向图使用拓扑排序，找到出度为0的点，聚合上游梯度，求出下游梯度   Status GradientTape<Gradient, BackwardFunction, TapeTensor>::ComputeGradient(       const VSpace<Gradient, BackwardFunction, TapeTensor>& vspace,       gtl::ArraySlice<int64> target_tensor_ids,       gtl::ArraySlice<int64> source_tensor_ids,       gtl::ArraySlice<Gradient*> output_gradients,       std::vector<Gradient*>* result) {     // 构建一个输入张量的集合     gtl::FlatSet<int64> sources_set(source_tensor_ids.begin(),                                     source_tensor_ids.end());     // 初始化，找到所有与输出张量有关的op，计算它们的出度、引用数等     BackpropInitialState<BackwardFunction, TapeTensor> state = PrepareBackprop(         target_tensor_ids, tensor_tape_, &op_tape_, sources_set, persistent_);     // 找到所有出度为0的op     std::vector<int64> op_stack =         InitialStack(state.op_tape, state.op_missing_tensor);     gtl::FlatMap<int64, std::vector<Gradient*>> gradients;     // 将所有最终输出的输出梯度设为1     Status s = InitialGradients(vspace, target_tensor_ids, output_gradients,                                 tensor_tape_, state.op_tape, &gradients);     while (!op_stack.empty()) {       获得一个op，从state.op_tape擦除之       获取输出的梯度（上游梯度）       计算输入的梯度（下游梯度）。大部分操作是使用CallBackwardFunction来完成       对每个输入张量，看它是哪些op的输出张量，将该op“未计算梯度的输出张量”的计数减1。当该计数降为0时，这个op相当于出度为0，可以放入op_stack     }     聚合所有源向量的梯度   }      

         Optimizer.minimize   |---Optimizer.compute_gradients       |---GradientTape.gradient           |---imperative_grad               |---TFE_Py_TapeGradient (python/eager/pywrap_tfe_src.cc)                   |---GradientTape<>::ComputeGradient (c/eager/tape.h)