diff --git a/torch_npu/csrc/aten/common/TensorFactories.cpp b/torch_npu/csrc/aten/common/TensorFactories.cpp
index 756018645026337bac14019313689dc1d0cb5ebb..27be7c30824c7deab84bf1b6f30ee24b7cc4d616 100644
--- a/torch_npu/csrc/aten/common/TensorFactories.cpp
+++ b/torch_npu/csrc/aten/common/TensorFactories.cpp
@@ -309,13 +309,10 @@ namespace at_npu
         c10::optional<c10::MemoryFormat> optional_memory_format)
     {
 
-      c10::TensorOptions options;
-      auto device = device_or_default(device_opt);
-      options = options.dtype(dtype_opt)
-                       .device(device)
-                       .layout(layout_opt)
-                       .pinned_memory(pin_memory_opt);
-
+      c10::TensorOptions options = c10::TensorOptions().dtype(dtype_opt)
+                                                       .device(device)
+                                                       .layout(layout_opt)
+                                                       .pinned_memory(pin_memory_opt);
       return at_npu::native::empty_like_npu(self, options, optional_memory_format);
     }
 
@@ -419,12 +416,10 @@ namespace at_npu
                                                      int64_t dst_format)
     {
       caffe2::TypeMeta dtype = c10::scalarTypeToTypeMeta(dtype_or_default(dtype_opt));
-      c10::TensorOptions options;
-      auto device = device_or_default(device_opt);
-      options = options.dtype(dtype_opt)
-                       .device(device)
-                       .layout(layout_opt)
-                       .pinned_memory(pin_memory_opt);
+      c10::TensorOptions options = c10::TensorOptions().dtype(dtype_opt)
+                                                       .device(device)
+                                                       .layout(layout_opt)
+                                                       .pinned_memory(pin_memory_opt);
       at::Tensor result = OpPreparation::ApplyTensorWithFormat(size, options, dst_format);
       if (names.has_value())
       {
@@ -514,12 +509,10 @@ namespace at_npu
                                                    c10::optional<bool> pin_memory_opt)
     {
 
-      c10::TensorOptions options;
-      auto device = device_or_default(device_opt);
-      options = options.dtype(dtype_opt)
-                       .device(device)
-                       .layout(layout_opt)
-                       .pinned_memory(pin_memory_opt);
+      c10::TensorOptions options = c10::TensorOptions().dtype(dtype_opt)
+                                                       .device(device)
+                                                       .layout(layout_opt)
+                                                       .pinned_memory(pin_memory_opt);
 
       window_function_checks("blackman_window", options, window_length);
       if (window_length == 0)
@@ -558,12 +551,10 @@ namespace at_npu
         c10::optional<bool> pin_memory_opt)
     {
 
-      c10::TensorOptions options;
-      auto device = device_or_default(device_opt);
-      options = options.dtype(dtype_opt)
-                       .device(device)
-                       .layout(layout_opt)
-                       .pinned_memory(pin_memory_opt);
+      c10::TensorOptions options = c10::TensorOptions().dtype(dtype_opt)
+                                                       .device(device)
+                                                       .layout(layout_opt)
+                                                       .pinned_memory(pin_memory_opt);
 
       window_function_checks("bartlett_window", options, window_length);
       if (window_length == 0)
@@ -604,12 +595,10 @@ namespace at_npu
         c10::optional<bool> pin_memory_opt)
     {
 
-      c10::TensorOptions options;
-      auto device = device_or_default(device_opt);
-      options = options.dtype(dtype_opt)
-                       .device(device)
-                       .layout(layout_opt)
-                       .pinned_memory(pin_memory_opt);
+      c10::TensorOptions options = c10::TensorOptions().dtype(dtype_opt)
+                                                       .device(device)
+                                                       .layout(layout_opt)
+                                                       .pinned_memory(pin_memory_opt);
 
       window_function_checks("hann_window", options, window_length);
       return at::hamming_window(window_length, periodic, 0.5, 0.5, options);
@@ -636,12 +625,10 @@ namespace at_npu
         c10::optional<bool> pin_memory_opt)
     {
 
-      c10::TensorOptions options;
-      auto device = device_or_default(device_opt);
-      options = options.dtype(dtype_opt)
-                       .device(device)
-                       .layout(layout_opt)
-                       .pinned_memory(pin_memory_opt);
+      c10::TensorOptions options = c10::TensorOptions().dtype(dtype_opt)
+                                                       .device(device)
+                                                       .layout(layout_opt)
+                                                       .pinned_memory(pin_memory_opt);
 
       window_function_checks("hamming_window", options, window_length);
       if (window_length == 0)
@@ -753,12 +740,10 @@ namespace at_npu
         c10::optional<at::Device> device_opt,
         c10::optional<bool> pin_memory_opt)
     {
-      c10::TensorOptions options;
-      auto device = device_or_default(device_opt);
-      options = options.dtype(dtype_opt)
-                       .device(device)
-                       .layout(layout_opt)
-                       .pinned_memory(pin_memory_opt);
+      c10::TensorOptions options = c10::TensorOptions().dtype(dtype_opt)
+                                                       .device(device)
+                                                       .layout(layout_opt)
+                                                       .pinned_memory(pin_memory_opt);
       TORCH_CHECK(
           options.layout() != at::kSparse,
           "full(...) is not implemented for sparse layout");
diff --git a/torch_npu/csrc/aten/ops/ArangeKernelNpu.cpp b/torch_npu/csrc/aten/ops/ArangeKernelNpu.cpp
index 494594327d438733d23a9a6ebb0005c747e13e20..a4619b997ff47a4d9404e68efc3d6b569da7e769 100644
--- a/torch_npu/csrc/aten/ops/ArangeKernelNpu.cpp
+++ b/torch_npu/csrc/aten/ops/ArangeKernelNpu.cpp
@@ -40,9 +40,9 @@ at::Tensor& arange_out_npu_nocheck(
     at::Scalar step) {
   OpCommand cmd;
   cmd.Name("Range")
-     .Input(start, result.scalar_type())
-     .Input(end, result.scalar_type())
-     .Input(step, result.scalar_type())
+     .Input(start, result.scalar_type(), CompileType::MEMORY_HOST_COMPILE_DEPENDENT)
+     .Input(end, result.scalar_type(), CompileType::MEMORY_HOST_COMPILE_DEPENDENT)
+     .Input(step, result.scalar_type(), CompileType::MEMORY_HOST_COMPILE_DEPENDENT)
      .Output(result)
      .Run();
 
@@ -58,13 +58,10 @@ at::Tensor NPUNativeFunctions::arange(
     c10::optional<at::Device> device_opt,
     c10::optional<bool> pin_memory_opt) {
 
-  auto device = device_or_default(device_opt);
-  at::TensorOptions option;
-  option = option.dtype(dtype_opt)
-                 .layout(layout_opt)
-                 .device(device)
-                 .pinned_memory(pin_memory_opt);
-
+  c10::TensorOptions option = c10::TensorOptions().dtype(dtype_opt)
+                                                       .device(device)
+                                                       .layout(layout_opt)
+                                                       .pinned_memory(pin_memory_opt);
   float start_value = CalcuOpUtil::get_scalar_float_value(start);
   float end_value = CalcuOpUtil::get_scalar_float_value(end);
   float step_value = CalcuOpUtil::get_scalar_float_value(step);
diff --git a/torch_npu/csrc/aten/ops/FullKernelNpu.cpp b/torch_npu/csrc/aten/ops/FullKernelNpu.cpp
index 8f644cbc0f9e59dd62593602c1b3505e305dfc07..20d64edc007cc84d46ad54959f3bf1a0b6428137 100644
--- a/torch_npu/csrc/aten/ops/FullKernelNpu.cpp
+++ b/torch_npu/csrc/aten/ops/FullKernelNpu.cpp
@@ -37,13 +37,11 @@ at::Tensor NPUNativeFunctions::full(
     c10::optional<at::Layout> layout_opt,
     c10::optional<at::Device> device_opt,
     c10::optional<bool> pin_memory_opt) {
-  c10::TensorOptions option;
-  auto device = device_or_default(device_opt);
-  option = option.dtype(dtype_opt)
-                 .device(device)
-                 .layout(layout_opt)
-                 .pinned_memory(pin_memory_opt);
-  at::Tensor result = OpPreparation::ApplyTensorWithSizes(size, option);
+  c10::TensorOptions options = c10::TensorOptions().dtype(dtype_opt)
+                                                       .device(device)
+                                                       .layout(layout_opt)
+                                                       .pinned_memory(pin_memory_opt);
+  at::Tensor result = OpPreparation::ApplyTensorWithSizes(size, options);
   return result.fill_(fill_value);
 }
 
diff --git a/torch_npu/csrc/aten/ops/RangeKernelNpu.cpp b/torch_npu/csrc/aten/ops/RangeKernelNpu.cpp
index df65f925d39f9a84819d0c68a1199f45a1bc5451..7dd3ae8c28caebfa9487dd89cf803f8c8862b426 100644
--- a/torch_npu/csrc/aten/ops/RangeKernelNpu.cpp
+++ b/torch_npu/csrc/aten/ops/RangeKernelNpu.cpp
@@ -55,13 +55,11 @@ at::Tensor NPUNativeFunctions::range(
     c10::optional<at::Layout> layout_opt,
     c10::optional<at::Device> device_opt,
     c10::optional<bool> pin_memory_opt) {
-  auto device = device_or_default(device_opt);
-  c10::TensorOptions option;
-  option = option.dtype(dtype_opt)
-                 .device(device)
-                 .layout(layout_opt)
-                 .pinned_memory(pin_memory_opt);
-  return at::range(start, end, 1, option);
+  c10::TensorOptions options = c10::TensorOptions().dtype(dtype_opt)
+                                                       .device(device_opt)
+                                                       .layout(layout_opt)
+                                                       .pinned_memory(pin_memory_opt);
+  return at::range(start, end, 1, options);
 }
 
 at::Tensor NPUNativeFunctions::range(
@@ -72,12 +70,10 @@ at::Tensor NPUNativeFunctions::range(
     c10::optional<at::Layout> layout_opt,
     c10::optional<at::Device> device_opt,
     c10::optional<bool> pin_memory_opt) {
-  auto device = device_or_default(device_opt);
-  c10::TensorOptions option;
-  option = option.dtype(dtype_opt)
-                 .device(device)
-                 .layout(layout_opt)
-                 .pinned_memory(pin_memory_opt);
+  c10::TensorOptions options = c10::TensorOptions().dtype(dtype_opt)
+                                                       .device(device)
+                                                       .layout(layout_opt)
+                                                       .pinned_memory(pin_memory_opt);
 
   float start_value = CalcuOpUtil::get_scalar_float_value(start);
   float end_value = CalcuOpUtil::get_scalar_float_value(end);
@@ -88,7 +84,7 @@ at::Tensor NPUNativeFunctions::range(
       "upper bound and larger bound inconsistent with step sign");
 
   auto outputSize = range_npu_output_size(start_value, end_value, step_value);
-  at::Tensor result = OpPreparation::ApplyTensorWithFormat(outputSize, option, ACL_FORMAT_NCHW);
+  at::Tensor result = OpPreparation::ApplyTensorWithFormat(outputSize, options, ACL_FORMAT_NCHW);
   return range_out_nocheck(start, end, step, result);
 }