Add aten::lop10/log1p/log2 and their variants

src/ATen/native/xpu/UnaryOps.cpp

@@ -198,6 +198,72 @@ Tensor& XPUNativeFunctions::log_out(const Tensor& self, Tensor& out) {
   return out;
 }
 
+Tensor XPUNativeFunctions::log10(const Tensor& self) {
+  Tensor out;
+  TensorIterator iter;
+  iter.build_borrowing_unary_float_op(out, self);
+  native::xpu::log10_kernel(iter);
+  return iter.output();
+}
+
+Tensor& XPUNativeFunctions::log10_(Tensor& self) {
+  TensorIterator iter;
+  iter.build_borrowing_unary_float_op(self, self);
+  native::xpu::log10_kernel(iter);
+  return self;
+}
+
+Tensor& XPUNativeFunctions::log10_out(const Tensor& self, Tensor& out) {
+  TensorIterator iter;
+  iter.build_borrowing_unary_float_op(out, self);
+  native::xpu::log10_kernel(iter);
+  return out;
+}
+
+Tensor XPUNativeFunctions::log1p(const Tensor& self) {
+  Tensor out;
+  TensorIterator iter;
+  iter.build_borrowing_unary_float_op(out, self);
+  native::xpu::log1p_kernel(iter);
+  return iter.output();
+}
+
+Tensor& XPUNativeFunctions::log1p_(Tensor& self) {
+  TensorIterator iter;
+  iter.build_borrowing_unary_float_op(self, self);
+  native::xpu::log1p_kernel(iter);
+  return self;
+}
+
+Tensor& XPUNativeFunctions::log1p_out(const Tensor& self, Tensor& out) {
+  TensorIterator iter;
+  iter.build_borrowing_unary_float_op(out, self);
+  native::xpu::log1p_kernel(iter);
+  return out;
+}
+
+Tensor XPUNativeFunctions::log2(const Tensor& self) {
+  Tensor out;
+  TensorIterator iter;
+  iter.build_borrowing_unary_float_op(out, self);
+  native::xpu::log2_kernel(iter);
+  return iter.output();
+}
+
+Tensor& XPUNativeFunctions::log2_(Tensor& self) {
+  TensorIterator iter;
+  iter.build_borrowing_unary_float_op(self, self);
+  native::xpu::log2_kernel(iter);
+  return self;
+}
+
+Tensor& XPUNativeFunctions::log2_out(const Tensor& self, Tensor& out) {
+  TensorIterator iter;
+  iter.build_borrowing_unary_float_op(out, self);
+  native::xpu::log2_kernel(iter);
+  return out;
+}
+
 Tensor XPUNativeFunctions::sqrt(const Tensor& self) {
   Tensor out;
   TensorIterator iter;

src/ATen/native/xpu/XPUFallback.template

@@ -240,9 +240,6 @@ TORCH_LIBRARY_IMPL(aten, XPU, m) {
     "linalg_solve_triangular",
     "_linalg_svd.U",
     "linspace.out",
-    "log10.out",
-    "log1p.out",
-    "log2.out",
     "logaddexp2.out",
     "logaddexp.out",
     "_logcumsumexp",

src/ATen/native/xpu/sycl/UnaryLogKernels.cpp

@@ -36,4 +36,52 @@ void log_kernel(TensorIteratorBase& iter) {
   }
 }
 
+template <typename scalar_t>
+struct Log10Functor {
+  scalar_t operator()(scalar_t x) const {
+    return std::log10(x);
+  }
+};
+
+void log10_kernel(TensorIteratorBase& iter) {
+  AT_DISPATCH_FLOATING_AND_COMPLEX_TYPES_AND2(
+      ScalarType::Half,
+      ScalarType::BFloat16,
+      iter.common_dtype(),
+      "log10_xpu",
+      [&]() { gpu_kernel(iter, Log10Functor<scalar_t>()); });
+}
+
+template <typename scalar_t>
+struct Log1pFunctor {
+  scalar_t operator()(scalar_t x) const {
+    return std::log1p(x);
+  }
+};
+
+void log1p_kernel(TensorIteratorBase& iter) {
+  AT_DISPATCH_FLOATING_AND_COMPLEX_TYPES_AND2(
+      ScalarType::Half,
+      ScalarType::BFloat16,
+      iter.common_dtype(),
+      "log1p_xpu",
+      [&]() { gpu_kernel(iter, Log1pFunctor<scalar_t>()); });
+}
+
+template <typename scalar_t>
+struct Log2Functor {
+  scalar_t operator()(scalar_t x) const {
+    return std::log2(x);
+  }
+};
+
+void log2_kernel(TensorIteratorBase& iter) {
+  AT_DISPATCH_FLOATING_AND_COMPLEX_TYPES_AND2(
+      ScalarType::Half,
+      ScalarType::BFloat16,
+      iter.common_dtype(),
+      "log2_xpu",
+      [&]() { gpu_kernel(iter, Log2Functor<scalar_t>()); });
+}
+
 } // namespace at::native::xpu

