#include <PhysicsTools/PatAlgos/plugins/BaseMVAValueMapProducer.cc>

Inheritance diagram for BaseMVAValueMapProducer< T >:

Public Member Functions
	BaseMVAValueMapProducer (const edm::ParameterSet &iConfig, const BaseMVACache *cache)

void	setValue (const std::string var, float val)

	~BaseMVAValueMapProducer () override

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< BaseMVACache > >
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

static edm::ParameterSetDescription	getDescription ()

static void	globalEndJob (const BaseMVACache *cache)

static std::unique_ptr< BaseMVACache >	initializeGlobalCache (const edm::ParameterSet &cfg)

Private Member Functions
void	beginStream (edm::StreamID) override

void	endStream () override

virtual void	fillAdditionalVariables (const T &)

void	produce (edm::Event &, const edm::EventSetup &) override

virtual void	readAdditionalCollections (edm::Event &, const edm::EventSetup &)
	to be implemented in derived classes, filling values for additional variables More...

Private Attributes
std::string	backend_

bool	batch_eval_

std::vector< std::pair< std::string, StringObjectFunction< T, true > > >	funcs_

std::string	inputTensorName_

bool	isClassifier_

std::string	name_

bool	onnx_

std::vector< StringObjectFunction< std::vector< float > > >	output_formulas_

std::vector< std::string >	output_names_

std::string	outputTensorName_

std::map< std::string, size_t >	positions_

TMVA::Reader *	reader_

edm::EDGetTokenT< edm::View< T > >	src_

bool	tf_

bool	tmva_

std::vector< float >	values_

std::string	weightfilename_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< BaseMVACache > >
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

template<typename T>
class BaseMVAValueMapProducer< T >

Description: [one line class summary]

Implementation: [Notes on implementation]

Definition at line 85 of file BaseMVAValueMapProducer.h.

Constructor & Destructor Documentation

◆ BaseMVAValueMapProducer()

template<typename T>

BaseMVAValueMapProducer< T >::BaseMVAValueMapProducer	(	const edm::ParameterSet &	iConfig,
		const BaseMVACache *	cache
	)

inlineexplicit

Definition at line 87 of file BaseMVAValueMapProducer.h.

       : src_(consumes<edm::View<T>>(iConfig.getParameter<edm::InputTag>("src"))),
         name_(iConfig.getParameter<std::string>("name")),
         backend_(iConfig.getParameter<std::string>("backend")),
         weightfilename_(iConfig.getParameter<edm::FileInPath>("weightFile").fullPath()),
         tmva_(backend_ == "TMVA"),
         tf_(backend_ == "TF"),
         onnx_(backend_ == "ONNX"),
         batch_eval_(iConfig.getParameter<bool>("batch_eval")) {
     if (tmva_) {
       reader_ = new TMVA::Reader();
       isClassifier_ = iConfig.getParameter<bool>("isClassifier");
     }
 
     std::vector<edm::ParameterSet> const& varsPSet = iConfig.getParameter<std::vector<edm::ParameterSet>>("variables");
     values_.resize(varsPSet.size());
     size_t i = 0;
     for (const edm::ParameterSet& var_pset : varsPSet) {
       const std::string& vname = var_pset.getParameter<std::string>("name");
       if (var_pset.existsAs<std::string>("expr"))
         funcs_.emplace_back(
             std::pair<std::string, StringObjectFunction<T, true>>(vname, var_pset.getParameter<std::string>("expr")));
       positions_[vname] = i;
       if (tmva_)
         reader_->AddVariable(vname, (&values_.front()) + i);
       i++;
     }
 
     if (tmva_) {
       reco::details::loadTMVAWeights(reader_, name_, weightfilename_);
     }
     if (tf_ || onnx_) {
       inputTensorName_ = iConfig.getParameter<std::string>("inputTensorName");
       outputTensorName_ = iConfig.getParameter<std::string>("outputTensorName");
       output_names_ = iConfig.getParameter<std::vector<std::string>>("outputNames");
       for (const auto& s : iConfig.getParameter<std::vector<std::string>>("outputFormulas")) {
         output_formulas_.push_back(StringObjectFunction<std::vector<float>>(s));
       }
     }
 
     if (tmva_)
       produces<edm::ValueMap<float>>();
     else {
       for (const auto& n : output_names_) {
         produces<edm::ValueMap<float>>(n);
       }
     }
   }

