Add aten::sign/signbit and their variants

src/ATen/native/xpu/UnaryOps.cpp

@@ -530,6 +530,71 @@ Tensor& XPUNativeFunctions::sigmoid_out(const Tensor& self, Tensor& out) {
   return out;
 }
 
+Tensor XPUNativeFunctions::sign(const Tensor& self) {
+  TORCH_CHECK(
+      !self.is_complex(),
+      "Unlike NumPy, torch.sign is not intended to support complex numbers. Please use torch.sgn instead.");
+  Tensor out;
+  TensorIterator iter;
+  iter.build_borrowing_unary_op(out, self);
+  native::xpu::sign_kernel(iter);
+  return iter.output();
+}
+
+Tensor& XPUNativeFunctions::sign_(Tensor& self) {
+  TORCH_CHECK(
+      !self.is_complex(),
+      "Unlike NumPy, torch.sign is not intended to support complex numbers. Please use torch.sgn instead.");
+  TensorIterator iter;
+  iter.build_borrowing_unary_op(self, self);
+  native::xpu::sign_kernel(iter);
+  return self;
+}
+
+Tensor& XPUNativeFunctions::sign_out(const Tensor& self, Tensor& out) {
+  TORCH_CHECK(
+      !self.is_complex(),
+      "Unlike NumPy, torch.sign is not intended to support complex numbers. Please use torch.sgn instead.");
+  TensorIterator iter;
+  iter.build_borrowing_unary_op(out, self);
+  native::xpu::sign_kernel(iter);
+  return out;
+}
+
+Tensor XPUNativeFunctions::signbit(const Tensor& self) {
+  TORCH_CHECK(
+      !self.is_complex(), "signbit is not implemented for complex tensors.");
+
+  Tensor out;
+  TensorIterator iter;
+  iter.build_borrowing_unary_force_boolean_op(out, self);
+
+  if (self.dtype() == at::kBool) {
+    iter.output().fill_(false);
+  } else {
+    native::xpu::signbit_kernel(iter);
+  }
+  return iter.output();
+}
+
+Tensor& XPUNativeFunctions::signbit_out(const Tensor& self, Tensor& out) {
+  TORCH_CHECK(
+      !self.is_complex(), "signbit is not implemented for complex tensors.");
+  TORCH_CHECK(
+      out.dtype() == at::kBool,
+      "signbit does not support non-boolean outputs.");
+
+  TensorIterator iter;
+  iter.build_borrowing_unary_force_boolean_op(out, self);
+
+  if (self.dtype() == at::kBool) {
+    out.fill_(false);
+  } else {
+    native::xpu::signbit_kernel(iter);
+  }
+  return out;
+}
+
 Tensor& XPUNativeFunctions::logit_out(
     const Tensor& self,
     std::optional<double> eps,

src/ATen/native/xpu/XPUFallback.template

@@ -247,8 +247,6 @@ TORCH_LIBRARY_IMPL(aten, XPU, m) {
     "_scaled_mm",
     "segment_reduce",
     "_segment_reduce_backward",
-    "signbit.out",
-    "sign.out",
     "sinc.out",
     "special_airy_ai.out",
     "special_bessel_j0.out",

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

@@ -54,6 +54,35 @@ void sign_kernel(TensorIteratorBase& iter) {
   }
 }
 
+template <typename scalar_t>
+struct SignbitIntFunctor {
+  bool operator()(scalar_t a) const {
+    return is_negative(a);
+  }
+};
+
+template <typename scalar_t>
+struct SignbitFunctor {
+  bool operator()(scalar_t a) const {
+    using opmath_t = at::opmath_type<scalar_t>;
+    return std::signbit(opmath_t{a});
+  }
+};
+
+void signbit_kernel(TensorIteratorBase& iter) {
+  // NOTE: signbit does not always support integral arguments.
+  if (at::isIntegralType(iter.input_dtype(), /*includeBool=*/false)) {
+    AT_DISPATCH_INTEGRAL_TYPES(iter.input_dtype(), "signbit_xpu", [&]() {
+      gpu_kernel(iter, SignbitIntFunctor<scalar_t>());
+    });
+  } else {
+    AT_DISPATCH_FLOATING_TYPES_AND2(
+        kBFloat16, ScalarType::Half, iter.input_dtype(), "signbit_xpu", [&]() {
+          gpu_kernel(iter, SignbitFunctor<scalar_t>());
+        });
+  }
+}
+
 template <typename scalar_t>
 struct LogicalNotFunctor {
   scalar_t operator()(scalar_t a) const {

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

@@ -12,4 +12,6 @@ void sgn_kernel(TensorIteratorBase& iter);
 
 void sign_kernel(TensorIteratorBase& iter);
 
+void signbit_kernel(TensorIteratorBase& iter);
+
 } // namespace at::native::xpu

test/xpu/run_test_with_skip.py

@@ -2240,6 +2240,12 @@ def launch_test(test_case, skip_list=None, exe_list=None):
     "test_scaled_mm_vs_emulated_float16_xpu",
     "test_scaled_mm_vs_emulated_float32_xpu",
     "test_scaled_mm_vs_emulated_row_wise_bfloat16_xpu",
+
+    # https://github.com/intel/torch-xpu-ops/issues/676
+    # Mismatched elements: 9 / 1003002 (0.0%)
+    # Greatest absolute difference: 711.126220703125 at index (472, 999) (up to 0.1 allowed)
+    # Greatest relative difference: 2.7107455730438232 at index (472, 997) (up to 0.1 allowed)
+    "test_cublas_addmm_size_1000_xpu_float32",
 )
 res += launch_test("test_matmul_cuda_xpu.py", skip_list=skip_list)
 

test/xpu/xpu_test_utils.py

@@ -190,6 +190,8 @@
     "sigmoid",
     "logsigmoid",
     "sgn",
+    "sign",
+    "signbit",
     "round",
     "nn.functional.embedding_bag",
     "bucketize",

yaml/xpu_functions.yaml

@@ -470,6 +470,11 @@ supported:
   - sigmoid
   - sigmoid.out
   - sigmoid_
+  - sign
+  - sign.out
+  - sign_
+  - signbit
+  - signbit.out
   - sigmoid_backward.grad_input
   - sigmoid_backward
   - hardsigmoid.out