dqm_algorithms::AutoencoderExampleAlgorithm Struct Reference

#include <AutoencoderExampleAlgorithm.h>

Inheritance diagram for dqm_algorithms::AutoencoderExampleAlgorithm:

Collaboration diagram for dqm_algorithms::AutoencoderExampleAlgorithm:

Public Member Functions
	AutoencoderExampleAlgorithm ()
virtual	~AutoencoderExampleAlgorithm () override=default
virtual AutoencoderExampleAlgorithm *	clone () override
virtual dqm_core::Result *	execute (const std::string &, const TObject &, const dqm_core::AlgorithmConfig &) override
void	printDescription (std::ostream &out)

Public Attributes
Ort::Env	env
Ort::SessionOptions	session_options
std::unique_ptr< Ort::Session >	session
std::vector< std::string >	input_names
std::vector< std::string >	output_names

Detailed Description

Definition at line 38 of file AutoencoderExampleAlgorithm.h.

Constructor & Destructor Documentation

AutoencoderExampleAlgorithm()

dqm_algorithms::AutoencoderExampleAlgorithm::AutoencoderExampleAlgorithm

(

)

Definition at line 59 of file AutoencoderExampleAlgorithm.cxx.

: env(ORT_LOGGING_LEVEL_WARNING, "test"), 
session_options()
{
 
  dqm_core::AlgorithmManager::instance().registerAlgorithm("AutoencoderExampleAlgorithm", this);
 
  // Demonstration Note:
  // The following code and some code in the execute method utilize the onnx cxx api.
  // Please refer to that documentation as you prepare cxx code for your algorithm.
 
  // Configure session options before use.
  session_options.SetIntraOpNumThreads(1);
 
  // Load the model.
  // eos does not have guaranteed availability, so we use PathResolver to find asg-calib/dev for non-production algorithms.
  const std::string model_path = PathResolverFindCalibFile("ONNXfiles/autoencoder_model.onnx");
  session = std::make_unique<Ort::Session>(env, model_path.c_str(), session_options);
 
  // Prepare and, if desired, print the input node names.
  size_t num_input_nodes = session->GetInputCount();
  Ort::AllocatorWithDefaultOptions allocator;
  for (size_t i = 0; i < num_input_nodes; ++i)
  {
      std::unique_ptr<char, Ort::detail::AllocatedFree> input_name_ptr = session->GetInputNameAllocated(i, allocator);
      char* input_name = input_name_ptr.get();
      input_names.push_back(input_name);
  }
 
  // Prepare and, if desired, print the output node names.
  size_t num_output_nodes = session->GetOutputCount();
  for (size_t i = 0; i < num_output_nodes; ++i)
  {
      std::unique_ptr<char, Ort::detail::AllocatedFree> output_name_ptr = session->GetOutputNameAllocated(i, allocator);
      char* output_name = output_name_ptr.get();
      output_names.push_back(output_name);
  }
 
}

~AutoencoderExampleAlgorithm()

virtual dqm_algorithms::AutoencoderExampleAlgorithm::~AutoencoderExampleAlgorithm ( )

overridevirtualdefault

Member Function Documentation

clone()

dqm_algorithms::AutoencoderExampleAlgorithm * dqm_algorithms::AutoencoderExampleAlgorithm::clone ( )

overridevirtual

Definition at line 101 of file AutoencoderExampleAlgorithm.cxx.

{
  return new AutoencoderExampleAlgorithm();
}

execute()

dqm_core::Result * dqm_algorithms::AutoencoderExampleAlgorithm::execute ( const std::string & name, const TObject & object, const dqm_core::AlgorithmConfig &  )

overridevirtual

Definition at line 115 of file AutoencoderExampleAlgorithm.cxx.

