Function EvalHybridSVDF

tensorflow/lite/kernels/internal/reference/svdf.h:130–206

}

inline void EvalHybridSVDF(
    TfLiteContext* context, TfLiteNode* node, const TfLiteTensor* input,
    const TfLiteTensor* weights_feature, const TfLiteTensor* weights_time,
    const TfLiteTensor* bias, const TfLiteSVDFParams* params,
    TfLiteTensor* scratch, TfLiteTensor* scaling_factors,
    TfLiteTensor* input_quantized, TfLiteTensor* state, TfLiteTensor* output) {
  const int rank = params->rank;
  const int batch_size = input->dims->data[0];
  const int input_size = input->dims->data[1];
  const int num_filters = weights_feature->dims->data[0];
  const int num_units = num_filters / rank;
  const int memory_size = weights_time->dims->data[1];

  // Initialize the pointer to input.
  const float* input_ptr_batch = GetTensorData<float>(input);

  // Initialize the pointer to storage for quantized values and the weights
  // feature.
  int8_t* quantized_input_ptr_batch;
  const int8_t* weights_feature_ptr;
  if (weights_feature->type == kTfLiteUInt8) {
    quantized_input_ptr_batch =
        reinterpret_cast<int8_t*>(GetTensorData<uint8_t>(input_quantized));
    weights_feature_ptr = reinterpret_cast<const int8_t*>(
        GetTensorData<uint8_t>(weights_feature));
  } else {
    quantized_input_ptr_batch = GetTensorData<int8_t>(input_quantized);
    weights_feature_ptr = GetTensorData<int8_t>(weights_feature);
  }

  // Initialize the pointer to storage for scaling factors.
  float* scaling_factors_ptr = GetTensorData<float>(scaling_factors);

  // Initialize the weights scale.
  const float weights_feature_scale = weights_feature->params.scale;

  // Clear the activation (state's leftmost column).
  // TODO(ghodrat): Add a test which initialize state with invalid values in
  // the leftmost column and make sure it passes.
  for (int b = 0; b < batch_size; ++b) {
    float* state_ptr_batch =
        GetTensorData<float>(state) + b * memory_size * num_filters;
    for (int c = 0; c < num_filters; ++c) {
      float* state_ptr = state_ptr_batch + c * memory_size;
      state_ptr[memory_size - 1] = 0.0;
    }
  }

  if (!tensor_utils::IsZeroVector(input_ptr_batch, batch_size * input_size)) {
    // Quantize input from float to int8.
    float unused_min, unused_max;
    for (int b = 0; b < batch_size; ++b) {
      const int offset = b * input_size;
      tensor_utils::SymmetricQuantizeFloats(
          input_ptr_batch + offset, input_size,
          quantized_input_ptr_batch + offset, &unused_min, &unused_max,
          &scaling_factors_ptr[b]);
      scaling_factors_ptr[b] *= weights_feature_scale;