◆ ~BaseMVAValueMapProducer()

template<typename T>

BaseMVAValueMapProducer< T >::~BaseMVAValueMapProducer ( )

inlineoverride

Definition at line 135 of file BaseMVAValueMapProducer.h.

135 {}

Member Function Documentation

◆ beginStream()

template<typename T>

void BaseMVAValueMapProducer< T >::beginStream ( edm::StreamID )

inlineoverrideprivate

Definition at line 149 of file BaseMVAValueMapProducer.h.

149 {};

◆ endStream()

template<typename T>

void BaseMVAValueMapProducer< T >::endStream ( )

inlineoverrideprivate

Definition at line 151 of file BaseMVAValueMapProducer.h.

151 {};

◆ fillAdditionalVariables()

template<typename T>

virtual void BaseMVAValueMapProducer< T >::fillAdditionalVariables ( const T & )

inlineprivatevirtual

Reimplemented in BJetEnergyRegressionMVA, and EvaluateMuonMVAID.

Definition at line 155 of file BaseMVAValueMapProducer.h.

155 {}

◆ fillDescriptions()

template<typename T >

void BaseMVAValueMapProducer< T >::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 328 of file BaseMVAValueMapProducer.h.

                                                                                             {
   edm::ParameterSetDescription desc = getDescription();
   std::string modname;
   if (typeid(T) == typeid(pat::Jet))
     modname += "Jet";
   else if (typeid(T) == typeid(pat::Muon))
     modname += "Muon";
   else if (typeid(T) == typeid(pat::Electron))
     modname += "Ele";
   modname += "BaseMVAValueMapProducer";
   descriptions.add(modname, desc);
 }

◆ getDescription()

template<typename T >

edm::ParameterSetDescription BaseMVAValueMapProducer< T >::getDescription ( )

static

Definition at line 286 of file BaseMVAValueMapProducer.h.

Referenced by EvaluateMuonMVAID::fillDescriptions(), and BJetEnergyRegressionMVA::fillDescriptions().

                                                                       {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("src")->setComment("input physics object collection");
 
   desc.add<std::string>("name")->setComment("output score variable name");
   desc.add<edm::FileInPath>("weightFile")->setComment("xml weight file, or TF/ONNX model file");
   desc.add<bool>("batch_eval", false)->setComment("Run inference in batch instead of per-object");
 
   edm::ParameterSetDescription variable;
   variable.add<std::string>("name")->setComment("name of the variable, either created by expr, or internally by code");
   variable.addOptional<std::string>("expr")->setComment(
       "a function to define the content of the model input, absence of it means the leaf is computed internally");
   variable.setComment("a PSet to define an entry to the ML model");
   desc.addVPSet("variables", variable);
 
   auto itn = edm::ParameterDescription<std::string>(
       "inputTensorName", "", true, edm::Comment("Name of tensorflow input tensor in the model"));
   auto otn = edm::ParameterDescription<std::string>(
       "outputTensorName", "", true, edm::Comment("Name of tensorflow output tensor in the model"));
   auto on = edm::ParameterDescription<std::vector<std::string>>(
       "outputNames",
       std::vector<std::string>(),
       true,
       edm::Comment("Names of the output values to be used in the output valuemap"));
   auto of = edm::ParameterDescription<std::vector<std::string>>(
       "outputFormulas",
       std::vector<std::string>(),
       true,
       edm::Comment("Formulas to be used to post process the output"));
   auto dog = edm::ParameterDescription<bool>(
       "disableONNXGraphOpt", false, true, edm::Comment("Disable ONNX runtime graph optimization"));
 
   desc.ifValue(edm::ParameterDescription<std::string>(
                    "backend", "TMVA", true, edm::Comment("the backend to evaluate the model:tmva, tf or onnx")),
                "TMVA" >> edm::ParameterDescription<bool>(
                              "isClassifier", true, true, edm::Comment("a classification or regression")) or
                    "TF" >> (itn and otn and on and of) or "ONNX" >> (itn and otn and on and of and dog));
 
   return desc;
 }