{
    // Using the TObject object, check if it is of TH2 type, throw error if not the right type.
    // Demonstration Note:
    //  The TObject object can vary depending on what kind of TObject you wish to utilize for your algorithm.
    //  The remainder of the execute method assumes the goals of this particular new algorithm. Modify as needed.
    const TH2* histogram;
    if (object.IsA()->InheritsFrom("TH2")) 
    {
        histogram = dynamic_cast<const TH2*>(&object);
        if (histogram->GetDimension() < 2)
        {
            throw dqm_core::BadConfig( ERS_HERE, name, "dimension of histogram < 2");
        }
    }
    else
    {
        throw dqm_core::BadConfig( ERS_HERE, name, "does not inherit from TH2" );
    }
 
    // Extract data from histogram.
    std::vector<std::vector<float>> hist_data = extract_histogram_data(histogram);
 
    // Run inference for the data using the model.
    std::vector<std::vector<float>> output_data;
    std::vector<int64_t> input_dims = {1, 3}; // Input here is as a single data point with 3 features
 
    Ort::MemoryInfo memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
    const char* input_names_cstr[] = { input_names[0].c_str() };
    const char* output_names_cstr[] = { output_names[0].c_str() };
    for (auto& input_data : hist_data) {
        // Create the input tensor.
        Ort::Value input_tensor = Ort::Value::CreateTensor<float>(memory_info, input_data.data(), input_data.size(), input_dims.data(), input_dims.size());
 
        // Run the inference.
        auto output_tensors = session->Run(Ort::RunOptions{nullptr}, input_names_cstr, &input_tensor, 1, output_names_cstr, 1);
 
        // Check if the std::vector or its output_tensors do or do not have valid values for existence.
        if (output_tensors.empty() || output_tensors[0].HasValue())
        {
            throw dqm_core::BadConfig(ERS_HERE, name, "Output tensor does not have values or does not exist");
        }
 
        // Check Tensor Size.
        const size_t tensor_size = output_tensors[0].GetTensorTypeAndShapeInfo().GetElementCount();
 
        if (tensor_size < 3)
        {
             throw dqm_core::BadConfig(ERS_HERE, name, "Output tensor < 3 elements");
        }
 
        // Prepare the output_data.
        float* raw_output = output_tensors[0].GetTensorMutableData<float>();
        std::vector<float> output_point(raw_output, raw_output + 3);
        output_data.push_back(output_point);
    }
 
    // Compute the reconstruction error.
    //  (Algorithm specific logic, post inference)
    std::vector<float> reconstruction_errors;
    for (size_t i = 0; i < hist_data.size(); ++i) {
        float error = 0.0;
        for (size_t j = 0; j < 3; ++j) {
            error += std::pow(hist_data[i][j] - output_data[i][j], 2);
        }
        reconstruction_errors.push_back(std::sqrt(error));
    }
 
    // Calculate threshold based on the 99th percentile of reconstruction errors
    //  (Algorithm specific logic, post inference)
    std::nth_element(reconstruction_errors.begin(), reconstruction_errors.begin() + std::roundl(reconstruction_errors.size() * (99. / 100.)), reconstruction_errors.end());
    float threshold = reconstruction_errors[reconstruction_errors.size() * 99 / 100];
 
    // Identify anomalies based on threshold vs reconstruction_error.
    //  (Algorithm specific logic, post inference)
    std::vector<bool> anomalies;
    for (const auto& error : reconstruction_errors) {
        anomalies.push_back(error > threshold);
    }
 
    // Demonstration Note:
    //  There are a lot of variations on how the result of the dqm_algorithm including how it interacts with the test display.
    //  I suggest looking at least at other algorithms for inspiration.
    //  The documentation and examples of that is outside of scope of this template.
    //  However, this template demonstrates at least the minimum required to setup the new algorithm and on the test display
    //  with perhaps some information of interest to this particular new algorithm.
 
    // Prepare the resulthisto
    TH2* resulthisto;
    if (histogram->InheritsFrom("TH2"))
    {
        resulthisto=static_cast<TH2*>(histogram->Clone());
    }
    else
    {
        throw dqm_core::BadConfig( ERS_HERE, name, "does not inherit from TH2" );
    }
    resulthisto->Reset();
 
    // Loop through anomalies to set result, print, etc.
    for (size_t i = 0; i < anomalies.size(); ++i) {
        if (anomalies[i])
        {
            // Set the resulting histogram to the bin content
            resulthisto->SetBinContent(hist_data[i][0], hist_data[i][1], hist_data[i][2]);
        }
    }
 
    // Prepare the result of the main/execute method
    dqm_core::Result* result = new dqm_core::Result();
 
    // For the result, set NBins to the number of anomalies
    result->tags_["NBins"] = anomalies.size();
 
    // For the result, set the resulting histogram to the bin content we SetBinContent above with
    result->object_ =  boost::shared_ptr<TObject>(resulthisto);
 
    // Set the thresholds
    double gthreshold = 5000;
    double rthreshold = 10000;
 
    // Determine if the overall histogram is green, yellow, or red and send that to the result
    if (anomalies.size() <= gthreshold)
    {
        result->status_ = dqm_core::Result::Green;
    }
    else if (anomalies.size() < rthreshold)
    {
        result->status_ = dqm_core::Result::Yellow;
    }
    else
    {
        result->status_ = dqm_core::Result::Red;
    }
 
    // For debugging, remove when done
    //dqm_core::Result *result = new dqm_core::Result(dqm_core::Result::Undefined);
    return result;
}

printDescription()

void dqm_algorithms::AutoencoderExampleAlgorithm::printDescription

(

std::ostream &

out

)

Definition at line 266 of file AutoencoderExampleAlgorithm.cxx.

{
    out<<"AutoencoderExampleAlgorithm: Load and process an onnx autoencoder model given the AutoencoderExampleAlgorithm.cxx "<<std::endl;
}

Member Data Documentation

env

Ort::Env dqm_algorithms::AutoencoderExampleAlgorithm::env

Definition at line 52 of file AutoencoderExampleAlgorithm.h.

input_names

std::vector<std::string> dqm_algorithms::AutoencoderExampleAlgorithm::input_names

Definition at line 55 of file AutoencoderExampleAlgorithm.h.

output_names

std::vector<std::string> dqm_algorithms::AutoencoderExampleAlgorithm::output_names

Definition at line 56 of file AutoencoderExampleAlgorithm.h.

session

std::unique_ptr<Ort::Session> dqm_algorithms::AutoencoderExampleAlgorithm::session

Definition at line 54 of file AutoencoderExampleAlgorithm.h.

session_options

Ort::SessionOptions dqm_algorithms::AutoencoderExampleAlgorithm::session_options

Definition at line 53 of file AutoencoderExampleAlgorithm.h.

---

The documentation for this struct was generated from the following files:

• AutoencoderExampleAlgorithm.h
• AutoencoderExampleAlgorithm.cxx