OnlineDQMDigiAD_cmssw.h

Go to the documentation of this file.

/*
 * OnlineDQMDigiAD_cmssw.cpp
 *
 * Created on: Jun 10, 2023
 * Author: Mulugeta W.Asres, UiA, Norway
 *
 * The implementation follows https://github.com/cms-sw/cmssw/tree/master/PhysicsTools/ONNXRuntime
 */
#ifndef OnlineDQMDigiAD_cmssw_H_
#define OnlineDQMDigiAD_cmssw_H_

#include "PhysicsTools/ONNXRuntime/interface/ONNXRuntime.h"
#include "FWCore/Utilities/interface/Exception.h"
#include "FWCore/Utilities/interface/thread_safety_macros.h"

#include <algorithm>
#include <cassert>
#include <functional>
#include <iostream>
#include <memory>
#include <numeric>

// Declare OnlineDQMDigiAD class
class OnlineDQMDigiAD {
public:
  OnlineDQMDigiAD(const std::string model_system_name,
                  const std::string &modelFilepath,
                  cms::Ort::Backend backend = cms::Ort::Backend::cpu);

  void IsModelExist(std::string hcal_subsystem_name);

  void InitializeState();

  std::vector<std::vector<float>> Inference(std::vector<float> &digiHcalMapTW,
                                            std::vector<float> &numEvents,
                                            std::vector<float> &adThr,
                                            std::vector<float> &input_model_state_memory_e_0_0,
                                            std::vector<float> &input_model_state_memory_e_0_1,
                                            std::vector<float> &input_model_state_memory_e_1_0,
                                            std::vector<float> &input_model_state_memory_e_1_1,
                                            std::vector<float> &input_model_state_memory_d_0_0,
                                            std::vector<float> &input_model_state_memory_d_0_1,
                                            std::vector<float> &input_model_state_memory_d_1_0,
                                            std::vector<float> &input_model_state_memory_d_1_1);
  std::vector<std::vector<float>> Inference_CMSSW(const std::vector<std::vector<float>> &digiHcal2DHist_depth_1,
                                                  const std::vector<std::vector<float>> &digiHcal2DHist_depth_2,
                                                  const std::vector<std::vector<float>> &digiHcal2DHist_depth_3,
                                                  const std::vector<std::vector<float>> &digiHcal2DHist_depth_4,
                                                  const std::vector<std::vector<float>> &digiHcal2DHist_depth_5,
                                                  const std::vector<std::vector<float>> &digiHcal2DHist_depth_6,
                                                  const std::vector<std::vector<float>> &digiHcal2DHist_depth_7,
                                                  const float LS_numEvents,
                                                  const float flagDecisionThr = 20);

  std::vector<std::vector<std::vector<float>>> ONNXOutputToDQMHistMap(
      const std::vector<std::vector<float>> &ad_model_output_vectors, const int selOutputIdx = 7);

private:
  // onnx session
  const std::vector<std::string> hcal_modeled_systems = {"he", "hb"};
  std::string hcal_subsystem_name;
  std::unique_ptr<cms::Ort::ONNXRuntime> ort_mSession = nullptr;
  std::string model_path;  // onnx model path

  // names of onnx model input vectors; do not change
  const std::vector<std::string> input_names = {
      "input_data",
      "input_data_exo",
      "anomaly_std_th",
      "e_rnn_hidden__layer_0_state_0",
      "e_rnn_hidden__layer_0_state_1",
      "e_rnn_hidden__layer_1_state_0",
      "e_rnn_hidden__layer_1_state_1",
      "d_rnn_hidden__layer_0_state_0",
      "d_rnn_hidden__layer_0_state_1",
      "d_rnn_hidden__layer_1_state_0",
      "d_rnn_hidden__layer_1_state_1",
  };

  // names of onnx model outputs vectors; do not change
  const std::vector<std::string> output_names = {
      "target_data",
      "pred_data",
      "pred_err_spatial",
      "pred_err_window_spatial",
      "pred_err_spatial_scaled",
      "pred_err_window_spatial_scaled",
      "pred_err_spatial_scaled_aml",
      "pred_err_window_spatial_scaled_aml",
      "e_rnn_hidden__layer_0_state_0_o",
      "e_rnn_hidden__layer_0_state_1_o",
      "e_rnn_hidden__layer_1_state_0_o",
      "e_rnn_hidden__layer_1_state_1_o",
      "d_rnn_hidden__layer_0_state_0_o",
      "d_rnn_hidden__layer_0_state_1_o",
      "d_rnn_hidden__layer_1_state_0_o",
      "d_rnn_hidden__layer_1_state_1_o",
  };

  // model state network config declaration : encoder and decoder have each two lstm layers(each hold two state vectors, h0, c0)
  const size_t num_state_vectors = 8;
  const unsigned int model_state_inner_dim = 2;  // do not change
  const std::vector<std::vector<unsigned int>> model_state_layer_dims = {
      {128, 32}, {128, 640}};  // do not change, encoder[layer_0, layer_1] and decoder [layer_0, layer_1]
  const std::vector<std::vector<unsigned int>> model_state_layer_serialized_dims = {
      {256, 64},
      {256,
       1280}};  // do not change, model_state_inner_dim*encoder[layer_0, layer_1] and model_state_inner_dim*decoder [layer_0, layer_1]
  // unsigned model_state_refresh_counter = 15;               // do not change for now. set due to onnx double datatype handling limitation that might cause precision error to propagate.
  unsigned model_state_refresh_counter =
      1;  // DQM multithread returns non-sequential LS. Hence, the model will not keep states (experimental)

  std::vector<float> input_model_state_memory_e_0_0{std::vector<float>(model_state_layer_serialized_dims[0][0])};
  std::vector<float> input_model_state_memory_e_0_1{std::vector<float>(model_state_layer_serialized_dims[0][0])};
  std::vector<float> input_model_state_memory_e_1_0{std::vector<float>(model_state_layer_serialized_dims[0][1])};
  std::vector<float> input_model_state_memory_e_1_1{std::vector<float>(model_state_layer_serialized_dims[0][1])};
  std::vector<float> input_model_state_memory_d_0_0{std::vector<float>(model_state_layer_serialized_dims[1][0])};
  std::vector<float> input_model_state_memory_d_0_1{std::vector<float>(model_state_layer_serialized_dims[1][0])};
  std::vector<float> input_model_state_memory_d_1_0{std::vector<float>(model_state_layer_serialized_dims[1][1])};
  std::vector<float> input_model_state_memory_d_1_1{std::vector<float>(model_state_layer_serialized_dims[1][1])};

  // input and outputs
  int64_t batch_size = 1;  // number maps to  be evaluated at once, a single time-window
  std::vector<std::vector<float>> input_values, output_values;
  std::vector<std::vector<int64_t>> input_shapes;

  std::vector<float> Serialize2DVector(const std::vector<std::vector<float>> &input_2d_vec);

  std::vector<std::vector<float>> Map1DTo2DVector(const std::vector<float> &input_1d_vec, const int numSplits);

  std::vector<float> PrepareONNXDQMMapVectors(std::vector<std::vector<std::vector<float>>> &digiHcal2DHist_depth_all);
};

#endif  // OnlineDQMDigiAD_cmssw_H_