| #include <torch/csrc/autograd/variable.h> |
| |
| namespace torch { |
| namespace autograd { |
| |
| using at::Tensor; |
| |
| // [Forward Grad View/inplace] |
| // It is important to us to allow view and inplace to work with dual Tensors. These operations |
| // should either compute the right gradient or raise a user-friendly error. |
| |
| // The basic case where all Tensors are dual Tensors is as follows: |
| // # Have: |
| // # foo is a dual Tensor that is not a view |
| // # bar is a dual Tensor of appropriate size (depending on cases) that is not a view |
| // |
| // # Case 1: no view |
| // foo.copy_(bar) |
| // |
| // # Case 2: with view, propagate from view to base |
| // view = foo[0] |
| // view.copy_(bar) |
| // |
| // # Case 3: with view, propagate from base to view |
| // view = foo[0] |
| // foo.copy_(bar) |
| // |
| // # In both cases, the forward grad of foo must be properly updated. |
| // # In the second and third cases, the forward grad of view must match |
| // # the one of foo for the subset they have in common. |
| // |
| // All these cases can be handled by the following layout constraint on the forward grad: |
| // - A Tensor and its forward grad (for all levels) must have the same metadata (size, stride |
| // and storage offset). Storage offset must be in this metadata because of as_strided. |
| // - View operations must create a forward grad that is a view of the base's forward grad. |
| // - Inplace operations must modify the input's forward grad inplace. |
| // |
| // This layout constraint is ensured in the `set_fw_grad` function below |
| |
| |
| // More complex cases arrise when non-dual Tensor interact with dual Tensors. |
| // The two most important cases are: |
| // |
| // # Have: |
| // # foo is a regular Tensor that is not a view |
| // # bar is a dual Tensor of appropriate size (depending on cases) that is not a view |
| // |
| // # Case 4: Changes on the view must propagate to its base |
| // view = foo[0] |
| // # view is still a regular Tensor here |
| // view.copy_(bar) |
| // # Now both view and foo are dual Tensor with appropriate forward grad |
| // |
| // # Case 5: Changes on the base must propagate on all its views |
| // view = foo[0] |
| // # view is still a regular Tensor here |
| // base.copy_(bar) |
| // # Now both view and foo are dual Tensor with appropriate forward grad |
| // |
| // # NB there is a case 6 involving changes on a view propagating to other views |
| // # but it is fully described by the two others and is skipped in this discussion. |
| // |
| // Case 4 is handled by set_fw_grad by properly setting the forward grad of the base if needed. |
| // Case 5 is handled in fw_grad by reading the forward grad from the base if needed. |
| |
| |
| namespace { |
| // Check if two Tensor have the same storage offset, sizes and strides |
| bool has_same_meta(const Variable& base, const Variable& other) { |
| if (!base.defined() || !other.defined()) { |
| return false; |
| } |
| if (base.storage_offset() != other.storage_offset()) { |
| return false; |
| } |
| if (base.dim() != other.dim()) { |
| return false; |
| } |
| for (int64_t i=0; i<base.dim(); ++i) { |
| if (base.sizes()[i] != other.sizes()[i]) { |
| return false; |
| } |
| if (base.strides()[i] != other.strides()[i]) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| Tensor new_with_same_meta(const Variable& base) { |
| // We need to create a storage of the same size to be able to have the same |
| // viewing behavior in all cases |
| // Explicit type here to appease Windows build |
| int64_t nelement_in_storage = base.storage().nbytes() / base.itemsize(); |
| auto new_tensor = at::zeros({nelement_in_storage}, base.options()); |
| auto res = new_tensor.as_strided(base.sizes(), base.strides(), base.storage_offset()); |
| return res; |
| } |
| } // anonymous namespace |
| |
| // This function is will ensure that the fw_grad_ is properly a view of the base for inplace ops on |
| // Tensors that do not have forward grad originally. |
| void AutogradMeta::set_fw_grad(const Variable& new_grad_, const Variable& self, uint64_t level, bool is_inplace_op) { |
| // Lazy initialization |
| { |
| std::lock_guard<std::mutex> lock(mutex_); |
| if (!fw_grad_) { |
| fw_grad_ = std::make_shared<ForwardGrad>(); |
| } |
| } |
| if (fw_grad_->contains(level)) { |
| // Setting the forward grad again is only allowed if it is a no-op. |
| // We do allow this case to simplify writing codegen for inplace ops. |
| TORCH_INTERNAL_ASSERT(new_grad_.defined(), "Cannot set a forward grad that is an undefined Tensor. Use " |
| "_fw_primal(level) to get a new Tensor with this forward grad unset."); |
| |
| TORCH_INTERNAL_ASSERT(is_inplace_op, "Only inplace operations can re-set the forward grad of a Tensor that " |
| "already has one."); |
| |
| TORCH_INTERNAL_ASSERT(fw_grad_->value(level).is_same(new_grad_), "Cannot set a value of a forward grad if it " |
| "already exists. Inplace operations should modify it inplace."); |
| } else { |
| // TODO(alband) remove this spurious version counter bump |
| auto new_grad = new_grad_; |
| |
| if (is_inplace_op && is_view_) { |
| auto this_view_meta = static_cast<DifferentiableViewMeta*>(this); |
| |
| // For inplace ops on a Tensor that does not already have a forward grad and is a view, we propagate |
| // the tangent to the base and ensure that the new_grad is a view of that base's tangent. |
| // This ensure that case 4 from [Forward Grad View/inplace] above works fine |
| // What happens in this long if statement is: |
| // - Check if the base already has a grad |
| // - If not, set a new fw_grad for it full of zeros |
| // - Take a view of the base's forward grad |
| // - Copy the given new_grad into this view |
| // - Use this view as the new new_grad |
| if (this_view_meta->has_fw_view()) { |
| auto view_info = this_view_meta->get_forward_view(); |
| auto& base = view_info.base_; |
| |
| if (!base.fw_grad(level).defined()) { |
| // Enforce same meta here to make sure that the view op below is always valid |
| Tensor new_base_fw_grad; |
| if (has_same_meta(new_grad, base)) { |
| // TODO extend this special case to when the underlying storage of new_grad |
| // can be re-used. |
| new_base_fw_grad = new_grad; |
| } else { |
| new_base_fw_grad = new_with_same_meta(base); |
| |
| // Update new_grad to be a view of the base |
| Tensor new_fw_grad_value; |
| if (view_info.has_view_fn()) { |
| new_fw_grad_value = view_info.view_fn()(new_base_fw_grad); |
| } else { |
| new_fw_grad_value = new_base_fw_grad.as_strided(self.sizes(), self.strides(), self.storage_offset()); |
| } |
| |
| new_fw_grad_value.copy_(new_grad); |
| new_grad = new_fw_grad_value; |
| } |
| |
| base.set_fw_grad(new_base_fw_grad, level, /* is_inplace_op */ false); |
| } |
| } |
| } |
| |
| // Enforce the basic layout constraint |
| if (!has_same_meta(new_grad, self)) { |
| Tensor new_grad_with_meta = new_with_same_meta(self); |
| new_grad_with_meta.copy_(new_grad); |
| new_grad = new_grad_with_meta; |
| } |
| |
| fw_grad_->set_value(new_grad, level); |
| } |
| } |
| |
| const Variable& AutogradMeta::fw_grad(uint64_t level, const Variable& self) const { |
| // Ensure that concurent fw_grad() "reads" are thread safe |
| std::lock_guard<std::mutex> lock(mutex_); |
| |
| const auto& direct_fw_grad = fw_grad_ ? fw_grad_->value(level) : ForwardGrad::undef_grad(); |
| |
| if (!direct_fw_grad.defined() && is_view_) { |
| // For view that don't have a forward grad, check if their base has one that |
| // has been defined by an inplace operation. |
| // This ensure that case 5 from [Forward Grad View/inplace] above works fine |
| auto const_view_meta = static_cast<const torch::autograd::DifferentiableViewMeta*>(this); |
| // This is ok to do as we ONLY modify fw_grad_ and this field is properly locked in all methods |
| // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast) |
| auto this_view_meta = const_cast<torch::autograd::DifferentiableViewMeta*>(const_view_meta); |
| if (this_view_meta->has_fw_view()) { |
| const auto& view_info = this_view_meta->get_forward_view(); |
| const auto& base = view_info.base_; |
| |
| const auto& base_val = base.fw_grad(level); |
| if (base_val.defined()) { |
| // Lazy initialization of fw_grad_ |
| this_view_meta->fw_grad_ = std::make_shared<ForwardGrad>(); |
| |
| Variable new_val; |
| if (view_info.has_view_fn()) { |
| new_val = view_info.view_fn()(base_val); |
| } else { |
| new_val = base_val.as_strided(self.sizes(), self.strides(), self.storage_offset()); |
| } |
| |
| this_view_meta->fw_grad_->set_value(new_val, level); |
| return this_view_meta->fw_grad_->value(level); |
| } |
| } |
| } |
| return direct_fw_grad; |
| } |
| |
| }} // torch::autograd |
