Method apply_fn

tensorflow/python/training/optimizer.py:661–736

()

    name = name if name is not None else self.get_name()
    grads_and_vars = tuple(grads_and_vars)  # Make sure repeat iteration works.
    def apply_fn():
      # No DistributionStrategy case.
      if not grads_and_vars:
        raise ValueError("No variables provided.")
      converted_grads_and_vars = []
      for g, v in grads_and_vars:
        if g is not None:
          try:
            # Convert the grad to Tensor or IndexedSlices if necessary.
            g = ops.convert_to_tensor_or_indexed_slices(g)
          except TypeError:
            raise TypeError(
                "Gradient must be convertible to a Tensor"
                " or IndexedSlices, or None: %s" % g)
          if not isinstance(g, (ops.Tensor, ops.IndexedSlices)):
            raise TypeError(
                "Gradient must be a Tensor, IndexedSlices, or None: %s" % g)
        p = _get_processor(v)
        converted_grads_and_vars.append((g, v, p))

      converted_grads_and_vars = tuple(converted_grads_and_vars)
      var_list = [v for g, v, _ in converted_grads_and_vars if g is not None]
      if not var_list:
        raise ValueError("No gradients provided for any variable: %s." %
                         ([str(v) for _, v, _ in converted_grads_and_vars],))
      with ops.init_scope():
        self._create_slots(var_list)
      update_ops = []
      with ops.name_scope(name, self._name) as sname:
        self._prepare()
        for grad, var, processor in converted_grads_and_vars:
          if grad is None:
            continue
          # We colocate all ops created in _apply_dense or _apply_sparse
          # on the same device as the variable.
          # TODO(apassos): figure out how to get the variable name here.
          if (context.executing_eagerly() or
              isinstance(var, resource_variable_ops.BaseResourceVariable)
              and not var._in_graph_mode):  # pylint: disable=protected-access
            scope_name = ""
          else:
            scope_name = var.op.name
          with ops.name_scope("update_" + scope_name), ops.colocate_with(var):
            update_ops.append(processor.update_op(self, grad))
            if (not context.executing_eagerly()) and isinstance(grad, ops.IndexedSlices):
              var._is_sparse = True
              update_ops.append(gen_io_ops.record_sparse_indices(grad.indices, var_name=scope_name))
              for slot_name in self.get_slot_names():
                slot = self.get_slot(var, slot_name)
                slot._is_sparse = True
                update_ops.append(gen_io_ops.record_sparse_indices(grad.indices, var_name=slot.op.name))
        if global_step is None:
          apply_updates = self._finish(update_ops, sname)
        else:
          with ops.control_dependencies([self._finish(update_ops, "update")]):
            with ops.colocate_with(global_step):
              if isinstance(global_step, resource_variable_ops.ResourceVariable):
                # TODO(apassos): the implicit read in assign_add is slow; consider