#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::vector< std::string >	variablesOrder_

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"))),
         variablesOrder_(iConfig.getParameter<std::vector<std::string>>("variablesOrder")),
         name_(iConfig.getParameter<std::string>("name")),
         backend_(iConfig.getParameter<std::string>("backend")),
         weightfilename_(iConfig.getParameter<edm::FileInPath>("weightFile").fullPath()),
         isClassifier_(iConfig.getParameter<bool>("isClassifier")),
         tmva_(backend_ == "TMVA"),
         tf_(backend_ == "TF"),
         onnx_(backend_ == "ONNX"),
         batch_eval_(iConfig.getParameter<bool>("batch_eval")) {
     if (!(tmva_ || tf_ || onnx_)) {
       throw cms::Exception("ConfigError") << "Only 'TF', 'ONNX' and 'TMVA' backends are supported\n";
     }
 
     if (tmva_)
       reader_ = new TMVA::Reader();
     edm::ParameterSet const& varsPSet = iConfig.getParameter<edm::ParameterSet>("variables");
     for (const std::string& vname : varsPSet.getParameterNamesForType<std::string>()) {
       funcs_.emplace_back(
           std::pair<std::string, StringObjectFunction<T, true>>(vname, varsPSet.getParameter<std::string>(vname)));
     }
 
     values_.resize(variablesOrder_.size());
     size_t i = 0;
     for (const auto& v : variablesOrder_) {
       positions_[v] = i;
       if (tmva_)
         reader_->AddVariable(v, (&values_.front()) + i);
       i++;
     }
     //      reader_.BookMVA(name_,iConfig.getParameter<edm::FileInPath>("weightFile").fullPath() );
     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 139 of file BaseMVAValueMapProducer.h.

139 {}

Member Function Documentation

◆ beginStream()

template<typename T>

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

inlineoverrideprivate

Definition at line 153 of file BaseMVAValueMapProducer.h.

153 {};

◆ endStream()

template<typename T>

void BaseMVAValueMapProducer< T >::endStream ( )

inlineoverrideprivate

Definition at line 155 of file BaseMVAValueMapProducer.h.

155 {};

◆ fillAdditionalVariables()

template<typename T>

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

inlineprivatevirtual

Reimplemented in BJetEnergyRegressionMVA, and EvaluateMuonMVAID.

Definition at line 159 of file BaseMVAValueMapProducer.h.

159 {}

◆ fillDescriptions()

template<typename T >

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

static

Definition at line 312 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 288 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::vector<std::string>>("variablesOrder")->setComment("ordered list of MVA input variable names");
   desc.add<std::string>("name")->setComment("output score variable name");
   desc.add<bool>("isClassifier")->setComment("is a classifier discriminator");
   edm::ParameterSetDescription variables;
   variables.setAllowAnything();
   desc.add<edm::ParameterSetDescription>("variables", variables)->setComment("list of input variable definitions");
   desc.add<edm::FileInPath>("weightFile")->setComment("xml weight file");
   desc.add<std::string>("backend", "TMVA")->setComment("TMVA, TF or ONNX");
   desc.add<std::string>("inputTensorName", "")->setComment("Name of tensorflow input tensor in the model");
   desc.add<std::string>("outputTensorName", "")->setComment("Name of tensorflow output tensor in the model");
   desc.add<std::vector<std::string>>("outputNames", std::vector<std::string>())
       ->setComment("Names of the output values to be used in the output valuemap");
   desc.add<std::vector<std::string>>("outputFormulas", std::vector<std::string>())
       ->setComment("Formulas to be used to post process the output");
   desc.add<bool>("batch_eval", false)->setComment("Run inference in batch instead of per-object");
   desc.add<bool>("disableONNXGraphOpt", false)->setComment("Disable ONNX runtime graph optimization");
 
   return desc;
 }

◆ globalEndJob()

template<typename T >

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

static

Definition at line 285 of file BaseMVAValueMapProducer.h.

285 {}

◆ initializeGlobalCache()

template<typename T >

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

static

Definition at line 278 of file BaseMVAValueMapProducer.h.

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

◆ produce()

template<typename T >

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

overrideprivate

Definition at line 183 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 158 of file BaseMVAValueMapProducer.h.

158 {}

◆ setValue()

template<typename T>

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

inline

Definition at line 141 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 169 of file BaseMVAValueMapProducer.h.

◆ batch_eval_

template<typename T>

bool BaseMVAValueMapProducer< T >::batch_eval_

private

Definition at line 175 of file BaseMVAValueMapProducer.h.

◆ funcs_

template<typename T>

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

private

Definition at line 163 of file BaseMVAValueMapProducer.h.

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

◆ inputTensorName_

template<typename T>

std::string BaseMVAValueMapProducer< T >::inputTensorName_

private

Definition at line 176 of file BaseMVAValueMapProducer.h.

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

◆ isClassifier_

template<typename T>

bool BaseMVAValueMapProducer< T >::isClassifier_

private

Definition at line 171 of file BaseMVAValueMapProducer.h.

◆ name_

template<typename T>

std::string BaseMVAValueMapProducer< T >::name_

private

Definition at line 168 of file BaseMVAValueMapProducer.h.

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

◆ onnx_

template<typename T>

bool BaseMVAValueMapProducer< T >::onnx_

private

Definition at line 174 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 179 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 178 of file BaseMVAValueMapProducer.h.

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

◆ outputTensorName_

template<typename T>

std::string BaseMVAValueMapProducer< T >::outputTensorName_

private

Definition at line 177 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 162 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 166 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 161 of file BaseMVAValueMapProducer.h.

◆ tf_

template<typename T>

bool BaseMVAValueMapProducer< T >::tf_

private

Definition at line 173 of file BaseMVAValueMapProducer.h.

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

◆ tmva_

template<typename T>

bool BaseMVAValueMapProducer< T >::tmva_

private

Definition at line 172 of file BaseMVAValueMapProducer.h.

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

◆ values_

template<typename T>

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

private

Definition at line 165 of file BaseMVAValueMapProducer.h.

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

◆ variablesOrder_

template<typename T>

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

private

Definition at line 164 of file BaseMVAValueMapProducer.h.

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

◆ weightfilename_

template<typename T>

std::string BaseMVAValueMapProducer< T >::weightfilename_

private

Definition at line 170 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_

◆ variablesOrder_

◆ weightfilename_

template<typename T>
class BaseMVAValueMapProducer< T >