OnlineDQMDigiAD Class Reference

#include <OnlineDQMDigiAD_cmssw.h>

Public Member Functions
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)
	Perform inference on a single image. More...
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)
	Perform inference on a single image. More...
void	InitializeState ()
	Resets ml model memory states to default and function needs to be called when new collision run starts. More...
void	IsModelExist (std::string hcal_subsystem_name)
	check whether onnx model integration is added for the selected hcal system More...
	OnlineDQMDigiAD (const std::string model_system_name, const std::string &modelFilepath, cms::Ort::Backend backend=cms::Ort::Backend::cpu)
	Constructor. More...
std::vector< std::vector< std::vector< float > > >	ONNXOutputToDQMHistMap (const std::vector< std::vector< float >> &ad_model_output_vectors, const int selOutputIdx=7)
	Converts 1D serialized vector output of the onnx into 3d hcal-hehp vector. More...

Private Member Functions
std::vector< std::vector< float > >	Map1DTo2DVector (const std::vector< float > &input_1d_vec, const int numSplits)
	Converts serialized 1d vectors into 2d. More...
std::vector< float >	PrepareONNXDQMMapVectors (std::vector< std::vector< std::vector< float >>> &digiHcal2DHist_depth_all)
	Prepares model input serialized dqm histogram from 2D histogram inputs from the cmssw. More...
std::vector< float >	Serialize2DVector (const std::vector< std::vector< float >> &input_2d_vec)
	Serializes 2d vectors into 1d. More...

Private Attributes
int64_t	batch_size = 1
const std::vector< std::string >	hcal_modeled_systems = {"he", "hb"}
std::string	hcal_subsystem_name
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])}
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])}
const std::vector< std::string >	input_names
std::vector< std::vector< int64_t > >	input_shapes
std::vector< std::vector< float > >	input_values
std::string	model_path
const unsigned int	model_state_inner_dim = 2
const std::vector< std::vector< unsigned int > >	model_state_layer_dims
const std::vector< std::vector< unsigned int > >	model_state_layer_serialized_dims
unsigned	model_state_refresh_counter
const size_t	num_state_vectors = 8
std::unique_ptr< cms::Ort::ONNXRuntime >	ort_mSession = nullptr
const std::vector< std::string >	output_names
std::vector< std::vector< float > >	output_values

Detailed Description

Definition at line 24 of file OnlineDQMDigiAD_cmssw.h.

Constructor & Destructor Documentation

OnlineDQMDigiAD()

OnlineDQMDigiAD::OnlineDQMDigiAD	(	const std::string	model_system_name,
		const std::string &	modelFilepath,
		cms::Ort::Backend	backend = cms::Ort::Backend::cpu
	)

Constructor.

Parameters

modelFilepath	path to the .onnx file
Backend	backend selection cpu or gpu

Definition at line 32 of file OnlineDQMDigiAD_cmssw.cc.