◆ globalEndJob()

template<typename T >

void BaseMVAValueMapProducer< T >::globalEndJob ( const BaseMVACache * cache )

static

Definition at line 283 of file BaseMVAValueMapProducer.h.

283 {}

◆ initializeGlobalCache()

template<typename T >

std::unique_ptr< BaseMVACache > BaseMVAValueMapProducer< T >::initializeGlobalCache ( const edm::ParameterSet & cfg )

static

Definition at line 273 of file BaseMVAValueMapProducer.h.

                                                                                                         {
   std::string backend = cfg.getParameter<std::string>("backend");
   bool disableONNXGraphOpt = false;
   if (backend == "ONNX")
     disableONNXGraphOpt = cfg.getParameter<bool>("disableONNXGraphOpt");
   return std::make_unique<BaseMVACache>(
       cfg.getParameter<edm::FileInPath>("weightFile").fullPath(), backend, disableONNXGraphOpt);
 }

◆ produce()

template<typename T >

void BaseMVAValueMapProducer< T >::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 178 of file BaseMVAValueMapProducer.h.

                                                                                       {
   edm::Handle<edm::View<T>> src;
   iEvent.getByToken(src_, src);
   readAdditionalCollections(iEvent, iSetup);
   std::vector<std::vector<float>> mvaOut((tmva_) ? 1 : output_names_.size());
   for (auto& v : mvaOut)
     v.reserve(src->size());
 
   if (batch_eval_) {
     if (!src->empty()) {
       std::vector<float> data;
       data.reserve(src->size() * positions_.size());
       for (auto const& o : *src) {
         for (auto const& p : funcs_) {
           setValue(p.first, p.second(o));
         }
         fillAdditionalVariables(o);
         data.insert(data.end(), values_.begin(), values_.end());
       }
 
       std::vector<float> outputs;
       if (tf_) {
         tensorflow::TensorShape input_size{(long long int)src->size(), (long long int)positions_.size()};
         tensorflow::NamedTensorList input_tensors;
         input_tensors.resize(1);
         input_tensors[0] =
             tensorflow::NamedTensor(inputTensorName_, tensorflow::Tensor(tensorflow::DT_FLOAT, input_size));
         for (unsigned i = 0; i < data.size(); ++i) {
           input_tensors[0].second.flat<float>()(i) = data[i];
         }
         std::vector<tensorflow::Tensor> output_tensors;
         tensorflow::run(globalCache()->getTFSession(), input_tensors, {outputTensorName_}, &output_tensors);
         for (unsigned i = 0; i < output_tensors.at(0).NumElements(); ++i) {
           outputs.push_back(output_tensors.at(0).flat<float>()(i));
         }
       } else if (onnx_) {
         cms::Ort::FloatArrays inputs{data};
         outputs =
             globalCache()->getONNXSession().run({inputTensorName_}, inputs, {}, {outputTensorName_}, src->size())[0];
       }
 
       const unsigned outdim = outputs.size() / src->size();
       for (unsigned i = 0; i < src->size(); ++i) {
         std::vector<float> tmpOut(outputs.begin() + i * outdim, outputs.begin() + (i + 1) * outdim);
         for (size_t k = 0; k < output_names_.size(); k++) {
           mvaOut[k].push_back(output_formulas_[k](tmpOut));
         }
       }
     }
   } else {
     for (auto const& o : *src) {
       for (auto const& p : funcs_) {
         setValue(p.first, p.second(o));
       }
       fillAdditionalVariables(o);
       if (tmva_) {
         mvaOut[0].push_back(isClassifier_ ? reader_->EvaluateMVA(name_) : reader_->EvaluateRegression(name_)[0]);
       } else {
         std::vector<float> tmpOut;
         if (tf_) {
           //currently support only one input sensor to reuse the TMVA like config
           tensorflow::TensorShape input_size{1, (long long int)positions_.size()};
           tensorflow::NamedTensorList input_tensors;
           input_tensors.resize(1);
           input_tensors[0] =
               tensorflow::NamedTensor(inputTensorName_, tensorflow::Tensor(tensorflow::DT_FLOAT, input_size));
           for (size_t j = 0; j < values_.size(); j++) {
             input_tensors[0].second.matrix<float>()(0, j) = values_[j];
           }
           std::vector<tensorflow::Tensor> outputs;
           tensorflow::run(globalCache()->getTFSession(), input_tensors, {outputTensorName_}, &outputs);
           for (int k = 0; k < outputs.at(0).matrix<float>().dimension(1); k++)
             tmpOut.push_back(outputs.at(0).matrix<float>()(0, k));
         } else if (onnx_) {
           cms::Ort::FloatArrays inputs{values_};
           tmpOut = globalCache()->getONNXSession().run({inputTensorName_}, inputs, {}, {outputTensorName_})[0];
         }
         for (size_t k = 0; k < output_names_.size(); k++)
           mvaOut[k].push_back(output_formulas_[k](tmpOut));
       }
     }
   }
 
   size_t k = 0;
   for (auto& m : mvaOut) {
     std::unique_ptr<edm::ValueMap<float>> mvaV(new edm::ValueMap<float>());
     edm::ValueMap<float>::Filler filler(*mvaV);
     filler.insert(src, m.begin(), m.end());
     filler.fill();
     iEvent.put(std::move(mvaV), (tmva_) ? "" : output_names_[k]);
     k++;
   }
 }

