MLPFProducer Class Reference

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::MLPFProducer ( const edm::ParameterSet &  cfg, const MLPFCache *  cache  )

explicit

Definition at line 31 of file MLPFProducer.cc.

    : 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

fillDescriptions()

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

static

Definition at line 132 of file MLPFProducer.cc.

                                                                              {
  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);
}

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

globalEndJob()

void MLPFProducer::globalEndJob ( MLPFCache *  cache )

static

Definition at line 130 of file MLPFProducer.cc.

{ delete cache->graph_def; }

References utilities::cache().

initializeGlobalCache()

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

static

Definition at line 116 of file MLPFProducer.cc.

                                                                                          {
  // 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;
}

References utilities::cache(), contentValuesFiles::fullPath, edm::FileInPath::fullPath(), tensorflow::loadGraphDef(), LogDebug, CalibrationSummaryClient_cfi::params, castor_dqm_sourceclient_file_cfg::path, and AlCaHLTBitMon_QueryRunRegistry::string.

produce()

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

override

Definition at line 38 of file MLPFProducer.cc.

                                                                      {
  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);
}

References reco::mlpf::argMax(), cms::cuda::assert(), reco::mlpf::BATCH_SIZE, gather_cfg::blocks, dqmMemoryStats::float, 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(), reco::mlpf::normalize(), reco::mlpf::NUM_CLASS, reco::mlpf::NUM_ELEMENT_FEATURES, reco::mlpf::NUM_MAX_ELEMENTS_BATCH, PatBasicFWLiteJetAnalyzer_Selector_cfg::outputs, reco::mlpf::pdgid_encoding, pfCandidatesPutToken_, tensorflow::run(), session_, and reco::mlpf::setCandidateRefs().

Member Data Documentation

inputTagBlocks_

const edm::EDGetTokenT<reco::PFBlockCollection> MLPFProducer::inputTagBlocks_

private

Definition at line 26 of file MLPFProducer.cc.

Referenced by produce().

model_path_

const std::string MLPFProducer::model_path_

private

Definition at line 27 of file MLPFProducer.cc.

pfCandidatesPutToken_

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

private

Definition at line 25 of file MLPFProducer.cc.

Referenced by produce().

session_

tensorflow::Session* MLPFProducer::session_

private

Definition at line 28 of file MLPFProducer.cc.

Referenced by produce().