Generalize the constraint for score_calibration in ImageClassifier

Major changes:
(1) Use the default_score value from Metadata instead of always falling back to `kDefaultCalibratedScore` (-1), which was defined in ImageClassifier.
(2) Removed the check for kMinCalibratedScore and kMaxCalibratedScore. First, it doesn't make sense to restrict the calibrated score to [0, 1]. The calibrated score is bounded by [0, scale]. Second, ComputeCalibratedScore returns either the default_score or the calibrated score derived from the sigmoid function. Therefore, it's redundant to check the value range once more in ImageClassifier.

PiperOrigin-RevId: 398850436

Author: lu-wang-g

tensorflow_lite_support/cc/task/vision/image_classifier.cc

@@ -46,26 +46,6 @@ using ::tflite::task::core::AssertAndReturnTypedTensor;
 using ::tflite::task::core::TaskAPIFactory;
 using ::tflite::task::core::TfLiteEngine;
 
-// Default score value used as a fallback for classes that (1) have no score
-// calibration data or (2) have a very low confident uncalibrated score, i.e.
-// lower than the `min_uncalibrated_score` threshold.
-//
-// (1) This happens when the ScoreCalibration does not cover all the classes
-// listed in the label map. This can be used to enforce the blacklisting of
-// given classes so that they are never returned.
-//
-// (2) This is an optional threshold provided part of the calibration data. It
-// is used to mitigate false alarms on some classes.
-//
-// In both cases, a class that gets assigned a score of -1 is never returned as
-// it gets discarded by the `score_threshold` check (see post-processing logic).
-constexpr float kDefaultCalibratedScore = -1.0f;
-
-// Calibrated scores should be in the [0, 1] range, otherwise an error is
-// returned at post-processing time.
-constexpr float kMinCalibratedScore = 0.0f;
-constexpr float kMaxCalibratedScore = 1.0f;
-
 }  // namespace
 
 /* static */
@@ -378,12 +358,6 @@ absl::Status ImageClassifier::InitScoreCalibrations() {
       continue;
     }
 
-    // Use a specific default score instead of the one specified by default in
-    // cc/task/vision/utils/score_calibration.h. See `kDefaultCalibratedScore`
-    // documentation for more details.
-    classification_heads_[i].calibration_params->default_score =
-        kDefaultCalibratedScore;
-
     score_calibrations_[i] = absl::make_unique<ScoreCalibration>();
     if (score_calibrations_[i] == nullptr) {
       return CreateStatusWithPayload(
@@ -453,23 +427,20 @@ StatusOr<ClassificationResult> ImageClassifier::Postprocess(
       for (auto& score_pair : score_pairs) {
         const std::string& class_name =
             head.label_map_items[score_pair.first].name;
+
+        // In ComputeCalibratedScore, score_pair.second is set to the
+        // default_score value from metadata [1] if the category (1) has no
+        // score calibration data or (2) has a very low confident uncalibrated
+        // score, i.e. lower than the `min_uncalibrated_score` threshold.
+        // Otherwise, score_pair.second is calculated based on the selected
+        // score transformation function, and the value is guaranteed to be in
+        // the range of [0, scale], where scale is a label-dependent sigmoid
+        // parameter.
+        //
+        // [1]:
+        // https://github.com/tensorflow/tflite-support/blob/af26cb6952ccdeee0e849df2b93dbe7e57f6bc48/tensorflow_lite_support/metadata/metadata_schema.fbs#L453
         score_pair.second = score_calibrations_[i]->ComputeCalibratedScore(
             class_name, score_pair.second);
-        if (score_pair.second > kMaxCalibratedScore) {
-          return CreateStatusWithPayload(
-              StatusCode::kInternal,
-              absl::StrFormat("calibrated score is too high: got %f, expected "
-                              "%f as maximum.",
-                              score_pair.second, kMaxCalibratedScore));
-        }
-        if (score_pair.second != kDefaultCalibratedScore &&
-            score_pair.second < kMinCalibratedScore) {
-          return CreateStatusWithPayload(
-              StatusCode::kInternal,
-              absl::StrFormat("calibrated score is too low: got %f, expected "
-                              "%f as minimum.",
-                              score_pair.second, kMinCalibratedScore));
-        }
       }
     }
 

tensorflow_lite_support/cc/task/vision/utils/score_calibration.cc

@@ -14,6 +14,7 @@ limitations under the License.
 ==============================================================================*/
 #include "tensorflow_lite_support/cc/task/vision/utils/score_calibration.h"
 
+#include <algorithm>
 #include <cmath>
 #include <memory>
 #include <utility>
@@ -95,6 +96,17 @@ StatusOr<Sigmoid> SigmoidFromLabelAndLine(absl::string_view label,
           TfLiteSupportStatus::kMetadataMalformedScoreCalibrationError);
     }
   }
+
+  // Verify if scale is a non-negative value.
+  if (float_params[0] < 0) {
+    return CreateStatusWithPayload(
+        StatusCode::kInvalidArgument,
+        absl::StrFormat(
+            "Expected scale to be a non-negative value, but got %f.",
+            float_params[0]),
+        TfLiteSupportStatus::kMetadataMalformedScoreCalibrationError);
+  }
+
   Sigmoid sigmoid;
   sigmoid.label = std::string(label);
   sigmoid.scale = float_params[0];
@@ -160,13 +172,20 @@ float ScoreCalibration::ComputeCalibratedScore(const std::string& label,
 
   // For numerical stability use 1 / (1+exp(-x)) when scale_shifted_score >= 0
   // and exp(x) / (1+exp(x)) when scale_shifted_score < 0.
+  float calibrated_score;
   if (scale_shifted_score >= 0.0) {
-    return sigmoid.value().scale /
-           (1.0 + std::exp(static_cast<double>(-scale_shifted_score)));
+    calibrated_score =
+        sigmoid.value().scale /
+        (1.0 + std::exp(static_cast<double>(-scale_shifted_score)));
   } else {
     float score_exp = std::exp(static_cast<double>(scale_shifted_score));
-    return sigmoid.value().scale * score_exp / (1.0 + score_exp);
+    calibrated_score = sigmoid.value().scale * score_exp / (1.0 + score_exp);
   }
+  // Scale is non-negative (checked in SigmoidFromLabelAndLine),
+  // thus calibrated_score should be in the range of [0, scale]. However, due to
+  // numberical stability issue, it may fall out of the boundary. Cap the value
+  // to [0, scale] instead.
+  return std::max(std::min(calibrated_score, sigmoid.value().scale), 0.0f);
 }
 
 absl::optional<Sigmoid> ScoreCalibration::FindSigmoidParameters(