Inheritance diagram for MLPFProducer:

Public Member Functions
	MLPFProducer (const edm::ParameterSet &, const MLPFCache *)

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

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< MLPFCache > >
	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 void	globalEndJob (MLPFCache *)

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

Private Attributes
const edm::EDGetTokenT < reco::PFBlockCollection >	inputTagBlocks_

const std::string	model_path_

const edm::EDPutTokenT < reco::PFCandidateCollection >	pfCandidatesPutToken_

tensorflow::Session *	session_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< MLPFCache > >
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

Definition at line 14 of file MLPFProducer.cc.

Constructor & Destructor Documentation

MLPFProducer::MLPFProducer	(	const edm::ParameterSet &	cfg,
		const MLPFCache *	cache
	)

explicit

Definition at line 31 of file MLPFProducer.cc.

References tensorflow::createSession(), edm::ParameterSet::getParameter(), MLPFCache::graph_def, inputTagBlocks_, model_path_, session_, and AlCaHLTBitMon_QueryRunRegistry::string.

     : pfCandidatesPutToken_{produces<reco::PFCandidateCollection>()},
       inputTagBlocks_(consumes<reco::PFBlockCollection>(cfg.getParameter<edm::InputTag>("src"))),
       model_path_(cfg.getParameter<std::string>("model_path")) {
   session_ = tensorflow::createSession(cache->graph_def);
 }

Member Function Documentation

void MLPFProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 132 of file MLPFProducer.cc.

References edm::ParameterSetDescription::add(), edm::ConfigurationDescriptions::addWithDefaultLabel(), submitPVResolutionJobs::desc, HLT_FULL_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                               {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("src", edm::InputTag("particleFlowBlock"));
   desc.add<std::string>("model_path", "RecoParticleFlow/PFProducer/data/mlpf/mlpf_2020_11_04.pb");
   descriptions.addWithDefaultLabel(desc);
 }

void MLPFProducer::globalEndJob ( MLPFCache * cache )

static

Definition at line 130 of file MLPFProducer.cc.

References MLPFCache::graph_def.

130 { delete cache->graph_def; }

MLPFCache::graph_def

const tensorflow::GraphDef * graph_def

Definition: MLPFProducer.cc:11

std::unique_ptr< MLPFCache > MLPFProducer::initializeGlobalCache ( const edm::ParameterSet & params )

static

Definition at line 116 of file MLPFProducer.cc.

References utilities::cache(), contentValuesFiles::fullPath, edm::FileInPath::fullPath(), edm::ParameterSet::getParameter(), tensorflow::loadGraphDef(), LogDebug, fed_dqm_sourceclient-live_cfg::path, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                           {
   // this method is supposed to create, initialize and return a MLPFCache instance
   std::unique_ptr<MLPFCache> cache = std::make_unique<MLPFCache>();
 
   //load the frozen TF graph of the GNN model
   std::string path = params.getParameter<std::string>("model_path");
   auto fullPath = edm::FileInPath(path).fullPath();
   LogDebug("MLPFProducer") << "Initializing MLPF model from " << fullPath;
 
   cache->graph_def = tensorflow::loadGraphDef(fullPath);
 
   return cache;
 }

void MLPFProducer::produce	(	edm::Event &	event,
		const edm::EventSetup &	setup
	)

override

Definition at line 38 of file MLPFProducer.cc.

