From 0d21c42968496b3b8e30ac78a7e093c20780611f Mon Sep 17 00:00:00 2001 From: leonardo Date: Thu, 29 Oct 2020 16:38:07 +0100 Subject: [PATCH 01/14] enable DeepCombinedJetTags as supported tagger --- PhysicsTools/PatAlgos/python/recoLayer0/bTagging_cff.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/PhysicsTools/PatAlgos/python/recoLayer0/bTagging_cff.py b/PhysicsTools/PatAlgos/python/recoLayer0/bTagging_cff.py index 89a9277aaeb9b..8e6d3e39e9329 100644 --- a/PhysicsTools/PatAlgos/python/recoLayer0/bTagging_cff.py +++ b/PhysicsTools/PatAlgos/python/recoLayer0/bTagging_cff.py @@ -193,6 +193,10 @@ , 'pfDeepFlavourJetTags:probuds' : [["pfDeepFlavourTagInfos"], ['pfDeepCSVTagInfos', "pfImpactParameterTagInfos", 'pfInclusiveSecondaryVertexFinderTagInfos']] , 'pfDeepFlavourJetTags:probg' : [["pfDeepFlavourTagInfos"], ['pfDeepCSVTagInfos', "pfImpactParameterTagInfos", 'pfInclusiveSecondaryVertexFinderTagInfos']] , 'pfDeepVertexJetTags:probb' : [["pfDeepFlavourTagInfos"], ['pfDeepCSVTagInfos', "pfImpactParameterTagInfos", 'pfInclusiveSecondaryVertexFinderTagInfos']] + , 'pfDeepCombinedJetTags:probb' : [["pfDeepFlavourTagInfos"], ['pfDeepCSVTagInfos', "pfImpactParameterTagInfos", 'pfInclusiveSecondaryVertexFinderTagInfos']] + , 'pfDeepCombinedJetTags:probc' : [["pfDeepFlavourTagInfos"], ['pfDeepCSVTagInfos', "pfImpactParameterTagInfos", 'pfInclusiveSecondaryVertexFinderTagInfos']] + , 'pfDeepCombinedJetTags:probuds' : [["pfDeepFlavourTagInfos"], ['pfDeepCSVTagInfos', "pfImpactParameterTagInfos", 'pfInclusiveSecondaryVertexFinderTagInfos']] + , 'pfDeepCombinedJetTags:probg' : [["pfDeepFlavourTagInfos"], ['pfDeepCSVTagInfos', "pfImpactParameterTagInfos", 'pfInclusiveSecondaryVertexFinderTagInfos']] , 'pfNegativeDeepFlavourJetTags:probb' : [["pfNegativeDeepFlavourTagInfos"], ['pfDeepCSVNegativeTagInfos', "pfImpactParameterTagInfos", 'pfInclusiveSecondaryVertexFinderNegativeTagInfos']] , 'pfNegativeDeepFlavourJetTags:probbb' : [["pfNegativeDeepFlavourTagInfos"], ['pfDeepCSVNegativeTagInfos', "pfImpactParameterTagInfos", 'pfInclusiveSecondaryVertexFinderNegativeTagInfos']] , 'pfNegativeDeepFlavourJetTags:problepb' : [["pfNegativeDeepFlavourTagInfos"], ['pfDeepCSVNegativeTagInfos', "pfImpactParameterTagInfos", 'pfInclusiveSecondaryVertexFinderNegativeTagInfos']] From bf3813a7f5c4ef85dffc567893652c9301a15f4f Mon Sep 17 00:00:00 2001 From: leonardo Date: Thu, 29 Oct 2020 16:38:38 +0100 Subject: [PATCH 02/14] move to ONNX and add combination --- RecoBTag/ONNXRuntime/python/pfDeepFlavour_cff.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/RecoBTag/ONNXRuntime/python/pfDeepFlavour_cff.py b/RecoBTag/ONNXRuntime/python/pfDeepFlavour_cff.py index a68d2585bad19..e4c446a178028 100644 --- a/RecoBTag/ONNXRuntime/python/pfDeepFlavour_cff.py +++ b/RecoBTag/ONNXRuntime/python/pfDeepFlavour_cff.py @@ -5,7 +5,8 @@ from RecoBTag.FeatureTools.pfDeepDoubleXTagInfos_cfi import pfDeepDoubleXTagInfos from RecoBTag.ONNXRuntime.pfDeepFlavourJetTags_cfi import pfDeepFlavourJetTags -from RecoBTag.TensorFlow.pfDeepVertexJetTags_cfi import pfDeepVertexJetTags +from RecoBTag.ONNXRuntime.pfDeepVertexJetTags_cfi import pfDeepVertexJetTags +from RecoBTag.ONNXRuntime.pfDeepCombinedJetTags_cfi import pfDeepCombinedJetTags from RecoBTag.ONNXRuntime.pfNegativeDeepFlavourJetTags_cfi import pfNegativeDeepFlavourJetTags from CommonTools.PileupAlgos.Puppi_cff import puppi from PhysicsTools.PatAlgos.slimming.primaryVertexAssociation_cfi import primaryVertexAssociation From 7bb2adf259930911a4a221d94c22d913bef8dcb9 Mon Sep 17 00:00:00 2001 From: leonardo Date: Thu, 29 Oct 2020 16:40:17 +0100 Subject: [PATCH 03/14] move producers to ONNX and add DeepCombinedONNXJetTags --- .../DeepCombinedONNXJetTagsProducer.cc | 352 ++++++++++++++++++ .../plugins/DeepVertexONNXJetTagsProducer.cc | 254 +++++++++++++ 2 files changed, 606 insertions(+) create mode 100644 RecoBTag/ONNXRuntime/plugins/DeepCombinedONNXJetTagsProducer.cc create mode 100644 RecoBTag/ONNXRuntime/plugins/DeepVertexONNXJetTagsProducer.cc diff --git a/RecoBTag/ONNXRuntime/plugins/DeepCombinedONNXJetTagsProducer.cc b/RecoBTag/ONNXRuntime/plugins/DeepCombinedONNXJetTagsProducer.cc new file mode 100644 index 0000000000000..1be01629b140a --- /dev/null +++ b/RecoBTag/ONNXRuntime/plugins/DeepCombinedONNXJetTagsProducer.cc @@ -0,0 +1,352 @@ +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/stream/EDProducer.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" + +#include "FWCore/Framework/interface/makeRefToBaseProdFrom.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Utilities/interface/StreamID.h" + +#include "DataFormats/BTauReco/interface/JetTag.h" + +#include "DataFormats/BTauReco/interface/DeepFlavourTagInfo.h" + +#include "PhysicsTools/ONNXRuntime/interface/ONNXRuntime.h" + +using namespace cms::Ort; + +class DeepCombinedONNXJetTagsProducer : public edm::stream::EDProducer> { +public: + explicit DeepCombinedONNXJetTagsProducer(const edm::ParameterSet&, const ONNXRuntime*); + ~DeepCombinedONNXJetTagsProducer() override; + + static void fillDescriptions(edm::ConfigurationDescriptions&); + + static std::unique_ptr initializeGlobalCache(const edm::ParameterSet&); + static void globalEndJob(const ONNXRuntime*); + +private: + typedef std::vector TagInfoCollection; + typedef reco::JetTagCollection JetTagCollection; + + void produce(edm::Event&, const edm::EventSetup&) override; + + void make_inputs(unsigned i_jet, const reco::DeepFlavourTagInfo& taginfo); + + const edm::EDGetTokenT src_; + std::vector flav_names_; + std::vector input_names_; + std::vector output_names_; + + enum InputIndexes { kGlobal = 0, kChargedCandidates = 1, kNeutralCandidates = 2, kVertices = 3, kGlobal1 = 4, kSeedingTracks = 5, kNeighbourTracks = 6 }; + constexpr static unsigned n_features_global_ = 15; + constexpr static unsigned n_cpf_ = 25; + constexpr static unsigned n_features_cpf_ = 16; + constexpr static unsigned n_npf_ = 25; + constexpr static unsigned n_features_npf_ = 6; + constexpr static unsigned n_sv_ = 4; + constexpr static unsigned n_features_sv_ = 12; + constexpr static unsigned n_features_global1_ = 4; + constexpr static unsigned n_seed_ = 10; + constexpr static unsigned n_features_seed_ = 21; + constexpr static unsigned n_neighbor_ = 20; + constexpr static unsigned n_features_neighbor_ = 36; + + const static std::vector input_sizes_; + + // hold the input data + FloatArrays data_; +}; + +const std::vector DeepCombinedONNXJetTagsProducer::input_sizes_{ + n_features_global_, n_cpf_* n_features_cpf_, n_npf_* n_features_npf_, n_sv_* n_features_sv_, + n_features_global1_, n_seed_* n_features_seed_, n_neighbor_* n_features_neighbor_, + n_neighbor_* n_features_neighbor_, n_neighbor_* n_features_neighbor_, n_neighbor_* n_features_neighbor_, + n_neighbor_* n_features_neighbor_, n_neighbor_* n_features_neighbor_, n_neighbor_* n_features_neighbor_, + n_neighbor_* n_features_neighbor_, n_neighbor_* n_features_neighbor_, n_neighbor_* n_features_neighbor_}; + +DeepCombinedONNXJetTagsProducer::DeepCombinedONNXJetTagsProducer(const edm::ParameterSet& iConfig, + const ONNXRuntime* cache) + : src_(consumes(iConfig.getParameter("src"))), + flav_names_(iConfig.getParameter>("flav_names")), + input_names_(iConfig.getParameter>("input_names")), + output_names_(iConfig.getParameter>("output_names")) { + // get output names from flav_names + for (const auto& flav_name : flav_names_) { + produces(flav_name); + } + + assert(input_names_.size() == input_sizes_.size()); +} + +DeepCombinedONNXJetTagsProducer::~DeepCombinedONNXJetTagsProducer() {} + +void DeepCombinedONNXJetTagsProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + // pfDeepFlavourJetTags + edm::ParameterSetDescription desc; + desc.add("src", edm::InputTag("pfDeepFlavourTagInfos")); + desc.add>("input_names", { + "input_1_DFla", "input_2_DFla", "input_3_DFla", "input_4_DFla", + "input_1", "input_2", "input_3", "input_4", "input_5", "input_6", "input_7", "input_8", "input_9", "input_10", "input_11", "input_12"}); + desc.add("model_path", + edm::FileInPath("RecoBTag/Combined/data/DeepVertex/phase1_deepvertexcombined.onnx")); + desc.add>("output_names", {"dense_13"}); + desc.add>( + "flav_names", std::vector{"probb", "probc", "probuds", "probg"}); + + descriptions.add("pfDeepCombinedJetTags", desc); +} + +std::unique_ptr DeepCombinedONNXJetTagsProducer::initializeGlobalCache(const edm::ParameterSet& iConfig) { + return std::make_unique(iConfig.getParameter("model_path").fullPath()); +} + +void DeepCombinedONNXJetTagsProducer::globalEndJob(const ONNXRuntime* cache) {} + +void DeepCombinedONNXJetTagsProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { + edm::Handle tag_infos; + iEvent.getByToken(src_, tag_infos); + + std::vector> output_tags; + if (!tag_infos->empty()) { + // initialize output collection + auto jet_ref = tag_infos->begin()->jet(); + auto ref2prod = edm::makeRefToBaseProdFrom(jet_ref, iEvent); + for (std::size_t i = 0; i < flav_names_.size(); i++) { + output_tags.emplace_back(std::make_unique(ref2prod)); + } + +// std::cout << "intializing data storage" << std::endl; + // init data storage + data_.clear(); + for (const auto& len : input_sizes_) { + data_.emplace_back(tag_infos->size() * len, 0); + } +// std::cout << "make inoputs" << std::endl; + // convert inputs + for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { + const auto& taginfo = (*tag_infos)[jet_n]; + make_inputs(jet_n, taginfo); + } + +// std::cout << "run the predictions" << std::endl; + // run prediction + auto outputs = globalCache()->run(input_names_, data_, {}, output_names_, tag_infos->size())[0]; + assert(outputs.size() == flav_names_.size() * tag_infos->size()); + + // get the outputs +// std::cout << "get predictions" << std::endl; + unsigned i_output = 0; + for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { + const auto& jet_ref = tag_infos->at(jet_n).jet(); + for (std::size_t flav_n = 0; flav_n < flav_names_.size(); flav_n++) { + (*(output_tags[flav_n]))[jet_ref] = outputs[i_output]; +// std::cout << outputs[i_output] << " my outttt cccc " << flav_names_[flav_n] << std::endl; + ++i_output; + } + } + } else { + // create empty output collection + for (std::size_t i = 0; i < flav_names_.size(); i++) { + output_tags.emplace_back(std::make_unique()); + } + } + + // put into the event + for (std::size_t flav_n = 0; flav_n < flav_names_.size(); ++flav_n) { + iEvent.put(std::move(output_tags[flav_n]), flav_names_[flav_n]); + } +} + +void DeepCombinedONNXJetTagsProducer::make_inputs(unsigned i_jet, const reco::DeepFlavourTagInfo& taginfo) { + const auto& features = taginfo.features(); + float* ptr = nullptr; + const float* start = nullptr; + unsigned offset = 0; + + // jet and other global features + offset = i_jet * input_sizes_[kGlobal]; + ptr = &data_[kGlobal][offset]; + // jet variables + const auto& jet_features = features.jet_features; + start = ptr; + *ptr = jet_features.pt; + *(++ptr) = jet_features.eta; + // number of elements in different collections + *(++ptr) = features.c_pf_features.size(); + *(++ptr) = features.n_pf_features.size(); + *(++ptr) = features.sv_features.size(); + *(++ptr) = features.npv; + // variables from ShallowTagInfo + const auto& tag_info_features = features.tag_info_features; + *(++ptr) = tag_info_features.trackSumJetEtRatio; + *(++ptr) = tag_info_features.trackSumJetDeltaR; + *(++ptr) = tag_info_features.vertexCategory; + *(++ptr) = tag_info_features.trackSip2dValAboveCharm; + *(++ptr) = tag_info_features.trackSip2dSigAboveCharm; + *(++ptr) = tag_info_features.trackSip3dValAboveCharm; + *(++ptr) = tag_info_features.trackSip3dSigAboveCharm; + *(++ptr) = tag_info_features.jetNSelectedTracks; + *(++ptr) = tag_info_features.jetNTracksEtaRel; + assert(start + n_features_global_ - 1 == ptr); + + // c_pf candidates + auto max_c_pf_n = std::min(features.c_pf_features.size(), (std::size_t)25); + offset = i_jet * input_sizes_[kChargedCandidates]; + for (std::size_t c_pf_n = 0; c_pf_n < max_c_pf_n; c_pf_n++) { + const auto& c_pf_features = features.c_pf_features.at(c_pf_n); + ptr = &data_[kChargedCandidates][offset + c_pf_n * n_features_cpf_]; + start = ptr; + *ptr = c_pf_features.btagPf_trackEtaRel; + *(++ptr) = c_pf_features.btagPf_trackPtRel; + *(++ptr) = c_pf_features.btagPf_trackPPar; + *(++ptr) = c_pf_features.btagPf_trackDeltaR; + *(++ptr) = c_pf_features.btagPf_trackPParRatio; + *(++ptr) = c_pf_features.btagPf_trackSip2dVal; + *(++ptr) = c_pf_features.btagPf_trackSip2dSig; + *(++ptr) = c_pf_features.btagPf_trackSip3dVal; + *(++ptr) = c_pf_features.btagPf_trackSip3dSig; + *(++ptr) = c_pf_features.btagPf_trackJetDistVal; + *(++ptr) = c_pf_features.ptrel; + *(++ptr) = c_pf_features.drminsv; + *(++ptr) = c_pf_features.vtx_ass; + *(++ptr) = c_pf_features.puppiw; + *(++ptr) = c_pf_features.chi2; + *(++ptr) = c_pf_features.quality; + assert(start + n_features_cpf_ - 1 == ptr); + } + + // n_pf candidates + auto max_n_pf_n = std::min(features.n_pf_features.size(), (std::size_t)25); + offset = i_jet * input_sizes_[kNeutralCandidates]; + for (std::size_t n_pf_n = 0; n_pf_n < max_n_pf_n; n_pf_n++) { + const auto& n_pf_features = features.n_pf_features.at(n_pf_n); + ptr = &data_[kNeutralCandidates][offset + n_pf_n * n_features_npf_]; + start = ptr; + *ptr = n_pf_features.ptrel; + *(++ptr) = n_pf_features.deltaR; + *(++ptr) = n_pf_features.isGamma; + *(++ptr) = n_pf_features.hadFrac; + *(++ptr) = n_pf_features.drminsv; + *(++ptr) = n_pf_features.puppiw; + assert(start + n_features_npf_ - 1 == ptr); + } + + // sv candidates + auto max_sv_n = std::min(features.sv_features.size(), (std::size_t)4); + offset = i_jet * input_sizes_[kVertices]; + for (std::size_t sv_n = 0; sv_n < max_sv_n; sv_n++) { + const auto& sv_features = features.sv_features.at(sv_n); + ptr = &data_[kVertices][offset + sv_n * n_features_sv_]; + start = ptr; + *ptr = sv_features.pt; + *(++ptr) = sv_features.deltaR; + *(++ptr) = sv_features.mass; + *(++ptr) = sv_features.ntracks; + *(++ptr) = sv_features.chi2; + *(++ptr) = sv_features.normchi2; + *(++ptr) = sv_features.dxy; + *(++ptr) = sv_features.dxysig; + *(++ptr) = sv_features.d3d; + *(++ptr) = sv_features.d3dsig; + *(++ptr) = sv_features.costhetasvpv; + *(++ptr) = sv_features.enratio; + assert(start + n_features_sv_ - 1 == ptr); + } + + // jet and other global features + offset = i_jet * input_sizes_[kGlobal1]; + ptr = &data_[kGlobal1][offset]; + start = ptr; + *ptr = jet_features.pt; + *(++ptr) = jet_features.eta; + *(++ptr) = jet_features.phi; + *(++ptr) = jet_features.mass; + assert(start + n_features_global1_ - 1 == ptr); + + // seeds + auto max_seed_n = std::min(features.seed_features.size(), (std::size_t)25); + offset = i_jet * input_sizes_[kSeedingTracks]; + for (std::size_t seed_n = 0; seed_n < max_seed_n; seed_n++) { + const auto& seed_features = features.seed_features.at(seed_n); + ptr = &data_[kSeedingTracks][offset + seed_n * n_features_seed_]; + start = ptr; + *ptr = seed_features.pt; + *(++ptr) = seed_features.eta; + *(++ptr) = seed_features.phi; + *(++ptr) = seed_features.mass; + *(++ptr) = seed_features.dz; + *(++ptr) = seed_features.dxy; + *(++ptr) = seed_features.ip3D; + *(++ptr) = seed_features.sip3D; + *(++ptr) = seed_features.ip2D; + *(++ptr) = seed_features.sip2D; + *(++ptr) = seed_features.signedIp3D; + *(++ptr) = seed_features.signedSip3D; + *(++ptr) = seed_features.signedIp2D; + *(++ptr) = seed_features.signedSip2D; + *(++ptr) = seed_features.trackProbability3D; + *(++ptr) = seed_features.trackProbability2D; + *(++ptr) = seed_features.chi2reduced; + *(++ptr) = seed_features.nPixelHits; + *(++ptr) = seed_features.nHits; + *(++ptr) = seed_features.jetAxisDistance; + *(++ptr) = seed_features.jetAxisDlength; + assert(start + n_features_seed_ - 1 == ptr); + } + + // neighbours + offset = i_jet * input_sizes_[kNeighbourTracks]; + for (std::size_t seed_n = 0; seed_n < max_seed_n; seed_n++) { + const auto& neighbourTracks_features = features.seed_features.at(seed_n).nearTracks; + auto max_neighbour_n = std::min(neighbourTracks_features.size(), (std::size_t)25); + for (std::size_t neighbour_n = 0; neighbour_n < max_neighbour_n; neighbour_n++) { + ptr = &data_[kNeighbourTracks+seed_n][offset + neighbour_n * n_features_neighbor_]; + start = ptr; + *ptr = neighbourTracks_features[neighbour_n].pt; + *(++ptr) = neighbourTracks_features[neighbour_n].eta; + *(++ptr) = neighbourTracks_features[neighbour_n].phi; + *(++ptr) = neighbourTracks_features[neighbour_n].dz; + *(++ptr) = neighbourTracks_features[neighbour_n].dxy; + *(++ptr) = neighbourTracks_features[neighbour_n].mass; + *(++ptr) = neighbourTracks_features[neighbour_n].ip3D; + *(++ptr) = neighbourTracks_features[neighbour_n].sip3D; + *(++ptr) = neighbourTracks_features[neighbour_n].ip2D; + *(++ptr) = neighbourTracks_features[neighbour_n].sip2D; + *(++ptr) = neighbourTracks_features[neighbour_n].distPCA; + *(++ptr) = neighbourTracks_features[neighbour_n].dsigPCA; + *(++ptr) = neighbourTracks_features[neighbour_n].x_PCAonSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].y_PCAonSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].z_PCAonSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].xerr_PCAonSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].yerr_PCAonSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].zerr_PCAonSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].x_PCAonTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].y_PCAonTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].z_PCAonTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].xerr_PCAonTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].yerr_PCAonTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].zerr_PCAonTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].dotprodSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeed2D; + *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeed3D; + *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeedVectors2D; + *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeedVectors3D; + *(++ptr) = neighbourTracks_features[neighbour_n].pvd_PCAonSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].pvd_PCAonTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].dist_PCAjetAxis; + *(++ptr) = neighbourTracks_features[neighbour_n].dotprod_PCAjetMomenta; + *(++ptr) = neighbourTracks_features[neighbour_n].deta_PCAjetDirs; + *(++ptr) = neighbourTracks_features[neighbour_n].dphi_PCAjetDirs; + assert(start + n_features_neighbor_ - 1 == ptr); + + + } + } +} + +//define this as a plug-in +DEFINE_FWK_MODULE(DeepCombinedONNXJetTagsProducer); diff --git a/RecoBTag/ONNXRuntime/plugins/DeepVertexONNXJetTagsProducer.cc b/RecoBTag/ONNXRuntime/plugins/DeepVertexONNXJetTagsProducer.cc new file mode 100644 index 0000000000000..3333c75bbb72a --- /dev/null +++ b/RecoBTag/ONNXRuntime/plugins/DeepVertexONNXJetTagsProducer.cc @@ -0,0 +1,254 @@ +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/stream/EDProducer.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" + +#include "FWCore/Framework/interface/makeRefToBaseProdFrom.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Utilities/interface/StreamID.h" + +#include "DataFormats/BTauReco/interface/JetTag.h" + +#include "DataFormats/BTauReco/interface/DeepFlavourTagInfo.h" + +#include "PhysicsTools/ONNXRuntime/interface/ONNXRuntime.h" + +using namespace cms::Ort; + +class DeepVertexONNXJetTagsProducer : public edm::stream::EDProducer> { +public: + explicit DeepVertexONNXJetTagsProducer(const edm::ParameterSet&, const ONNXRuntime*); + ~DeepVertexONNXJetTagsProducer() override; + + static void fillDescriptions(edm::ConfigurationDescriptions&); + + static std::unique_ptr initializeGlobalCache(const edm::ParameterSet&); + static void globalEndJob(const ONNXRuntime*); + +private: + typedef std::vector TagInfoCollection; + typedef reco::JetTagCollection JetTagCollection; + + void produce(edm::Event&, const edm::EventSetup&) override; + + void make_inputs(unsigned i_jet, const reco::DeepFlavourTagInfo& taginfo); + + const edm::EDGetTokenT src_; + std::vector flav_names_; + std::vector input_names_; + std::vector output_names_; + + enum InputIndexes { kGlobal = 0, kSeedingTracks = 1, kNeighbourTracks = 2 }; + constexpr static unsigned n_features_global_ = 4; + constexpr static unsigned n_seed_ = 10; + constexpr static unsigned n_features_seed_ = 21; + constexpr static unsigned n_neighbor_ = 20; + constexpr static unsigned n_features_neighbor_ = 36; + + const static std::vector input_sizes_; + + // hold the input data + FloatArrays data_; +}; + +const std::vector DeepVertexONNXJetTagsProducer::input_sizes_{ + n_features_global_, n_seed_* n_features_seed_, n_neighbor_* n_features_neighbor_, + n_neighbor_* n_features_neighbor_, n_neighbor_* n_features_neighbor_, n_neighbor_* n_features_neighbor_, + n_neighbor_* n_features_neighbor_, n_neighbor_* n_features_neighbor_, n_neighbor_* n_features_neighbor_, + n_neighbor_* n_features_neighbor_, n_neighbor_* n_features_neighbor_, n_neighbor_* n_features_neighbor_}; + +DeepVertexONNXJetTagsProducer::DeepVertexONNXJetTagsProducer(const edm::ParameterSet& iConfig, + const ONNXRuntime* cache) + : src_(consumes(iConfig.getParameter("src"))), + flav_names_(iConfig.getParameter>("flav_names")), + input_names_(iConfig.getParameter>("input_names")), + output_names_(iConfig.getParameter>("output_names")) { + // get output names from flav_names + for (const auto& flav_name : flav_names_) { + produces(flav_name); + } + + assert(input_names_.size() == input_sizes_.size()); +} + +DeepVertexONNXJetTagsProducer::~DeepVertexONNXJetTagsProducer() {} + +void DeepVertexONNXJetTagsProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + // pfDeepFlavourJetTags + edm::ParameterSetDescription desc; + desc.add("src", edm::InputTag("pfDeepFlavourTagInfos")); + desc.add>("input_names", {"input_1", "input_2", "input_3", "input_4", "input_5", "input_6", "input_7", "input_8", "input_9", "input_10", "input_11", "input_12"}); + desc.add("model_path", + edm::FileInPath("RecoBTag/Combined/data/DeepVertex/phase1_deepvertex.onnx")); + desc.add>("output_names", {"dense_6"}); + desc.add>( + "flav_names", std::vector{"probb", "probc", "probuds", "probg"}); + + descriptions.add("pfDeepVertexJetTags", desc); +} + +std::unique_ptr DeepVertexONNXJetTagsProducer::initializeGlobalCache(const edm::ParameterSet& iConfig) { + return std::make_unique(iConfig.getParameter("model_path").fullPath()); +} + +void DeepVertexONNXJetTagsProducer::globalEndJob(const ONNXRuntime* cache) {} + +void DeepVertexONNXJetTagsProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { + edm::Handle tag_infos; + iEvent.getByToken(src_, tag_infos); + + std::vector> output_tags; + if (!tag_infos->empty()) { + // initialize output collection + auto jet_ref = tag_infos->begin()->jet(); + auto ref2prod = edm::makeRefToBaseProdFrom(jet_ref, iEvent); + for (std::size_t i = 0; i < flav_names_.size(); i++) { + output_tags.emplace_back(std::make_unique(ref2prod)); + } + +// std::cout << "intializing data storage" << std::endl; + // init data storage + data_.clear(); + for (const auto& len : input_sizes_) { + data_.emplace_back(tag_infos->size() * len, 0); + } +// std::cout << "make inoputs" << std::endl; + // convert inputs + for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { + const auto& taginfo = (*tag_infos)[jet_n]; + make_inputs(jet_n, taginfo); + } + +// std::cout << "run the predictions" << std::endl; + // run prediction + auto outputs = globalCache()->run(input_names_, data_, {}, output_names_, tag_infos->size())[0]; + assert(outputs.size() == flav_names_.size() * tag_infos->size()); + + // get the outputs +// std::cout << "get predictions" << std::endl; + unsigned i_output = 0; + for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { + const auto& jet_ref = tag_infos->at(jet_n).jet(); + for (std::size_t flav_n = 0; flav_n < flav_names_.size(); flav_n++) { + (*(output_tags[flav_n]))[jet_ref] = outputs[i_output]; +// std::cout << outputs[i_output] << " my outttt " << flav_names_[flav_n] << std::endl; + ++i_output; + } + } + } else { + // create empty output collection + for (std::size_t i = 0; i < flav_names_.size(); i++) { + output_tags.emplace_back(std::make_unique()); + } + } + + // put into the event + for (std::size_t flav_n = 0; flav_n < flav_names_.size(); ++flav_n) { + iEvent.put(std::move(output_tags[flav_n]), flav_names_[flav_n]); + } +} + +void DeepVertexONNXJetTagsProducer::make_inputs(unsigned i_jet, const reco::DeepFlavourTagInfo& taginfo) { + const auto& features = taginfo.features(); + float* ptr = nullptr; + const float* start = nullptr; + unsigned offset = 0; + + // jet and other global features + offset = i_jet * input_sizes_[kGlobal]; + ptr = &data_[kGlobal][offset]; + // jet variables + const auto& jet_features = features.jet_features; + start = ptr; + *ptr = jet_features.pt; + *(++ptr) = jet_features.eta; + *(++ptr) = jet_features.phi; + *(++ptr) = jet_features.mass; + assert(start + n_features_global_ - 1 == ptr); + + // seeds + auto max_seed_n = std::min(features.seed_features.size(), (std::size_t)25); + offset = i_jet * input_sizes_[kSeedingTracks]; + for (std::size_t seed_n = 0; seed_n < max_seed_n; seed_n++) { + const auto& seed_features = features.seed_features.at(seed_n); + ptr = &data_[kSeedingTracks][offset + seed_n * n_features_seed_]; + start = ptr; + *ptr = seed_features.pt; + *(++ptr) = seed_features.eta; + *(++ptr) = seed_features.phi; + *(++ptr) = seed_features.mass; + *(++ptr) = seed_features.dz; + *(++ptr) = seed_features.dxy; + *(++ptr) = seed_features.ip3D; + *(++ptr) = seed_features.sip3D; + *(++ptr) = seed_features.ip2D; + *(++ptr) = seed_features.sip2D; + *(++ptr) = seed_features.signedIp3D; + *(++ptr) = seed_features.signedSip3D; + *(++ptr) = seed_features.signedIp2D; + *(++ptr) = seed_features.signedSip2D; + *(++ptr) = seed_features.trackProbability3D; + *(++ptr) = seed_features.trackProbability2D; + *(++ptr) = seed_features.chi2reduced; + *(++ptr) = seed_features.nPixelHits; + *(++ptr) = seed_features.nHits; + *(++ptr) = seed_features.jetAxisDistance; + *(++ptr) = seed_features.jetAxisDlength; + assert(start + n_features_seed_ - 1 == ptr); + } + + // neighbours + offset = i_jet * input_sizes_[kNeighbourTracks]; + for (std::size_t seed_n = 0; seed_n < max_seed_n; seed_n++) { + const auto& neighbourTracks_features = features.seed_features.at(seed_n).nearTracks; + auto max_neighbour_n = std::min(neighbourTracks_features.size(), (std::size_t)25); + for (std::size_t neighbour_n = 0; neighbour_n < max_neighbour_n; neighbour_n++) { + ptr = &data_[kNeighbourTracks+seed_n][offset + neighbour_n * n_features_neighbor_]; + start = ptr; + *ptr = neighbourTracks_features[neighbour_n].pt; + *(++ptr) = neighbourTracks_features[neighbour_n].eta; + *(++ptr) = neighbourTracks_features[neighbour_n].phi; + *(++ptr) = neighbourTracks_features[neighbour_n].dz; + *(++ptr) = neighbourTracks_features[neighbour_n].dxy; + *(++ptr) = neighbourTracks_features[neighbour_n].mass; + *(++ptr) = neighbourTracks_features[neighbour_n].ip3D; + *(++ptr) = neighbourTracks_features[neighbour_n].sip3D; + *(++ptr) = neighbourTracks_features[neighbour_n].ip2D; + *(++ptr) = neighbourTracks_features[neighbour_n].sip2D; + *(++ptr) = neighbourTracks_features[neighbour_n].distPCA; + *(++ptr) = neighbourTracks_features[neighbour_n].dsigPCA; + *(++ptr) = neighbourTracks_features[neighbour_n].x_PCAonSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].y_PCAonSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].z_PCAonSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].xerr_PCAonSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].yerr_PCAonSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].zerr_PCAonSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].x_PCAonTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].y_PCAonTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].z_PCAonTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].xerr_PCAonTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].yerr_PCAonTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].zerr_PCAonTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].dotprodSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeed2D; + *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeed3D; + *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeedVectors2D; + *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeedVectors3D; + *(++ptr) = neighbourTracks_features[neighbour_n].pvd_PCAonSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].pvd_PCAonTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].dist_PCAjetAxis; + *(++ptr) = neighbourTracks_features[neighbour_n].dotprod_PCAjetMomenta; + *(++ptr) = neighbourTracks_features[neighbour_n].deta_PCAjetDirs; + *(++ptr) = neighbourTracks_features[neighbour_n].dphi_PCAjetDirs; + assert(start + n_features_neighbor_ - 1 == ptr); + + + } + } +} + +//define this as a plug-in +DEFINE_FWK_MODULE(DeepVertexONNXJetTagsProducer); From b62be9788bc1d8dbf6b50d40c888f819cd71a26d Mon Sep 17 00:00:00 2001 From: leonardo Date: Thu, 29 Oct 2020 16:51:31 +0100 Subject: [PATCH 04/14] adding cfg to run the DeepVertex and comb. taggers and compare to DeepJet etc. --- .../test/test_deep_vertexcomb_cfg.py | 87 +++++++++++++++++++ 1 file changed, 87 insertions(+) create mode 100644 RecoBTag/ONNXRuntime/test/test_deep_vertexcomb_cfg.py diff --git a/RecoBTag/ONNXRuntime/test/test_deep_vertexcomb_cfg.py b/RecoBTag/ONNXRuntime/test/test_deep_vertexcomb_cfg.py new file mode 100644 index 0000000000000..cd250cf9f9876 --- /dev/null +++ b/RecoBTag/ONNXRuntime/test/test_deep_vertexcomb_cfg.py @@ -0,0 +1,87 @@ + +import FWCore.ParameterSet.Config as cms +from PhysicsTools.PatAlgos.tools.helpers import getPatAlgosToolsTask + +process = cms.Process("PATtest") + +## MessageLogger +process.load("FWCore.MessageLogger.MessageLogger_cfi") + +## Options and Output Report +process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(True) ) + +## Source +process.source = cms.Source("PoolSource", + fileNames = cms.untracked.vstring() +) +## Maximal Number of Events +process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(100) ) + +## Geometry and Detector Conditions (needed for a few patTuple production steps) +process.load("Configuration.Geometry.GeometryRecoDB_cff") +process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") +from Configuration.AlCa.GlobalTag import GlobalTag +process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:run2_mc') +process.load("Configuration.StandardSequences.MagneticField_cff") + +## Output Module Configuration (expects a path 'p') +from PhysicsTools.PatAlgos.patEventContent_cff import patEventContentNoCleaning +process.out = cms.OutputModule("PoolOutputModule", + fileName = cms.untracked.string('patTuple.root'), + ## save only events passing the full path + #SelectEvents = cms.untracked.PSet( SelectEvents = cms.vstring('p') ), + ## save PAT output; you need a '*' to unpack the list of commands + ## 'patEventContent' + outputCommands = cms.untracked.vstring('drop *', *patEventContentNoCleaning ) + ) + +patAlgosToolsTask = getPatAlgosToolsTask(process) +process.outpath = cms.EndPath(process.out, patAlgosToolsTask) + +## and add them to the event content +from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection + +updateJetCollection( + process, + jetSource = cms.InputTag('slimmedJets'), + pvSource = cms.InputTag('offlineSlimmedPrimaryVertices'), + svSource = cms.InputTag('slimmedSecondaryVertices'), + jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'), + btagDiscriminators = [ + 'pfCombinedSecondaryVertexV2BJetTags', + 'pfDeepCSVJetTags:probudsg', + 'pfDeepCSVJetTags:probb', + 'pfDeepCSVJetTags:probc', + 'pfDeepCSVJetTags:probbb', + 'pfDeepFlavourJetTags:probb', + 'pfDeepFlavourJetTags:probbb', + 'pfDeepFlavourJetTags:problepb', + 'pfDeepFlavourJetTags:probc', + 'pfDeepFlavourJetTags:probuds', + 'pfDeepFlavourJetTags:probg', + 'pfDeepVertexJetTags:probb', + 'pfDeepCombinedJetTags:probb', + + ] + ) + +from PhysicsTools.PatAlgos.patInputFiles_cff import filesRelValTTbarPileUpMINIAODSIM + +process.source.fileNames = filesRelValTTbarPileUpMINIAODSIM +process.source.fileNames = cms.untracked.vstring('/store/mc/RunIIFall17MiniAODv2/TTToHadronic_TuneCP5_13TeV-powheg-pythia8/MINIAODSIM/PU2017_12Apr2018_new_pmx_94X_mc2017_realistic_v14-v2/60000/FCC2AFA9-4BBB-E811-B35F-0CC47AFB7D48.root') + +process.maxEvents.input = 10 + +from Configuration.EventContent.EventContent_cff import MINIAODSIMEventContent +process.out.outputCommands = MINIAODSIMEventContent.outputCommands +process.out.outputCommands.append('keep *_selectedUpdatedPatJets*_*_*') +process.out.outputCommands.append('keep *_pfDeepCSVTagInfos*_*_*') +process.out.outputCommands.append('keep *_pfDeepFlavourTagInfos*_*_*') +process.out.outputCommands.append('keep *_pfDeepFlavourJetTags*_*_*') +process.out.outputCommands.append('keep *_updatedPatJets*_*_*') + +process.out.fileName = 'test_deep_vertexcomb_MINIAODSIM.root' + +# ## +# process.options.wantSummary = False ## (to suppress the long output at the end of the job) +# process.add_(cms.Service("InitRootHandlers", DebugLevel =cms.untracked.int32(3))) From c01ee199ef99ceed2a3774634e35e9a93f95d2e3 Mon Sep 17 00:00:00 2001 From: leonardo Date: Thu, 29 Oct 2020 17:49:36 +0100 Subject: [PATCH 05/14] ran scram build code-format --- .../DeepCombinedONNXJetTagsProducer.cc | 157 +++++++++++------- .../plugins/DeepVertexONNXJetTagsProducer.cc | 140 +++++++++------- 2 files changed, 170 insertions(+), 127 deletions(-) diff --git a/RecoBTag/ONNXRuntime/plugins/DeepCombinedONNXJetTagsProducer.cc b/RecoBTag/ONNXRuntime/plugins/DeepCombinedONNXJetTagsProducer.cc index 1be01629b140a..239a0095f36de 100644 --- a/RecoBTag/ONNXRuntime/plugins/DeepCombinedONNXJetTagsProducer.cc +++ b/RecoBTag/ONNXRuntime/plugins/DeepCombinedONNXJetTagsProducer.cc @@ -40,7 +40,15 @@ class DeepCombinedONNXJetTagsProducer : public edm::stream::EDProducer input_names_; std::vector output_names_; - enum InputIndexes { kGlobal = 0, kChargedCandidates = 1, kNeutralCandidates = 2, kVertices = 3, kGlobal1 = 4, kSeedingTracks = 5, kNeighbourTracks = 6 }; + enum InputIndexes { + kGlobal = 0, + kChargedCandidates = 1, + kNeutralCandidates = 2, + kVertices = 3, + kGlobal1 = 4, + kSeedingTracks = 5, + kNeighbourTracks = 6 + }; constexpr static unsigned n_features_global_ = 15; constexpr static unsigned n_cpf_ = 25; constexpr static unsigned n_features_cpf_ = 16; @@ -60,15 +68,25 @@ class DeepCombinedONNXJetTagsProducer : public edm::stream::EDProducer DeepCombinedONNXJetTagsProducer::input_sizes_{ - n_features_global_, n_cpf_* n_features_cpf_, n_npf_* n_features_npf_, n_sv_* n_features_sv_, - n_features_global1_, n_seed_* n_features_seed_, n_neighbor_* n_features_neighbor_, - n_neighbor_* n_features_neighbor_, n_neighbor_* n_features_neighbor_, n_neighbor_* n_features_neighbor_, - n_neighbor_* n_features_neighbor_, n_neighbor_* n_features_neighbor_, n_neighbor_* n_features_neighbor_, - n_neighbor_* n_features_neighbor_, n_neighbor_* n_features_neighbor_, n_neighbor_* n_features_neighbor_}; +const std::vector DeepCombinedONNXJetTagsProducer::input_sizes_{n_features_global_, + n_cpf_* n_features_cpf_, + n_npf_* n_features_npf_, + n_sv_* n_features_sv_, + n_features_global1_, + n_seed_* n_features_seed_, + n_neighbor_* n_features_neighbor_, + n_neighbor_* n_features_neighbor_, + n_neighbor_* n_features_neighbor_, + n_neighbor_* n_features_neighbor_, + n_neighbor_* n_features_neighbor_, + n_neighbor_* n_features_neighbor_, + n_neighbor_* n_features_neighbor_, + n_neighbor_* n_features_neighbor_, + n_neighbor_* n_features_neighbor_, + n_neighbor_* n_features_neighbor_}; DeepCombinedONNXJetTagsProducer::DeepCombinedONNXJetTagsProducer(const edm::ParameterSet& iConfig, - const ONNXRuntime* cache) + const ONNXRuntime* cache) : src_(consumes(iConfig.getParameter("src"))), flav_names_(iConfig.getParameter>("flav_names")), input_names_(iConfig.getParameter>("input_names")), @@ -87,14 +105,27 @@ void DeepCombinedONNXJetTagsProducer::fillDescriptions(edm::ConfigurationDescrip // pfDeepFlavourJetTags edm::ParameterSetDescription desc; desc.add("src", edm::InputTag("pfDeepFlavourTagInfos")); - desc.add>("input_names", { - "input_1_DFla", "input_2_DFla", "input_3_DFla", "input_4_DFla", - "input_1", "input_2", "input_3", "input_4", "input_5", "input_6", "input_7", "input_8", "input_9", "input_10", "input_11", "input_12"}); + desc.add>("input_names", + {"input_1_DFla", + "input_2_DFla", + "input_3_DFla", + "input_4_DFla", + "input_1", + "input_2", + "input_3", + "input_4", + "input_5", + "input_6", + "input_7", + "input_8", + "input_9", + "input_10", + "input_11", + "input_12"}); desc.add("model_path", edm::FileInPath("RecoBTag/Combined/data/DeepVertex/phase1_deepvertexcombined.onnx")); desc.add>("output_names", {"dense_13"}); - desc.add>( - "flav_names", std::vector{"probb", "probc", "probuds", "probg"}); + desc.add>("flav_names", std::vector{"probb", "probc", "probuds", "probg"}); descriptions.add("pfDeepCombinedJetTags", desc); } @@ -118,32 +149,32 @@ void DeepCombinedONNXJetTagsProducer::produce(edm::Event& iEvent, const edm::Eve output_tags.emplace_back(std::make_unique(ref2prod)); } -// std::cout << "intializing data storage" << std::endl; + // std::cout << "intializing data storage" << std::endl; // init data storage data_.clear(); for (const auto& len : input_sizes_) { data_.emplace_back(tag_infos->size() * len, 0); } -// std::cout << "make inoputs" << std::endl; + // std::cout << "make inoputs" << std::endl; // convert inputs for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { const auto& taginfo = (*tag_infos)[jet_n]; make_inputs(jet_n, taginfo); } - -// std::cout << "run the predictions" << std::endl; + + // std::cout << "run the predictions" << std::endl; // run prediction auto outputs = globalCache()->run(input_names_, data_, {}, output_names_, tag_infos->size())[0]; assert(outputs.size() == flav_names_.size() * tag_infos->size()); // get the outputs -// std::cout << "get predictions" << std::endl; + // std::cout << "get predictions" << std::endl; unsigned i_output = 0; for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { const auto& jet_ref = tag_infos->at(jet_n).jet(); for (std::size_t flav_n = 0; flav_n < flav_names_.size(); flav_n++) { (*(output_tags[flav_n]))[jet_ref] = outputs[i_output]; -// std::cout << outputs[i_output] << " my outttt cccc " << flav_names_[flav_n] << std::endl; + // std::cout << outputs[i_output] << " my outttt cccc " << flav_names_[flav_n] << std::endl; ++i_output; } } @@ -165,7 +196,7 @@ void DeepCombinedONNXJetTagsProducer::make_inputs(unsigned i_jet, const reco::De float* ptr = nullptr; const float* start = nullptr; unsigned offset = 0; - + // jet and other global features offset = i_jet * input_sizes_[kGlobal]; ptr = &data_[kGlobal][offset]; @@ -300,50 +331,48 @@ void DeepCombinedONNXJetTagsProducer::make_inputs(unsigned i_jet, const reco::De // neighbours offset = i_jet * input_sizes_[kNeighbourTracks]; for (std::size_t seed_n = 0; seed_n < max_seed_n; seed_n++) { - const auto& neighbourTracks_features = features.seed_features.at(seed_n).nearTracks; - auto max_neighbour_n = std::min(neighbourTracks_features.size(), (std::size_t)25); - for (std::size_t neighbour_n = 0; neighbour_n < max_neighbour_n; neighbour_n++) { - ptr = &data_[kNeighbourTracks+seed_n][offset + neighbour_n * n_features_neighbor_]; - start = ptr; - *ptr = neighbourTracks_features[neighbour_n].pt; - *(++ptr) = neighbourTracks_features[neighbour_n].eta; - *(++ptr) = neighbourTracks_features[neighbour_n].phi; - *(++ptr) = neighbourTracks_features[neighbour_n].dz; - *(++ptr) = neighbourTracks_features[neighbour_n].dxy; - *(++ptr) = neighbourTracks_features[neighbour_n].mass; - *(++ptr) = neighbourTracks_features[neighbour_n].ip3D; - *(++ptr) = neighbourTracks_features[neighbour_n].sip3D; - *(++ptr) = neighbourTracks_features[neighbour_n].ip2D; - *(++ptr) = neighbourTracks_features[neighbour_n].sip2D; - *(++ptr) = neighbourTracks_features[neighbour_n].distPCA; - *(++ptr) = neighbourTracks_features[neighbour_n].dsigPCA; - *(++ptr) = neighbourTracks_features[neighbour_n].x_PCAonSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].y_PCAonSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].z_PCAonSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].xerr_PCAonSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].yerr_PCAonSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].zerr_PCAonSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].x_PCAonTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].y_PCAonTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].z_PCAonTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].xerr_PCAonTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].yerr_PCAonTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].zerr_PCAonTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].dotprodSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeed2D; - *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeed3D; - *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeedVectors2D; - *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeedVectors3D; - *(++ptr) = neighbourTracks_features[neighbour_n].pvd_PCAonSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].pvd_PCAonTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].dist_PCAjetAxis; - *(++ptr) = neighbourTracks_features[neighbour_n].dotprod_PCAjetMomenta; - *(++ptr) = neighbourTracks_features[neighbour_n].deta_PCAjetDirs; - *(++ptr) = neighbourTracks_features[neighbour_n].dphi_PCAjetDirs; - assert(start + n_features_neighbor_ - 1 == ptr); - - + const auto& neighbourTracks_features = features.seed_features.at(seed_n).nearTracks; + auto max_neighbour_n = std::min(neighbourTracks_features.size(), (std::size_t)25); + for (std::size_t neighbour_n = 0; neighbour_n < max_neighbour_n; neighbour_n++) { + ptr = &data_[kNeighbourTracks + seed_n][offset + neighbour_n * n_features_neighbor_]; + start = ptr; + *ptr = neighbourTracks_features[neighbour_n].pt; + *(++ptr) = neighbourTracks_features[neighbour_n].eta; + *(++ptr) = neighbourTracks_features[neighbour_n].phi; + *(++ptr) = neighbourTracks_features[neighbour_n].dz; + *(++ptr) = neighbourTracks_features[neighbour_n].dxy; + *(++ptr) = neighbourTracks_features[neighbour_n].mass; + *(++ptr) = neighbourTracks_features[neighbour_n].ip3D; + *(++ptr) = neighbourTracks_features[neighbour_n].sip3D; + *(++ptr) = neighbourTracks_features[neighbour_n].ip2D; + *(++ptr) = neighbourTracks_features[neighbour_n].sip2D; + *(++ptr) = neighbourTracks_features[neighbour_n].distPCA; + *(++ptr) = neighbourTracks_features[neighbour_n].dsigPCA; + *(++ptr) = neighbourTracks_features[neighbour_n].x_PCAonSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].y_PCAonSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].z_PCAonSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].xerr_PCAonSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].yerr_PCAonSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].zerr_PCAonSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].x_PCAonTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].y_PCAonTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].z_PCAonTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].xerr_PCAonTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].yerr_PCAonTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].zerr_PCAonTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].dotprodSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeed2D; + *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeed3D; + *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeedVectors2D; + *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeedVectors3D; + *(++ptr) = neighbourTracks_features[neighbour_n].pvd_PCAonSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].pvd_PCAonTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].dist_PCAjetAxis; + *(++ptr) = neighbourTracks_features[neighbour_n].dotprod_PCAjetMomenta; + *(++ptr) = neighbourTracks_features[neighbour_n].deta_PCAjetDirs; + *(++ptr) = neighbourTracks_features[neighbour_n].dphi_PCAjetDirs; + assert(start + n_features_neighbor_ - 1 == ptr); } } } diff --git a/RecoBTag/ONNXRuntime/plugins/DeepVertexONNXJetTagsProducer.cc b/RecoBTag/ONNXRuntime/plugins/DeepVertexONNXJetTagsProducer.cc index 3333c75bbb72a..45b357e4e7c38 100644 --- a/RecoBTag/ONNXRuntime/plugins/DeepVertexONNXJetTagsProducer.cc +++ b/RecoBTag/ONNXRuntime/plugins/DeepVertexONNXJetTagsProducer.cc @@ -53,14 +53,20 @@ class DeepVertexONNXJetTagsProducer : public edm::stream::EDProducer DeepVertexONNXJetTagsProducer::input_sizes_{ - n_features_global_, n_seed_* n_features_seed_, n_neighbor_* n_features_neighbor_, - n_neighbor_* n_features_neighbor_, n_neighbor_* n_features_neighbor_, n_neighbor_* n_features_neighbor_, - n_neighbor_* n_features_neighbor_, n_neighbor_* n_features_neighbor_, n_neighbor_* n_features_neighbor_, - n_neighbor_* n_features_neighbor_, n_neighbor_* n_features_neighbor_, n_neighbor_* n_features_neighbor_}; - -DeepVertexONNXJetTagsProducer::DeepVertexONNXJetTagsProducer(const edm::ParameterSet& iConfig, - const ONNXRuntime* cache) +const std::vector DeepVertexONNXJetTagsProducer::input_sizes_{n_features_global_, + n_seed_* n_features_seed_, + n_neighbor_* n_features_neighbor_, + n_neighbor_* n_features_neighbor_, + n_neighbor_* n_features_neighbor_, + n_neighbor_* n_features_neighbor_, + n_neighbor_* n_features_neighbor_, + n_neighbor_* n_features_neighbor_, + n_neighbor_* n_features_neighbor_, + n_neighbor_* n_features_neighbor_, + n_neighbor_* n_features_neighbor_, + n_neighbor_* n_features_neighbor_}; + +DeepVertexONNXJetTagsProducer::DeepVertexONNXJetTagsProducer(const edm::ParameterSet& iConfig, const ONNXRuntime* cache) : src_(consumes(iConfig.getParameter("src"))), flav_names_(iConfig.getParameter>("flav_names")), input_names_(iConfig.getParameter>("input_names")), @@ -79,12 +85,22 @@ void DeepVertexONNXJetTagsProducer::fillDescriptions(edm::ConfigurationDescripti // pfDeepFlavourJetTags edm::ParameterSetDescription desc; desc.add("src", edm::InputTag("pfDeepFlavourTagInfos")); - desc.add>("input_names", {"input_1", "input_2", "input_3", "input_4", "input_5", "input_6", "input_7", "input_8", "input_9", "input_10", "input_11", "input_12"}); - desc.add("model_path", - edm::FileInPath("RecoBTag/Combined/data/DeepVertex/phase1_deepvertex.onnx")); + desc.add>("input_names", + {"input_1", + "input_2", + "input_3", + "input_4", + "input_5", + "input_6", + "input_7", + "input_8", + "input_9", + "input_10", + "input_11", + "input_12"}); + desc.add("model_path", edm::FileInPath("RecoBTag/Combined/data/DeepVertex/phase1_deepvertex.onnx")); desc.add>("output_names", {"dense_6"}); - desc.add>( - "flav_names", std::vector{"probb", "probc", "probuds", "probg"}); + desc.add>("flav_names", std::vector{"probb", "probc", "probuds", "probg"}); descriptions.add("pfDeepVertexJetTags", desc); } @@ -108,32 +124,32 @@ void DeepVertexONNXJetTagsProducer::produce(edm::Event& iEvent, const edm::Event output_tags.emplace_back(std::make_unique(ref2prod)); } -// std::cout << "intializing data storage" << std::endl; + // std::cout << "intializing data storage" << std::endl; // init data storage data_.clear(); for (const auto& len : input_sizes_) { data_.emplace_back(tag_infos->size() * len, 0); } -// std::cout << "make inoputs" << std::endl; + // std::cout << "make inoputs" << std::endl; // convert inputs for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { const auto& taginfo = (*tag_infos)[jet_n]; make_inputs(jet_n, taginfo); } - -// std::cout << "run the predictions" << std::endl; + + // std::cout << "run the predictions" << std::endl; // run prediction auto outputs = globalCache()->run(input_names_, data_, {}, output_names_, tag_infos->size())[0]; assert(outputs.size() == flav_names_.size() * tag_infos->size()); // get the outputs -// std::cout << "get predictions" << std::endl; + // std::cout << "get predictions" << std::endl; unsigned i_output = 0; for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { const auto& jet_ref = tag_infos->at(jet_n).jet(); for (std::size_t flav_n = 0; flav_n < flav_names_.size(); flav_n++) { (*(output_tags[flav_n]))[jet_ref] = outputs[i_output]; -// std::cout << outputs[i_output] << " my outttt " << flav_names_[flav_n] << std::endl; + // std::cout << outputs[i_output] << " my outttt " << flav_names_[flav_n] << std::endl; ++i_output; } } @@ -202,50 +218,48 @@ void DeepVertexONNXJetTagsProducer::make_inputs(unsigned i_jet, const reco::Deep // neighbours offset = i_jet * input_sizes_[kNeighbourTracks]; for (std::size_t seed_n = 0; seed_n < max_seed_n; seed_n++) { - const auto& neighbourTracks_features = features.seed_features.at(seed_n).nearTracks; - auto max_neighbour_n = std::min(neighbourTracks_features.size(), (std::size_t)25); - for (std::size_t neighbour_n = 0; neighbour_n < max_neighbour_n; neighbour_n++) { - ptr = &data_[kNeighbourTracks+seed_n][offset + neighbour_n * n_features_neighbor_]; - start = ptr; - *ptr = neighbourTracks_features[neighbour_n].pt; - *(++ptr) = neighbourTracks_features[neighbour_n].eta; - *(++ptr) = neighbourTracks_features[neighbour_n].phi; - *(++ptr) = neighbourTracks_features[neighbour_n].dz; - *(++ptr) = neighbourTracks_features[neighbour_n].dxy; - *(++ptr) = neighbourTracks_features[neighbour_n].mass; - *(++ptr) = neighbourTracks_features[neighbour_n].ip3D; - *(++ptr) = neighbourTracks_features[neighbour_n].sip3D; - *(++ptr) = neighbourTracks_features[neighbour_n].ip2D; - *(++ptr) = neighbourTracks_features[neighbour_n].sip2D; - *(++ptr) = neighbourTracks_features[neighbour_n].distPCA; - *(++ptr) = neighbourTracks_features[neighbour_n].dsigPCA; - *(++ptr) = neighbourTracks_features[neighbour_n].x_PCAonSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].y_PCAonSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].z_PCAonSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].xerr_PCAonSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].yerr_PCAonSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].zerr_PCAonSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].x_PCAonTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].y_PCAonTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].z_PCAonTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].xerr_PCAonTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].yerr_PCAonTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].zerr_PCAonTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].dotprodSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeed2D; - *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeed3D; - *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeedVectors2D; - *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeedVectors3D; - *(++ptr) = neighbourTracks_features[neighbour_n].pvd_PCAonSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].pvd_PCAonTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].dist_PCAjetAxis; - *(++ptr) = neighbourTracks_features[neighbour_n].dotprod_PCAjetMomenta; - *(++ptr) = neighbourTracks_features[neighbour_n].deta_PCAjetDirs; - *(++ptr) = neighbourTracks_features[neighbour_n].dphi_PCAjetDirs; - assert(start + n_features_neighbor_ - 1 == ptr); - - + const auto& neighbourTracks_features = features.seed_features.at(seed_n).nearTracks; + auto max_neighbour_n = std::min(neighbourTracks_features.size(), (std::size_t)25); + for (std::size_t neighbour_n = 0; neighbour_n < max_neighbour_n; neighbour_n++) { + ptr = &data_[kNeighbourTracks + seed_n][offset + neighbour_n * n_features_neighbor_]; + start = ptr; + *ptr = neighbourTracks_features[neighbour_n].pt; + *(++ptr) = neighbourTracks_features[neighbour_n].eta; + *(++ptr) = neighbourTracks_features[neighbour_n].phi; + *(++ptr) = neighbourTracks_features[neighbour_n].dz; + *(++ptr) = neighbourTracks_features[neighbour_n].dxy; + *(++ptr) = neighbourTracks_features[neighbour_n].mass; + *(++ptr) = neighbourTracks_features[neighbour_n].ip3D; + *(++ptr) = neighbourTracks_features[neighbour_n].sip3D; + *(++ptr) = neighbourTracks_features[neighbour_n].ip2D; + *(++ptr) = neighbourTracks_features[neighbour_n].sip2D; + *(++ptr) = neighbourTracks_features[neighbour_n].distPCA; + *(++ptr) = neighbourTracks_features[neighbour_n].dsigPCA; + *(++ptr) = neighbourTracks_features[neighbour_n].x_PCAonSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].y_PCAonSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].z_PCAonSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].xerr_PCAonSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].yerr_PCAonSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].zerr_PCAonSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].x_PCAonTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].y_PCAonTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].z_PCAonTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].xerr_PCAonTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].yerr_PCAonTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].zerr_PCAonTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].dotprodSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeed2D; + *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeed3D; + *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeedVectors2D; + *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeedVectors3D; + *(++ptr) = neighbourTracks_features[neighbour_n].pvd_PCAonSeed; + *(++ptr) = neighbourTracks_features[neighbour_n].pvd_PCAonTrack; + *(++ptr) = neighbourTracks_features[neighbour_n].dist_PCAjetAxis; + *(++ptr) = neighbourTracks_features[neighbour_n].dotprod_PCAjetMomenta; + *(++ptr) = neighbourTracks_features[neighbour_n].deta_PCAjetDirs; + *(++ptr) = neighbourTracks_features[neighbour_n].dphi_PCAjetDirs; + assert(start + n_features_neighbor_ - 1 == ptr); } } } From 58b94b0d6b6dd655f51eea4e0230babafd226850 Mon Sep 17 00:00:00 2001 From: leonardo Date: Thu, 5 Nov 2020 11:52:11 +0100 Subject: [PATCH 06/14] applied minimal corrections --- .../DeepCombinedONNXJetTagsProducer.cc | 29 ++++++++----------- .../plugins/DeepVertexONNXJetTagsProducer.cc | 17 ++++------- 2 files changed, 18 insertions(+), 28 deletions(-) diff --git a/RecoBTag/ONNXRuntime/plugins/DeepCombinedONNXJetTagsProducer.cc b/RecoBTag/ONNXRuntime/plugins/DeepCombinedONNXJetTagsProducer.cc index 239a0095f36de..d7139808d81f2 100644 --- a/RecoBTag/ONNXRuntime/plugins/DeepCombinedONNXJetTagsProducer.cc +++ b/RecoBTag/ONNXRuntime/plugins/DeepCombinedONNXJetTagsProducer.cc @@ -149,32 +149,27 @@ void DeepCombinedONNXJetTagsProducer::produce(edm::Event& iEvent, const edm::Eve output_tags.emplace_back(std::make_unique(ref2prod)); } - // std::cout << "intializing data storage" << std::endl; // init data storage data_.clear(); for (const auto& len : input_sizes_) { data_.emplace_back(tag_infos->size() * len, 0); } - // std::cout << "make inoputs" << std::endl; // convert inputs for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { const auto& taginfo = (*tag_infos)[jet_n]; make_inputs(jet_n, taginfo); } - // std::cout << "run the predictions" << std::endl; // run prediction - auto outputs = globalCache()->run(input_names_, data_, {}, output_names_, tag_infos->size())[0]; + const auto outputs = globalCache()->run(input_names_, data_, {}, output_names_, tag_infos->size())[0]; assert(outputs.size() == flav_names_.size() * tag_infos->size()); // get the outputs - // std::cout << "get predictions" << std::endl; unsigned i_output = 0; for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { - const auto& jet_ref = tag_infos->at(jet_n).jet(); + const auto& jet_ref = (*tag_infos)[jet_n].jet(); for (std::size_t flav_n = 0; flav_n < flav_names_.size(); flav_n++) { (*(output_tags[flav_n]))[jet_ref] = outputs[i_output]; - // std::cout << outputs[i_output] << " my outttt cccc " << flav_names_[flav_n] << std::endl; ++i_output; } } @@ -224,10 +219,10 @@ void DeepCombinedONNXJetTagsProducer::make_inputs(unsigned i_jet, const reco::De assert(start + n_features_global_ - 1 == ptr); // c_pf candidates - auto max_c_pf_n = std::min(features.c_pf_features.size(), (std::size_t)25); + auto max_c_pf_n = std::min(features.c_pf_features.size(), (std::size_t)n_cpf_); offset = i_jet * input_sizes_[kChargedCandidates]; for (std::size_t c_pf_n = 0; c_pf_n < max_c_pf_n; c_pf_n++) { - const auto& c_pf_features = features.c_pf_features.at(c_pf_n); + const auto& c_pf_features = features.c_pf_features[c_pf_n]; ptr = &data_[kChargedCandidates][offset + c_pf_n * n_features_cpf_]; start = ptr; *ptr = c_pf_features.btagPf_trackEtaRel; @@ -250,10 +245,10 @@ void DeepCombinedONNXJetTagsProducer::make_inputs(unsigned i_jet, const reco::De } // n_pf candidates - auto max_n_pf_n = std::min(features.n_pf_features.size(), (std::size_t)25); + auto max_n_pf_n = std::min(features.n_pf_features.size(), (std::size_t)n_npf_); offset = i_jet * input_sizes_[kNeutralCandidates]; for (std::size_t n_pf_n = 0; n_pf_n < max_n_pf_n; n_pf_n++) { - const auto& n_pf_features = features.n_pf_features.at(n_pf_n); + const auto& n_pf_features = features.n_pf_features[n_pf_n]; ptr = &data_[kNeutralCandidates][offset + n_pf_n * n_features_npf_]; start = ptr; *ptr = n_pf_features.ptrel; @@ -266,10 +261,10 @@ void DeepCombinedONNXJetTagsProducer::make_inputs(unsigned i_jet, const reco::De } // sv candidates - auto max_sv_n = std::min(features.sv_features.size(), (std::size_t)4); + auto max_sv_n = std::min(features.sv_features.size(), (std::size_t)n_sv_); offset = i_jet * input_sizes_[kVertices]; for (std::size_t sv_n = 0; sv_n < max_sv_n; sv_n++) { - const auto& sv_features = features.sv_features.at(sv_n); + const auto& sv_features = features.sv_features[sv_n]; ptr = &data_[kVertices][offset + sv_n * n_features_sv_]; start = ptr; *ptr = sv_features.pt; @@ -298,10 +293,10 @@ void DeepCombinedONNXJetTagsProducer::make_inputs(unsigned i_jet, const reco::De assert(start + n_features_global1_ - 1 == ptr); // seeds - auto max_seed_n = std::min(features.seed_features.size(), (std::size_t)25); + auto max_seed_n = std::min(features.seed_features.size(), (std::size_t)n_seed_); offset = i_jet * input_sizes_[kSeedingTracks]; for (std::size_t seed_n = 0; seed_n < max_seed_n; seed_n++) { - const auto& seed_features = features.seed_features.at(seed_n); + const auto& seed_features = features.seed_features[seed_n]; ptr = &data_[kSeedingTracks][offset + seed_n * n_features_seed_]; start = ptr; *ptr = seed_features.pt; @@ -331,8 +326,8 @@ void DeepCombinedONNXJetTagsProducer::make_inputs(unsigned i_jet, const reco::De // neighbours offset = i_jet * input_sizes_[kNeighbourTracks]; for (std::size_t seed_n = 0; seed_n < max_seed_n; seed_n++) { - const auto& neighbourTracks_features = features.seed_features.at(seed_n).nearTracks; - auto max_neighbour_n = std::min(neighbourTracks_features.size(), (std::size_t)25); + const auto& neighbourTracks_features = features.seed_features[seed_n].nearTracks; + auto max_neighbour_n = std::min(neighbourTracks_features.size(), (std::size_t)n_neighbor_); for (std::size_t neighbour_n = 0; neighbour_n < max_neighbour_n; neighbour_n++) { ptr = &data_[kNeighbourTracks + seed_n][offset + neighbour_n * n_features_neighbor_]; start = ptr; diff --git a/RecoBTag/ONNXRuntime/plugins/DeepVertexONNXJetTagsProducer.cc b/RecoBTag/ONNXRuntime/plugins/DeepVertexONNXJetTagsProducer.cc index 45b357e4e7c38..dd9057abde117 100644 --- a/RecoBTag/ONNXRuntime/plugins/DeepVertexONNXJetTagsProducer.cc +++ b/RecoBTag/ONNXRuntime/plugins/DeepVertexONNXJetTagsProducer.cc @@ -124,32 +124,27 @@ void DeepVertexONNXJetTagsProducer::produce(edm::Event& iEvent, const edm::Event output_tags.emplace_back(std::make_unique(ref2prod)); } - // std::cout << "intializing data storage" << std::endl; // init data storage data_.clear(); for (const auto& len : input_sizes_) { data_.emplace_back(tag_infos->size() * len, 0); } - // std::cout << "make inoputs" << std::endl; // convert inputs for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { const auto& taginfo = (*tag_infos)[jet_n]; make_inputs(jet_n, taginfo); } - // std::cout << "run the predictions" << std::endl; // run prediction - auto outputs = globalCache()->run(input_names_, data_, {}, output_names_, tag_infos->size())[0]; + const auto outputs = globalCache()->run(input_names_, data_, {}, output_names_, tag_infos->size())[0]; assert(outputs.size() == flav_names_.size() * tag_infos->size()); // get the outputs - // std::cout << "get predictions" << std::endl; unsigned i_output = 0; for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { - const auto& jet_ref = tag_infos->at(jet_n).jet(); + const auto& jet_ref = (*tag_infos)[jet_n].jet(); for (std::size_t flav_n = 0; flav_n < flav_names_.size(); flav_n++) { (*(output_tags[flav_n]))[jet_ref] = outputs[i_output]; - // std::cout << outputs[i_output] << " my outttt " << flav_names_[flav_n] << std::endl; ++i_output; } } @@ -185,10 +180,10 @@ void DeepVertexONNXJetTagsProducer::make_inputs(unsigned i_jet, const reco::Deep assert(start + n_features_global_ - 1 == ptr); // seeds - auto max_seed_n = std::min(features.seed_features.size(), (std::size_t)25); + auto max_seed_n = std::min(features.seed_features.size(), (std::size_t)n_seed_); offset = i_jet * input_sizes_[kSeedingTracks]; for (std::size_t seed_n = 0; seed_n < max_seed_n; seed_n++) { - const auto& seed_features = features.seed_features.at(seed_n); + const auto& seed_features = features.seed_features[seed_n]; ptr = &data_[kSeedingTracks][offset + seed_n * n_features_seed_]; start = ptr; *ptr = seed_features.pt; @@ -218,8 +213,8 @@ void DeepVertexONNXJetTagsProducer::make_inputs(unsigned i_jet, const reco::Deep // neighbours offset = i_jet * input_sizes_[kNeighbourTracks]; for (std::size_t seed_n = 0; seed_n < max_seed_n; seed_n++) { - const auto& neighbourTracks_features = features.seed_features.at(seed_n).nearTracks; - auto max_neighbour_n = std::min(neighbourTracks_features.size(), (std::size_t)25); + const auto& neighbourTracks_features = features.seed_features[seed_n].nearTracks; + auto max_neighbour_n = std::min(neighbourTracks_features.size(), (std::size_t)n_neighbor_); for (std::size_t neighbour_n = 0; neighbour_n < max_neighbour_n; neighbour_n++) { ptr = &data_[kNeighbourTracks + seed_n][offset + neighbour_n * n_features_neighbor_]; start = ptr; From 8d771d02a71d04b5dca30f9bf766141712facf67 Mon Sep 17 00:00:00 2001 From: leonardo Date: Mon, 9 Nov 2020 17:40:31 +0100 Subject: [PATCH 07/14] added helpers to reduce code repetition --- RecoBTag/ONNXRuntime/BuildFile.xml | 6 ++ .../ONNXRuntime/interface/tensor_fillers.h | 16 ++++ RecoBTag/ONNXRuntime/plugins/BuildFile.xml | 1 + RecoBTag/ONNXRuntime/src/tensor_fillers.cc | 82 +++++++++++++++++++ 4 files changed, 105 insertions(+) create mode 100644 RecoBTag/ONNXRuntime/BuildFile.xml create mode 100644 RecoBTag/ONNXRuntime/interface/tensor_fillers.h create mode 100644 RecoBTag/ONNXRuntime/src/tensor_fillers.cc diff --git a/RecoBTag/ONNXRuntime/BuildFile.xml b/RecoBTag/ONNXRuntime/BuildFile.xml new file mode 100644 index 0000000000000..f75e71b863efd --- /dev/null +++ b/RecoBTag/ONNXRuntime/BuildFile.xml @@ -0,0 +1,6 @@ + + + + + + diff --git a/RecoBTag/ONNXRuntime/interface/tensor_fillers.h b/RecoBTag/ONNXRuntime/interface/tensor_fillers.h new file mode 100644 index 0000000000000..784b19568b812 --- /dev/null +++ b/RecoBTag/ONNXRuntime/interface/tensor_fillers.h @@ -0,0 +1,16 @@ +#ifndef RecoBTag_ONNXRuntime_tensor_fillers_h +#define RecoBTag_ONNXRuntime_tensor_fillers_h + +#include "DataFormats/BTauReco/interface/DeepFlavourTagInfo.h" + +namespace btagbtvdeep { + + void jet4vec_tensor_filler(float*& ptr, const btagbtvdeep::JetFeatures& jet_features); + + void seedTrack_tensor_filler(float*& ptr, const btagbtvdeep::SeedingTrackFeatures& seed_features); + + void neighbourTrack_tensor_filler(float*& ptr, const btagbtvdeep::TrackPairFeatures& neighbourTrack_features); + +} + +#endif diff --git a/RecoBTag/ONNXRuntime/plugins/BuildFile.xml b/RecoBTag/ONNXRuntime/plugins/BuildFile.xml index 286d9847a92b3..251a68aa90c81 100644 --- a/RecoBTag/ONNXRuntime/plugins/BuildFile.xml +++ b/RecoBTag/ONNXRuntime/plugins/BuildFile.xml @@ -4,5 +4,6 @@ + diff --git a/RecoBTag/ONNXRuntime/src/tensor_fillers.cc b/RecoBTag/ONNXRuntime/src/tensor_fillers.cc new file mode 100644 index 0000000000000..ad44b52ab27ff --- /dev/null +++ b/RecoBTag/ONNXRuntime/src/tensor_fillers.cc @@ -0,0 +1,82 @@ +#include "RecoBTag/ONNXRuntime/interface/tensor_fillers.h" + +namespace btagbtvdeep { + + void jet4vec_tensor_filler(float*& ptr, const btagbtvdeep::JetFeatures& jet_features) { + + *ptr = jet_features.pt; + *(++ptr) = jet_features.eta; + *(++ptr) = jet_features.phi; + *(++ptr) = jet_features.mass; + + } + + + void seedTrack_tensor_filler(float*& ptr, const btagbtvdeep::SeedingTrackFeatures& seed_features) { + + *ptr = seed_features.pt; + *(++ptr) = seed_features.eta; + *(++ptr) = seed_features.phi; + *(++ptr) = seed_features.mass; + *(++ptr) = seed_features.dz; + *(++ptr) = seed_features.dxy; + *(++ptr) = seed_features.ip3D; + *(++ptr) = seed_features.sip3D; + *(++ptr) = seed_features.ip2D; + *(++ptr) = seed_features.sip2D; + *(++ptr) = seed_features.signedIp3D; + *(++ptr) = seed_features.signedSip3D; + *(++ptr) = seed_features.signedIp2D; + *(++ptr) = seed_features.signedSip2D; + *(++ptr) = seed_features.trackProbability3D; + *(++ptr) = seed_features.trackProbability2D; + *(++ptr) = seed_features.chi2reduced; + *(++ptr) = seed_features.nPixelHits; + *(++ptr) = seed_features.nHits; + *(++ptr) = seed_features.jetAxisDistance; + *(++ptr) = seed_features.jetAxisDlength; + + } + + void neighbourTrack_tensor_filler(float*& ptr, const btagbtvdeep::TrackPairFeatures& neighbourTrack_features) { + + *ptr = neighbourTrack_features.pt; + *(++ptr) = neighbourTrack_features.eta; + *(++ptr) = neighbourTrack_features.phi; + *(++ptr) = neighbourTrack_features.dz; + *(++ptr) = neighbourTrack_features.dxy; + *(++ptr) = neighbourTrack_features.mass; + *(++ptr) = neighbourTrack_features.ip3D; + *(++ptr) = neighbourTrack_features.sip3D; + *(++ptr) = neighbourTrack_features.ip2D; + *(++ptr) = neighbourTrack_features.sip2D; + *(++ptr) = neighbourTrack_features.distPCA; + *(++ptr) = neighbourTrack_features.dsigPCA; + *(++ptr) = neighbourTrack_features.x_PCAonSeed; + *(++ptr) = neighbourTrack_features.y_PCAonSeed; + *(++ptr) = neighbourTrack_features.z_PCAonSeed; + *(++ptr) = neighbourTrack_features.xerr_PCAonSeed; + *(++ptr) = neighbourTrack_features.yerr_PCAonSeed; + *(++ptr) = neighbourTrack_features.zerr_PCAonSeed; + *(++ptr) = neighbourTrack_features.x_PCAonTrack; + *(++ptr) = neighbourTrack_features.y_PCAonTrack; + *(++ptr) = neighbourTrack_features.z_PCAonTrack; + *(++ptr) = neighbourTrack_features.xerr_PCAonTrack; + *(++ptr) = neighbourTrack_features.yerr_PCAonTrack; + *(++ptr) = neighbourTrack_features.zerr_PCAonTrack; + *(++ptr) = neighbourTrack_features.dotprodTrack; + *(++ptr) = neighbourTrack_features.dotprodSeed; + *(++ptr) = neighbourTrack_features.dotprodTrackSeed2D; + *(++ptr) = neighbourTrack_features.dotprodTrackSeed3D; + *(++ptr) = neighbourTrack_features.dotprodTrackSeedVectors2D; + *(++ptr) = neighbourTrack_features.dotprodTrackSeedVectors3D; + *(++ptr) = neighbourTrack_features.pvd_PCAonSeed; + *(++ptr) = neighbourTrack_features.pvd_PCAonTrack; + *(++ptr) = neighbourTrack_features.dist_PCAjetAxis; + *(++ptr) = neighbourTrack_features.dotprod_PCAjetMomenta; + *(++ptr) = neighbourTrack_features.deta_PCAjetDirs; + *(++ptr) = neighbourTrack_features.dphi_PCAjetDirs; + + } + +} // namespace btagbtvdeep From 888f2a7126f4057935a499e49a0a2debc6a16c48 Mon Sep 17 00:00:00 2001 From: leonardo Date: Mon, 9 Nov 2020 17:41:39 +0100 Subject: [PATCH 08/14] update of the producers to run only on pt raw>15 and eta<2.5 + added helpers --- .../DeepCombinedONNXJetTagsProducer.cc | 115 +++++++----------- .../plugins/DeepVertexONNXJetTagsProducer.cc | 115 +++++++----------- 2 files changed, 84 insertions(+), 146 deletions(-) diff --git a/RecoBTag/ONNXRuntime/plugins/DeepCombinedONNXJetTagsProducer.cc b/RecoBTag/ONNXRuntime/plugins/DeepCombinedONNXJetTagsProducer.cc index d7139808d81f2..48f6cb000b9cc 100644 --- a/RecoBTag/ONNXRuntime/plugins/DeepCombinedONNXJetTagsProducer.cc +++ b/RecoBTag/ONNXRuntime/plugins/DeepCombinedONNXJetTagsProducer.cc @@ -15,6 +15,8 @@ #include "PhysicsTools/ONNXRuntime/interface/ONNXRuntime.h" +#include "RecoBTag/ONNXRuntime/interface/tensor_fillers.h" + using namespace cms::Ort; class DeepCombinedONNXJetTagsProducer : public edm::stream::EDProducer> { @@ -40,6 +42,9 @@ class DeepCombinedONNXJetTagsProducer : public edm::stream::EDProducer input_names_; std::vector output_names_; + const double min_jet_pt_; + const double max_jet_eta_; + enum InputIndexes { kGlobal = 0, kChargedCandidates = 1, @@ -90,7 +95,9 @@ DeepCombinedONNXJetTagsProducer::DeepCombinedONNXJetTagsProducer(const edm::Para : src_(consumes(iConfig.getParameter("src"))), flav_names_(iConfig.getParameter>("flav_names")), input_names_(iConfig.getParameter>("input_names")), - output_names_(iConfig.getParameter>("output_names")) { + output_names_(iConfig.getParameter>("output_names")), + min_jet_pt_(iConfig.getParameter("min_jet_pt")), + max_jet_eta_(iConfig.getParameter("max_jet_eta")) { // get output names from flav_names for (const auto& flav_name : flav_names_) { produces(flav_name); @@ -126,6 +133,8 @@ void DeepCombinedONNXJetTagsProducer::fillDescriptions(edm::ConfigurationDescrip edm::FileInPath("RecoBTag/Combined/data/DeepVertex/phase1_deepvertexcombined.onnx")); desc.add>("output_names", {"dense_13"}); desc.add>("flav_names", std::vector{"probb", "probc", "probuds", "probg"}); + desc.add("min_jet_pt", 15.0); + desc.add("max_jet_eta", 2.5); descriptions.add("pfDeepCombinedJetTags", desc); } @@ -140,8 +149,22 @@ void DeepCombinedONNXJetTagsProducer::produce(edm::Event& iEvent, const edm::Eve edm::Handle tag_infos; iEvent.getByToken(src_, tag_infos); + data_.clear(); + std::vector> output_tags; if (!tag_infos->empty()) { + unsigned int good_taginfo_count = 0; + for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { + const auto& jet_ref = (*tag_infos)[jet_n].jet(); + if (jet_ref->pt() > min_jet_pt_ && std::fabs(jet_ref->eta()) < max_jet_eta_) + good_taginfo_count++; + } + + // init data storage w correct size + for (const auto& len : input_sizes_) { + data_.emplace_back(good_taginfo_count * len, 0); + } + // initialize output collection auto jet_ref = tag_infos->begin()->jet(); auto ref2prod = edm::makeRefToBaseProdFrom(jet_ref, iEvent); @@ -149,28 +172,32 @@ void DeepCombinedONNXJetTagsProducer::produce(edm::Event& iEvent, const edm::Eve output_tags.emplace_back(std::make_unique(ref2prod)); } - // init data storage - data_.clear(); - for (const auto& len : input_sizes_) { - data_.emplace_back(tag_infos->size() * len, 0); - } // convert inputs + unsigned int inputs_done_count = 0; for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { - const auto& taginfo = (*tag_infos)[jet_n]; - make_inputs(jet_n, taginfo); + const auto& jet_ref = (*tag_infos)[jet_n].jet(); + if (jet_ref->pt() > min_jet_pt_ && std::fabs(jet_ref->eta()) < max_jet_eta_) { + const auto& taginfo = (*tag_infos)[jet_n]; + make_inputs(inputs_done_count, taginfo); + inputs_done_count++; + } } // run prediction - const auto outputs = globalCache()->run(input_names_, data_, {}, output_names_, tag_infos->size())[0]; - assert(outputs.size() == flav_names_.size() * tag_infos->size()); + assert(inputs_done_count == good_taginfo_count); + const auto outputs = globalCache()->run(input_names_, data_, {}, output_names_, good_taginfo_count)[0]; + assert(outputs.size() == flav_names_.size() * good_taginfo_count); // get the outputs unsigned i_output = 0; for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { const auto& jet_ref = (*tag_infos)[jet_n].jet(); for (std::size_t flav_n = 0; flav_n < flav_names_.size(); flav_n++) { - (*(output_tags[flav_n]))[jet_ref] = outputs[i_output]; - ++i_output; + if (jet_ref->pt() > min_jet_pt_ && std::fabs(jet_ref->eta()) < max_jet_eta_) { + (*(output_tags[flav_n]))[jet_ref] = outputs[i_output]; + ++i_output; + } else + (*(output_tags[flav_n]))[jet_ref] = -2; } } } else { @@ -286,10 +313,7 @@ void DeepCombinedONNXJetTagsProducer::make_inputs(unsigned i_jet, const reco::De offset = i_jet * input_sizes_[kGlobal1]; ptr = &data_[kGlobal1][offset]; start = ptr; - *ptr = jet_features.pt; - *(++ptr) = jet_features.eta; - *(++ptr) = jet_features.phi; - *(++ptr) = jet_features.mass; + jet4vec_tensor_filler(ptr, jet_features); assert(start + n_features_global1_ - 1 == ptr); // seeds @@ -299,27 +323,7 @@ void DeepCombinedONNXJetTagsProducer::make_inputs(unsigned i_jet, const reco::De const auto& seed_features = features.seed_features[seed_n]; ptr = &data_[kSeedingTracks][offset + seed_n * n_features_seed_]; start = ptr; - *ptr = seed_features.pt; - *(++ptr) = seed_features.eta; - *(++ptr) = seed_features.phi; - *(++ptr) = seed_features.mass; - *(++ptr) = seed_features.dz; - *(++ptr) = seed_features.dxy; - *(++ptr) = seed_features.ip3D; - *(++ptr) = seed_features.sip3D; - *(++ptr) = seed_features.ip2D; - *(++ptr) = seed_features.sip2D; - *(++ptr) = seed_features.signedIp3D; - *(++ptr) = seed_features.signedSip3D; - *(++ptr) = seed_features.signedIp2D; - *(++ptr) = seed_features.signedSip2D; - *(++ptr) = seed_features.trackProbability3D; - *(++ptr) = seed_features.trackProbability2D; - *(++ptr) = seed_features.chi2reduced; - *(++ptr) = seed_features.nPixelHits; - *(++ptr) = seed_features.nHits; - *(++ptr) = seed_features.jetAxisDistance; - *(++ptr) = seed_features.jetAxisDlength; + seedTrack_tensor_filler(ptr, seed_features); assert(start + n_features_seed_ - 1 == ptr); } @@ -331,42 +335,7 @@ void DeepCombinedONNXJetTagsProducer::make_inputs(unsigned i_jet, const reco::De for (std::size_t neighbour_n = 0; neighbour_n < max_neighbour_n; neighbour_n++) { ptr = &data_[kNeighbourTracks + seed_n][offset + neighbour_n * n_features_neighbor_]; start = ptr; - *ptr = neighbourTracks_features[neighbour_n].pt; - *(++ptr) = neighbourTracks_features[neighbour_n].eta; - *(++ptr) = neighbourTracks_features[neighbour_n].phi; - *(++ptr) = neighbourTracks_features[neighbour_n].dz; - *(++ptr) = neighbourTracks_features[neighbour_n].dxy; - *(++ptr) = neighbourTracks_features[neighbour_n].mass; - *(++ptr) = neighbourTracks_features[neighbour_n].ip3D; - *(++ptr) = neighbourTracks_features[neighbour_n].sip3D; - *(++ptr) = neighbourTracks_features[neighbour_n].ip2D; - *(++ptr) = neighbourTracks_features[neighbour_n].sip2D; - *(++ptr) = neighbourTracks_features[neighbour_n].distPCA; - *(++ptr) = neighbourTracks_features[neighbour_n].dsigPCA; - *(++ptr) = neighbourTracks_features[neighbour_n].x_PCAonSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].y_PCAonSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].z_PCAonSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].xerr_PCAonSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].yerr_PCAonSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].zerr_PCAonSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].x_PCAonTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].y_PCAonTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].z_PCAonTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].xerr_PCAonTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].yerr_PCAonTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].zerr_PCAonTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].dotprodSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeed2D; - *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeed3D; - *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeedVectors2D; - *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeedVectors3D; - *(++ptr) = neighbourTracks_features[neighbour_n].pvd_PCAonSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].pvd_PCAonTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].dist_PCAjetAxis; - *(++ptr) = neighbourTracks_features[neighbour_n].dotprod_PCAjetMomenta; - *(++ptr) = neighbourTracks_features[neighbour_n].deta_PCAjetDirs; - *(++ptr) = neighbourTracks_features[neighbour_n].dphi_PCAjetDirs; + neighbourTrack_tensor_filler(ptr, neighbourTracks_features[neighbour_n]); assert(start + n_features_neighbor_ - 1 == ptr); } } diff --git a/RecoBTag/ONNXRuntime/plugins/DeepVertexONNXJetTagsProducer.cc b/RecoBTag/ONNXRuntime/plugins/DeepVertexONNXJetTagsProducer.cc index dd9057abde117..3e8f649913e94 100644 --- a/RecoBTag/ONNXRuntime/plugins/DeepVertexONNXJetTagsProducer.cc +++ b/RecoBTag/ONNXRuntime/plugins/DeepVertexONNXJetTagsProducer.cc @@ -15,6 +15,8 @@ #include "PhysicsTools/ONNXRuntime/interface/ONNXRuntime.h" +#include "RecoBTag/ONNXRuntime/interface/tensor_fillers.h" + using namespace cms::Ort; class DeepVertexONNXJetTagsProducer : public edm::stream::EDProducer> { @@ -40,6 +42,9 @@ class DeepVertexONNXJetTagsProducer : public edm::stream::EDProducer input_names_; std::vector output_names_; + const double min_jet_pt_; + const double max_jet_eta_; + enum InputIndexes { kGlobal = 0, kSeedingTracks = 1, kNeighbourTracks = 2 }; constexpr static unsigned n_features_global_ = 4; constexpr static unsigned n_seed_ = 10; @@ -70,7 +75,9 @@ DeepVertexONNXJetTagsProducer::DeepVertexONNXJetTagsProducer(const edm::Paramete : src_(consumes(iConfig.getParameter("src"))), flav_names_(iConfig.getParameter>("flav_names")), input_names_(iConfig.getParameter>("input_names")), - output_names_(iConfig.getParameter>("output_names")) { + output_names_(iConfig.getParameter>("output_names")), + min_jet_pt_(iConfig.getParameter("min_jet_pt")), + max_jet_eta_(iConfig.getParameter("max_jet_eta")) { // get output names from flav_names for (const auto& flav_name : flav_names_) { produces(flav_name); @@ -101,6 +108,8 @@ void DeepVertexONNXJetTagsProducer::fillDescriptions(edm::ConfigurationDescripti desc.add("model_path", edm::FileInPath("RecoBTag/Combined/data/DeepVertex/phase1_deepvertex.onnx")); desc.add>("output_names", {"dense_6"}); desc.add>("flav_names", std::vector{"probb", "probc", "probuds", "probg"}); + desc.add("min_jet_pt", 15.0); + desc.add("max_jet_eta", 2.5); descriptions.add("pfDeepVertexJetTags", desc); } @@ -115,8 +124,22 @@ void DeepVertexONNXJetTagsProducer::produce(edm::Event& iEvent, const edm::Event edm::Handle tag_infos; iEvent.getByToken(src_, tag_infos); + data_.clear(); + std::vector> output_tags; if (!tag_infos->empty()) { + unsigned int good_taginfo_count = 0; + for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { + const auto& jet_ref = (*tag_infos)[jet_n].jet(); + if (jet_ref->pt() > min_jet_pt_ && std::fabs(jet_ref->eta()) < max_jet_eta_) + good_taginfo_count++; + } + + // init data storage w correct size + for (const auto& len : input_sizes_) { + data_.emplace_back(good_taginfo_count * len, 0); + } + // initialize output collection auto jet_ref = tag_infos->begin()->jet(); auto ref2prod = edm::makeRefToBaseProdFrom(jet_ref, iEvent); @@ -124,28 +147,32 @@ void DeepVertexONNXJetTagsProducer::produce(edm::Event& iEvent, const edm::Event output_tags.emplace_back(std::make_unique(ref2prod)); } - // init data storage - data_.clear(); - for (const auto& len : input_sizes_) { - data_.emplace_back(tag_infos->size() * len, 0); - } // convert inputs + unsigned int inputs_done_count = 0; for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { - const auto& taginfo = (*tag_infos)[jet_n]; - make_inputs(jet_n, taginfo); + const auto& jet_ref = (*tag_infos)[jet_n].jet(); + if (jet_ref->pt() > min_jet_pt_ && std::fabs(jet_ref->eta()) < max_jet_eta_) { + const auto& taginfo = (*tag_infos)[jet_n]; + make_inputs(inputs_done_count, taginfo); + inputs_done_count++; + } } // run prediction - const auto outputs = globalCache()->run(input_names_, data_, {}, output_names_, tag_infos->size())[0]; - assert(outputs.size() == flav_names_.size() * tag_infos->size()); + assert(inputs_done_count == good_taginfo_count); + const auto outputs = globalCache()->run(input_names_, data_, {}, output_names_, good_taginfo_count)[0]; + assert(outputs.size() == flav_names_.size() * good_taginfo_count); // get the outputs unsigned i_output = 0; for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { const auto& jet_ref = (*tag_infos)[jet_n].jet(); for (std::size_t flav_n = 0; flav_n < flav_names_.size(); flav_n++) { - (*(output_tags[flav_n]))[jet_ref] = outputs[i_output]; - ++i_output; + if (jet_ref->pt() > min_jet_pt_ && std::fabs(jet_ref->eta()) < max_jet_eta_) { + (*(output_tags[flav_n]))[jet_ref] = outputs[i_output]; + ++i_output; + } else + (*(output_tags[flav_n]))[jet_ref] = -2; } } } else { @@ -173,10 +200,7 @@ void DeepVertexONNXJetTagsProducer::make_inputs(unsigned i_jet, const reco::Deep // jet variables const auto& jet_features = features.jet_features; start = ptr; - *ptr = jet_features.pt; - *(++ptr) = jet_features.eta; - *(++ptr) = jet_features.phi; - *(++ptr) = jet_features.mass; + jet4vec_tensor_filler(ptr, jet_features); assert(start + n_features_global_ - 1 == ptr); // seeds @@ -186,27 +210,7 @@ void DeepVertexONNXJetTagsProducer::make_inputs(unsigned i_jet, const reco::Deep const auto& seed_features = features.seed_features[seed_n]; ptr = &data_[kSeedingTracks][offset + seed_n * n_features_seed_]; start = ptr; - *ptr = seed_features.pt; - *(++ptr) = seed_features.eta; - *(++ptr) = seed_features.phi; - *(++ptr) = seed_features.mass; - *(++ptr) = seed_features.dz; - *(++ptr) = seed_features.dxy; - *(++ptr) = seed_features.ip3D; - *(++ptr) = seed_features.sip3D; - *(++ptr) = seed_features.ip2D; - *(++ptr) = seed_features.sip2D; - *(++ptr) = seed_features.signedIp3D; - *(++ptr) = seed_features.signedSip3D; - *(++ptr) = seed_features.signedIp2D; - *(++ptr) = seed_features.signedSip2D; - *(++ptr) = seed_features.trackProbability3D; - *(++ptr) = seed_features.trackProbability2D; - *(++ptr) = seed_features.chi2reduced; - *(++ptr) = seed_features.nPixelHits; - *(++ptr) = seed_features.nHits; - *(++ptr) = seed_features.jetAxisDistance; - *(++ptr) = seed_features.jetAxisDlength; + seedTrack_tensor_filler(ptr, seed_features); assert(start + n_features_seed_ - 1 == ptr); } @@ -218,42 +222,7 @@ void DeepVertexONNXJetTagsProducer::make_inputs(unsigned i_jet, const reco::Deep for (std::size_t neighbour_n = 0; neighbour_n < max_neighbour_n; neighbour_n++) { ptr = &data_[kNeighbourTracks + seed_n][offset + neighbour_n * n_features_neighbor_]; start = ptr; - *ptr = neighbourTracks_features[neighbour_n].pt; - *(++ptr) = neighbourTracks_features[neighbour_n].eta; - *(++ptr) = neighbourTracks_features[neighbour_n].phi; - *(++ptr) = neighbourTracks_features[neighbour_n].dz; - *(++ptr) = neighbourTracks_features[neighbour_n].dxy; - *(++ptr) = neighbourTracks_features[neighbour_n].mass; - *(++ptr) = neighbourTracks_features[neighbour_n].ip3D; - *(++ptr) = neighbourTracks_features[neighbour_n].sip3D; - *(++ptr) = neighbourTracks_features[neighbour_n].ip2D; - *(++ptr) = neighbourTracks_features[neighbour_n].sip2D; - *(++ptr) = neighbourTracks_features[neighbour_n].distPCA; - *(++ptr) = neighbourTracks_features[neighbour_n].dsigPCA; - *(++ptr) = neighbourTracks_features[neighbour_n].x_PCAonSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].y_PCAonSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].z_PCAonSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].xerr_PCAonSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].yerr_PCAonSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].zerr_PCAonSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].x_PCAonTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].y_PCAonTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].z_PCAonTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].xerr_PCAonTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].yerr_PCAonTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].zerr_PCAonTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].dotprodSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeed2D; - *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeed3D; - *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeedVectors2D; - *(++ptr) = neighbourTracks_features[neighbour_n].dotprodTrackSeedVectors3D; - *(++ptr) = neighbourTracks_features[neighbour_n].pvd_PCAonSeed; - *(++ptr) = neighbourTracks_features[neighbour_n].pvd_PCAonTrack; - *(++ptr) = neighbourTracks_features[neighbour_n].dist_PCAjetAxis; - *(++ptr) = neighbourTracks_features[neighbour_n].dotprod_PCAjetMomenta; - *(++ptr) = neighbourTracks_features[neighbour_n].deta_PCAjetDirs; - *(++ptr) = neighbourTracks_features[neighbour_n].dphi_PCAjetDirs; + neighbourTrack_tensor_filler(ptr, neighbourTracks_features[neighbour_n]); assert(start + n_features_neighbor_ - 1 == ptr); } } From 55e3195d97b99064341504af6553f3a838c56d34 Mon Sep 17 00:00:00 2001 From: leonardo Date: Tue, 10 Nov 2020 09:33:11 +0100 Subject: [PATCH 09/14] clang of tensor fillers --- .../ONNXRuntime/interface/tensor_fillers.h | 12 +- RecoBTag/ONNXRuntime/src/tensor_fillers.cc | 141 +++++++++--------- 2 files changed, 73 insertions(+), 80 deletions(-) diff --git a/RecoBTag/ONNXRuntime/interface/tensor_fillers.h b/RecoBTag/ONNXRuntime/interface/tensor_fillers.h index 784b19568b812..df864d171b4d3 100644 --- a/RecoBTag/ONNXRuntime/interface/tensor_fillers.h +++ b/RecoBTag/ONNXRuntime/interface/tensor_fillers.h @@ -4,13 +4,13 @@ #include "DataFormats/BTauReco/interface/DeepFlavourTagInfo.h" namespace btagbtvdeep { - - void jet4vec_tensor_filler(float*& ptr, const btagbtvdeep::JetFeatures& jet_features); - void seedTrack_tensor_filler(float*& ptr, const btagbtvdeep::SeedingTrackFeatures& seed_features); + void jet4vec_tensor_filler(float*& ptr, const btagbtvdeep::JetFeatures& jet_features); - void neighbourTrack_tensor_filler(float*& ptr, const btagbtvdeep::TrackPairFeatures& neighbourTrack_features); + void seedTrack_tensor_filler(float*& ptr, const btagbtvdeep::SeedingTrackFeatures& seed_features); -} + void neighbourTrack_tensor_filler(float*& ptr, const btagbtvdeep::TrackPairFeatures& neighbourTrack_features); -#endif +} // namespace btagbtvdeep + +#endif diff --git a/RecoBTag/ONNXRuntime/src/tensor_fillers.cc b/RecoBTag/ONNXRuntime/src/tensor_fillers.cc index ad44b52ab27ff..db60a7b02eaf6 100644 --- a/RecoBTag/ONNXRuntime/src/tensor_fillers.cc +++ b/RecoBTag/ONNXRuntime/src/tensor_fillers.cc @@ -2,81 +2,74 @@ namespace btagbtvdeep { - void jet4vec_tensor_filler(float*& ptr, const btagbtvdeep::JetFeatures& jet_features) { + void jet4vec_tensor_filler(float*& ptr, const btagbtvdeep::JetFeatures& jet_features) { + *ptr = jet_features.pt; + *(++ptr) = jet_features.eta; + *(++ptr) = jet_features.phi; + *(++ptr) = jet_features.mass; + } - *ptr = jet_features.pt; - *(++ptr) = jet_features.eta; - *(++ptr) = jet_features.phi; - *(++ptr) = jet_features.mass; + void seedTrack_tensor_filler(float*& ptr, const btagbtvdeep::SeedingTrackFeatures& seed_features) { + *ptr = seed_features.pt; + *(++ptr) = seed_features.eta; + *(++ptr) = seed_features.phi; + *(++ptr) = seed_features.mass; + *(++ptr) = seed_features.dz; + *(++ptr) = seed_features.dxy; + *(++ptr) = seed_features.ip3D; + *(++ptr) = seed_features.sip3D; + *(++ptr) = seed_features.ip2D; + *(++ptr) = seed_features.sip2D; + *(++ptr) = seed_features.signedIp3D; + *(++ptr) = seed_features.signedSip3D; + *(++ptr) = seed_features.signedIp2D; + *(++ptr) = seed_features.signedSip2D; + *(++ptr) = seed_features.trackProbability3D; + *(++ptr) = seed_features.trackProbability2D; + *(++ptr) = seed_features.chi2reduced; + *(++ptr) = seed_features.nPixelHits; + *(++ptr) = seed_features.nHits; + *(++ptr) = seed_features.jetAxisDistance; + *(++ptr) = seed_features.jetAxisDlength; + } - } - - - void seedTrack_tensor_filler(float*& ptr, const btagbtvdeep::SeedingTrackFeatures& seed_features) { - - *ptr = seed_features.pt; - *(++ptr) = seed_features.eta; - *(++ptr) = seed_features.phi; - *(++ptr) = seed_features.mass; - *(++ptr) = seed_features.dz; - *(++ptr) = seed_features.dxy; - *(++ptr) = seed_features.ip3D; - *(++ptr) = seed_features.sip3D; - *(++ptr) = seed_features.ip2D; - *(++ptr) = seed_features.sip2D; - *(++ptr) = seed_features.signedIp3D; - *(++ptr) = seed_features.signedSip3D; - *(++ptr) = seed_features.signedIp2D; - *(++ptr) = seed_features.signedSip2D; - *(++ptr) = seed_features.trackProbability3D; - *(++ptr) = seed_features.trackProbability2D; - *(++ptr) = seed_features.chi2reduced; - *(++ptr) = seed_features.nPixelHits; - *(++ptr) = seed_features.nHits; - *(++ptr) = seed_features.jetAxisDistance; - *(++ptr) = seed_features.jetAxisDlength; - - } - - void neighbourTrack_tensor_filler(float*& ptr, const btagbtvdeep::TrackPairFeatures& neighbourTrack_features) { - - *ptr = neighbourTrack_features.pt; - *(++ptr) = neighbourTrack_features.eta; - *(++ptr) = neighbourTrack_features.phi; - *(++ptr) = neighbourTrack_features.dz; - *(++ptr) = neighbourTrack_features.dxy; - *(++ptr) = neighbourTrack_features.mass; - *(++ptr) = neighbourTrack_features.ip3D; - *(++ptr) = neighbourTrack_features.sip3D; - *(++ptr) = neighbourTrack_features.ip2D; - *(++ptr) = neighbourTrack_features.sip2D; - *(++ptr) = neighbourTrack_features.distPCA; - *(++ptr) = neighbourTrack_features.dsigPCA; - *(++ptr) = neighbourTrack_features.x_PCAonSeed; - *(++ptr) = neighbourTrack_features.y_PCAonSeed; - *(++ptr) = neighbourTrack_features.z_PCAonSeed; - *(++ptr) = neighbourTrack_features.xerr_PCAonSeed; - *(++ptr) = neighbourTrack_features.yerr_PCAonSeed; - *(++ptr) = neighbourTrack_features.zerr_PCAonSeed; - *(++ptr) = neighbourTrack_features.x_PCAonTrack; - *(++ptr) = neighbourTrack_features.y_PCAonTrack; - *(++ptr) = neighbourTrack_features.z_PCAonTrack; - *(++ptr) = neighbourTrack_features.xerr_PCAonTrack; - *(++ptr) = neighbourTrack_features.yerr_PCAonTrack; - *(++ptr) = neighbourTrack_features.zerr_PCAonTrack; - *(++ptr) = neighbourTrack_features.dotprodTrack; - *(++ptr) = neighbourTrack_features.dotprodSeed; - *(++ptr) = neighbourTrack_features.dotprodTrackSeed2D; - *(++ptr) = neighbourTrack_features.dotprodTrackSeed3D; - *(++ptr) = neighbourTrack_features.dotprodTrackSeedVectors2D; - *(++ptr) = neighbourTrack_features.dotprodTrackSeedVectors3D; - *(++ptr) = neighbourTrack_features.pvd_PCAonSeed; - *(++ptr) = neighbourTrack_features.pvd_PCAonTrack; - *(++ptr) = neighbourTrack_features.dist_PCAjetAxis; - *(++ptr) = neighbourTrack_features.dotprod_PCAjetMomenta; - *(++ptr) = neighbourTrack_features.deta_PCAjetDirs; - *(++ptr) = neighbourTrack_features.dphi_PCAjetDirs; - - } + void neighbourTrack_tensor_filler(float*& ptr, const btagbtvdeep::TrackPairFeatures& neighbourTrack_features) { + *ptr = neighbourTrack_features.pt; + *(++ptr) = neighbourTrack_features.eta; + *(++ptr) = neighbourTrack_features.phi; + *(++ptr) = neighbourTrack_features.dz; + *(++ptr) = neighbourTrack_features.dxy; + *(++ptr) = neighbourTrack_features.mass; + *(++ptr) = neighbourTrack_features.ip3D; + *(++ptr) = neighbourTrack_features.sip3D; + *(++ptr) = neighbourTrack_features.ip2D; + *(++ptr) = neighbourTrack_features.sip2D; + *(++ptr) = neighbourTrack_features.distPCA; + *(++ptr) = neighbourTrack_features.dsigPCA; + *(++ptr) = neighbourTrack_features.x_PCAonSeed; + *(++ptr) = neighbourTrack_features.y_PCAonSeed; + *(++ptr) = neighbourTrack_features.z_PCAonSeed; + *(++ptr) = neighbourTrack_features.xerr_PCAonSeed; + *(++ptr) = neighbourTrack_features.yerr_PCAonSeed; + *(++ptr) = neighbourTrack_features.zerr_PCAonSeed; + *(++ptr) = neighbourTrack_features.x_PCAonTrack; + *(++ptr) = neighbourTrack_features.y_PCAonTrack; + *(++ptr) = neighbourTrack_features.z_PCAonTrack; + *(++ptr) = neighbourTrack_features.xerr_PCAonTrack; + *(++ptr) = neighbourTrack_features.yerr_PCAonTrack; + *(++ptr) = neighbourTrack_features.zerr_PCAonTrack; + *(++ptr) = neighbourTrack_features.dotprodTrack; + *(++ptr) = neighbourTrack_features.dotprodSeed; + *(++ptr) = neighbourTrack_features.dotprodTrackSeed2D; + *(++ptr) = neighbourTrack_features.dotprodTrackSeed3D; + *(++ptr) = neighbourTrack_features.dotprodTrackSeedVectors2D; + *(++ptr) = neighbourTrack_features.dotprodTrackSeedVectors3D; + *(++ptr) = neighbourTrack_features.pvd_PCAonSeed; + *(++ptr) = neighbourTrack_features.pvd_PCAonTrack; + *(++ptr) = neighbourTrack_features.dist_PCAjetAxis; + *(++ptr) = neighbourTrack_features.dotprod_PCAjetMomenta; + *(++ptr) = neighbourTrack_features.deta_PCAjetDirs; + *(++ptr) = neighbourTrack_features.dphi_PCAjetDirs; + } } // namespace btagbtvdeep From 36059888bc545fdd50267b0fe81d559fb43c936c Mon Sep 17 00:00:00 2001 From: leonardo Date: Wed, 11 Nov 2020 10:13:01 +0100 Subject: [PATCH 10/14] added methods to fillers --- .../ONNXRuntime/interface/tensor_fillers.h | 8 +++ RecoBTag/ONNXRuntime/src/tensor_fillers.cc | 66 +++++++++++++++++++ 2 files changed, 74 insertions(+) diff --git a/RecoBTag/ONNXRuntime/interface/tensor_fillers.h b/RecoBTag/ONNXRuntime/interface/tensor_fillers.h index df864d171b4d3..bb1a25a2d0f0b 100644 --- a/RecoBTag/ONNXRuntime/interface/tensor_fillers.h +++ b/RecoBTag/ONNXRuntime/interface/tensor_fillers.h @@ -5,6 +5,14 @@ namespace btagbtvdeep { + void jet_tensor_filler(float*& ptr, const btagbtvdeep::DeepFlavourFeatures& features); + + void cpf_tensor_filler(float*& ptr, const btagbtvdeep::ChargedCandidateFeatures& c_pf_features); + + void npf_tensor_filler(float*& ptr, const btagbtvdeep::NeutralCandidateFeatures& n_pf_features); + + void sv_tensor_filler(float*& ptr, const btagbtvdeep::SecondaryVertexFeatures& sv_features); + void jet4vec_tensor_filler(float*& ptr, const btagbtvdeep::JetFeatures& jet_features); void seedTrack_tensor_filler(float*& ptr, const btagbtvdeep::SeedingTrackFeatures& seed_features); diff --git a/RecoBTag/ONNXRuntime/src/tensor_fillers.cc b/RecoBTag/ONNXRuntime/src/tensor_fillers.cc index db60a7b02eaf6..da49b1b0119d7 100644 --- a/RecoBTag/ONNXRuntime/src/tensor_fillers.cc +++ b/RecoBTag/ONNXRuntime/src/tensor_fillers.cc @@ -2,6 +2,72 @@ namespace btagbtvdeep { + void jet_tensor_filler(float*& ptr, const btagbtvdeep::DeepFlavourFeatures& features) { + // jet variables + const auto& jet_features = features.jet_features; + *ptr = jet_features.pt; + *(++ptr) = jet_features.eta; + // number of elements in different collections + *(++ptr) = features.c_pf_features.size(); + *(++ptr) = features.n_pf_features.size(); + *(++ptr) = features.sv_features.size(); + *(++ptr) = features.npv; + // variables from ShallowTagInfo + const auto& tag_info_features = features.tag_info_features; + *(++ptr) = tag_info_features.trackSumJetEtRatio; + *(++ptr) = tag_info_features.trackSumJetDeltaR; + *(++ptr) = tag_info_features.vertexCategory; + *(++ptr) = tag_info_features.trackSip2dValAboveCharm; + *(++ptr) = tag_info_features.trackSip2dSigAboveCharm; + *(++ptr) = tag_info_features.trackSip3dValAboveCharm; + *(++ptr) = tag_info_features.trackSip3dSigAboveCharm; + *(++ptr) = tag_info_features.jetNSelectedTracks; + *(++ptr) = tag_info_features.jetNTracksEtaRel; + } + + void cpf_tensor_filler(float*& ptr, const btagbtvdeep::ChargedCandidateFeatures& c_pf_features) { + *ptr = c_pf_features.btagPf_trackEtaRel; + *(++ptr) = c_pf_features.btagPf_trackPtRel; + *(++ptr) = c_pf_features.btagPf_trackPPar; + *(++ptr) = c_pf_features.btagPf_trackDeltaR; + *(++ptr) = c_pf_features.btagPf_trackPParRatio; + *(++ptr) = c_pf_features.btagPf_trackSip2dVal; + *(++ptr) = c_pf_features.btagPf_trackSip2dSig; + *(++ptr) = c_pf_features.btagPf_trackSip3dVal; + *(++ptr) = c_pf_features.btagPf_trackSip3dSig; + *(++ptr) = c_pf_features.btagPf_trackJetDistVal; + *(++ptr) = c_pf_features.ptrel; + *(++ptr) = c_pf_features.drminsv; + *(++ptr) = c_pf_features.vtx_ass; + *(++ptr) = c_pf_features.puppiw; + *(++ptr) = c_pf_features.chi2; + *(++ptr) = c_pf_features.quality; + } + + void npf_tensor_filler(float*& ptr, const btagbtvdeep::NeutralCandidateFeatures& n_pf_features) { + *ptr = n_pf_features.ptrel; + *(++ptr) = n_pf_features.deltaR; + *(++ptr) = n_pf_features.isGamma; + *(++ptr) = n_pf_features.hadFrac; + *(++ptr) = n_pf_features.drminsv; + *(++ptr) = n_pf_features.puppiw; + } + + void sv_tensor_filler(float*& ptr, const btagbtvdeep::SecondaryVertexFeatures& sv_features) { + *ptr = sv_features.pt; + *(++ptr) = sv_features.deltaR; + *(++ptr) = sv_features.mass; + *(++ptr) = sv_features.ntracks; + *(++ptr) = sv_features.chi2; + *(++ptr) = sv_features.normchi2; + *(++ptr) = sv_features.dxy; + *(++ptr) = sv_features.dxysig; + *(++ptr) = sv_features.d3d; + *(++ptr) = sv_features.d3dsig; + *(++ptr) = sv_features.costhetasvpv; + *(++ptr) = sv_features.enratio; + } + void jet4vec_tensor_filler(float*& ptr, const btagbtvdeep::JetFeatures& jet_features) { *ptr = jet_features.pt; *(++ptr) = jet_features.eta; From f1b55a686b8ed5b168f26cbbd5e47508784eced6 Mon Sep 17 00:00:00 2001 From: leonardo Date: Wed, 11 Nov 2020 10:13:46 +0100 Subject: [PATCH 11/14] move constexpr to external header --- .../ONNXRuntime/interface/tensor_configs.h | 32 +++++++++++++++++++ 1 file changed, 32 insertions(+) create mode 100644 RecoBTag/ONNXRuntime/interface/tensor_configs.h diff --git a/RecoBTag/ONNXRuntime/interface/tensor_configs.h b/RecoBTag/ONNXRuntime/interface/tensor_configs.h new file mode 100644 index 0000000000000..9b19bf3832975 --- /dev/null +++ b/RecoBTag/ONNXRuntime/interface/tensor_configs.h @@ -0,0 +1,32 @@ +#ifndef RecoBTag_ONNXRuntime_tensor_configs_h +#define RecoBTag_ONNXRuntime_tensor_configs_h + +namespace deepflavour { + + constexpr unsigned n_features_global = 15; + + constexpr unsigned n_cpf = 25; + constexpr unsigned n_features_cpf = 16; + + constexpr unsigned n_npf = 25; + constexpr unsigned n_features_npf = 6; + + constexpr unsigned n_sv = 4; + constexpr unsigned n_features_sv = 12; + +} + +namespace deepvertex { + + constexpr unsigned n_features_global = 4; + + constexpr unsigned n_seed = 10; + constexpr unsigned n_features_seed = 21; + + constexpr unsigned n_neighbor = 20; + constexpr unsigned n_features_neighbor = 36; + +} + +#endif + From c6abee071df1609dfede8ffa2f386cc80a2db003 Mon Sep 17 00:00:00 2001 From: leonardo Date: Wed, 11 Nov 2020 10:14:16 +0100 Subject: [PATCH 12/14] modified the producers --- .../DeepCombinedONNXJetTagsProducer.cc | 103 +++++------------- .../plugins/DeepVertexONNXJetTagsProducer.cc | 33 +++--- 2 files changed, 47 insertions(+), 89 deletions(-) diff --git a/RecoBTag/ONNXRuntime/plugins/DeepCombinedONNXJetTagsProducer.cc b/RecoBTag/ONNXRuntime/plugins/DeepCombinedONNXJetTagsProducer.cc index 48f6cb000b9cc..99193460081a7 100644 --- a/RecoBTag/ONNXRuntime/plugins/DeepCombinedONNXJetTagsProducer.cc +++ b/RecoBTag/ONNXRuntime/plugins/DeepCombinedONNXJetTagsProducer.cc @@ -16,6 +16,7 @@ #include "PhysicsTools/ONNXRuntime/interface/ONNXRuntime.h" #include "RecoBTag/ONNXRuntime/interface/tensor_fillers.h" +#include "RecoBTag/ONNXRuntime/interface/tensor_configs.h" using namespace cms::Ort; @@ -54,18 +55,18 @@ class DeepCombinedONNXJetTagsProducer : public edm::stream::EDProducer input_sizes_; @@ -153,11 +154,14 @@ void DeepCombinedONNXJetTagsProducer::produce(edm::Event& iEvent, const edm::Eve std::vector> output_tags; if (!tag_infos->empty()) { - unsigned int good_taginfo_count = 0; + unsigned good_taginfo_count = 0; + std::vector good_taginfo_jets(tag_infos->size(), false); for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { const auto& jet_ref = (*tag_infos)[jet_n].jet(); - if (jet_ref->pt() > min_jet_pt_ && std::fabs(jet_ref->eta()) < max_jet_eta_) + if (jet_ref->pt() > min_jet_pt_ && std::fabs(jet_ref->eta()) < max_jet_eta_) { good_taginfo_count++; + good_taginfo_jets[jet_n] = true; + } } // init data storage w correct size @@ -173,10 +177,9 @@ void DeepCombinedONNXJetTagsProducer::produce(edm::Event& iEvent, const edm::Eve } // convert inputs - unsigned int inputs_done_count = 0; + unsigned inputs_done_count = 0; for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { - const auto& jet_ref = (*tag_infos)[jet_n].jet(); - if (jet_ref->pt() > min_jet_pt_ && std::fabs(jet_ref->eta()) < max_jet_eta_) { + if (good_taginfo_jets[jet_n]) { const auto& taginfo = (*tag_infos)[jet_n]; make_inputs(inputs_done_count, taginfo); inputs_done_count++; @@ -193,11 +196,12 @@ void DeepCombinedONNXJetTagsProducer::produce(edm::Event& iEvent, const edm::Eve for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { const auto& jet_ref = (*tag_infos)[jet_n].jet(); for (std::size_t flav_n = 0; flav_n < flav_names_.size(); flav_n++) { - if (jet_ref->pt() > min_jet_pt_ && std::fabs(jet_ref->eta()) < max_jet_eta_) { + if (good_taginfo_jets[jet_n]) { (*(output_tags[flav_n]))[jet_ref] = outputs[i_output]; ++i_output; - } else + } else { (*(output_tags[flav_n]))[jet_ref] = -2; + } } } } else { @@ -222,27 +226,8 @@ void DeepCombinedONNXJetTagsProducer::make_inputs(unsigned i_jet, const reco::De // jet and other global features offset = i_jet * input_sizes_[kGlobal]; ptr = &data_[kGlobal][offset]; - // jet variables - const auto& jet_features = features.jet_features; start = ptr; - *ptr = jet_features.pt; - *(++ptr) = jet_features.eta; - // number of elements in different collections - *(++ptr) = features.c_pf_features.size(); - *(++ptr) = features.n_pf_features.size(); - *(++ptr) = features.sv_features.size(); - *(++ptr) = features.npv; - // variables from ShallowTagInfo - const auto& tag_info_features = features.tag_info_features; - *(++ptr) = tag_info_features.trackSumJetEtRatio; - *(++ptr) = tag_info_features.trackSumJetDeltaR; - *(++ptr) = tag_info_features.vertexCategory; - *(++ptr) = tag_info_features.trackSip2dValAboveCharm; - *(++ptr) = tag_info_features.trackSip2dSigAboveCharm; - *(++ptr) = tag_info_features.trackSip3dValAboveCharm; - *(++ptr) = tag_info_features.trackSip3dSigAboveCharm; - *(++ptr) = tag_info_features.jetNSelectedTracks; - *(++ptr) = tag_info_features.jetNTracksEtaRel; + jet_tensor_filler(ptr, features); assert(start + n_features_global_ - 1 == ptr); // c_pf candidates @@ -252,22 +237,7 @@ void DeepCombinedONNXJetTagsProducer::make_inputs(unsigned i_jet, const reco::De const auto& c_pf_features = features.c_pf_features[c_pf_n]; ptr = &data_[kChargedCandidates][offset + c_pf_n * n_features_cpf_]; start = ptr; - *ptr = c_pf_features.btagPf_trackEtaRel; - *(++ptr) = c_pf_features.btagPf_trackPtRel; - *(++ptr) = c_pf_features.btagPf_trackPPar; - *(++ptr) = c_pf_features.btagPf_trackDeltaR; - *(++ptr) = c_pf_features.btagPf_trackPParRatio; - *(++ptr) = c_pf_features.btagPf_trackSip2dVal; - *(++ptr) = c_pf_features.btagPf_trackSip2dSig; - *(++ptr) = c_pf_features.btagPf_trackSip3dVal; - *(++ptr) = c_pf_features.btagPf_trackSip3dSig; - *(++ptr) = c_pf_features.btagPf_trackJetDistVal; - *(++ptr) = c_pf_features.ptrel; - *(++ptr) = c_pf_features.drminsv; - *(++ptr) = c_pf_features.vtx_ass; - *(++ptr) = c_pf_features.puppiw; - *(++ptr) = c_pf_features.chi2; - *(++ptr) = c_pf_features.quality; + cpf_tensor_filler(ptr, c_pf_features); assert(start + n_features_cpf_ - 1 == ptr); } @@ -278,12 +248,7 @@ void DeepCombinedONNXJetTagsProducer::make_inputs(unsigned i_jet, const reco::De const auto& n_pf_features = features.n_pf_features[n_pf_n]; ptr = &data_[kNeutralCandidates][offset + n_pf_n * n_features_npf_]; start = ptr; - *ptr = n_pf_features.ptrel; - *(++ptr) = n_pf_features.deltaR; - *(++ptr) = n_pf_features.isGamma; - *(++ptr) = n_pf_features.hadFrac; - *(++ptr) = n_pf_features.drminsv; - *(++ptr) = n_pf_features.puppiw; + npf_tensor_filler(ptr, n_pf_features); assert(start + n_features_npf_ - 1 == ptr); } @@ -294,23 +259,13 @@ void DeepCombinedONNXJetTagsProducer::make_inputs(unsigned i_jet, const reco::De const auto& sv_features = features.sv_features[sv_n]; ptr = &data_[kVertices][offset + sv_n * n_features_sv_]; start = ptr; - *ptr = sv_features.pt; - *(++ptr) = sv_features.deltaR; - *(++ptr) = sv_features.mass; - *(++ptr) = sv_features.ntracks; - *(++ptr) = sv_features.chi2; - *(++ptr) = sv_features.normchi2; - *(++ptr) = sv_features.dxy; - *(++ptr) = sv_features.dxysig; - *(++ptr) = sv_features.d3d; - *(++ptr) = sv_features.d3dsig; - *(++ptr) = sv_features.costhetasvpv; - *(++ptr) = sv_features.enratio; + sv_tensor_filler(ptr, sv_features); assert(start + n_features_sv_ - 1 == ptr); } - // jet and other global features + // jet variables offset = i_jet * input_sizes_[kGlobal1]; + const auto& jet_features = features.jet_features; ptr = &data_[kGlobal1][offset]; start = ptr; jet4vec_tensor_filler(ptr, jet_features); diff --git a/RecoBTag/ONNXRuntime/plugins/DeepVertexONNXJetTagsProducer.cc b/RecoBTag/ONNXRuntime/plugins/DeepVertexONNXJetTagsProducer.cc index 3e8f649913e94..c9805e66f04f7 100644 --- a/RecoBTag/ONNXRuntime/plugins/DeepVertexONNXJetTagsProducer.cc +++ b/RecoBTag/ONNXRuntime/plugins/DeepVertexONNXJetTagsProducer.cc @@ -16,6 +16,7 @@ #include "PhysicsTools/ONNXRuntime/interface/ONNXRuntime.h" #include "RecoBTag/ONNXRuntime/interface/tensor_fillers.h" +#include "RecoBTag/ONNXRuntime/interface/tensor_configs.h" using namespace cms::Ort; @@ -46,11 +47,11 @@ class DeepVertexONNXJetTagsProducer : public edm::stream::EDProducer input_sizes_; @@ -128,11 +129,14 @@ void DeepVertexONNXJetTagsProducer::produce(edm::Event& iEvent, const edm::Event std::vector> output_tags; if (!tag_infos->empty()) { - unsigned int good_taginfo_count = 0; + unsigned good_taginfo_count = 0; + std::vector good_taginfo_jets(tag_infos->size(), false); for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { const auto& jet_ref = (*tag_infos)[jet_n].jet(); - if (jet_ref->pt() > min_jet_pt_ && std::fabs(jet_ref->eta()) < max_jet_eta_) + if (jet_ref->pt() > min_jet_pt_ && std::fabs(jet_ref->eta()) < max_jet_eta_) { good_taginfo_count++; + good_taginfo_jets[jet_n] = true; + } } // init data storage w correct size @@ -148,10 +152,9 @@ void DeepVertexONNXJetTagsProducer::produce(edm::Event& iEvent, const edm::Event } // convert inputs - unsigned int inputs_done_count = 0; + unsigned inputs_done_count = 0; for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { - const auto& jet_ref = (*tag_infos)[jet_n].jet(); - if (jet_ref->pt() > min_jet_pt_ && std::fabs(jet_ref->eta()) < max_jet_eta_) { + if (good_taginfo_jets[jet_n]) { const auto& taginfo = (*tag_infos)[jet_n]; make_inputs(inputs_done_count, taginfo); inputs_done_count++; @@ -168,11 +171,12 @@ void DeepVertexONNXJetTagsProducer::produce(edm::Event& iEvent, const edm::Event for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { const auto& jet_ref = (*tag_infos)[jet_n].jet(); for (std::size_t flav_n = 0; flav_n < flav_names_.size(); flav_n++) { - if (jet_ref->pt() > min_jet_pt_ && std::fabs(jet_ref->eta()) < max_jet_eta_) { + if (good_taginfo_jets[jet_n]) { (*(output_tags[flav_n]))[jet_ref] = outputs[i_output]; ++i_output; - } else + } else { (*(output_tags[flav_n]))[jet_ref] = -2; + } } } } else { @@ -194,11 +198,10 @@ void DeepVertexONNXJetTagsProducer::make_inputs(unsigned i_jet, const reco::Deep const float* start = nullptr; unsigned offset = 0; - // jet and other global features - offset = i_jet * input_sizes_[kGlobal]; - ptr = &data_[kGlobal][offset]; // jet variables + offset = i_jet * input_sizes_[kGlobal]; const auto& jet_features = features.jet_features; + ptr = &data_[kGlobal][offset]; start = ptr; jet4vec_tensor_filler(ptr, jet_features); assert(start + n_features_global_ - 1 == ptr); From af629132e18d46d47a1bde6f04eadad45ea182d3 Mon Sep 17 00:00:00 2001 From: leonardo Date: Wed, 11 Nov 2020 10:26:55 +0100 Subject: [PATCH 13/14] clean RecoBTag/TensorFlow used only by DeepVertex --- RecoBTag/TensorFlow/BuildFile.xml | 5 - .../TensorFlow/interface/tensor_fillers.h | 66 ---- RecoBTag/TensorFlow/plugins/BuildFile.xml | 7 - .../plugins/DeepVertexTFJetTagsProducer.cc | 316 ------------------ RecoBTag/TensorFlow/src/tensor_fillers.cc | 251 -------------- .../TensorFlow/test/test_deepvertex_cfg.py | 77 ----- 6 files changed, 722 deletions(-) delete mode 100644 RecoBTag/TensorFlow/BuildFile.xml delete mode 100644 RecoBTag/TensorFlow/interface/tensor_fillers.h delete mode 100644 RecoBTag/TensorFlow/plugins/BuildFile.xml delete mode 100644 RecoBTag/TensorFlow/plugins/DeepVertexTFJetTagsProducer.cc delete mode 100644 RecoBTag/TensorFlow/src/tensor_fillers.cc delete mode 100644 RecoBTag/TensorFlow/test/test_deepvertex_cfg.py diff --git a/RecoBTag/TensorFlow/BuildFile.xml b/RecoBTag/TensorFlow/BuildFile.xml deleted file mode 100644 index 12e3ac6997187..0000000000000 --- a/RecoBTag/TensorFlow/BuildFile.xml +++ /dev/null @@ -1,5 +0,0 @@ - - - - - diff --git a/RecoBTag/TensorFlow/interface/tensor_fillers.h b/RecoBTag/TensorFlow/interface/tensor_fillers.h deleted file mode 100644 index bdc9bcf995489..0000000000000 --- a/RecoBTag/TensorFlow/interface/tensor_fillers.h +++ /dev/null @@ -1,66 +0,0 @@ -#ifndef RecoBTag_TensorFlow_tensor_fillers_h -#define RecoBTag_TensorFlow_tensor_fillers_h - -#include "PhysicsTools/TensorFlow/interface/TensorFlow.h" -#include "DataFormats/BTauReco/interface/DeepFlavourTagInfo.h" -#include "DataFormats/BTauReco/interface/DeepDoubleXTagInfo.h" - -namespace btagbtvdeep { - - // Note on setting tensor values: - // Instead of using the more convenient tensor.matrix (etc) methods, - // we can exploit that in the following methods values are set along - // the innermost (= last) axis. Those values are stored contiguously in - // the memory, so it is most performant to get the pointer to the first - // value and use pointer arithmetic to iterate through the next pointers. - - void jet_tensor_filler(tensorflow::Tensor& tensor, - std::size_t jet_n, - const btagbtvdeep::DeepFlavourFeatures& features); - - void jet4vec_tensor_filler(tensorflow::Tensor& tensor, - std::size_t jet_n, - const btagbtvdeep::DeepFlavourFeatures& features); - - void db_tensor_filler(tensorflow::Tensor& tensor, - std::size_t jet_n, - const btagbtvdeep::DeepDoubleXFeatures& features); - - void c_pf_tensor_filler(tensorflow::Tensor& tensor, - std::size_t jet_n, - std::size_t c_pf_n, - const btagbtvdeep::ChargedCandidateFeatures& c_pf_features); - - void c_pf_reduced_tensor_filler(tensorflow::Tensor& tensor, - std::size_t jet_n, - std::size_t c_pf_n, - const btagbtvdeep::ChargedCandidateFeatures& c_pf_features); - - void n_pf_tensor_filler(tensorflow::Tensor& tensor, - std::size_t jet_n, - std::size_t n_pf_n, - const btagbtvdeep::NeutralCandidateFeatures& n_pf_features); - - void sv_tensor_filler(tensorflow::Tensor& tensor, - std::size_t jet_n, - std::size_t sv_n, - const btagbtvdeep::SecondaryVertexFeatures& sv_features); - - void sv_reduced_tensor_filler(tensorflow::Tensor& tensor, - std::size_t jet_n, - std::size_t sv_n, - const btagbtvdeep::SecondaryVertexFeatures& sv_features); - - void seed_tensor_filler(tensorflow::Tensor& tensor, - std::size_t jet_n, - std::size_t seed_n, - const btagbtvdeep::SeedingTrackFeatures& seed_features); - - void neighbourTracks_tensor_filler(tensorflow::Tensor& tensor, - std::size_t jet_n, - std::size_t seed_n, - const btagbtvdeep::SeedingTrackFeatures& seed_features); - -} // namespace btagbtvdeep - -#endif diff --git a/RecoBTag/TensorFlow/plugins/BuildFile.xml b/RecoBTag/TensorFlow/plugins/BuildFile.xml deleted file mode 100644 index 1b4348b1c5d05..0000000000000 --- a/RecoBTag/TensorFlow/plugins/BuildFile.xml +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - diff --git a/RecoBTag/TensorFlow/plugins/DeepVertexTFJetTagsProducer.cc b/RecoBTag/TensorFlow/plugins/DeepVertexTFJetTagsProducer.cc deleted file mode 100644 index b46514513a6f2..0000000000000 --- a/RecoBTag/TensorFlow/plugins/DeepVertexTFJetTagsProducer.cc +++ /dev/null @@ -1,316 +0,0 @@ - -#include "FWCore/Framework/interface/Frameworkfwd.h" -#include "FWCore/Framework/interface/stream/EDProducer.h" - -#include "FWCore/Framework/interface/Event.h" -#include "FWCore/Framework/interface/MakerMacros.h" - -#include "FWCore/Framework/interface/makeRefToBaseProdFrom.h" - -#include "FWCore/ParameterSet/interface/ParameterSet.h" -#include "FWCore/Utilities/interface/StreamID.h" - -#include "DataFormats/BTauReco/interface/JetTag.h" - -#include "DataFormats/BTauReco/interface/DeepFlavourTagInfo.h" - -#include "PhysicsTools/TensorFlow/interface/TensorFlow.h" - -#include "RecoBTag/TensorFlow/interface/tensor_fillers.h" - -// Declaration of the data structure that is hold by the edm::GlobalCache. -// In TensorFlow, the computational graph is stored in a stateless graph object which can be shared -// by multiple session instances which handle the initialization of variables related to the graph. -// Following this approach in CMSSW, a graph should be stored in a GlobalCache which can be accessed -// by sessions owned by multiple stream module copies. Instead of using only the plain graph, we -// make use of a cache struct that can be extended in the future if nedded. In addition, the graph -// is protected via std::atomic, which should not affect the performance as it is only accessed in -// the module constructor and not in the actual produce loop. -struct DeepVertexTFCache { - DeepVertexTFCache() : graphDef(nullptr) {} - - std::atomic graphDef; -}; - -class DeepVertexTFJetTagsProducer : public edm::stream::EDProducer> { -public: - explicit DeepVertexTFJetTagsProducer(const edm::ParameterSet&, const DeepVertexTFCache*); - ~DeepVertexTFJetTagsProducer() override; - - static void fillDescriptions(edm::ConfigurationDescriptions&); - - static std::unique_ptr initializeGlobalCache(const edm::ParameterSet&); - static void globalEndJob(const DeepVertexTFCache*); - - enum InputIndexes { - kGlobal = 0, - kSeedingTracks = 1, - kNeighbourTracks = 2, - - }; - - enum OutputIndexes { - kJetFlavour = 0, - - }; - -private: - typedef std::vector TagInfoCollection; - typedef reco::JetTagCollection JetTagCollection; - - void beginStream(edm::StreamID) override {} - void produce(edm::Event&, const edm::EventSetup&) override; - void endStream() override {} - - const edm::EDGetTokenT src_; - std::vector>> flav_pairs_; - std::vector input_names_; - std::vector output_names_; - std::vector lp_names_; - - // session for TF evaluation - tensorflow::Session* session_; - // vector of learning phase tensors, i.e., boolean scalar tensors pointing to false - std::vector lp_tensors_; - // flag to evaluate model batch or jet by jet - bool batch_eval_; - std::string singleThreadPool_; - - const double min_jet_pt_; - const double max_jet_eta_; -}; - -DeepVertexTFJetTagsProducer::DeepVertexTFJetTagsProducer(const edm::ParameterSet& iConfig, - const DeepVertexTFCache* cache) - : src_(consumes(iConfig.getParameter("src"))), - input_names_(iConfig.getParameter>("input_names")), - output_names_(iConfig.getParameter>("output_names")), - lp_names_(iConfig.getParameter>("lp_names")), - session_(nullptr), - batch_eval_(iConfig.getParameter("batch_eval")), - singleThreadPool_(iConfig.getParameter("singleThreadPool")), - min_jet_pt_(iConfig.getParameter("min_jet_pt")), - max_jet_eta_(iConfig.getParameter("max_jet_eta")) - -{ - // get threading config - size_t nThreads = iConfig.getParameter("nThreads"); - - // create the session using the meta graph from the cache - session_ = tensorflow::createSession(cache->graphDef, nThreads); - - // get output names from flav_table - const auto& flav_pset = iConfig.getParameter("flav_table"); - for (const auto& flav_pair : flav_pset.tbl()) { - const auto& flav_name = flav_pair.first; - flav_pairs_.emplace_back(flav_name, flav_pset.getParameter>(flav_name)); - } - - for (const auto& flav_pair : flav_pairs_) { - produces(flav_pair.first); - } - - // flag inputs (required because of batch norm) - // names for the learing phase placeholders (to init and set as false) - for (size_t i = 0; i < lp_names_.size(); i++) { - // create a bool tensor, set its value to false and store it - tensorflow::Tensor t(tensorflow::DT_BOOL, {}); - t.scalar()() = false; - lp_tensors_.push_back(t); - } -} - -DeepVertexTFJetTagsProducer::~DeepVertexTFJetTagsProducer() { - // close and delete the session - if (session_ != nullptr) { - tensorflow::closeSession(session_); - } -} - -void DeepVertexTFJetTagsProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { - // pfDeepVertexJetTags - edm::ParameterSetDescription desc; - desc.add("src", edm::InputTag("pfDeepFlavourTagInfos")); - desc.add>("input_names", - {"input_1", - "input_2", - "input_3", - "input_4", - "input_5", - "input_6", - "input_7", - "input_8", - "input_9", - "input_10", - "input_11", - "input_12"}); - desc.add("graph_path", edm::FileInPath("RecoBTag/Combined/data/DeepVertex/Converted_retraining.pb")); - desc.add>("lp_names", {}); - desc.add>("output_names", {"output_node0"}); ///SIGMOID - { - edm::ParameterSetDescription psd0; - psd0.add>("probb", {0}); - psd0.add>("probc", {1}); - psd0.add>("probuds", {2}); - psd0.add>("probg", {3}); - desc.add("flav_table", psd0); - } - - desc.add("batch_eval", false); - desc.add("min_jet_pt", 15.0); - desc.add("max_jet_eta", 2.5); - desc.add("nThreads", 1); - desc.add("singleThreadPool", "no_threads"); - - descriptions.add("pfDeepVertexJetTags", desc); -} - -std::unique_ptr DeepVertexTFJetTagsProducer::initializeGlobalCache(const edm::ParameterSet& iConfig) { - // set the tensorflow log level to error - tensorflow::setLogging("3"); - - // get the pb file - std::string pbFile = iConfig.getParameter("graph_path").fullPath(); - - // load the graph def and save it in the cache - DeepVertexTFCache* cache = new DeepVertexTFCache(); - cache->graphDef = tensorflow::loadGraphDef(pbFile); - - return std::unique_ptr(cache); -} - -void DeepVertexTFJetTagsProducer::globalEndJob(const DeepVertexTFCache* cache) { - if (cache->graphDef != nullptr) { - delete cache->graphDef; - } -} - -void DeepVertexTFJetTagsProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { - edm::Handle tag_infos; - iEvent.getByToken(src_, tag_infos); - - // initialize output collection - std::vector> output_tags; - for (std::size_t i = 0; i < flav_pairs_.size(); i++) { - if (!tag_infos->empty()) { - auto jet_ref = tag_infos->begin()->jet(); - output_tags.emplace_back(std::make_unique(edm::makeRefToBaseProdFrom(jet_ref, iEvent))); - } else { - output_tags.emplace_back(std::make_unique()); - } - } - - //changes wrt to DeepFlavour from here - - const int64_t n_jets = tag_infos->size(); - // either all jets or one per batch for the time being - const int64_t n_batch_jets = batch_eval_ ? n_jets : 1; - - std::vector input_sizes{ - {n_batch_jets, 4}, // input_1 - global jet features - - {n_batch_jets, 10, 21}, // input_2 - seeds - {n_batch_jets, 20, 36}, // input_3 - neighbours - {n_batch_jets, 20, 36}, // input_4 - neighbours - {n_batch_jets, 20, 36}, // input_5 - neighbours - {n_batch_jets, 20, 36}, // input_6 - neighbours - {n_batch_jets, 20, 36}, // input_7 - neighbours - {n_batch_jets, 20, 36}, // input_8 - neighbours - {n_batch_jets, 20, 36}, // input_9 - neighbours - {n_batch_jets, 20, 36}, // input_10 - neighbours - {n_batch_jets, 20, 36}, // input_11 - neighbours - {n_batch_jets, 20, 36}, // input_12 - neighbours - - }; - - // create a list of named tensors, i.e. a vector of (string, Tensor) pairs, with proper size to - // prevent element copying that would occur via push_back's - // the default Tensor constructor creates a scalar so this should be fine w.r.t. to memory - tensorflow::NamedTensorList input_tensors; - input_tensors.resize(input_sizes.size()); //+ lp_tensors_.size()); - - // add actual input tensors that hold physics information - for (std::size_t i = 0; i < input_sizes.size(); i++) { - input_tensors[i] = - tensorflow::NamedTensor(input_names_[i], tensorflow::Tensor(tensorflow::DT_FLOAT, input_sizes.at(i))); - } - - // add learning-phase tensors behind them - for (std::size_t i = 0; i < lp_tensors_.size(); i++) { - input_tensors[input_sizes.size() + i] = tensorflow::NamedTensor(lp_names_[i], lp_tensors_[i]); - } - - std::size_t n_batches = n_jets / n_batch_jets; // either 1 or n_jets - - for (std::size_t batch_n = 0; batch_n < n_batches; batch_n++) { - bool run_session = true; //run session can be skipped for unintersting jets only when n_batch_jets==1 - - // tensors have to be zeroed before filling per batch - for (std::size_t i = 0; i < input_sizes.size(); i++) { - input_tensors[i].second.flat().setZero(); - } - - // fill values of the input tensors - for (std::size_t jet_bn = 0; jet_bn < (std::size_t)n_batch_jets; jet_bn++) { - // global jet index (jet_bn is the jet batch index) - std::size_t jet_n = batch_n * n_batch_jets + jet_bn; - - // jet and other global features - const auto& features = tag_infos->at(jet_n).features(); - - //check if jet needs btag with n_batch_jets==1 - if ((features.jet_features.pt < min_jet_pt_ || std::fabs(features.jet_features.eta) > max_jet_eta_) && - n_batch_jets == 1) { - run_session = false; - continue; - } - - jet4vec_tensor_filler(input_tensors.at(kGlobal).second, jet_bn, features); - - // seed features - auto max_seed_n = - std::min(features.seed_features.size(), (std::size_t)input_sizes.at(kSeedingTracks).dim_size(1)); - - for (std::size_t seed_n = 0; seed_n < max_seed_n; seed_n++) { - const auto& seed_features = features.seed_features.at(seed_n); - - seed_tensor_filler(input_tensors.at(kSeedingTracks).second, jet_bn, seed_n, seed_features); - neighbourTracks_tensor_filler( - input_tensors.at(kNeighbourTracks + seed_n).second, jet_bn, seed_n, seed_features); - } - - } //different block - - // run the session - std::vector outputs; - // std::cout <<"Input size" << input_tensors.size() << std::endl; - if (run_session) - tensorflow::run(session_, input_tensors, output_names_, &outputs, singleThreadPool_); - - // set output values for flavour probs - for (std::size_t jet_bn = 0; jet_bn < (std::size_t)n_batch_jets; jet_bn++) { - // global jet index (jet_bn is the jet batch index) - std::size_t jet_n = batch_n * n_batch_jets + jet_bn; - - const auto& jet_ref = tag_infos->at(jet_n).jet(); - for (std::size_t flav_n = 0; flav_n < flav_pairs_.size(); flav_n++) { - const auto& flav_pair = flav_pairs_.at(flav_n); - float o_sum = 0.; - for (const unsigned int& ind : flav_pair.second) { - if (run_session) - o_sum += outputs.at(kJetFlavour).matrix()(jet_bn, ind); - else - o_sum = -2; - } - (*(output_tags.at(flav_n)))[jet_ref] = o_sum; - } - } - } - - for (std::size_t i = 0; i < flav_pairs_.size(); i++) { - iEvent.put(std::move(output_tags[i]), flav_pairs_.at(i).first); - } -} - -//define this as a plug-in -DEFINE_FWK_MODULE(DeepVertexTFJetTagsProducer); diff --git a/RecoBTag/TensorFlow/src/tensor_fillers.cc b/RecoBTag/TensorFlow/src/tensor_fillers.cc deleted file mode 100644 index 4eec2671939c9..0000000000000 --- a/RecoBTag/TensorFlow/src/tensor_fillers.cc +++ /dev/null @@ -1,251 +0,0 @@ -#include "RecoBTag/TensorFlow/interface/tensor_fillers.h" - -namespace btagbtvdeep { - - // Note on setting tensor values: - // Instead of using the more convenient tensor.matrix (etc) methods, - // we can exploit that in the following methods values are set along - // the innermost (= last) axis. Those values are stored contiguously in - // the memory, so it is most performant to get the pointer to the first - // value and use pointer arithmetic to iterate through the next pointers. - - void jet_tensor_filler(tensorflow::Tensor& tensor, - std::size_t jet_n, - const btagbtvdeep::DeepFlavourFeatures& features) { - float* ptr = &tensor.matrix()(jet_n, 0); - - // jet variables - const auto& jet_features = features.jet_features; - *ptr = jet_features.pt; - *(++ptr) = jet_features.eta; - // number of elements in different collections - *(++ptr) = features.c_pf_features.size(); - *(++ptr) = features.n_pf_features.size(); - *(++ptr) = features.sv_features.size(); - *(++ptr) = features.npv; - // variables from ShallowTagInfo - const auto& tag_info_features = features.tag_info_features; - *(++ptr) = tag_info_features.trackSumJetEtRatio; - *(++ptr) = tag_info_features.trackSumJetDeltaR; - *(++ptr) = tag_info_features.vertexCategory; - *(++ptr) = tag_info_features.trackSip2dValAboveCharm; - *(++ptr) = tag_info_features.trackSip2dSigAboveCharm; - *(++ptr) = tag_info_features.trackSip3dValAboveCharm; - *(++ptr) = tag_info_features.trackSip3dSigAboveCharm; - *(++ptr) = tag_info_features.jetNSelectedTracks; - *(++ptr) = tag_info_features.jetNTracksEtaRel; - } - - void jet4vec_tensor_filler(tensorflow::Tensor& tensor, - std::size_t jet_n, - const btagbtvdeep::DeepFlavourFeatures& features) { - float* ptr = &tensor.matrix()(jet_n, 0); - - // jet 4 vector variables - const auto& jet_features = features.jet_features; - *ptr = jet_features.pt; - *(++ptr) = jet_features.eta; - *(++ptr) = jet_features.phi; - *(++ptr) = jet_features.mass; - } - - void db_tensor_filler(tensorflow::Tensor& tensor, - std::size_t jet_n, - const btagbtvdeep::DeepDoubleXFeatures& features) { - float* ptr = &tensor.tensor()(jet_n, 0, 0); - - // variables from BoostedDoubleSVTagInfo - const auto& tag_info_features = features.tag_info_features; - *ptr = tag_info_features.jetNTracks; - *(++ptr) = tag_info_features.jetNSecondaryVertices; - *(++ptr) = tag_info_features.tau1_trackEtaRel_0; - *(++ptr) = tag_info_features.tau1_trackEtaRel_1; - *(++ptr) = tag_info_features.tau1_trackEtaRel_2; - *(++ptr) = tag_info_features.tau2_trackEtaRel_0; - *(++ptr) = tag_info_features.tau2_trackEtaRel_1; - *(++ptr) = tag_info_features.tau2_trackEtaRel_2; - *(++ptr) = tag_info_features.tau1_flightDistance2dSig; - *(++ptr) = tag_info_features.tau2_flightDistance2dSig; - *(++ptr) = tag_info_features.tau1_vertexDeltaR; - // Note: this variable is not used in the 27-input BDT - // *(++ptr) = tag_info_features.tau2_vertexDeltaR; - *(++ptr) = tag_info_features.tau1_vertexEnergyRatio; - *(++ptr) = tag_info_features.tau2_vertexEnergyRatio; - *(++ptr) = tag_info_features.tau1_vertexMass; - *(++ptr) = tag_info_features.tau2_vertexMass; - *(++ptr) = tag_info_features.trackSip2dSigAboveBottom_0; - *(++ptr) = tag_info_features.trackSip2dSigAboveBottom_1; - *(++ptr) = tag_info_features.trackSip2dSigAboveCharm; - *(++ptr) = tag_info_features.trackSip3dSig_0; - *(++ptr) = tag_info_features.tau1_trackSip3dSig_0; - *(++ptr) = tag_info_features.tau1_trackSip3dSig_1; - *(++ptr) = tag_info_features.trackSip3dSig_1; - *(++ptr) = tag_info_features.tau2_trackSip3dSig_0; - *(++ptr) = tag_info_features.tau2_trackSip3dSig_1; - *(++ptr) = tag_info_features.trackSip3dSig_2; - *(++ptr) = tag_info_features.trackSip3dSig_3; - *(++ptr) = tag_info_features.z_ratio; - } - - void c_pf_tensor_filler(tensorflow::Tensor& tensor, - std::size_t jet_n, - std::size_t c_pf_n, - const btagbtvdeep::ChargedCandidateFeatures& c_pf_features) { - float* ptr = &tensor.tensor()(jet_n, c_pf_n, 0); - - *ptr = c_pf_features.btagPf_trackEtaRel; - *(++ptr) = c_pf_features.btagPf_trackPtRel; - *(++ptr) = c_pf_features.btagPf_trackPPar; - *(++ptr) = c_pf_features.btagPf_trackDeltaR; - *(++ptr) = c_pf_features.btagPf_trackPParRatio; - *(++ptr) = c_pf_features.btagPf_trackSip2dVal; - *(++ptr) = c_pf_features.btagPf_trackSip2dSig; - *(++ptr) = c_pf_features.btagPf_trackSip3dVal; - *(++ptr) = c_pf_features.btagPf_trackSip3dSig; - *(++ptr) = c_pf_features.btagPf_trackJetDistVal; - *(++ptr) = c_pf_features.ptrel; - *(++ptr) = c_pf_features.drminsv; - *(++ptr) = c_pf_features.vtx_ass; - *(++ptr) = c_pf_features.puppiw; - *(++ptr) = c_pf_features.chi2; - *(++ptr) = c_pf_features.quality; - } - - void c_pf_reduced_tensor_filler(tensorflow::Tensor& tensor, - std::size_t jet_n, - std::size_t c_pf_n, - const btagbtvdeep::ChargedCandidateFeatures& c_pf_features) { - float* ptr = &tensor.tensor()(jet_n, c_pf_n, 0); - - *ptr = c_pf_features.btagPf_trackEtaRel; - *(++ptr) = c_pf_features.btagPf_trackPtRatio; - *(++ptr) = c_pf_features.btagPf_trackPParRatio; - *(++ptr) = c_pf_features.btagPf_trackSip2dVal; - *(++ptr) = c_pf_features.btagPf_trackSip2dSig; - *(++ptr) = c_pf_features.btagPf_trackSip3dVal; - *(++ptr) = c_pf_features.btagPf_trackSip3dSig; - *(++ptr) = c_pf_features.btagPf_trackJetDistVal; - } - - void n_pf_tensor_filler(tensorflow::Tensor& tensor, - std::size_t jet_n, - std::size_t n_pf_n, - const btagbtvdeep::NeutralCandidateFeatures& n_pf_features) { - float* ptr = &tensor.tensor()(jet_n, n_pf_n, 0); - - *ptr = n_pf_features.ptrel; - *(++ptr) = n_pf_features.deltaR; - *(++ptr) = n_pf_features.isGamma; - *(++ptr) = n_pf_features.hadFrac; - *(++ptr) = n_pf_features.drminsv; - *(++ptr) = n_pf_features.puppiw; - } - - void sv_tensor_filler(tensorflow::Tensor& tensor, - std::size_t jet_n, - std::size_t sv_n, - const btagbtvdeep::SecondaryVertexFeatures& sv_features) { - float* ptr = &tensor.tensor()(jet_n, sv_n, 0); - - *ptr = sv_features.pt; - *(++ptr) = sv_features.deltaR; - *(++ptr) = sv_features.mass; - *(++ptr) = sv_features.ntracks; - *(++ptr) = sv_features.chi2; - *(++ptr) = sv_features.normchi2; - *(++ptr) = sv_features.dxy; - *(++ptr) = sv_features.dxysig; - *(++ptr) = sv_features.d3d; - *(++ptr) = sv_features.d3dsig; - *(++ptr) = sv_features.costhetasvpv; - *(++ptr) = sv_features.enratio; - } - - void sv_reduced_tensor_filler(tensorflow::Tensor& tensor, - std::size_t jet_n, - std::size_t sv_n, - const btagbtvdeep::SecondaryVertexFeatures& sv_features) { - float* ptr = &tensor.tensor()(jet_n, sv_n, 0); - - *ptr = sv_features.d3d; - *(++ptr) = sv_features.d3dsig; - } - - void seed_tensor_filler(tensorflow::Tensor& tensor, - std::size_t jet_n, - std::size_t seed_n, - const btagbtvdeep::SeedingTrackFeatures& seed_features) { - float* ptr = &tensor.tensor()(jet_n, seed_n, 0); - - *ptr = seed_features.pt; - *(++ptr) = seed_features.eta; - *(++ptr) = seed_features.phi; - *(++ptr) = seed_features.mass; - *(++ptr) = seed_features.dz; - *(++ptr) = seed_features.dxy; - *(++ptr) = seed_features.ip3D; - *(++ptr) = seed_features.sip3D; - *(++ptr) = seed_features.ip2D; - *(++ptr) = seed_features.sip2D; - *(++ptr) = seed_features.signedIp3D; - *(++ptr) = seed_features.signedSip3D; - *(++ptr) = seed_features.signedIp2D; - *(++ptr) = seed_features.signedSip2D; - *(++ptr) = seed_features.trackProbability3D; - *(++ptr) = seed_features.trackProbability2D; - *(++ptr) = seed_features.chi2reduced; - *(++ptr) = seed_features.nPixelHits; - *(++ptr) = seed_features.nHits; - *(++ptr) = seed_features.jetAxisDistance; - *(++ptr) = seed_features.jetAxisDlength; - } - - void neighbourTracks_tensor_filler(tensorflow::Tensor& tensor, - std::size_t jet_n, - std::size_t seed_n, - const btagbtvdeep::SeedingTrackFeatures& seed_features) { - std::vector neighbourTracks_features = seed_features.nearTracks; - - for (unsigned int t_i = 0; t_i < neighbourTracks_features.size(); t_i++) { - float* ptr = &tensor.tensor()(jet_n, t_i, 0); - - *ptr = neighbourTracks_features[t_i].pt; - *(++ptr) = neighbourTracks_features[t_i].eta; - *(++ptr) = neighbourTracks_features[t_i].phi; - *(++ptr) = neighbourTracks_features[t_i].dz; - *(++ptr) = neighbourTracks_features[t_i].dxy; - *(++ptr) = neighbourTracks_features[t_i].mass; - *(++ptr) = neighbourTracks_features[t_i].ip3D; - *(++ptr) = neighbourTracks_features[t_i].sip3D; - *(++ptr) = neighbourTracks_features[t_i].ip2D; - *(++ptr) = neighbourTracks_features[t_i].sip2D; - *(++ptr) = neighbourTracks_features[t_i].distPCA; - *(++ptr) = neighbourTracks_features[t_i].dsigPCA; - *(++ptr) = neighbourTracks_features[t_i].x_PCAonSeed; - *(++ptr) = neighbourTracks_features[t_i].y_PCAonSeed; - *(++ptr) = neighbourTracks_features[t_i].z_PCAonSeed; - *(++ptr) = neighbourTracks_features[t_i].xerr_PCAonSeed; - *(++ptr) = neighbourTracks_features[t_i].yerr_PCAonSeed; - *(++ptr) = neighbourTracks_features[t_i].zerr_PCAonSeed; - *(++ptr) = neighbourTracks_features[t_i].x_PCAonTrack; - *(++ptr) = neighbourTracks_features[t_i].y_PCAonTrack; - *(++ptr) = neighbourTracks_features[t_i].z_PCAonTrack; - *(++ptr) = neighbourTracks_features[t_i].xerr_PCAonTrack; - *(++ptr) = neighbourTracks_features[t_i].yerr_PCAonTrack; - *(++ptr) = neighbourTracks_features[t_i].zerr_PCAonTrack; - *(++ptr) = neighbourTracks_features[t_i].dotprodTrack; - *(++ptr) = neighbourTracks_features[t_i].dotprodSeed; - *(++ptr) = neighbourTracks_features[t_i].dotprodTrackSeed2D; - *(++ptr) = neighbourTracks_features[t_i].dotprodTrackSeed3D; - *(++ptr) = neighbourTracks_features[t_i].dotprodTrackSeedVectors2D; - *(++ptr) = neighbourTracks_features[t_i].dotprodTrackSeedVectors3D; - *(++ptr) = neighbourTracks_features[t_i].pvd_PCAonSeed; - *(++ptr) = neighbourTracks_features[t_i].pvd_PCAonTrack; - *(++ptr) = neighbourTracks_features[t_i].dist_PCAjetAxis; - *(++ptr) = neighbourTracks_features[t_i].dotprod_PCAjetMomenta; - *(++ptr) = neighbourTracks_features[t_i].deta_PCAjetDirs; - *(++ptr) = neighbourTracks_features[t_i].dphi_PCAjetDirs; - } - } - -} // namespace btagbtvdeep diff --git a/RecoBTag/TensorFlow/test/test_deepvertex_cfg.py b/RecoBTag/TensorFlow/test/test_deepvertex_cfg.py deleted file mode 100644 index ca268829ca6e5..0000000000000 --- a/RecoBTag/TensorFlow/test/test_deepvertex_cfg.py +++ /dev/null @@ -1,77 +0,0 @@ - -import FWCore.ParameterSet.Config as cms -from PhysicsTools.PatAlgos.tools.helpers import getPatAlgosToolsTask - -process = cms.Process("PATtest") - -## MessageLogger -process.load("FWCore.MessageLogger.MessageLogger_cfi") - -## Options and Output Report -process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(True) ) - -## Source -process.source = cms.Source("PoolSource", - fileNames = cms.untracked.vstring() -) -## Maximal Number of Events -process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(100) ) - -## Geometry and Detector Conditions (needed for a few patTuple production steps) -process.load("Configuration.Geometry.GeometryRecoDB_cff") -process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") -from Configuration.AlCa.GlobalTag import GlobalTag -process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:run2_mc') -process.load("Configuration.StandardSequences.MagneticField_cff") - -## Output Module Configuration (expects a path 'p') -from PhysicsTools.PatAlgos.patEventContent_cff import patEventContentNoCleaning -process.out = cms.OutputModule("PoolOutputModule", - fileName = cms.untracked.string('patTuple.root'), - ## save only events passing the full path - #SelectEvents = cms.untracked.PSet( SelectEvents = cms.vstring('p') ), - ## save PAT output; you need a '*' to unpack the list of commands - ## 'patEventContent' - outputCommands = cms.untracked.vstring('drop *', *patEventContentNoCleaning ) - ) - -patAlgosToolsTask = getPatAlgosToolsTask(process) -process.outpath = cms.EndPath(process.out, patAlgosToolsTask) - -## and add them to the event content -from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection - -updateJetCollection( - process, - jetSource = cms.InputTag('slimmedJets'), - pvSource = cms.InputTag('offlineSlimmedPrimaryVertices'), - svSource = cms.InputTag('slimmedSecondaryVertices'), - jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'), - btagDiscriminators = [ - 'pfDeepVertexJetTags:probb', - ] - ) - -from PhysicsTools.PatAlgos.patInputFiles_cff import filesRelValTTbarPileUpMINIAODSIM - -process.source.fileNames = filesRelValTTbarPileUpMINIAODSIM -process.source.fileNames = cms.untracked.vstring( - '/store/mc/RunIIFall17MiniAODv2/TTToHadronic_TuneCP5_13TeV-powheg-pythia8/MINIAODSIM/PU2017_12Apr2018_new_pmx_94X_mc2017_realistic_v14-v2/60000/FCC2AFA9-4BBB-E811-B35F-0CC47AFB7D48.root' - #'file:/scratch/lgiannini/bTAG_test_CMSSW/CMSSW_10_1_0_pre3/src/RecoBTag/DeepFlavour/test/0055C65C-E558-E811-AB0E-008CFA582BF4.root') - -process.maxEvents.input = 10 - -from Configuration.EventContent.EventContent_cff import MINIAODSIMEventContent -process.out.outputCommands = MINIAODSIMEventContent.outputCommands -process.out.outputCommands.append('keep *_selectedUpdatedPatJets*_*_*') -process.out.outputCommands.append('keep *_pfDeepCSVTagInfos*_*_*') -process.out.outputCommands.append('keep *_pfDeepFlavourTagInfos*_*_*') -process.out.outputCommands.append('keep *_pfDeepFlavourJetTags*_*_*') -process.out.outputCommands.append('keep *_pfDeepVertexJetTags*_*_*') -process.out.outputCommands.append('keep *_updatedPatJets*_*_*') - -process.out.fileName = 'test_deep_vertex_MINIAODSIM_myCfg.root' - -# ## -# process.options.wantSummary = False ## (to suppress the long output at the end of the job) -# process.add_(cms.Service("InitRootHandlers", DebugLevel =cms.untracked.int32(3))) From 49d85c2466e7e478fad470eb966501f1be595db5 Mon Sep 17 00:00:00 2001 From: leonardo Date: Wed, 11 Nov 2020 10:40:22 +0100 Subject: [PATCH 14/14] clang code check --- .../ONNXRuntime/interface/tensor_configs.h | 25 +++++++++---------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/RecoBTag/ONNXRuntime/interface/tensor_configs.h b/RecoBTag/ONNXRuntime/interface/tensor_configs.h index 9b19bf3832975..e528b4e92f74a 100644 --- a/RecoBTag/ONNXRuntime/interface/tensor_configs.h +++ b/RecoBTag/ONNXRuntime/interface/tensor_configs.h @@ -4,29 +4,28 @@ namespace deepflavour { constexpr unsigned n_features_global = 15; - - constexpr unsigned n_cpf = 25; + + constexpr unsigned n_cpf = 25; constexpr unsigned n_features_cpf = 16; - - constexpr unsigned n_npf = 25; + + constexpr unsigned n_npf = 25; constexpr unsigned n_features_npf = 6; - - constexpr unsigned n_sv = 4; + + constexpr unsigned n_sv = 4; constexpr unsigned n_features_sv = 12; -} - +} // namespace deepflavour + namespace deepvertex { - + constexpr unsigned n_features_global = 4; - + constexpr unsigned n_seed = 10; constexpr unsigned n_features_seed = 21; - + constexpr unsigned n_neighbor = 20; constexpr unsigned n_features_neighbor = 36; -} +} // namespace deepvertex #endif -