for (auto globalTensor : module.getOps<tf_saved_model::GlobalTensorOp>()) {
    auto exportedNames = tf_saved_model::GetExportedNames(globalTensor);
    std::string name;
    if (exportedNames.empty()) {
      name = "global_ml_" + globalTensor.getSymName().str();
    } else if (exportedNames.size() == 1) {
      name = exportedNames[0].str();
    } else {
      return globalTensor.emitError()

namespace calibrator {

void CalibrationStatisticsCollectorMinMax::ClearData() {
  // global_min will be updated by std::min(global_min, input_value) so
  // it is initialized with the value numeric_limits<float>::max().
  min_max_statistics_.set_global_min(std::numeric_limits<float>::max());

  // global_max will be updated by std::max(global_max, input_value) so it
  // is initialized with the value numeric_limits<float>::lowest().

// Calibration algorithm's collecting statistics.
// NEXT_ID: 4
message CalibrationStatistics {
  message MinMaxStatistics {
    // global minimum of all sample datasets.
    float global_min = 1;

    // global maximum of all sample datasets.
    float global_max = 2;
  }

  message AverageMinMaxStatistics {
    // sum of batch's minimum in each sample dataset.
    float min_sum = 1;

  std::optional<CalibrationStatistics> statistics = collector.GetStatistics();

  EXPECT_TRUE(statistics.has_value());
  EXPECT_EQ(statistics.value().min_max_statistics().global_min(), -5.0f);
  EXPECT_EQ(statistics.value().min_max_statistics().global_max(), 10.0f);
}

TEST(CalibrationStatisticsCollectorTest, SimpleAverageMinMax) {
  auto collector = CalibrationStatisticsCollectorAverageMinMax();

  collector.Collect(

        calibration_method=_CalibrationMethod.CALIBRATION_METHOD_MIN_MAX
    )
    statistics = calib_stats_pb2.CalibrationStatistics()
    statistics.min_max_statistics.global_min = 1.0
    statistics.min_max_statistics.global_max = 5.0

    min_value, max_value = calibration_algorithm.get_min_max_value(
        statistics, calib_opts
    )
    self.assertAllEqual((min_value, max_value), (1.0, 5.0))

  const CalibrationStatistics& stats = statistics_map.statistics().at("1");
  ASSERT_TRUE(stats.has_min_max_statistics());
  EXPECT_FLOAT_EQ(stats.min_max_statistics().global_min(), 1.f);
  EXPECT_FLOAT_EQ(stats.min_max_statistics().global_max(), 5.f);
}

TEST_F(CalibrationStatisticsSaverTest, SimpleAverageMinMax) {
  std::vector<std::string> ids{"1"};
  std::vector<int32_t> calibration_methods{

    Returns:
      (min_value, max_value): Min and max calculated using MinMax
    """
    return (
        self._statistics.min_max_statistics.global_min,
        self._statistics.min_max_statistics.global_max,
    )


@_implements(_CalibrationMethod.CALIBRATION_METHOD_AVERAGE_MIN_MAX)
class _AverageMinMax(_CalibrationAlgorithmBase):

  // compute streams used in each XLA device. It is only used if
  // `use_global_compute_stream` in `XlaDevice::Options` is set to true.
  static mutex global_mu_;
  static std::vector<std::shared_ptr<se::Stream>>* global_compute_streams_
      TF_GUARDED_BY(global_mu_);
};

// Builds OpKernel registrations on 'device' for the JIT operators
// registered on 'jit_device'. Returns ownership of a XlaDeviceOpRegistrations

                                           const Metadata** metadata) {
  return GetMetadataFromDevice(ctx->device(), metadata);
}

/* static */ mutex XlaDevice::global_mu_(LINKER_INITIALIZED);
/* static */ std::vector<std::shared_ptr<se::Stream>>*
    XlaDevice::global_compute_streams_ =
        new std::vector<std::shared_ptr<se::Stream>>;