create internal versions of exp and log to ensure identical cross platform results

Author: paulbkoch

python/interpret-core/interpret/utils/_native.py

@@ -265,7 +265,7 @@ def flat_mean(self, vals, weights=None):
                 msg = "vals and weights must have the same shape to call flat_mean."
                 raise Exception(msg)
 
-        n_tensor_bins = math.prod(vals.shape)
+        n_tensor_bins = prod(vals.shape)
 
         mean_result = ct.c_double(np.nan)
 
@@ -341,6 +341,18 @@ def safe_stddev(self, tensor, weights=None):
 
         return stddev_result
 
+    def safe_exp(self, vals):
+        self._unsafe.SafeExp(
+            prod(vals.shape),
+            Native._make_pointer(vals, np.float64, None),
+        )
+
+    def safe_log(self, vals):
+        self._unsafe.SafeLog(
+            prod(vals.shape),
+            Native._make_pointer(vals, np.float64, None),
+        )
+
     def create_rng(self, random_state):
         if random_state is None:
             return None  # non-deterministic
@@ -1096,6 +1108,22 @@ def _initialize(self, is_debug):
         ]
         self._unsafe.SafeStandardDeviation.restype = ct.c_int32
 
+        self._unsafe.SafeExp.argtypes = [
+            # int64_t count
+            ct.c_int64,
+            # double * inout
+            ct.c_void_p,
+        ]
+        self._unsafe.SafeExp.restype = None
+
+        self._unsafe.SafeLog.argtypes = [
+            # int64_t count
+            ct.c_int64,
+            # double * inout
+            ct.c_void_p,
+        ]
+        self._unsafe.SafeLog.restype = None
+
         self._unsafe.MeasureRNG.argtypes = []
         self._unsafe.MeasureRNG.restype = ct.c_int64
 

shared/libebm/bridge/bridge.h

@@ -213,6 +213,9 @@ INTERNAL_IMPORT_EXPORT_INCLUDE ErrorEbm CreateMetric_Cpu_64(
       //   MetricWrapper * const pMetricWrapperOut,
 );
 
+INTERNAL_IMPORT_EXPORT_INCLUDE void Exp_Cpu_64(const size_t c, double* const a);
+INTERNAL_IMPORT_EXPORT_INCLUDE void Log_Cpu_64(const size_t c, double* const a);
+
 INTERNAL_IMPORT_EXPORT_INCLUDE double FinishMetricC(
       const ObjectiveWrapper* const pObjectiveWrapper, const double metricSum);
 INTERNAL_IMPORT_EXPORT_INCLUDE BoolEbm CheckTargetsC(

shared/libebm/compute/cpu_ebm/cpu_64.cpp

@@ -519,4 +519,26 @@ INTERNAL_IMPORT_EXPORT_BODY ErrorEbm CreateMetric_Cpu_64(
    return Error_UnexpectedInternal;
 }
 
+INTERNAL_IMPORT_EXPORT_BODY void Exp_Cpu_64(const size_t c, double* const a) {
+   double* p = a;
+   double* aEnd = a + c;
+   while(aEnd != p) {
+      Cpu_64_Float val = Cpu_64_Float::Load(p);
+      val = Exp(val);
+      val.Store(p);
+      p += Cpu_64_Float::k_cSIMDPack;
+   }
+}
+
+INTERNAL_IMPORT_EXPORT_BODY void Log_Cpu_64(const size_t c, double* const a) {
+   double* p = a;
+   double* aEnd = a + c;
+   while(aEnd != p) {
+      Cpu_64_Float val = Cpu_64_Float::Load(p);
+      val = Log(val);
+      val.Store(p);
+      p += Cpu_64_Float::k_cSIMDPack;
+   }
+}
+
 } // namespace DEFINED_ZONE_NAME

shared/libebm/inc/libebm.h