References jetsAK4_CHS_cff::backend, cms::Ort::ONNXRuntime::defaultSessionOptions(), edm::FileInPath::fullPath(), HLT_2023v12_cff::model_path, eostools::move(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                  {
  std::string instanceName{"DESMOD Digioccupancy Map AD inference"};

  /**************** Initailize Model Memory States ******************/
  InitializeState();  // initailize model memory states to zero

  /**************** Create ORT session ******************/
  // Set up options for session
  auto session_options = ONNXRuntime::defaultSessionOptions(backend);
  // Create session by loading the onnx model
  model_path = edm::FileInPath(modelFilepath).fullPath();
  auto uOrtSession = std::make_unique<ONNXRuntime>(model_path, &session_options);
  ort_mSession = std::move(uOrtSession);

  // check model availability
  hcal_subsystem_name = model_system_name;

  IsModelExist(hcal_subsystem_name);  // assert model integration for the given hcal system name

  if (hcal_subsystem_name == "he") {
    std::vector<std::vector<int64_t>> input_shapes_ = {
        {batch_size, 64, 72, 7, 1},
        {batch_size, 1},
        {1, 1},
        {batch_size, model_state_inner_dim, model_state_layer_dims[0][0]},
        {batch_size, model_state_inner_dim, model_state_layer_dims[0][0]},
        {batch_size, model_state_inner_dim, model_state_layer_dims[0][1]},
        {batch_size, model_state_inner_dim, model_state_layer_dims[0][1]},
        {batch_size, model_state_inner_dim, model_state_layer_dims[1][0]},
        {batch_size, model_state_inner_dim, model_state_layer_dims[1][0]},
        {batch_size, model_state_inner_dim, model_state_layer_dims[1][1]},
        {batch_size, model_state_inner_dim, model_state_layer_dims[1][1]}};  // input dims
    input_shapes = input_shapes_;
  }

  else if (hcal_subsystem_name == "hb") {
    std::vector<std::vector<int64_t>> input_shapes_ = {
        {batch_size, 64, 72, 4, 1},
        {batch_size, 1},
        {1, 1},
        {batch_size, model_state_inner_dim, model_state_layer_dims[0][0]},
        {batch_size, model_state_inner_dim, model_state_layer_dims[0][0]},
        {batch_size, model_state_inner_dim, model_state_layer_dims[0][1]},
        {batch_size, model_state_inner_dim, model_state_layer_dims[0][1]},
        {batch_size, model_state_inner_dim, model_state_layer_dims[1][0]},
        {batch_size, model_state_inner_dim, model_state_layer_dims[1][0]},
        {batch_size, model_state_inner_dim, model_state_layer_dims[1][1]},
        {batch_size, model_state_inner_dim, model_state_layer_dims[1][1]}};  // input dims
    input_shapes = input_shapes_;
  }
}

Member Function Documentation

Inference()

std::vector< std::vector< float > > OnlineDQMDigiAD::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
	)

Perform inference on a single image.

Parameters

digiHcalMapTW	The input digipccupany maps in time window
numEvents	The input number of events for map renormalization in time window
adThr	The anomaly detection decision threshold
input_model_state_memory_	The model memory states
output_tensors	output arrays

Returns

the list of multidimensional arrays

Definition at line 183 of file OnlineDQMDigiAD_cmssw.cc.

References HLT_2023v12_cff::input_names, simpleEdmComparison::numEvents, and HLT_2023v12_cff::output_names.

                                                                                                             {
  /**************** Preprocessing ******************/
  // Create input tensor (including size and value) from the loaded inputs
  // Compute the product of all input dimension
  // Assign memory for input tensor
  // inputTensors will be used by the Session Run for inference

  input_values.clear();
  input_values.emplace_back(digiHcalMapTW);
  input_values.emplace_back(numEvents);
  input_values.emplace_back(adThr);
  input_values.emplace_back(input_model_state_memory_e_0_0);
  input_values.emplace_back(input_model_state_memory_e_0_1);
  input_values.emplace_back(input_model_state_memory_e_1_0);
  input_values.emplace_back(input_model_state_memory_e_1_1);
  input_values.emplace_back(input_model_state_memory_d_0_0);
  input_values.emplace_back(input_model_state_memory_d_0_1);
  input_values.emplace_back(input_model_state_memory_d_1_0);
  input_values.emplace_back(input_model_state_memory_d_1_1);

  /**************** Inference ******************/

  output_values = ort_mSession->run(input_names, input_values, input_shapes, output_names, batch_size);

  return output_values;
}

Inference_CMSSW()

std::vector< std::vector< float > > OnlineDQMDigiAD::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
	)

Perform inference on a single image.

Parameters

digiHcal2DHist_depth_1	2D histogram digioccupancy of the 1st depth of the hcal-hehb
digiHcal2DHist_depth_2	2D histogram digioccupancy of the 2nd depth of the hcal-hehb
digiHcal2DHist_depth_3	2D histogram digioccupancy of the 3rd depth of the hcal-hehb
digiHcal2DHist_depth_4	2D histogram digioccupancy of the 4th depth of the hcal-hehb
digiHcal2DHist_depth_5	2D histogram digioccupancy of the 5th depth of the hcal-hehb
digiHcal2DHist_depth_5	2D histogram digioccupancy of the 6th depth of the hcal-hehb
digiHcal2DHist_depth_7	2D histogram digioccupancy of the 7th depth of the hcal-hehb
LS_numEvents	The input number of events for digioccupancy map renormalization
flagDecisionThr	The anomaly detection decision threshold, decrease to increase sensitivity

Returns

ad_model_output_vectors: the vectors of multidimensional arrays: output_data_0, output_data_1, ...

