Remove unnecessary tensor clone (pytorch#148159)

Fixes #ISSUE_NUMBER

Pull Request resolved: pytorch#148159
Approved by: https://github.com/Skylion007

Author: cyyever

aten/src/ATen/functorch/BatchRulesScatterOps.cpp

@@ -1155,7 +1155,9 @@ std::tuple<Tensor, std::optional<int64_t>> index_fill_int_scalar_batch_rule_impl
     return std::make_tuple(self_, 0);
   }
 
-  self_ = self_bdim.has_value() ? self_ : self_.clone();
+  if (!self_bdim.has_value()) {
+    self_ = self_.clone();
+  }
 
   return index_fill_batch_rule_helper(batch_size, self_logical_rank, index_logical_rank, self_, dim, index_, value);
 }
@@ -1209,7 +1211,9 @@ std::tuple<Tensor, std::optional<int64_t>> index_fill_int_tensor_batch_rule_impl
     return std::make_tuple(self_, 0);
   }
 
-  self_ = self_bdim.has_value() ? self_ : self_.clone();
+  if (!self_bdim.has_value()) {
+    self_ = self_.clone();
+  }
 
   // calling .item() on value is safe here because value is guaranteed to not be a batched tensor.
   return index_fill_batch_rule_helper(batch_size, self_logical_rank, index_logical_rank, self_, dim, index_, value.item());

aten/src/ATen/native/mps/operations/Inverse.mm

@@ -19,7 +19,7 @@
     TORCH_WARN_ONCE(
         "torch.linalg_inv_ex.inverse is supported by MPS on MacOS 13+, please upgrade. Falling back to CPU.");
     auto cpu_info = at::empty({0}, kInt, std::nullopt, kCPU, std::nullopt, std::nullopt);
-    auto cpu_result = result.clone().to("cpu");
+    auto cpu_result = result.to("cpu");
     at::linalg_inv_ex_out(cpu_result, cpu_info, A.to("cpu"));
     info.copy_(cpu_info);
     result.copy_(cpu_result);

aten/src/ATen/native/sparse/SparseCsrTensorMath.cpp

@@ -344,7 +344,7 @@ Tensor sparse_mask_sparse_compressed(
   }
 
   if (!mask.numel() || !mask._nnz()) {
-    return mask.clone().to(self.device(), self.scalar_type());
+    return mask.to(self.device(), self.scalar_type(), /*non_blocking=*/false, /*copy=*/true);
   }
 
   if (self.layout() == kStrided) {

aten/src/ATen/native/sparse/SparseTensor.cpp

@@ -795,7 +795,7 @@ SparseTensor sparse_mask(const Tensor& t, const SparseTensor& mask) {
 
   if (t.layout() == at::kSparse) {
     if (!t._nnz()) {
-      auto res = mask.clone().to(t.device(), t.scalar_type());
+      auto res = mask.to(t.device(), t.scalar_type(), /*non_blocking=*/false, /*copy=*/true);
       res._values().zero_();
       return res;
     }

torch/csrc/api/include/torch/nn/module.h

@@ -689,11 +689,11 @@ void Module::to_impl(Ts&&... ts) {
   }
   // Then move every parameter to the new dtype/device.
   for (auto& parameter : named_parameters(/*recurse=*/false)) {
-    parameter->set_data(autograd::Variable(*parameter).to(ts...));
+    parameter->set_data(parameter->to(ts...));
   }
   // Then move every buffer to the new dtype/device.
   for (auto& buffer : named_buffers(/*recurse=*/false)) {
-    buffer->set_data(autograd::Variable(*buffer).to(ts...));
+    buffer->set_data(buffer->to(ts...));
   }
 }
 

torch/csrc/distributed/c10d/reducer.cpp

@@ -2315,14 +2315,14 @@ void verify_params_across_processes(
     }
   }
 
-  auto metadata_dev = metadata.clone().to(params[0].device());
-  std::vector<at::Tensor> vec{metadata_dev};
+  metadata = metadata.to(params[0].device());
+  std::vector<at::Tensor> vec{metadata};
   process_group->broadcast(vec)->wait();
 
   // Technically, process 0 doesn't need to double-check metadata, because it
   // was the source.  But no harm keeping work aligned.
   auto control = at::empty({static_cast<long>(i)}, options);
-  control.copy_(metadata_dev, /*non_blocking=*/false);
+  control.copy_(metadata, /*non_blocking=*/false);
   auto control_accessor = control.accessor<int64_t, 1>();
   i = 0;
   for (const auto p : c10::irange(params.size())) {

torch/csrc/jit/python/python_ir.cpp

@@ -756,8 +756,7 @@ void initPythonIRBindings(PyObject* module_) {
           [](Node& n, const char* name, const at::Tensor& v) {
             return n.t_(
                 Symbol::attr(name),
-                autograd::Variable(v.view(std::vector<int64_t>{}))
-                    .set_requires_grad(false));
+                v.view(std::vector<int64_t>{}).set_requires_grad(false));
           })
       .def(
           "z",
@@ -782,8 +781,7 @@ void initPythonIRBindings(PyObject* module_) {
           "zs_",
           [](Node& n, const char* name, TensorsAttr::ValueType v) {
             for (auto& i : v) {
-              i = autograd::Variable(i.view(std::vector<int64_t>{}))
-                      .set_requires_grad(false);
+              i = i.view(std::vector<int64_t>{}).set_requires_grad(false);
             }
             return n.ts_(Symbol::attr(name), std::move(v));
           })

torch/csrc/jit/runtime/argument_spec.h

@@ -101,7 +101,7 @@ struct ArgumentSpec {
     const at::Tensor* t = reinterpret_cast<const at::Tensor*>(&input);
     arg.defined_ = t->defined();
     if (arg.defined_) {
-      arg.requires_grad_ = with_grad && autograd::Variable(*t).requires_grad();
+      arg.requires_grad_ = with_grad && t->requires_grad();
       arg.dim_ = t->dim();
       at::Device device = t->device();
       arg.dev_type_ =

torch/csrc/jit/runtime/graph_executor.cpp

@@ -322,9 +322,8 @@ struct DifferentiableGraphBackward : public autograd::Node {
   }
 
   void addOutputForTensor(const at::Tensor& tensor) {
-    auto v = Variable(tensor);
     add_next_edge(
-        v.defined() ? torch::autograd::impl::gradient_edge(v)
+        tensor.defined() ? torch::autograd::impl::gradient_edge(tensor)
                     : autograd::Edge{});
   }
   void addOutputForIValue(const IValue& value) {

torch/csrc/jit/tensorexpr/kernel.cpp

@@ -1448,7 +1448,7 @@ void TensorExprKernel::bindConstant(const torch::jit::Value* v) {
       ToDtype(scalar_type));
 
   if (!const_tensor.is_contiguous()) {
-    const_tensor = const_tensor.clone().contiguous();
+    const_tensor = const_tensor.clone(at::MemoryFormat::Contiguous);
     unpacked_constant_tensors_.push_back(const_tensor);
   }
 

torch/testing/_internal/common_utils.py

@@ -2297,7 +2297,7 @@ def to_gpu(obj, type_map=None):
         assert obj.is_leaf
         t = type_map.get(obj.dtype, obj.dtype)
         with torch.no_grad():
-            res = obj.clone().to(dtype=t, device="cuda")
+            res = obj.to(dtype=t, device="cuda", copy=True)
             res.requires_grad = obj.requires_grad
         return res
     elif torch.is_storage(obj):