Update on "[Executorch][Portable] Dont upcast to double for sigmoid"

Upcasting to double for compute precision may not be aten compliant.

Reason for internal test change:
Apparently running on broadwell CPU vs test runner with Cooper lake gives
different results for this change.

Without this change:
Both broadwell and Cooper lake will produce "Once upon a time, there was a
little"

With this change:
Broadwell still produces "Once upon a time, there was a little", while
Cooperlake produces "Once upon a time, there was a girl".

So one possibility is that that some XNNPACK kernel for Cooper lake is produces
slightly different numerical result that propagates through.

Still landing this change since upcasting to double for compute, does not seem
necessary.

Differential Revision: [D65928920](https://our.internmc.facebook.com/intern/diff/D65928920/)

[ghstack-poisoned]

Author: kimishpatel

kernels/portable/cpu/op_sigmoid.cpp

@@ -36,32 +36,26 @@ Tensor& sigmoid_out(KernelRuntimeContext& ctx, const Tensor& in, Tensor& out) {
       out,
       "Failed to resize output tensor.");
 
-  ScalarType common_type = in.scalar_type();
-  ScalarType compute_type = utils::get_compute_type(common_type);
-  // For integer types, we need to promote to the next higher float type
-  if (compute_type != ScalarType::Float && compute_type != ScalarType::Double) {
-    compute_type = ScalarType::Float;
-  }
+  ScalarType compute_type =
+      executorch::runtime::isFloatingType(in.scalar_type()) ? in.scalar_type()
+                                                            : ScalarType::Float;
+  compute_type = utils::get_compute_type(compute_type);
 
   // @lint-ignore CLANGTIDY facebook-hte-CArray
   static constexpr const char op_name[] = "sigmoid.out";
 
-  ET_KERNEL_CHECK(
-      ctx, executorch::runtime::isRealType(compute_type), InvalidArgument, out);
-
-  ET_SWITCH_REALB_TYPES(compute_type, ctx, op_name, CTYPE_COMPUTE, [&]() {
+  ET_SWITCH_FLOAT_TYPES(compute_type, ctx, op_name, CTYPE_COMPUTE, [&]() {
     utils::apply_unitensor_elementwise_fn<CTYPE_COMPUTE, op_name>(
         [](const CTYPE_COMPUTE val_in) {
-          CTYPE_COMPUTE in_casted = static_cast<CTYPE_COMPUTE>(val_in);
           CTYPE_COMPUTE out_val = static_cast<CTYPE_COMPUTE>(1.0) /
-              (static_cast<CTYPE_COMPUTE>(1.0) + exp(-in_casted));
+              (static_cast<CTYPE_COMPUTE>(1.0) + exp(-val_in));
           return out_val;
         },
         ctx,
         in,
         utils::SupportedTensorDtypes::REALHBBF16,
         out,
-        utils::SupportedTensorDtypes::REALHBBF16);
+        utils::SupportedTensorDtypes::FLOATHBF16);
   });
 
   return out;