References reco::mlpf::argMax(), cms::cuda::assert(), reco::mlpf::BATCH_SIZE, gather_cfg::blocks, reco::mlpf::getElementProperties(), reco::mlpf::getPFElements(), reco::mlpf::IDX_CHARGE, reco::mlpf::IDX_ENERGY, reco::mlpf::IDX_ETA, reco::mlpf::IDX_PHI, input, inputTagBlocks_, reco::mlpf::LSH_BIN_SIZE, reco::mlpf::makeCandidate(), mlpf_cff::mlpf, reco::mlpf::normalize(), reco::mlpf::NUM_CLASS, reco::mlpf::NUM_ELEMENT_FEATURES, reco::mlpf::NUM_MAX_ELEMENTS_BATCH, reco::mlpf::pdgid_encoding, pfCandidatesPutToken_, tensorflow::run(), session_, and reco::mlpf::setCandidateRefs().

                                                                       {
   using namespace reco::mlpf;
 
   const auto& blocks = event.get(inputTagBlocks_);
   const auto& all_elements = getPFElements(blocks);
 
   const long long int num_elements_total = all_elements.size();
 
   //tensor size must be a multiple of the bin size and larger than the number of elements
   const auto tensor_size = LSH_BIN_SIZE * (num_elements_total / LSH_BIN_SIZE + 1);
   assert(tensor_size <= NUM_MAX_ELEMENTS_BATCH);
 
   //Create the input tensor
   tensorflow::TensorShape shape({BATCH_SIZE, tensor_size, NUM_ELEMENT_FEATURES});
   tensorflow::Tensor input(tensorflow::DT_FLOAT, shape);
   input.flat<float>().setZero();
 
   //Fill the input tensor
   unsigned int ielem = 0;
   for (const auto* pelem : all_elements) {
     const auto& elem = *pelem;
 
     //prepare the input array from the PFElement
     const auto& props = getElementProperties(elem);
 
     //copy features to the input array
     for (unsigned int iprop = 0; iprop < NUM_ELEMENT_FEATURES; iprop++) {
       input.tensor<float, 3>()(0, ielem, iprop) = normalize(props[iprop]);
     }
     ielem += 1;
   }
 
   //TF model input and output tensor names
   const tensorflow::NamedTensorList input_list = {{"x:0", input}};
   const std::vector<std::string> output_names = {"Identity:0"};
 
   //Prepare the output tensor
   std::vector<tensorflow::Tensor> outputs;
 
   //run the GNN inference, given the inputs and the output.
   //Note that the GNN enables information transfer between the input PFElements,
   //such that the output ML-PFCandidates are in general combinations of the input PFElements, in the form of
   //y_out = Adj.x_in, where x_in is input matrix (num_elem, NUM_ELEMENT_FEATURES), y_out is the output matrix (num_elem, NUM_OUTPUT_FEATURES)
   //and Adj is an adjacency matrix between the elements that is constructed on the fly during model inference.
   tensorflow::run(session_, input_list, output_names, &outputs);
 
   //process the output tensor to ML-PFCandidates.
   //The output can contain up to num_elem particles, with predicted PDGID=0 corresponding to no particles predicted.
   const auto out_arr = outputs[0].tensor<float, 3>();
 
   std::vector<reco::PFCandidate> pOutputCandidateCollection;
   for (unsigned int ielem = 0; ielem < all_elements.size(); ielem++) {
     //get the coefficients in the output corresponding to the class probabilities (raw logits)
     std::vector<float> pred_id_logits;
     for (unsigned int idx_id = 0; idx_id <= NUM_CLASS; idx_id++) {
       pred_id_logits.push_back(out_arr(0, ielem, idx_id));
     }
 
     //get the most probable class PDGID
     int pred_pid = pdgid_encoding[argMax(pred_id_logits)];
 
     //get the predicted momentum components
     float pred_eta = out_arr(0, ielem, IDX_ETA);
     float pred_phi = out_arr(0, ielem, IDX_PHI);
     float pred_charge = out_arr(0, ielem, IDX_CHARGE);
     float pred_e = out_arr(0, ielem, IDX_ENERGY);
 
     //a particle was predicted for this PFElement, otherwise it was a spectator
     if (pred_pid != 0) {
       auto cand = makeCandidate(pred_pid, pred_charge, pred_e, pred_eta, pred_phi);
       setCandidateRefs(cand, all_elements, ielem);
       pOutputCandidateCollection.push_back(cand);
     }
   }  //loop over PFElements
 
   event.emplace(pfCandidatesPutToken_, pOutputCandidateCollection);
 }