label_image 예제를 보면 get_top_n 에서
(prediction[i] + 128) / 256.0 나 prediction[i] / 255.0
같은 quantization 범위에 맞춘 무언가가 보이는데
TfLiteQuantizationParams.scale 와 TfLiteQuantizationParams.zero_point을 이용하면 자동화 가능할 느낌.
template <class T>
void get_top_n(T* prediction, int prediction_size, size_t num_results,
float threshold, std::vector<std::pair<float, int>>* top_results,
TfLiteType input_type) {
// Will contain top N results in ascending order.
std::priority_queue<std::pair<float, int>, std::vector<std::pair<float, int>>,
std::greater<std::pair<float, int>>>
top_result_pq;
const long count = prediction_size; // NOLINT(runtime/int)
float value = 0.0;
for (int i = 0; i < count; ++i) {
switch (input_type) {
case kTfLiteFloat32:
value = prediction[i];
break;
case kTfLiteInt8:
value = (prediction[i] + 128) / 256.0;
break;
case kTfLiteUInt8:
value = prediction[i] / 255.0;
break;
default:
break;
}
// Only add it if it beats the threshold and has a chance at being in
// the top N.
if (value < threshold) {
continue;
}
top_result_pq.push(std::pair<float, int>(value, i));
// If at capacity, kick the smallest value out.
if (top_result_pq.size() > num_results) {
top_result_pq.pop();
}
}
// Copy to output vector and reverse into descending order.
while (!top_result_pq.empty()) {
top_results->push_back(top_result_pq.top());
top_result_pq.pop();
}
std::reverse(top_results->begin(), top_results->end());
}
netron 에서 보면 quantization 범위가 나오는데, 어딘가 저장하고는 있는 듯 해서 검색 중
// SupportedQuantizationTypes.
typedef enum TfLiteQuantizationType {
// No quantization.
kTfLiteNoQuantization = 0,
// Affine quantization (with support for per-channel quantization).
// Corresponds to TfLiteAffineQuantization.
kTfLiteAffineQuantization = 1,
} TfLiteQuantizationType;
// Structure specifying the quantization used by the tensor, if-any.
typedef struct TfLiteQuantization {
// The type of quantization held by params.
TfLiteQuantizationType type;
// Holds a reference to one of the quantization param structures specified
// below.
void* params;
} TfLiteQuantization;
// Legacy. Will be deprecated in favor of TfLiteAffineQuantization.
// If per-layer quantization is specified this field will still be populated in
// addition to TfLiteAffineQuantization.
// Parameters for asymmetric quantization. Quantized values can be converted
// back to float using:
// real_value = scale * (quantized_value - zero_point)
typedef struct TfLiteQuantizationParams {
float scale;
int32_t zero_point;
} TfLiteQuantizationParams;
// Parameters for asymmetric quantization across a dimension (i.e per output
// channel quantization).
// quantized_dimension specifies which dimension the scales and zero_points
// correspond to.
// For a particular value in quantized_dimension, quantized values can be
// converted back to float using:
// real_value = scale * (quantized_value - zero_point)
typedef struct TfLiteAffineQuantization {
TfLiteFloatArray* scale;
TfLiteIntArray* zero_point;
int32_t quantized_dimension;
} TfLiteAffineQuantization;
typedef struct TfLiteTensor {
TfLiteType type;
TfLitePtrUnion data;
TfLiteIntArray* dims;
TfLiteQuantizationParams params;
TfLiteAllocationType allocation_type;
size_t bytes;
const void* allocation;
const char* name;
struct TfLiteDelegate* delegate;
TfLiteBufferHandle buffer_handle;
bool data_is_stale;
bool is_variable;
TfLiteQuantization quantization;
TfLiteSparsity* sparsity;
const TfLiteIntArray* dims_signature;
} TfLiteTensor;
+
2021.05.26
typedef struct TfLiteIntArray {
int size;
// gcc 6.1+ have a bug where flexible members aren't properly handled
// https://github.com/google/re2/commit/b94b7cd42e9f02673cd748c1ac1d16db4052514c
#if (!defined(__clang__) && defined(__GNUC__) && __GNUC__ == 6 && \
__GNUC_MINOR__ >= 1) || \
defined(HEXAGON) || (__clang_major__ == 7 && __clang_minor__ == 1)
int data[0];
#else
int data[];
#endif
} TfLiteIntArray;
// Fixed size list of floats. Used for per-channel quantization.
typedef struct TfLiteFloatArray {
int size;
// gcc 6.1+ have a bug where flexible members aren't properly handled
// https://github.com/google/re2/commit/b94b7cd42e9f02673cd748c1ac1d16db4052514c
// This also applies to the toolchain used for Qualcomm Hexagon DSPs.
#if !defined(__clang__) && defined(__GNUC__) && __GNUC__ == 6 && \
__GNUC_MINOR__ >= 1
float data[0];
#else
float data[];
#endif
} TfLiteFloatArray;
class Interpreter {
/// Invoke the interpreter (run the whole graph in dependency order).
///
/// NOTE: It is possible that the interpreter is not in a ready state
/// to evaluate (i.e. if a ResizeTensor() has been performed without an
/// AllocateTensors().
/// Returns status of success or failure.
TfLiteStatus Invoke();
/// WARNING: Experimental interface, subject to change
Subgraph& primary_subgraph() {
return *subgraphs_.front(); /// Safe as subgraphs_ always has 1 entry.
}
/// Read only access to list of inputs.
const std::vector<int>& inputs() const { return primary_subgraph().inputs(); }
/// Read only access to list of outputs.
const std::vector<int>& outputs() const {
return primary_subgraph().outputs();
}
// Subgraphs
std::vector<std::unique_ptr<Subgraph>> subgraphs_;
};
[링크 : https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/interpreter.h]
class Subgraph {
// Array of indices representing the tensors that are inputs to the
// interpreter.
std::vector<int> inputs_;
// Array of indices representing the tensors that are outputs to the
// interpreter.
std::vector<int> outputs_;
// Read only access to list of inputs.
std::vector<int>& inputs() { return inputs_; }
// Read only access to list of inputs.
const std::vector<int>& inputs() const { return inputs_; }
// Read only access to list of outputs.
std::vector<int>& outputs() { return outputs_; }
// Read only access to list of outputs.
const std::vector<int>& outputs() const { return outputs_; }
};
[링크 : https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/core/subgraph.h]