◆ readAdditionalCollections()

template<typename T>

virtual void BaseMVAValueMapProducer< T >::readAdditionalCollections	(	edm::Event &	,
		const edm::EventSetup &
	)

inlineprivatevirtual

to be implemented in derived classes, filling values for additional variables

Reimplemented in BJetEnergyRegressionMVA.

Definition at line 154 of file BaseMVAValueMapProducer.h.

154 {}

◆ setValue()

template<typename T>

void BaseMVAValueMapProducer< T >::setValue	(	const std::string	var,
		float	val
	)

inline

Definition at line 137 of file BaseMVAValueMapProducer.h.

                                                 {
     if (positions_.find(var) != positions_.end())
       values_[positions_[var]] = val;
   }

Member Data Documentation

◆ backend_

template<typename T>

std::string BaseMVAValueMapProducer< T >::backend_

private

Definition at line 164 of file BaseMVAValueMapProducer.h.

◆ batch_eval_

template<typename T>

bool BaseMVAValueMapProducer< T >::batch_eval_

private

Definition at line 170 of file BaseMVAValueMapProducer.h.

◆ funcs_

template<typename T>

std::vector<std::pair<std::string, StringObjectFunction<T, true> > > BaseMVAValueMapProducer< T >::funcs_

private

Definition at line 159 of file BaseMVAValueMapProducer.h.

Referenced by BaseMVAValueMapProducer< pat::Muon >::BaseMVAValueMapProducer().

◆ inputTensorName_

template<typename T>

std::string BaseMVAValueMapProducer< T >::inputTensorName_

private

Definition at line 171 of file BaseMVAValueMapProducer.h.

Referenced by BaseMVAValueMapProducer< pat::Muon >::BaseMVAValueMapProducer().

◆ isClassifier_

template<typename T>

bool BaseMVAValueMapProducer< T >::isClassifier_

private

Definition at line 166 of file BaseMVAValueMapProducer.h.

Referenced by BaseMVAValueMapProducer< pat::Muon >::BaseMVAValueMapProducer().

◆ name_

template<typename T>

std::string BaseMVAValueMapProducer< T >::name_

private

Definition at line 163 of file BaseMVAValueMapProducer.h.

Referenced by BaseMVAValueMapProducer< pat::Muon >::BaseMVAValueMapProducer().

◆ onnx_

template<typename T>

bool BaseMVAValueMapProducer< T >::onnx_

private