Definition at line 221 of file OnlineDQMDigiAD_cmssw.cc.

References gather_cfg::cout, mps_fire::i, simpleEdmComparison::numEvents, HLT_2023v12_cff::output_names, and AlCaHLTBitMon_QueryRunRegistry::string.

{
  /**************** Prepare data ******************/
  // merging all 2d hist into one 3d depth[ieta[iphi]]
  std::vector<std::vector<std::vector<float>>> digiHcal2DHist_depth_all;

  if (hcal_subsystem_name == "he") {
    digiHcal2DHist_depth_all.push_back(digiHcal2DHist_depth_1);
    digiHcal2DHist_depth_all.push_back(digiHcal2DHist_depth_2);
    digiHcal2DHist_depth_all.push_back(digiHcal2DHist_depth_3);
    digiHcal2DHist_depth_all.push_back(digiHcal2DHist_depth_4);
    digiHcal2DHist_depth_all.push_back(digiHcal2DHist_depth_5);
    digiHcal2DHist_depth_all.push_back(digiHcal2DHist_depth_6);
    digiHcal2DHist_depth_all.push_back(digiHcal2DHist_depth_7);
  }

  else if (hcal_subsystem_name == "hb") {
    digiHcal2DHist_depth_all.push_back(digiHcal2DHist_depth_1);
    digiHcal2DHist_depth_all.push_back(digiHcal2DHist_depth_2);
    digiHcal2DHist_depth_all.push_back(digiHcal2DHist_depth_3);
    digiHcal2DHist_depth_all.push_back(digiHcal2DHist_depth_4);
  }

  // convert the 3d depth[ieta[iphi]] vector into 1d and commbined
  std::vector<float> digiHcalMapTW = PrepareONNXDQMMapVectors(digiHcal2DHist_depth_all);

  std::vector<float> adThr{flagDecisionThr};  // AD decision threshold, increase to reduce sensitivity
  std::vector<float> numEvents{LS_numEvents};

  // call model inference
  /**************** Inference ******************/
  std::vector<std::vector<float>> output_tensors = Inference(digiHcalMapTW,
                                                             numEvents,
                                                             adThr,
                                                             input_model_state_memory_e_0_0,
                                                             input_model_state_memory_e_0_1,
                                                             input_model_state_memory_e_1_0,
                                                             input_model_state_memory_e_1_1,
                                                             input_model_state_memory_d_0_0,
                                                             input_model_state_memory_d_0_1,
                                                             input_model_state_memory_d_1_0,
                                                             input_model_state_memory_d_1_1);

  // auto output_tensors = Inference(digiHcalMapTW, numEvents, adThr);
  //std::cout << "******* model inference is success *******" << std::endl;

  /**************** Output post processing ******************/
  //  split outputs into ad output vectors and state_memory vectors
  std::string state_output_name_tag = "rnn_hidden";
  std::vector<std::vector<float>> ad_model_output_vectors, ad_model_state_vectors;
  for (size_t i = 0; i < output_tensors.size(); i++) {
    std::string output_names_startstr = output_names[i].substr(
        2, state_output_name_tag.length());  // Extract the same number of characters as str2 from mOutputNames
    if (output_names_startstr == state_output_name_tag) {
      ad_model_state_vectors.emplace_back(output_tensors[i]);
    } else {
      ad_model_output_vectors.emplace_back(output_tensors[i]);
    }
  }

  if (ad_model_output_vectors.size() == num_state_vectors) {
    input_model_state_memory_e_0_0 = ad_model_state_vectors[0];
    input_model_state_memory_e_0_1 = ad_model_state_vectors[1];
    input_model_state_memory_e_1_0 = ad_model_state_vectors[2];
    input_model_state_memory_e_1_1 = ad_model_state_vectors[3];
    input_model_state_memory_d_0_0 = ad_model_state_vectors[4];
    input_model_state_memory_d_0_1 = ad_model_state_vectors[5];
    input_model_state_memory_d_1_0 = ad_model_state_vectors[6];
    input_model_state_memory_d_1_1 = ad_model_state_vectors[7];
  } else {
    std::cout << "Warning: the number of output state vectors does NOT equals to expected!. The states are set to  "
                 "default values."
              << std::endl;
    InitializeState();
  }

  // # if onnx is returning serialized 1d vectors instead of vector of 3d vectors
  // aml score and flag are at index 5 and 7 of the vector ad_model_output_vectors: anomaly score: ad_model_output_vectors[5], anomaly flags: ad_model_output_vectors[7]
  /*
      selOutputIdx: index to select of the onnx output. e.g. 5 is the anomaly score and 7 is the anomaly flag (1 is with anomaly, 0 is healthy)
      std::vector<std::vector<std::vector<float>>> digiHcal3DHist_ANOMALY_FLAG = ONNXOutputToDQMHistMap(ad_model_output_vectors, 7)
      std::vector<std::vector<std::vector<float>>> digiHcal3DHist_ANOMALY_SCORE = ONNXOutputToDQMHistMap(ad_model_output_vectors, 5)
      */

  // reduce counter for each ls call. due to onnx double datatype handling limitation that might cause precision error to propagate.
  if (--model_state_refresh_counter == 0)
    InitializeState();

  return ad_model_output_vectors;
}

