filter infinity value when calculate average score

Author: BigBigMiao

src/Microsoft.ML.AutoML/Experiment/Runners/CrossValRunner.cs

@@ -69,8 +69,8 @@ public CrossValRunner(MLContext context,
 
         private static double CalcAverageScore(IEnumerable<double> scores)
         {
-            var newScores = scores.Where(r => !double.IsNaN(r));
-            // Return NaN iff all scores are NaN
+            var newScores = scores.Where(r => !double.IsNaN(r) && !double.IsInfinity(r));
+            // Return NaN iff all scores are NaN or infinity.
             if (newScores.Count() == 0)
                 return double.NaN;
             return newScores.Average();

src/Microsoft.ML.AutoML/Experiment/Runners/CrossValSummaryRunner.cs

@@ -80,7 +80,7 @@ public CrossValSummaryRunner(MLContext context,
             var bestModel = trainResults.ElementAt(bestFoldIndex).model;
 
             // Get the average metrics across all folds
-            var avgScore = GetAverageOfNonNaNScores(trainResults.Select(x => x.score));
+            var avgScore = GetAverageOfNonNaNAndNonInfinityScores(trainResults.Select(x => x.score));
             var indexClosestToAvg = GetIndexClosestToAverage(trainResults.Select(r => r.score), avgScore);
             var metricsClosestToAvg = trainResults[indexClosestToAvg].metrics;
             var avgMetrics = GetAverageMetrics(trainResults.Select(x => x.metrics), metricsClosestToAvg);
@@ -99,14 +99,14 @@ private static TMetrics GetAverageMetrics(IEnumerable<TMetrics> metrics, TMetric
                 Contracts.Assert(newMetrics != null);
 
                 var result = new BinaryClassificationMetrics(
-                    auc: GetAverageOfNonNaNScores(newMetrics.Select(x => x.AreaUnderRocCurve)),
-                    accuracy: GetAverageOfNonNaNScores(newMetrics.Select(x => x.Accuracy)),
-                    positivePrecision: GetAverageOfNonNaNScores(newMetrics.Select(x => x.PositivePrecision)),
-                    positiveRecall: GetAverageOfNonNaNScores(newMetrics.Select(x => x.PositiveRecall)),
-                    negativePrecision: GetAverageOfNonNaNScores(newMetrics.Select(x => x.NegativePrecision)),
-                    negativeRecall: GetAverageOfNonNaNScores(newMetrics.Select(x => x.NegativeRecall)),
-                    f1Score: GetAverageOfNonNaNScores(newMetrics.Select(x => x.F1Score)),
-                    auprc: GetAverageOfNonNaNScores(newMetrics.Select(x => x.AreaUnderPrecisionRecallCurve)),
+                    auc: GetAverageOfNonNaNAndNonInfinityScores(newMetrics.Select(x => x.AreaUnderRocCurve)),
+                    accuracy: GetAverageOfNonNaNAndNonInfinityScores(newMetrics.Select(x => x.Accuracy)),
+                    positivePrecision: GetAverageOfNonNaNAndNonInfinityScores(newMetrics.Select(x => x.PositivePrecision)),
+                    positiveRecall: GetAverageOfNonNaNAndNonInfinityScores(newMetrics.Select(x => x.PositiveRecall)),
+                    negativePrecision: GetAverageOfNonNaNAndNonInfinityScores(newMetrics.Select(x => x.NegativePrecision)),
+                    negativeRecall: GetAverageOfNonNaNAndNonInfinityScores(newMetrics.Select(x => x.NegativeRecall)),
+                    f1Score: GetAverageOfNonNaNAndNonInfinityScores(newMetrics.Select(x => x.F1Score)),
+                    auprc: GetAverageOfNonNaNAndNonInfinityScores(newMetrics.Select(x => x.AreaUnderPrecisionRecallCurve)),
                     // Return ConfusionMatrix from the fold closest to average score
                     confusionMatrix: (metricsClosestToAvg as BinaryClassificationMetrics).ConfusionMatrix);
                 return result as TMetrics;
@@ -118,12 +118,12 @@ private static TMetrics GetAverageMetrics(IEnumerable<TMetrics> metrics, TMetric
                 Contracts.Assert(newMetrics != null);
 
                 var result = new MulticlassClassificationMetrics(
-                    accuracyMicro: GetAverageOfNonNaNScores(newMetrics.Select(x => x.MicroAccuracy)),
-                    accuracyMacro: GetAverageOfNonNaNScores(newMetrics.Select(x => x.MacroAccuracy)),
-                    logLoss: GetAverageOfNonNaNScores(newMetrics.Select(x => x.LogLoss)),
-                    logLossReduction: GetAverageOfNonNaNScores(newMetrics.Select(x => x.LogLossReduction)),
+                    accuracyMicro: GetAverageOfNonNaNAndNonInfinityScores(newMetrics.Select(x => x.MicroAccuracy)),
+                    accuracyMacro: GetAverageOfNonNaNAndNonInfinityScores(newMetrics.Select(x => x.MacroAccuracy)),
+                    logLoss: GetAverageOfNonNaNAndNonInfinityScores(newMetrics.Select(x => x.LogLoss)),
+                    logLossReduction: GetAverageOfNonNaNAndNonInfinityScores(newMetrics.Select(x => x.LogLossReduction)),
                     topKPredictionCount: newMetrics.ElementAt(0).TopKPredictionCount,
-                    topKAccuracy: GetAverageOfNonNaNScores(newMetrics.Select(x => x.TopKAccuracy)),
+                    topKAccuracy: GetAverageOfNonNaNAndNonInfinityScores(newMetrics.Select(x => x.TopKAccuracy)),
                     // Return PerClassLogLoss and ConfusionMatrix from the fold closest to average score
                     perClassLogLoss: (metricsClosestToAvg as MulticlassClassificationMetrics).PerClassLogLoss.ToArray(),
                     confusionMatrix: (metricsClosestToAvg as MulticlassClassificationMetrics).ConfusionMatrix);
@@ -136,23 +136,29 @@ private static TMetrics GetAverageMetrics(IEnumerable<TMetrics> metrics, TMetric
                 Contracts.Assert(newMetrics != null);
 
                 var result = new RegressionMetrics(
-                    l1: GetAverageOfNonNaNScores(newMetrics.Select(x => x.MeanAbsoluteError)),
-                    l2: GetAverageOfNonNaNScores(newMetrics.Select(x => x.MeanSquaredError)),
-                    rms: GetAverageOfNonNaNScores(newMetrics.Select(x => x.RootMeanSquaredError)),
-                    lossFunction: GetAverageOfNonNaNScores(newMetrics.Select(x => x.LossFunction)),
-                    rSquared: GetAverageOfNonNaNScores(newMetrics.Select(x => x.RSquared)));
+                    l1: GetAverageOfNonNaNAndNonInfinityScores(newMetrics.Select(x => x.MeanAbsoluteError)),
+                    l2: GetAverageOfNonNaNAndNonInfinityScores(newMetrics.Select(x => x.MeanSquaredError)),
+                    rms: GetAverageOfNonNaNAndNonInfinityScores(newMetrics.Select(x => x.RootMeanSquaredError)),
+                    lossFunction: GetAverageOfNonNaNAndNonInfinityScores(newMetrics.Select(x => x.LossFunction)),
+                    rSquared: GetAverageOfNonNaNAndNonInfinityScores(newMetrics.Select(x => x.RSquared)));
                 return result as TMetrics;
             }
 
             throw new NotImplementedException($"Metric {typeof(TMetrics)} not implemented");
         }
 
-        private static double GetAverageOfNonNaNScores(IEnumerable<double> results)
+        /// <summary>
+        /// return the average of non-nan and non-infinity scores from <paramref name="results"/>, if all scores are nan/infinity, nan will be returned.
+        /// </summary>
+        /// <param name="results"></param>
+        /// <returns></returns>
+        private static double GetAverageOfNonNaNAndNonInfinityScores(IEnumerable<double> results)
         {
-            var newResults = results.Where(r => !double.IsNaN(r));
-            // Return NaN iff all scores are NaN
+            var newResults = results.Where(r => !double.IsNaN(r) && !double.IsInfinity(r));
+            // Return NaN iff all scores are NaN or Infinity
             if (newResults.Count() == 0)
                 return double.NaN;
+
             // Return average of non-NaN scores otherwise
             return newResults.Average(r => r);
         }