inference-engine/samples/calibration_tool/data_stats.cpp

   1 // Copyright (C) 2018 Intel Corporation
   2 //
   3 // SPDX-License-Identifier: Apache-2.0
   4 //
   5
   6 #include <stdlib.h>
   7 #include <cfloat>
   8 #include <cmath>
   9 #include <stdint.h>
  10 #include <iostream>
  11 #include <limits>
  12 #include <vector>
  13 #include <algorithm>
  14 #include <string>
  15
  16 #include "data_stats.h"
  17
  18
  19 TensorStatistic::TensorStatistic(float* data, size_t count, size_t nbuckets) {
  20     _min = std::numeric_limits<float>::max();
  21     _max = std::numeric_limits<float>::min();
  22     for (size_t i = 0; i < count; i++) {
  23         float val = static_cast<float>(data[i]);
  24         if (_min > val) {
  25             _min = val;
  26         }
  27
  28         if (_max < val) {
  29             _max = val;
  30         }
  31     }
  32
  33     if (_min == _max) {
  34         return;
  35     }
  36 }
  37
  38 float TensorStatistic::getMaxValue() const {
  39     return _max;
  40 }
  41
  42
  43 float TensorStatistic::getMinValue() const {
  44     return _min;
  45 }
  46
  47 std::vector<std::string> AggregatedDataStats::registeredLayers() {
  48     std::vector<std::string> layers;
  49     for (auto l : _data) {
  50         layers.push_back(l.first);
  51     }
  52     return layers;
  53 }
  54
  55 void AggregatedDataStats::registerLayer(std::string layer) {
  56     _data[layer];
  57 }
  58
  59 void AggregatedDataStats::addTensorStatistics(const std::string& name, size_t channel, float* data, size_t count) {
  60     auto&& byChannel = _data[name];
  61     byChannel[channel].push_back(TensorStatistic(data, count));
  62 }
  63
  64 void AggregatedDataStats::addTensorStatistics(const std::string &name, size_t channel, uint8_t *data, size_t count) {
  65     std::vector<float> intermediate;
  66     for (size_t i = 0; i < count; i++) {
  67         intermediate.push_back(data[i]);
  68     }
  69     addTensorStatistics(name, channel, intermediate.data(), count);
  70 }
  71
  72 size_t AggregatedDataStats::getNumberChannels(const std::string& name) const {
  73     auto it = _data.find(name);
  74     if (it != _data.end()) {
  75         return it->second.size();
  76     }
  77     return 0;
  78 }
  79
  80 void AggregatedDataStats::getDataMinMax(const std::string& name, size_t channel, float& min, float& max, float threshold) {
  81     // take data by name
  82     auto it = _data.find(name);
  83     if (it != _data.end()) {
  84         auto stats = it->second[channel];
  85         // having absolute min/max values, we can create new statistic
  86         std::vector<float> maxValues;
  87         std::vector<float> minValues;
  88         for (size_t i = 0; i < stats.size(); i++) {
  89             const TensorStatistic& tsS = stats[i];
  90             maxValues.push_back(tsS.getMaxValue());
  91             minValues.push_back(tsS.getMinValue());
  92         }
  93         // define number of elements to throw out
  94         size_t elementToTake = maxValues.size() * threshold / 100;
  95         int elementsToThrow = maxValues.size() - elementToTake;
  96         std::sort(maxValues.begin(), maxValues.end());
  97         std::sort(minValues.begin(), minValues.end());
  98
  99         min = minValues[elementsToThrow];
 100         max = maxValues[elementToTake - 1];
 101     } else {
 102         min = max = 0.f;
 103     }
 104 }
 105