InitializeState()

void OnlineDQMDigiAD::InitializeState

(

)

Resets ml model memory states to default and function needs to be called when new collision run starts.

Definition at line 95 of file OnlineDQMDigiAD_cmssw.cc.

References ntuplemaker::fill, and nano_mu_digi_cff::float.

                                      {
  // model memory states vectors init, only when the runs starts or for the first LS
  std::fill(input_model_state_memory_e_0_0.begin(),
            input_model_state_memory_e_0_0.end(),
            float(0.0));  // init model memory states-encoder_layer_0_state_0 to zero
  std::fill(input_model_state_memory_e_0_1.begin(),
            input_model_state_memory_e_0_1.end(),
            float(0.0));  // init model memory states-encoder_layer_0_state_1 to zero
  std::fill(input_model_state_memory_e_1_0.begin(),
            input_model_state_memory_e_1_0.end(),
            float(0.0));  // init model memory states-encoder_layer_1_state_0 to zero
  std::fill(input_model_state_memory_e_1_1.begin(),
            input_model_state_memory_e_1_1.end(),
            float(0.0));  // init model memory states-encoder_layer_1_state_1 to zero
  std::fill(input_model_state_memory_d_0_0.begin(),
            input_model_state_memory_d_0_0.end(),
            float(0.0));  // init model memory states-decoder_layer_0_state_0 to zero
  std::fill(input_model_state_memory_d_0_1.begin(),
            input_model_state_memory_d_0_1.end(),
            float(0.0));  // init model memory states-decoder_layer_0_state_1 to zero
  std::fill(input_model_state_memory_d_1_0.begin(),
            input_model_state_memory_d_1_0.end(),
            float(0.0));  // init model memory states-decoder_layer_1_state_0 to zero
  std::fill(input_model_state_memory_d_1_1.begin(),
            input_model_state_memory_d_1_1.end(),
            float(0.0));  // init model memory states-decoder_layer_1_state_1 to zero

  // model_state_refresh_counter = 15; // counter set due to onnx double datatype handling limitation that might cause precision error to propagate.
  model_state_refresh_counter =
      1;  // DQM multithread returns non-sequential LS. Hence, the model will not keep states (experimental)
}

IsModelExist()

void OnlineDQMDigiAD::IsModelExist

(

std::string

hcal_subsystem_name

)

check whether onnx model integration is added for the selected hcal system

Definition at line 86 of file OnlineDQMDigiAD_cmssw.cc.