Definition at line 169 of file BaseMVAValueMapProducer.h.

Referenced by BaseMVAValueMapProducer< pat::Muon >::BaseMVAValueMapProducer().

◆ output_formulas_

template<typename T>

std::vector<StringObjectFunction<std::vector<float> > > BaseMVAValueMapProducer< T >::output_formulas_

private

Definition at line 174 of file BaseMVAValueMapProducer.h.

Referenced by BaseMVAValueMapProducer< pat::Muon >::BaseMVAValueMapProducer().

◆ output_names_

template<typename T>

std::vector<std::string> BaseMVAValueMapProducer< T >::output_names_

private

Definition at line 173 of file BaseMVAValueMapProducer.h.

Referenced by BaseMVAValueMapProducer< pat::Muon >::BaseMVAValueMapProducer().

◆ outputTensorName_

template<typename T>

std::string BaseMVAValueMapProducer< T >::outputTensorName_

private

Definition at line 172 of file BaseMVAValueMapProducer.h.

Referenced by BaseMVAValueMapProducer< pat::Muon >::BaseMVAValueMapProducer().

◆ positions_

template<typename T>

std::map<std::string, size_t> BaseMVAValueMapProducer< T >::positions_

private

Definition at line 158 of file BaseMVAValueMapProducer.h.

Referenced by BaseMVAValueMapProducer< pat::Muon >::BaseMVAValueMapProducer(), and BaseMVAValueMapProducer< pat::Muon >::setValue().

◆ reader_

template<typename T>

TMVA::Reader* BaseMVAValueMapProducer< T >::reader_

private

Definition at line 161 of file BaseMVAValueMapProducer.h.

Referenced by BaseMVAValueMapProducer< pat::Muon >::BaseMVAValueMapProducer().

◆ src_

template<typename T>

edm::EDGetTokenT<edm::View<T> > BaseMVAValueMapProducer< T >::src_

private

Definition at line 157 of file BaseMVAValueMapProducer.h.

◆ tf_

template<typename T>

bool BaseMVAValueMapProducer< T >::tf_

private

Definition at line 168 of file BaseMVAValueMapProducer.h.

Referenced by BaseMVAValueMapProducer< pat::Muon >::BaseMVAValueMapProducer().

◆ tmva_

template<typename T>

bool BaseMVAValueMapProducer< T >::tmva_

private

Definition at line 167 of file BaseMVAValueMapProducer.h.

Referenced by BaseMVAValueMapProducer< pat::Muon >::BaseMVAValueMapProducer().

◆ values_

template<typename T>

std::vector<float> BaseMVAValueMapProducer< T >::values_

private

Definition at line 160 of file BaseMVAValueMapProducer.h.

Referenced by BaseMVAValueMapProducer< pat::Muon >::BaseMVAValueMapProducer(), and BaseMVAValueMapProducer< pat::Muon >::setValue().

◆ weightfilename_

template<typename T>

std::string BaseMVAValueMapProducer< T >::weightfilename_

private

Definition at line 165 of file BaseMVAValueMapProducer.h.

Referenced by BaseMVAValueMapProducer< pat::Muon >::BaseMVAValueMapProducer().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

template<typename T> class BaseMVAValueMapProducer< T >

Constructor & Destructor Documentation

◆ BaseMVAValueMapProducer()

◆ ~BaseMVAValueMapProducer()

Member Function Documentation

◆ beginStream()

◆ endStream()

◆ fillAdditionalVariables()

◆ fillDescriptions()

◆ getDescription()

◆ globalEndJob()

◆ initializeGlobalCache()

◆ produce()

◆ readAdditionalCollections()

◆ setValue()

Member Data Documentation

◆ backend_

◆ batch_eval_

◆ funcs_

◆ inputTensorName_

◆ isClassifier_

◆ name_

◆ onnx_

◆ output_formulas_

◆ output_names_

◆ outputTensorName_

◆ positions_

◆ reader_

◆ src_

◆ tf_

◆ tmva_

◆ values_

◆ weightfilename_

template<typename T>
class BaseMVAValueMapProducer< T >