src/ATen/native/xpu/sycl/UnaryLogKernels.h

@@ -6,4 +6,10 @@ namespace at::native::xpu {
 
 void log_kernel(TensorIteratorBase& iter);
 
+void log10_kernel(TensorIteratorBase& iter);
+
+void log1p_kernel(TensorIteratorBase& iter);
+
+void log2_kernel(TensorIteratorBase& iter);
+
 } // namespace at::native::xpu

test/xpu/extended/run_test_with_skip.py

@@ -13,6 +13,10 @@
     "test_compare_cpu_cumsum_xpu_bfloat16",
     "test_compare_cpu_cumsum_xpu_float16",
     "test_compare_cpu_log_xpu_complex64",
+    "test_compare_cpu_log10_xpu_complex64",
+    "test_compare_cpu_log1p_xpu_complex64",
+    "test_compare_cpu_log2_xpu_complex64",
+    "test_compare_cpu_log2_xpu_complex128",
     "test_compare_cpu_mul_xpu_complex64",
     "test_compare_cpu_pow_xpu_complex128",
     "test_compare_cpu_pow_xpu_complex64",

test/xpu/run_test_with_skip.py

@@ -38,8 +38,6 @@ def launch_test(test_case, skip_list=None, exe_list=None):
 res = 0
 
 # test_ops
-
-
 skip_list = (
     # Skip list of base line
     "test_dtypes___rmod___xpu",
@@ -794,6 +792,14 @@ def launch_test(test_case, skip_list=None, exe_list=None):
     # in XPU supported operators. Then the case will work.
     "test_noncontiguous_samples_nn_functional_avg_pool1d_xpu_int64",
     "test_noncontiguous_samples_nn_functional_local_response_norm_xpu_int64",
+
+    # Numeric difference
+    # https://github.com/intel/torch-xpu-ops/issues/544
+    # Mismatched elements: 7 / 1048576 (0.0%)
+    # Greatest absolute difference: 0.4922053598013041 at index (765, 860) (up to 1e-07 allowed)
+    # Greatest relative difference: 0.15330001655652495 at index (765, 860) (up to 1e-07 allowed)
+    "test_python_ref__refs_log2_xpu_complex128",
+
     # torch.complex32 - "sinh_cpu" not implemented for 'ComplexHalf'
     "test_dtypes_cosh_xpu",
 )
@@ -1520,6 +1526,10 @@ def launch_test(test_case, skip_list=None, exe_list=None):
     "test_reference_numerics_extremal_asin_xpu_complex64",
     "test_reference_numerics_large__refs_acosh_xpu_complex64",
     "test_reference_numerics_large_acosh_xpu_complex64",
+    "test_reference_numerics_extremal__refs_log10_xpu_complex64",
+    "test_reference_numerics_extremal__refs_log1p_xpu_complex64",
+    "test_reference_numerics_extremal_log10_xpu_complex64",
+    "test_reference_numerics_extremal_log1p_xpu_complex64",
     "test_reference_numerics_extremal__refs_tan_xpu_complex128",
     "test_reference_numerics_extremal__refs_tan_xpu_complex64",
     "test_reference_numerics_extremal_tan_xpu_complex128",
@@ -1547,6 +1557,13 @@ def launch_test(test_case, skip_list=None, exe_list=None):
     # Failed: Unexpected success
     "test_reference_numerics_large__refs_rsqrt_xpu_complex32",
     "test_reference_numerics_large_rsqrt_xpu_complex32",
+
+    # Numeric difference
+    # https://github.com/intel/torch-xpu-ops/issues/544
+    # Expected 0.00497517 but got 0.00497520063072443.
+    # Absolute difference: 3.063072442997111e-08 (up to 0.0 allowed)
+    # Relative difference: 6.156719153309558e-06 (up to 1e-06 allowed)
+    "test_log1p_complex_xpu_complex64",
 )
 res += launch_test("test_unary_ufuncs_xpu.py", skip_list)
 

test/xpu/xpu_test_utils.py

@@ -77,6 +77,9 @@
     "isnan",
     "le",
     "log",
+    "log10",
+    "log1p",
+    "log2",
     "lt",
     "logical_and",
     "logical_or",

yaml/xpu_functions.yaml

@@ -175,6 +175,15 @@ supported:
   - log
   - log_
   - log.out
+  - log10
+  - log10_
+  - log10.out
+  - log1p
+  - log1p_
+  - log1p.out
+  - log2
+  - log2_
+  - log2.out
   - logical_and
   - logical_and_
   - logical_and.out