References submitPVResolutionJobs::err, spr::find(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                {
  if (std::find(hcal_modeled_systems.begin(), hcal_modeled_systems.end(), hcal_subsystem_name) ==
      hcal_modeled_systems.end()) {
    std::string err =
        "ML for OnlineDQM is not currently supported for the selected " + hcal_subsystem_name + " system!\n";
    throw std::invalid_argument(err);
  }
}

Map1DTo2DVector()

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

private

Converts serialized 1d vectors into 2d.

Definition at line 137 of file OnlineDQMDigiAD_cmssw.cc.

References mps_fire::i.

                                                                                      {
  std::size_t const splitted_size = input_1d_vec.size() / numSplits;
  // check splitted_size*numSplits == input_1d_vec.size()
  std::vector<std::vector<float>> output_2d_vec;

  for (size_t i = 0; i < input_1d_vec.size(); i += numSplits - 1) {
    std::vector<float> chunch_vec(input_1d_vec.begin() + i, input_1d_vec.begin() + i + splitted_size);
    output_2d_vec.push_back(chunch_vec);
  }
  return output_2d_vec;
}

ONNXOutputToDQMHistMap()

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

Converts 1D serialized vector output of the onnx into 3d hcal-hehp vector.

Parameters

ad_model_output_vectors	vector of 3D histogram maps the hcal-hehb, each vector output from the onnx. e.g 3d map of anomaly score and 3d map of anomaly flag or label
selOutputIdx	index to select of the onnx output. e.g. 5 is the anomaly score and 7 is the anomaly flag (1 is with anomaly, 0 is healthy)

Returns

ad_model_output_vectors: the vectors of multidimensional arrays: output_data_0, output_data_1, ...

Definition at line 164 of file OnlineDQMDigiAD_cmssw.cc.

                                                                                        {
  // each output_vector is a serialized 3d hist map
  const unsigned short numDepth = 7;
  const unsigned short numDIeta = 64;

  const std::vector<float> &output_vector = ad_model_output_vectors[selOutputIdx];
  std::vector<std::vector<float>> output_2d_vec = Map1DTo2DVector(output_vector, numDepth);

  std::vector<std::vector<std::vector<float>>> digiHcal3DHist;
  for (const std::vector<float> &output_vector_depth : output_2d_vec) {
    std::vector<std::vector<float>> digiHcal2DHist_depth = Map1DTo2DVector(output_vector_depth, numDIeta);
    digiHcal3DHist.push_back(digiHcal2DHist_depth);
  }

  return digiHcal3DHist;
}

PrepareONNXDQMMapVectors()

std::vector< float > OnlineDQMDigiAD::PrepareONNXDQMMapVectors ( std::vector< std::vector< std::vector< float >>> &  digiHcal2DHist_depth_all )

private

Prepares model input serialized dqm histogram from 2D histogram inputs from the cmssw.

Parameters

digiHcal2DHist_depth_all

3D vector (depth[ieta[iphi]]) of combined 2D histogram digioccupancy of the any depth of the hcal

Definition at line 150 of file OnlineDQMDigiAD_cmssw.cc.

References trackerHitRTTI::vector.

                                                                      {
  std::vector<float> digi3DHistVector_serialized;

  for (const std::vector<std::vector<float>> &digiHcal2DHist_depth : digiHcal2DHist_depth_all) {
    std::vector<float> digiHcalDHist_serialized_depth = Serialize2DVector(digiHcal2DHist_depth);
    digi3DHistVector_serialized.insert(digi3DHistVector_serialized.end(),
                                       digiHcalDHist_serialized_depth.begin(),
                                       digiHcalDHist_serialized_depth.end());
  }

  return digi3DHistVector_serialized;
}

Serialize2DVector()

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

private

Serializes 2d vectors into 1d.

Definition at line 127 of file OnlineDQMDigiAD_cmssw.cc.

References convertSQLitetoXML_cfg::output.

                                                                                                   {
  std::vector<float> output;
  for (const auto &row : input_2d_vec) {
    for (const auto &element : row) {
      output.push_back(element);
    }
  }
  return output;
}

Member Data Documentation

batch_size

int64_t OnlineDQMDigiAD::batch_size = 1

private

Definition at line 162 of file OnlineDQMDigiAD_cmssw.h.

hcal_modeled_systems

const std::vector<std::string> OnlineDQMDigiAD::hcal_modeled_systems = {"he", "hb"}

private

Definition at line 99 of file OnlineDQMDigiAD_cmssw.h.

hcal_subsystem_name

std::string OnlineDQMDigiAD::hcal_subsystem_name

private

Definition at line 100 of file OnlineDQMDigiAD_cmssw.h.

input_model_state_memory_d_0_0

std::vector<float> OnlineDQMDigiAD::input_model_state_memory_d_0_0 {std::vector<float>(model_state_layer_serialized_dims[1][0])}

private

Definition at line 156 of file OnlineDQMDigiAD_cmssw.h.

input_model_state_memory_d_0_1

std::vector<float> OnlineDQMDigiAD::input_model_state_memory_d_0_1 {std::vector<float>(model_state_layer_serialized_dims[1][0])}

private

Definition at line 157 of file OnlineDQMDigiAD_cmssw.h.

input_model_state_memory_d_1_0

std::vector<float> OnlineDQMDigiAD::input_model_state_memory_d_1_0 {std::vector<float>(model_state_layer_serialized_dims[1][1])}

private

Definition at line 158 of file OnlineDQMDigiAD_cmssw.h.

input_model_state_memory_d_1_1

std::vector<float> OnlineDQMDigiAD::input_model_state_memory_d_1_1 {std::vector<float>(model_state_layer_serialized_dims[1][1])}

private

Definition at line 159 of file OnlineDQMDigiAD_cmssw.h.

input_model_state_memory_e_0_0

std::vector<float> OnlineDQMDigiAD::input_model_state_memory_e_0_0 {std::vector<float>(model_state_layer_serialized_dims[0][0])}

private

Definition at line 152 of file OnlineDQMDigiAD_cmssw.h.

input_model_state_memory_e_0_1

std::vector<float> OnlineDQMDigiAD::input_model_state_memory_e_0_1 {std::vector<float>(model_state_layer_serialized_dims[0][0])}

private

Definition at line 153 of file OnlineDQMDigiAD_cmssw.h.

input_model_state_memory_e_1_0

std::vector<float> OnlineDQMDigiAD::input_model_state_memory_e_1_0 {std::vector<float>(model_state_layer_serialized_dims[0][1])}

private

Definition at line 154 of file OnlineDQMDigiAD_cmssw.h.

input_model_state_memory_e_1_1

std::vector<float> OnlineDQMDigiAD::input_model_state_memory_e_1_1 {std::vector<float>(model_state_layer_serialized_dims[0][1])}

private

Definition at line 155 of file OnlineDQMDigiAD_cmssw.h.

input_names

const std::vector<std::string> OnlineDQMDigiAD::input_names

private

Initial value:

= {
      "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",
  }

Definition at line 105 of file OnlineDQMDigiAD_cmssw.h.

input_shapes

std::vector<std::vector<int64_t> > OnlineDQMDigiAD::input_shapes

private

Definition at line 164 of file OnlineDQMDigiAD_cmssw.h.

input_values

std::vector<std::vector<float> > OnlineDQMDigiAD::input_values

private

Definition at line 163 of file OnlineDQMDigiAD_cmssw.h.

model_path

std::string OnlineDQMDigiAD::model_path

private

Definition at line 102 of file OnlineDQMDigiAD_cmssw.h.

model_state_inner_dim

const unsigned int OnlineDQMDigiAD::model_state_inner_dim = 2

private

Definition at line 141 of file OnlineDQMDigiAD_cmssw.h.

model_state_layer_dims

const std::vector<std::vector<unsigned int> > OnlineDQMDigiAD::model_state_layer_dims

private

Initial value:

= {
      {128, 32}, {128, 640}}

Definition at line 142 of file OnlineDQMDigiAD_cmssw.h.

model_state_layer_serialized_dims

const std::vector<std::vector<unsigned int> > OnlineDQMDigiAD::model_state_layer_serialized_dims

private

Initial value:

= {
      {256, 64},
      {256,
       1280}}

Definition at line 144 of file OnlineDQMDigiAD_cmssw.h.

model_state_refresh_counter

unsigned OnlineDQMDigiAD::model_state_refresh_counter

private

Initial value:

=
      1

Definition at line 149 of file OnlineDQMDigiAD_cmssw.h.

num_state_vectors

const size_t OnlineDQMDigiAD::num_state_vectors = 8

private

Definition at line 140 of file OnlineDQMDigiAD_cmssw.h.

ort_mSession

std::unique_ptr<cms::Ort::ONNXRuntime> OnlineDQMDigiAD::ort_mSession = nullptr

private

Definition at line 101 of file OnlineDQMDigiAD_cmssw.h.

output_names

const std::vector<std::string> OnlineDQMDigiAD::output_names

private

Initial value:

= {
      "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",
  }

Definition at line 120 of file OnlineDQMDigiAD_cmssw.h.

output_values

std::vector<std::vector<float> > OnlineDQMDigiAD::output_values

private

Definition at line 163 of file OnlineDQMDigiAD_cmssw.h.