@@ -322,6 +322,9 @@ EBM_API_INCLUDE ErrorEbm EBM_CALLING_CONVENTION SafeMean(
 EBM_API_INCLUDE ErrorEbm EBM_CALLING_CONVENTION SafeStandardDeviation(
       IntEbm countBags, IntEbm countTensorBins, const double* vals, const double* weights, double* tensorOut);
 
+EBM_API_INCLUDE void EBM_CALLING_CONVENTION SafeExp(IntEbm count, double* inout);
+EBM_API_INCLUDE void EBM_CALLING_CONVENTION SafeLog(IntEbm count, double* inout);
+
 EBM_API_INCLUDE IntEbm EBM_CALLING_CONVENTION MeasureRNG(void);
 EBM_API_INCLUDE void EBM_CALLING_CONVENTION InitRNG(SeedEbm seed, void* rngOut);
 EBM_API_INCLUDE void EBM_CALLING_CONVENTION CopyRNG(void* rng, void* rngOut);

shared/libebm/interpretable_numerics.cpp

@@ -1772,6 +1772,62 @@ EBM_API_BODY ErrorEbm EBM_CALLING_CONVENTION SafeStandardDeviation(
    return Error_None;
 }
 
+EBM_API_BODY void EBM_CALLING_CONVENTION SafeExp(IntEbm count, double* inout) {
+   if(count <= IntEbm{0}) {
+      if(count < IntEbm{0}) {
+         LOG_0(Trace_Error, "ERROR SafeExp count < IntEbm{0}");
+      }
+      return;
+   }
+   if(IsConvertError<size_t>(count)) {
+      LOG_0(Trace_Error, "ERROR SafeExp IsConvertError<size_t>(count)");
+      return;
+   }
+   const size_t c = static_cast<size_t>(count);
+
+   if(IsMultiplyError(sizeof(*inout), c)) {
+      LOG_0(Trace_Error, "ERROR SafeExp IsMultiplyError(sizeof(*inout), c)");
+      return;
+   }
+
+   if(nullptr == inout) {
+      LOG_0(Trace_Error, "ERROR SafeExp nullptr == inout");
+      return;
+   }
+
+   Exp_Cpu_64(c, inout);
+
+   // TODO: add a SIMD version here
+}
+
+EBM_API_BODY void EBM_CALLING_CONVENTION SafeLog(IntEbm count, double* inout) {
+   if(count <= IntEbm{0}) {
+      if(count < IntEbm{0}) {
+         LOG_0(Trace_Error, "ERROR SafeLog count < IntEbm{0}");
+      }
+      return;
+   }
+   if(IsConvertError<size_t>(count)) {
+      LOG_0(Trace_Error, "ERROR SafeLog IsConvertError<size_t>(count)");
+      return;
+   }
+   const size_t c = static_cast<size_t>(count);
+
+   if(IsMultiplyError(sizeof(*inout), c)) {
+      LOG_0(Trace_Error, "ERROR SafeLog IsMultiplyError(sizeof(*inout), c)");
+      return;
+   }
+
+   if(nullptr == inout) {
+      LOG_0(Trace_Error, "ERROR SafeLog nullptr == inout");
+      return;
+   }
+
+   Log_Cpu_64(c, inout);
+
+   // TODO: add a SIMD version here
+}
+
 // we don't care if an extra log message is outputted due to the non-atomic nature of the decrement to this value
 static int g_cLogEnterGetHistogramCutCount = 25;
 static int g_cLogExitGetHistogramCutCount = 25;

shared/libebm/libebm_exports.def

@@ -8,6 +8,8 @@ EXPORTS
   SafeSum
   SafeMean
   SafeStandardDeviation
+  SafeExp
+  SafeLog
   MeasureRNG
   InitRNG
   CopyRNG

shared/libebm/libebm_exports.txt

@@ -7,6 +7,8 @@
       SafeSum;
       SafeMean;
       SafeStandardDeviation;
+      SafeExp;
+      SafeLog;
       MeasureRNG;
       InitRNG;
       CopyRNG;