From ae7a00b54993f6f2aa2b267c5e9093ce696099c5 Mon Sep 17 00:00:00 2001 From: Huilin Qu Date: Tue, 3 Dec 2019 15:57:55 +0100 Subject: [PATCH 1/9] MXNet-based ParticleNet V00. --- .../python/recoLayer0/bTagging_cff.py | 16 + .../PatAlgos/python/tools/jetTools.py | 23 + RecoBTag/Configuration/python/RecoBTag_cff.py | 1 + .../plugins/ParticleNetTagInfoProducer.cc | 406 ++++++++++++++++++ RecoBTag/MXNet/plugins/BuildFile.xml | 7 + .../plugins/ParticleNetJetTagsProducer.cc | 287 +++++++++++++ ...rrelatedParticleNetPreprocessParams_cfi.py | 246 +++++++++++ .../V00/pfParticleNetPreprocessParams_cfi.py | 271 ++++++++++++ ...tedParticleNetDiscriminatorsJetTags_cfi.py | 50 +++ .../pfParticleNetDiscriminatorsJetTags_cfi.py | 99 +++++ RecoBTag/MXNet/python/pfParticleNet_cff.py | 47 ++ 11 files changed, 1453 insertions(+) create mode 100644 RecoBTag/FeatureTools/plugins/ParticleNetTagInfoProducer.cc create mode 100644 RecoBTag/MXNet/plugins/BuildFile.xml create mode 100644 RecoBTag/MXNet/plugins/ParticleNetJetTagsProducer.cc create mode 100644 RecoBTag/MXNet/python/Parameters/ParticleNet/V00/pfMassDecorrelatedParticleNetPreprocessParams_cfi.py create mode 100644 RecoBTag/MXNet/python/Parameters/ParticleNet/V00/pfParticleNetPreprocessParams_cfi.py create mode 100644 RecoBTag/MXNet/python/pfMassDecorrelatedParticleNetDiscriminatorsJetTags_cfi.py create mode 100644 RecoBTag/MXNet/python/pfParticleNetDiscriminatorsJetTags_cfi.py create mode 100644 RecoBTag/MXNet/python/pfParticleNet_cff.py diff --git a/PhysicsTools/PatAlgos/python/recoLayer0/bTagging_cff.py b/PhysicsTools/PatAlgos/python/recoLayer0/bTagging_cff.py index 90535a86c5d5b..71f4bec0cdc71 100644 --- a/PhysicsTools/PatAlgos/python/recoLayer0/bTagging_cff.py +++ b/PhysicsTools/PatAlgos/python/recoLayer0/bTagging_cff.py @@ -45,6 +45,8 @@ , 'pfDeepDoubleXTagInfos' # DeepBoostedJet tag infos , 'pfDeepBoostedJetTagInfos' + # ParticleNet tag infos + , 'pfParticleNetTagInfos' # Pixel Cluster tag infos , 'pixelClusterTagInfos' ] @@ -231,3 +233,17 @@ for disc in _pfMassDecorrelatedDeepBoostedJetTagsMetaDiscrs: supportedMetaDiscr[disc] = _pfMassDecorrelatedDeepBoostedJetTagsProbs # ----------------------------------- + +# ----------------------------------- +# setup ParticleNet +from RecoBTag.MXNet.pfParticleNet_cff import _pfParticleNetJetTagsProbs, _pfParticleNetJetTagsMetaDiscrs, \ + _pfMassDecorrelatedParticleNetJetTagsProbs, _pfMassDecorrelatedParticleNetJetTagsMetaDiscrs +# update supportedBtagDiscr +for disc in _pfParticleNetJetTagsProbs + _pfMassDecorrelatedParticleNetJetTagsProbs: + supportedBtagDiscr[disc] = [["pfParticleNetTagInfos"]] +# update supportedMetaDiscr +for disc in _pfParticleNetJetTagsMetaDiscrs: + supportedMetaDiscr[disc] = _pfParticleNetJetTagsProbs +for disc in _pfMassDecorrelatedParticleNetJetTagsMetaDiscrs: + supportedMetaDiscr[disc] = _pfMassDecorrelatedParticleNetJetTagsProbs +# ----------------------------------- diff --git a/PhysicsTools/PatAlgos/python/tools/jetTools.py b/PhysicsTools/PatAlgos/python/tools/jetTools.py index 564219c86ff07..19bf211c46459 100644 --- a/PhysicsTools/PatAlgos/python/tools/jetTools.py +++ b/PhysicsTools/PatAlgos/python/tools/jetTools.py @@ -662,6 +662,29 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou ), process, task) + if btagInfo == 'pfParticleNetTagInfos': + if pfCandidates.value() == 'packedPFCandidates': + # case 1: running over jets whose daughters are PackedCandidates (only via updateJetCollection for now) + puppi_value_map = "" + vertex_associator = "" + elif pfCandidates.value() == 'particleFlow': + raise ValueError("Running pfDeepBoostedJetTagInfos with reco::PFCandidates is currently not supported.") + # case 2: running on new jet collection whose daughters are PFCandidates (e.g., cluster jets in RECO/AOD) + puppi_value_map = "puppi" + vertex_associator = "primaryVertexAssociation:original" + else: + raise ValueError("Invalid pfCandidates collection: %s." % pfCandidates.value()) + addToProcessAndTask(btagPrefix+btagInfo+labelName+postfix, + btag.pfParticleNetTagInfos.clone( + jets = jetSource, + vertices = pvSource, + secondary_vertices = svSource, + pf_candidates = pfCandidates, + puppi_value_map = puppi_value_map, + vertex_associator = vertex_associator, + ), + process, task) + acceptedTagInfos.append(btagInfo) elif hasattr(toptag, btagInfo) : acceptedTagInfos.append(btagInfo) diff --git a/RecoBTag/Configuration/python/RecoBTag_cff.py b/RecoBTag/Configuration/python/RecoBTag_cff.py index beced0b4824dc..04a99862421ba 100644 --- a/RecoBTag/Configuration/python/RecoBTag_cff.py +++ b/RecoBTag/Configuration/python/RecoBTag_cff.py @@ -10,6 +10,7 @@ from RecoBTag.ONNXRuntime.pfDeepFlavour_cff import * from RecoBTag.ONNXRuntime.pfDeepDoubleX_cff import * from RecoBTag.ONNXRuntime.pfDeepBoostedJet_cff import * +from RecoBTag.MXNet.pfParticleNet_cff import * from RecoVertex.AdaptiveVertexFinder.inclusiveVertexing_cff import * from RecoBTag.PixelCluster.pixelClusterTagInfos_cfi import * diff --git a/RecoBTag/FeatureTools/plugins/ParticleNetTagInfoProducer.cc b/RecoBTag/FeatureTools/plugins/ParticleNetTagInfoProducer.cc new file mode 100644 index 0000000000000..b7ad415649dd7 --- /dev/null +++ b/RecoBTag/FeatureTools/plugins/ParticleNetTagInfoProducer.cc @@ -0,0 +1,406 @@ +#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/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Utilities/interface/StreamID.h" + +#include "DataFormats/Candidate/interface/Candidate.h" + +#include "DataFormats/PatCandidates/interface/Jet.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" + +#include "RecoBTag/FeatureTools/interface/TrackInfoBuilder.h" +#include "RecoBTag/FeatureTools/interface/deep_helpers.h" +#include "TrackingTools/Records/interface/TransientTrackRecord.h" + +#include "DataFormats/Candidate/interface/VertexCompositePtrCandidate.h" +#include "DataFormats/VertexReco/interface/VertexFwd.h" + +#include "DataFormats/BTauReco/interface/DeepBoostedJetTagInfo.h" + +using namespace btagbtvdeep; + +class ParticleNetTagInfoProducer : public edm::stream::EDProducer<> { +public: + explicit ParticleNetTagInfoProducer(const edm::ParameterSet &); + ~ParticleNetTagInfoProducer() override; + + static void fillDescriptions(edm::ConfigurationDescriptions &descriptions); + +private: + typedef std::vector DeepBoostedJetTagInfoCollection; + typedef reco::VertexCompositePtrCandidateCollection SVCollection; + typedef reco::VertexCollection VertexCollection; + typedef edm::View CandidateView; + + void beginStream(edm::StreamID) override {} + void produce(edm::Event &, const edm::EventSetup &) override; + void endStream() override {} + + void fillParticleFeatures(DeepBoostedJetFeatures &fts, const reco::Jet &jet); + void fillSVFeatures(DeepBoostedJetFeatures &fts, const reco::Jet &jet); + + const double jet_radius_; + const double min_jet_pt_; + const double min_pt_for_track_properties_; + + edm::EDGetTokenT> jet_token_; + edm::EDGetTokenT vtx_token_; + edm::EDGetTokenT sv_token_; + edm::EDGetTokenT pfcand_token_; + + bool use_puppi_value_map_; + bool use_pvasq_value_map_; + + edm::EDGetTokenT> puppi_value_map_token_; + edm::EDGetTokenT> pvasq_value_map_token_; + edm::EDGetTokenT> pvas_token_; + + edm::Handle vtxs_; + edm::Handle svs_; + edm::Handle pfcands_; + edm::ESHandle track_builder_; + edm::Handle> puppi_value_map_; + edm::Handle> pvasq_value_map_; + edm::Handle> pvas_; + + const static std::vector particle_features_; + const static std::vector sv_features_; + const reco::Vertex *pv_ = nullptr; +}; + +const std::vector ParticleNetTagInfoProducer::particle_features_{ + "pfcand_mask", "pfcand_VTX_ass", "pfcand_lostInnerHits", "pfcand_quality", + "pfcand_charge", "pfcand_isEl", "pfcand_isMu", "pfcand_isChargedHad", + "pfcand_isGamma", "pfcand_isNeutralHad", "pfcand_phirel", "pfcand_etarel", + "pfcand_abseta", "pfcand_pt_log_nopuppi", "pfcand_e_log_nopuppi", "pfcand_normchi2", + "pfcand_dz", "pfcand_dzsig", "pfcand_dxy", "pfcand_dxysig", + "pfcand_btagEtaRel", "pfcand_btagPtRatio", "pfcand_btagPParRatio", "pfcand_btagSip3dVal", + "pfcand_btagSip3dSig", "pfcand_btagJetDistVal", +}; + +const std::vector ParticleNetTagInfoProducer::sv_features_{ + "sv_mask", + "sv_phirel", + "sv_etarel", + "sv_abseta", + "sv_mass", + "sv_pt_log", + "sv_ntracks", + "sv_normchi2", + "sv_dxy", + "sv_dxysig", + "sv_d3d", + "sv_d3dsig", + "sv_costhetasvpv", +}; + +ParticleNetTagInfoProducer::ParticleNetTagInfoProducer(const edm::ParameterSet &iConfig) + : jet_radius_(iConfig.getParameter("jet_radius")), + min_jet_pt_(iConfig.getParameter("min_jet_pt")), + min_pt_for_track_properties_(iConfig.getParameter("min_pt_for_track_properties")), + jet_token_(consumes>(iConfig.getParameter("jets"))), + vtx_token_(consumes(iConfig.getParameter("vertices"))), + sv_token_(consumes(iConfig.getParameter("secondary_vertices"))), + pfcand_token_(consumes(iConfig.getParameter("pf_candidates"))), + use_puppi_value_map_(false), + use_pvasq_value_map_(false) { + const auto &puppi_value_map_tag = iConfig.getParameter("puppi_value_map"); + if (!puppi_value_map_tag.label().empty()) { + puppi_value_map_token_ = consumes>(puppi_value_map_tag); + use_puppi_value_map_ = true; + } + + const auto &pvas_tag = iConfig.getParameter("vertex_associator"); + if (!pvas_tag.label().empty()) { + pvasq_value_map_token_ = consumes>(pvas_tag); + pvas_token_ = consumes>(pvas_tag); + use_pvasq_value_map_ = true; + } + + produces(); +} + +ParticleNetTagInfoProducer::~ParticleNetTagInfoProducer() {} + +void ParticleNetTagInfoProducer::fillDescriptions(edm::ConfigurationDescriptions &descriptions) { + // pfParticleNetTagInfos + edm::ParameterSetDescription desc; + desc.add("jet_radius", 0.8); + desc.add("min_jet_pt", 150); + desc.add("min_pt_for_track_properties", -1); + desc.add("vertices", edm::InputTag("offlinePrimaryVertices")); + desc.add("secondary_vertices", edm::InputTag("inclusiveCandidateSecondaryVertices")); + desc.add("pf_candidates", edm::InputTag("particleFlow")); + desc.add("jets", edm::InputTag("ak8PFJetsPuppi")); + desc.add("puppi_value_map", edm::InputTag("puppi")); + desc.add("vertex_associator", edm::InputTag("primaryVertexAssociation", "original")); + descriptions.add("pfParticleNetTagInfos", desc); +} + +void ParticleNetTagInfoProducer::produce(edm::Event &iEvent, const edm::EventSetup &iSetup) { + auto output_tag_infos = std::make_unique(); + + edm::Handle> jets; + iEvent.getByToken(jet_token_, jets); + + iEvent.getByToken(vtx_token_, vtxs_); + if (vtxs_->empty()) { + // produce empty TagInfos in case no primary vertex + iEvent.put(std::move(output_tag_infos)); + return; // exit event + } + // primary vertex + pv_ = &vtxs_->at(0); + + iEvent.getByToken(sv_token_, svs_); + + iEvent.getByToken(pfcand_token_, pfcands_); + + iSetup.get().get("TransientTrackBuilder", track_builder_); + + if (use_puppi_value_map_) { + iEvent.getByToken(puppi_value_map_token_, puppi_value_map_); + } + + if (use_pvasq_value_map_) { + iEvent.getByToken(pvasq_value_map_token_, pvasq_value_map_); + iEvent.getByToken(pvas_token_, pvas_); + } + + for (std::size_t jet_n = 0; jet_n < jets->size(); jet_n++) { + const auto &jet = (*jets)[jet_n]; + edm::RefToBase jet_ref(jets, jet_n); + + // create jet features + DeepBoostedJetFeatures features; + // declare all the feature variables (init as empty vector) + for (const auto &name : particle_features_) { + features.add(name); + } + for (const auto &name : sv_features_) { + features.add(name); + } + + // fill values only if above pt threshold and has daughters, otherwise left + // empty + bool fill_vars = true; + if (jet.pt() < min_jet_pt_) + fill_vars = false; + if (jet.numberOfDaughters() == 0) + fill_vars = false; + + if (fill_vars) { + fillParticleFeatures(features, jet); + fillSVFeatures(features, jet); + + features.check_consistency(particle_features_); + features.check_consistency(sv_features_); + } + + // this should always be done even if features are not filled + output_tag_infos->emplace_back(features, jet_ref); + } + + iEvent.put(std::move(output_tag_infos)); +} + +void ParticleNetTagInfoProducer::fillParticleFeatures(DeepBoostedJetFeatures &fts, const reco::Jet &jet) { + // do nothing if jet does not have constituents + if (jet.numberOfDaughters() == 0) + return; + + // some jet properties + math::XYZVector jet_dir = jet.momentum().Unit(); + GlobalVector jet_ref_track_dir(jet.px(), jet.py(), jet.pz()); + const float etasign = jet.eta() > 0 ? 1 : -1; + + std::map puppi_wgt_cache; + auto puppiWgt = [&](const reco::CandidatePtr &cand) { + const auto *pack_cand = dynamic_cast(&(*cand)); + const auto *reco_cand = dynamic_cast(&(*cand)); + float wgt = 1.; + if (pack_cand) { + wgt = pack_cand->puppiWeight(); + } else if (reco_cand) { + if (use_puppi_value_map_) { + wgt = (*puppi_value_map_)[cand]; + } else { + throw edm::Exception(edm::errors::InvalidReference) << "Puppi value map is missing"; + } + } else { + throw edm::Exception(edm::errors::InvalidReference) << "Cannot convert to either pat::PackedCandidate or " + "reco::PFCandidate"; + } + puppi_wgt_cache[cand.key()] = wgt; + return wgt; + }; + + std::vector daughters; + for (const auto &cand : jet.daughterPtrVector()) { + // remove particles w/ extremely low puppi weights + if ((puppiWgt(cand)) < 0.01) + continue; + // get the original reco/packed candidate not scaled by the puppi weight + daughters.push_back(pfcands_->ptrAt(cand.key())); + } + // sort by original pt (not Puppi-weighted) + std::sort(daughters.begin(), daughters.end(), [](const auto &a, const auto &b) { return a->pt() > b->pt(); }); + + // reserve space + for (const auto &name : particle_features_) { + fts.reserve(name, daughters.size()); + } + + auto useTrackProperties = [&](const reco::PFCandidate *reco_cand) { + const auto *trk = reco_cand->bestTrack(); + return trk != nullptr && trk->pt() > min_pt_for_track_properties_; + }; + + for (const auto &cand : daughters) { + const auto *packed_cand = dynamic_cast(&(*cand)); + const auto *reco_cand = dynamic_cast(&(*cand)); + + if (packed_cand) { + fts.fill("pfcand_VTX_ass", packed_cand->pvAssociationQuality()); + fts.fill("pfcand_lostInnerHits", packed_cand->lostInnerHits()); + fts.fill("pfcand_quality", packed_cand->bestTrack() ? packed_cand->bestTrack()->qualityMask() : 0); + + fts.fill("pfcand_charge", packed_cand->charge()); + fts.fill("pfcand_isEl", std::abs(packed_cand->pdgId()) == 11); + fts.fill("pfcand_isMu", std::abs(packed_cand->pdgId()) == 13); + fts.fill("pfcand_isChargedHad", std::abs(packed_cand->pdgId()) == 211); + fts.fill("pfcand_isGamma", std::abs(packed_cand->pdgId()) == 22); + fts.fill("pfcand_isNeutralHad", std::abs(packed_cand->pdgId()) == 130); + + // impact parameters + fts.fill("pfcand_dz", catch_infs(packed_cand->dz())); + fts.fill("pfcand_dzsig", packed_cand->bestTrack() ? catch_infs(packed_cand->dz() / packed_cand->dzError()) : 0); + fts.fill("pfcand_dxy", catch_infs(packed_cand->dxy())); + fts.fill("pfcand_dxysig", + packed_cand->bestTrack() ? catch_infs(packed_cand->dxy() / packed_cand->dxyError()) : 0); + + } else if (reco_cand) { + // get vertex association quality + int pv_ass_quality = 0; // fallback value + float vtx_ass = 0; + if (use_pvasq_value_map_) { + pv_ass_quality = (*pvasq_value_map_)[cand]; + const reco::VertexRef &PV_orig = (*pvas_)[cand]; + vtx_ass = vtx_ass_from_pfcand(*reco_cand, pv_ass_quality, PV_orig); + } else { + throw edm::Exception(edm::errors::InvalidReference) << "Vertex association missing"; + } + + fts.fill("pfcand_VTX_ass", vtx_ass); + fts.fill("pfcand_lostInnerHits", useTrackProperties(reco_cand) ? lost_inner_hits_from_pfcand(*reco_cand) : 0); + fts.fill("pfcand_quality", useTrackProperties(reco_cand) ? quality_from_pfcand(*reco_cand) : 0); + + fts.fill("pfcand_charge", reco_cand->charge()); + fts.fill("pfcand_isEl", std::abs(reco_cand->pdgId()) == 11); + fts.fill("pfcand_isMu", std::abs(reco_cand->pdgId()) == 13); + fts.fill("pfcand_isChargedHad", std::abs(reco_cand->pdgId()) == 211); + fts.fill("pfcand_isGamma", std::abs(reco_cand->pdgId()) == 22); + fts.fill("pfcand_isNeutralHad", std::abs(reco_cand->pdgId()) == 130); + + // impact parameters + const auto *trk = reco_cand->bestTrack(); + float dz = trk ? trk->dz(pv_->position()) : 0; + float dxy = trk ? trk->dxy(pv_->position()) : 0; + fts.fill("pfcand_dz", catch_infs(dz)); + fts.fill("pfcand_dzsig", trk ? catch_infs(dz / trk->dzError()) : 0); + fts.fill("pfcand_dxy", catch_infs(dxy)); + fts.fill("pfcand_dxysig", trk ? catch_infs(dxy / trk->dxyError()) : 0); + } + + // basic kinematics + fts.fill("pfcand_mask", 1); + fts.fill("pfcand_phirel", reco::deltaPhi(*cand, jet)); + fts.fill("pfcand_etarel", etasign * (cand->eta() - jet.eta())); + fts.fill("pfcand_abseta", std::abs(cand->eta())); + + fts.fill("pfcand_pt_log_nopuppi", catch_infs(std::log(cand->pt()), -99)); + fts.fill("pfcand_e_log_nopuppi", catch_infs(std::log(cand->energy()), -99)); + + // track info + const reco::Track *trk = nullptr; + if (packed_cand) { + trk = packed_cand->bestTrack(); + } else if (reco_cand && useTrackProperties(reco_cand)) { + trk = reco_cand->bestTrack(); + } + if (trk) { + fts.fill("pfcand_normchi2", catch_infs(std::floor(trk->normalizedChi2()))); + + TrackInfoBuilder trkinfo(track_builder_); + trkinfo.buildTrackInfo(&(*cand), jet_dir, jet_ref_track_dir, *pv_); + fts.fill("pfcand_btagEtaRel", trkinfo.getTrackEtaRel()); + fts.fill("pfcand_btagPtRatio", trkinfo.getTrackPtRatio()); + fts.fill("pfcand_btagPParRatio", trkinfo.getTrackPParRatio()); + fts.fill("pfcand_btagSip3dVal", trkinfo.getTrackSip3dVal()); + fts.fill("pfcand_btagSip3dSig", trkinfo.getTrackSip3dSig()); + fts.fill("pfcand_btagJetDistVal", trkinfo.getTrackJetDistVal()); + } else { + fts.fill("pfcand_normchi2", 999); + + fts.fill("pfcand_btagEtaRel", 0); + fts.fill("pfcand_btagPtRatio", 0); + fts.fill("pfcand_btagPParRatio", 0); + fts.fill("pfcand_btagSip3dVal", 0); + fts.fill("pfcand_btagSip3dSig", 0); + fts.fill("pfcand_btagJetDistVal", 0); + } + } +} + +void ParticleNetTagInfoProducer::fillSVFeatures(DeepBoostedJetFeatures &fts, const reco::Jet &jet) { + std::vector jetSVs; + for (const auto &sv : *svs_) { + if (reco::deltaR2(sv, jet) < jet_radius_ * jet_radius_) { + jetSVs.push_back(&sv); + } + } + // sort by dxy significance + std::sort(jetSVs.begin(), + jetSVs.end(), + [&](const reco::VertexCompositePtrCandidate *sva, const reco::VertexCompositePtrCandidate *svb) { + return sv_vertex_comparator(*sva, *svb, *pv_); + }); + + // reserve space + for (const auto &name : sv_features_) { + fts.reserve(name, jetSVs.size()); + } + + const float etasign = jet.eta() > 0 ? 1 : -1; + + for (const auto *sv : jetSVs) { + // basic kinematics + fts.fill("sv_mask", 1); + fts.fill("sv_phirel", reco::deltaPhi(*sv, jet)); + fts.fill("sv_etarel", etasign * (sv->eta() - jet.eta())); + fts.fill("sv_abseta", std::abs(sv->eta())); + fts.fill("sv_mass", sv->mass()); + fts.fill("sv_pt_log", catch_infs(std::log(sv->pt()), -99)); + + // sv properties + fts.fill("sv_ntracks", sv->numberOfDaughters()); + fts.fill("sv_normchi2", catch_infs(sv->vertexNormalizedChi2())); + + const auto &dxy = vertexDxy(*sv, *pv_); + fts.fill("sv_dxy", dxy.value()); + fts.fill("sv_dxysig", dxy.significance()); + + const auto &d3d = vertexD3d(*sv, *pv_); + fts.fill("sv_d3d", d3d.value()); + fts.fill("sv_d3dsig", d3d.significance()); + + fts.fill("sv_costhetasvpv", vertexDdotP(*sv, *pv_)); + } +} + +// define this as a plug-in +DEFINE_FWK_MODULE(ParticleNetTagInfoProducer); diff --git a/RecoBTag/MXNet/plugins/BuildFile.xml b/RecoBTag/MXNet/plugins/BuildFile.xml new file mode 100644 index 0000000000000..ff17f046f6995 --- /dev/null +++ b/RecoBTag/MXNet/plugins/BuildFile.xml @@ -0,0 +1,7 @@ + + + + + + + diff --git a/RecoBTag/MXNet/plugins/ParticleNetJetTagsProducer.cc b/RecoBTag/MXNet/plugins/ParticleNetJetTagsProducer.cc new file mode 100644 index 0000000000000..f0da617c46032 --- /dev/null +++ b/RecoBTag/MXNet/plugins/ParticleNetJetTagsProducer.cc @@ -0,0 +1,287 @@ +#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/DeepBoostedJetTagInfo.h" + +#include +#include +#include +#include +#include "PhysicsTools/MXNet/interface/Predictor.h" + +// Hold the mxnet model block (symbol + params) in the edm::GlobalCache. +struct MXBlockCache { + MXBlockCache() : block(nullptr) {} + + std::atomic block; +}; + +// struct to hold preprocessing parameters +struct PreprocessParams { + struct VarInfo { + VarInfo() {} + VarInfo(float median, float norm_factor) : center(median), norm_factor(norm_factor) {} + float center = 0; + float norm_factor = 1; + }; + + unsigned var_length = 0; + std::vector var_names; + std::unordered_map var_info_map; + + VarInfo get_info(const std::string &name) const { + auto item = var_info_map.find(name); + if (item != var_info_map.end()) { + return item->second; + } else { + throw cms::Exception("InvalidArgument") << "Cannot find variable info for " << name; + } + } +}; + +class ParticleNetJetTagsProducer : public edm::stream::EDProducer> { +public: + explicit ParticleNetJetTagsProducer(const edm::ParameterSet &, const MXBlockCache *); + ~ParticleNetJetTagsProducer() override; + + static void fillDescriptions(edm::ConfigurationDescriptions &); + + static std::unique_ptr initializeGlobalCache(const edm::ParameterSet &); + static void globalEndJob(const MXBlockCache *); + +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 {} + + std::vector center_norm_pad(const std::vector &input, + float center, + float scale, + unsigned target_length, + float pad_value = 0, + float min = 0, + float max = -1); + void make_inputs(const reco::DeepBoostedJetTagInfo &taginfo); + + const edm::EDGetTokenT src_; + std::vector flav_names_; // names of the output scores + std::vector input_names_; // names of each input group - the ordering is important! + std::vector> input_shapes_; // shapes of each input group + std::unordered_map prep_info_map_; // preprocessing info for each input group + + std::vector> data_; + std::unique_ptr predictor_; + + bool debug_ = false; +}; + +ParticleNetJetTagsProducer::ParticleNetJetTagsProducer(const edm::ParameterSet &iConfig, const MXBlockCache *cache) + : src_(consumes(iConfig.getParameter("src"))), + flav_names_(iConfig.getParameter>("flav_names")), + debug_(iConfig.getUntrackedParameter("debugMode", false)) { + // load preprocessing info + const auto &prep_pset = iConfig.getParameterSet("preprocessParams"); + input_names_ = prep_pset.getParameter>("input_names"); + for (const auto &group_name : input_names_) { + const auto &group_pset = prep_pset.getParameterSet(group_name); + input_shapes_.push_back(group_pset.getParameter>("input_shape")); + auto &prep_params = prep_info_map_[group_name]; + prep_params.var_length = group_pset.getParameter("var_length"); + prep_params.var_names = group_pset.getParameter>("var_names"); + const auto &var_info_pset = group_pset.getParameterSet("var_infos"); + for (const auto &var_name : prep_params.var_names) { + const auto &var_pset = var_info_pset.getParameterSet(var_name); + double median = var_pset.getParameter("median"); + double norm_factor = var_pset.getParameter("norm_factor"); + prep_params.var_info_map[var_name] = PreprocessParams::VarInfo(median, norm_factor); + } + + // create data storage with a fixed size vector initilized w/ 0 + unsigned len = prep_params.var_length * prep_params.var_names.size(); + data_.emplace_back(len, 0); + } + + if (debug_) { + for (unsigned i = 0; i < input_names_.size(); ++i) { + const auto &group_name = input_names_.at(i); + std::cout << group_name << "\nshapes: "; + for (const auto &x : input_shapes_.at(i)) { + std::cout << x << ", "; + } + std::cout << "\nvariables: "; + for (const auto &x : prep_info_map_.at(group_name).var_names) { + std::cout << x << ", "; + } + std::cout << "\n"; + } + } + + // init MXNetPredictor + predictor_.reset(new mxnet::cpp::Predictor(*cache->block)); + predictor_->set_input_shapes(input_names_, input_shapes_); + + // get output names from flav_names + for (const auto &flav_name : flav_names_) { + produces(flav_name); + } +} + +ParticleNetJetTagsProducer::~ParticleNetJetTagsProducer() {} + +void ParticleNetJetTagsProducer::fillDescriptions(edm::ConfigurationDescriptions &descriptions) { + // pfParticleNetJetTags + edm::ParameterSetDescription desc; + desc.add("src", edm::InputTag("pfParticleNetTagInfos")); + edm::ParameterSetDescription preprocessParams; + preprocessParams.setAllowAnything(); + desc.add("preprocessParams", preprocessParams); + desc.add("model_path", + edm::FileInPath("RecoBTag/Combined/data/DeepBoostedJet/V01/full/resnet-symbol.json")); + desc.add("param_path", + edm::FileInPath("RecoBTag/Combined/data/DeepBoostedJet/V01/full/resnet-0000.params")); + desc.add>( + "flav_names", + std::vector{ + "probTbcq", "probTbqq", "probTbc", "probTbq", "probTbel", "probTbmu", "probTbta", + "probWcq", "probWqq", "probZbb", "probZcc", "probZqq", "probHbb", "probHcc", + "probHqqqq", "probQCDbb", "probQCDcc", "probQCDb", "probQCDc", "probQCDothers", + }); + desc.addOptionalUntracked("debugMode", false); + + descriptions.add("pfParticleNetJetTags", desc); +} + +std::unique_ptr ParticleNetJetTagsProducer::initializeGlobalCache(const edm::ParameterSet &iConfig) { + // get the model files + std::string model_file = iConfig.getParameter("model_path").fullPath(); + std::string param_file = iConfig.getParameter("param_path").fullPath(); + + // load the model and params and save it in the cache + MXBlockCache *cache = new MXBlockCache(); + cache->block = new mxnet::cpp::Block(model_file, param_file); + return std::unique_ptr(cache); +} + +void ParticleNetJetTagsProducer::globalEndJob(const MXBlockCache *cache) { + if (cache->block != nullptr) { + delete cache->block; + } +} + +void ParticleNetJetTagsProducer::produce(edm::Event &iEvent, const edm::EventSetup &iSetup) { + edm::Handle tag_infos; + iEvent.getByToken(src_, tag_infos); + + // initialize output collection + std::vector> output_tags; + if (!tag_infos->empty()) { + 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)); + } + } else { + for (std::size_t i = 0; i < flav_names_.size(); i++) { + output_tags.emplace_back(std::make_unique()); + } + } + + for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { + const auto &taginfo = (*tag_infos)[jet_n]; + std::vector outputs(flav_names_.size(), 0); // init as all zeros + + if (!taginfo.features().empty()) { + // convert inputs + make_inputs(taginfo); + // run prediction and get outputs + outputs = predictor_->predict(data_); + assert(outputs.size() == flav_names_.size()); + } + + 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[flav_n]; + } + } + + if (debug_) { + std::cout << "=== " << iEvent.id().run() << ":" << iEvent.id().luminosityBlock() << ":" << iEvent.id().event() + << " ===" << std::endl; + for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { + const auto &jet_ref = tag_infos->at(jet_n).jet(); + std::cout << " - Jet #" << jet_n << ", pt=" << jet_ref->pt() << ", eta=" << jet_ref->eta() + << ", phi=" << jet_ref->phi() << std::endl; + for (std::size_t flav_n = 0; flav_n < flav_names_.size(); ++flav_n) { + std::cout << " " << flav_names_.at(flav_n) << " = " << (*(output_tags.at(flav_n)))[jet_ref] << std::endl; + } + } + } + + // 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]); + } +} + +std::vector ParticleNetJetTagsProducer::center_norm_pad(const std::vector &input, + float center, + float norm_factor, + unsigned target_length, + float pad_value, + float min, + float max) { + // do variable shifting/scaling/padding/clipping in one go + + assert(min <= pad_value && pad_value <= max); + + std::vector out(target_length, pad_value); + for (unsigned i = 0; i < input.size() && i < target_length; ++i) { + out[i] = std::clamp((input[i] - center) * norm_factor, min, max); + } + return out; +} + +void ParticleNetJetTagsProducer::make_inputs(const reco::DeepBoostedJetTagInfo &taginfo) { + for (unsigned igroup = 0; igroup < input_names_.size(); ++igroup) { + const auto &group_name = input_names_[igroup]; + auto &group_values = data_[igroup]; + const auto &prep_params = prep_info_map_.at(group_name); + // first reset group_values to 0 + std::fill(group_values.begin(), group_values.end(), 0); + unsigned curr_pos = 0; + // transform/pad + for (const auto &varname : prep_params.var_names) { + const auto &raw_value = taginfo.features().get(varname); + const auto &info = prep_params.get_info(varname); + const float pad = 0; // pad w/ zero + auto val = center_norm_pad(raw_value, info.center, info.norm_factor, prep_params.var_length, pad, -5, 5); + std::copy(val.begin(), val.end(), group_values.begin() + curr_pos); + curr_pos += prep_params.var_length; + + if (debug_) { + std::cout << " -- var=" << varname << ", center=" << info.center << ", scale=" << info.norm_factor + << ", pad=" << pad << std::endl; + std::cout << "values (first 7 and last 3): " << val.at(0) << ", " << val.at(1) << ", " << val.at(2) << ", " + << val.at(3) << ", " << val.at(4) << ", " << val.at(5) << ", " << val.at(6) << " ... " + << val.at(prep_params.var_length - 3) << ", " << val.at(prep_params.var_length - 2) << ", " + << val.at(prep_params.var_length - 1) << std::endl; + } + } + } +} + +//define this as a plug-in +DEFINE_FWK_MODULE(ParticleNetJetTagsProducer); diff --git a/RecoBTag/MXNet/python/Parameters/ParticleNet/V00/pfMassDecorrelatedParticleNetPreprocessParams_cfi.py b/RecoBTag/MXNet/python/Parameters/ParticleNet/V00/pfMassDecorrelatedParticleNetPreprocessParams_cfi.py new file mode 100644 index 0000000000000..cdf1c024843ec --- /dev/null +++ b/RecoBTag/MXNet/python/Parameters/ParticleNet/V00/pfMassDecorrelatedParticleNetPreprocessParams_cfi.py @@ -0,0 +1,246 @@ +import FWCore.ParameterSet.Config as cms + +pfMassDecorrelatedParticleNetPreprocessParams = cms.PSet( + input_names = cms.vstring( + 'pf_points', + 'pf_features', + 'pf_mask', + 'sv_points', + 'sv_features', + 'sv_mask' + ), + pf_features = cms.PSet( + input_shape = cms.vuint32(1, 20, 100), + var_infos = cms.PSet( + pfcand_VTX_ass = cms.PSet( + median = cms.double(7.0), + norm_factor = cms.double(1.0) + ), + pfcand_abseta = cms.PSet( + median = cms.double(0.570207834244), + norm_factor = cms.double(1.65039794176) + ), + pfcand_btagEtaRel = cms.PSet( + median = cms.double(1.02164459229), + norm_factor = cms.double(0.450494647657) + ), + pfcand_btagJetDistVal = cms.PSet( + median = cms.double(-8.01788191893e-05), + norm_factor = cms.double(172.900234853) + ), + pfcand_btagPParRatio = cms.PSet( + median = cms.double(0.777632951736), + norm_factor = cms.double(1.28595373661) + ), + pfcand_btagPtRatio = cms.PSet( + median = cms.double(0.00793754169717), + norm_factor = cms.double(4.41778965372) + ), + pfcand_btagSip3dSig = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(0.871534329165) + ), + pfcand_btagSip3dVal = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(252.165554148) + ), + pfcand_charge = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(1.0) + ), + pfcand_dxy = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(473.799859238) + ), + pfcand_dxysig = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(1.66318902024) + ), + pfcand_dz = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(297.458232668) + ), + pfcand_dzsig = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(1.38690098449) + ), + pfcand_e_log_nopuppi = cms.PSet( + median = cms.double(1.42155307531), + norm_factor = cms.double(0.519927136489) + ), + pfcand_etarel = cms.PSet( + median = cms.double(-0.00481873401441), + norm_factor = cms.double(4.44798275517) + ), + pfcand_lostInnerHits = cms.PSet( + median = cms.double(-1.0), + norm_factor = cms.double(1.0) + ), + pfcand_normchi2 = cms.PSet( + median = cms.double(3.0), + norm_factor = cms.double(0.00100401606426) + ), + pfcand_phirel = cms.PSet( + median = cms.double(-0.000108399453893), + norm_factor = cms.double(4.39792304438) + ), + pfcand_pt_log_nopuppi = cms.PSet( + median = cms.double(1.12241530418), + norm_factor = cms.double(0.514354843556) + ), + pfcand_quality = cms.PSet( + median = cms.double(5.0), + norm_factor = cms.double(0.2) + ) + ), + var_length = cms.uint32(100), + var_names = cms.vstring( + 'pfcand_pt_log_nopuppi', + 'pfcand_e_log_nopuppi', + 'pfcand_etarel', + 'pfcand_phirel', + 'pfcand_abseta', + 'pfcand_charge', + 'pfcand_VTX_ass', + 'pfcand_lostInnerHits', + 'pfcand_normchi2', + 'pfcand_quality', + 'pfcand_dz', + 'pfcand_dzsig', + 'pfcand_dxy', + 'pfcand_dxysig', + 'pfcand_btagEtaRel', + 'pfcand_btagPtRatio', + 'pfcand_btagPParRatio', + 'pfcand_btagSip3dVal', + 'pfcand_btagSip3dSig', + 'pfcand_btagJetDistVal' + ) + ), + pf_mask = cms.PSet( + input_shape = cms.vuint32(1, 1, 100), + var_infos = cms.PSet( + pfcand_mask = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(1.0) + ) + ), + var_length = cms.uint32(100), + var_names = cms.vstring('pfcand_mask') + ), + pf_points = cms.PSet( + input_shape = cms.vuint32(1, 2, 100), + var_infos = cms.PSet( + pfcand_etarel = cms.PSet( + median = cms.double(-0.00481873401441), + norm_factor = cms.double(4.44798275517) + ), + pfcand_phirel = cms.PSet( + median = cms.double(-0.000108399453893), + norm_factor = cms.double(4.39792304438) + ) + ), + var_length = cms.uint32(100), + var_names = cms.vstring( + 'pfcand_etarel', + 'pfcand_phirel' + ) + ), + sv_features = cms.PSet( + input_shape = cms.vuint32(1, 12, 7), + var_infos = cms.PSet( + sv_abseta = cms.PSet( + median = cms.double(0.549196600914), + norm_factor = cms.double(1.59394768801) + ), + sv_costhetasvpv = cms.PSet( + median = cms.double(0.999762713909), + norm_factor = cms.double(183.233393766) + ), + sv_d3d = cms.PSet( + median = cms.double(0.551342129707), + norm_factor = cms.double(0.223128153806) + ), + sv_d3dsig = cms.PSet( + median = cms.double(8.35655975342), + norm_factor = cms.double(0.0238999954695) + ), + sv_dxy = cms.PSet( + median = cms.double(0.421502441168), + norm_factor = cms.double(0.312218277088) + ), + sv_dxysig = cms.PSet( + median = cms.double(8.34426879883), + norm_factor = cms.double(0.0239017055779) + ), + sv_etarel = cms.PSet( + median = cms.double(-0.00247404468246), + norm_factor = cms.double(8.44460188362) + ), + sv_mass = cms.PSet( + median = cms.double(1.3346953392), + norm_factor = cms.double(0.309230848837) + ), + sv_normchi2 = cms.PSet( + median = cms.double(0.806915462017), + norm_factor = cms.double(0.724496098658) + ), + sv_ntracks = cms.PSet( + median = cms.double(3.0), + norm_factor = cms.double(0.5) + ), + sv_phirel = cms.PSet( + median = cms.double(0.000502154347487), + norm_factor = cms.double(8.73243388771) + ), + sv_pt_log = cms.PSet( + median = cms.double(3.78325366974), + norm_factor = cms.double(0.692538144148) + ) + ), + var_length = cms.uint32(7), + var_names = cms.vstring( + 'sv_pt_log', + 'sv_mass', + 'sv_phirel', + 'sv_etarel', + 'sv_abseta', + 'sv_ntracks', + 'sv_normchi2', + 'sv_dxy', + 'sv_dxysig', + 'sv_d3d', + 'sv_d3dsig', + 'sv_costhetasvpv' + ) + ), + sv_mask = cms.PSet( + input_shape = cms.vuint32(1, 1, 7), + var_infos = cms.PSet( + sv_mask = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(1.0) + ) + ), + var_length = cms.uint32(7), + var_names = cms.vstring('sv_mask') + ), + sv_points = cms.PSet( + input_shape = cms.vuint32(1, 2, 7), + var_infos = cms.PSet( + sv_etarel = cms.PSet( + median = cms.double(-0.00247404468246), + norm_factor = cms.double(8.44460188362) + ), + sv_phirel = cms.PSet( + median = cms.double(0.000502154347487), + norm_factor = cms.double(8.73243388771) + ) + ), + var_length = cms.uint32(7), + var_names = cms.vstring( + 'sv_phirel', + 'sv_etarel' + ) + ) +) diff --git a/RecoBTag/MXNet/python/Parameters/ParticleNet/V00/pfParticleNetPreprocessParams_cfi.py b/RecoBTag/MXNet/python/Parameters/ParticleNet/V00/pfParticleNetPreprocessParams_cfi.py new file mode 100644 index 0000000000000..8985e567ca12e --- /dev/null +++ b/RecoBTag/MXNet/python/Parameters/ParticleNet/V00/pfParticleNetPreprocessParams_cfi.py @@ -0,0 +1,271 @@ +import FWCore.ParameterSet.Config as cms + +pfParticleNetPreprocessParams = cms.PSet( + input_names = cms.vstring( + 'pf_points', + 'pf_features', + 'pf_mask', + 'sv_points', + 'sv_features', + 'sv_mask' + ), + pf_features = cms.PSet( + input_shape = cms.vuint32(1, 25, 100), + var_infos = cms.PSet( + pfcand_VTX_ass = cms.PSet( + median = cms.double(7.0), + norm_factor = cms.double(1.0) + ), + pfcand_abseta = cms.PSet( + median = cms.double(0.570207834244), + norm_factor = cms.double(1.65039794176) + ), + pfcand_btagEtaRel = cms.PSet( + median = cms.double(1.02164459229), + norm_factor = cms.double(0.450494647657) + ), + pfcand_btagJetDistVal = cms.PSet( + median = cms.double(-8.01788191893e-05), + norm_factor = cms.double(172.900234853) + ), + pfcand_btagPParRatio = cms.PSet( + median = cms.double(0.777632951736), + norm_factor = cms.double(1.28595373661) + ), + pfcand_btagPtRatio = cms.PSet( + median = cms.double(0.00793754169717), + norm_factor = cms.double(4.41778965372) + ), + pfcand_btagSip3dSig = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(0.871534329165) + ), + pfcand_btagSip3dVal = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(252.165554148) + ), + pfcand_charge = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(1.0) + ), + pfcand_dxy = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(473.799859238) + ), + pfcand_dxysig = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(1.66318902024) + ), + pfcand_dz = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(297.458232668) + ), + pfcand_dzsig = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(1.38690098449) + ), + pfcand_e_log_nopuppi = cms.PSet( + median = cms.double(1.42155307531), + norm_factor = cms.double(0.519927136489) + ), + pfcand_etarel = cms.PSet( + median = cms.double(-0.00481873401441), + norm_factor = cms.double(4.44798275517) + ), + pfcand_isChargedHad = cms.PSet( + median = cms.double(1.0), + norm_factor = cms.double(1.0) + ), + pfcand_isEl = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(1.0) + ), + pfcand_isGamma = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(1.0) + ), + pfcand_isMu = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(1.0) + ), + pfcand_isNeutralHad = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(1.0) + ), + pfcand_lostInnerHits = cms.PSet( + median = cms.double(-1.0), + norm_factor = cms.double(1.0) + ), + pfcand_normchi2 = cms.PSet( + median = cms.double(3.0), + norm_factor = cms.double(0.00100401606426) + ), + pfcand_phirel = cms.PSet( + median = cms.double(-0.000108399453893), + norm_factor = cms.double(4.39792304438) + ), + pfcand_pt_log_nopuppi = cms.PSet( + median = cms.double(1.12241530418), + norm_factor = cms.double(0.514354843556) + ), + pfcand_quality = cms.PSet( + median = cms.double(5.0), + norm_factor = cms.double(0.2) + ) + ), + var_length = cms.uint32(100), + var_names = cms.vstring( + 'pfcand_pt_log_nopuppi', + 'pfcand_e_log_nopuppi', + 'pfcand_etarel', + 'pfcand_phirel', + 'pfcand_abseta', + 'pfcand_charge', + 'pfcand_isMu', + 'pfcand_isEl', + 'pfcand_isChargedHad', + 'pfcand_isGamma', + 'pfcand_isNeutralHad', + 'pfcand_VTX_ass', + 'pfcand_lostInnerHits', + 'pfcand_normchi2', + 'pfcand_quality', + 'pfcand_dz', + 'pfcand_dzsig', + 'pfcand_dxy', + 'pfcand_dxysig', + 'pfcand_btagEtaRel', + 'pfcand_btagPtRatio', + 'pfcand_btagPParRatio', + 'pfcand_btagSip3dVal', + 'pfcand_btagSip3dSig', + 'pfcand_btagJetDistVal' + ) + ), + pf_mask = cms.PSet( + input_shape = cms.vuint32(1, 1, 100), + var_infos = cms.PSet( + pfcand_mask = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(1.0) + ) + ), + var_length = cms.uint32(100), + var_names = cms.vstring('pfcand_mask') + ), + pf_points = cms.PSet( + input_shape = cms.vuint32(1, 2, 100), + var_infos = cms.PSet( + pfcand_etarel = cms.PSet( + median = cms.double(-0.00481873401441), + norm_factor = cms.double(4.44798275517) + ), + pfcand_phirel = cms.PSet( + median = cms.double(-0.000108399453893), + norm_factor = cms.double(4.39792304438) + ) + ), + var_length = cms.uint32(100), + var_names = cms.vstring( + 'pfcand_etarel', + 'pfcand_phirel' + ) + ), + sv_features = cms.PSet( + input_shape = cms.vuint32(1, 12, 7), + var_infos = cms.PSet( + sv_abseta = cms.PSet( + median = cms.double(0.549196600914), + norm_factor = cms.double(1.59394768801) + ), + sv_costhetasvpv = cms.PSet( + median = cms.double(0.999762713909), + norm_factor = cms.double(183.233393766) + ), + sv_d3d = cms.PSet( + median = cms.double(0.551342129707), + norm_factor = cms.double(0.223128153806) + ), + sv_d3dsig = cms.PSet( + median = cms.double(8.35655975342), + norm_factor = cms.double(0.0238999954695) + ), + sv_dxy = cms.PSet( + median = cms.double(0.421502441168), + norm_factor = cms.double(0.312218277088) + ), + sv_dxysig = cms.PSet( + median = cms.double(8.34426879883), + norm_factor = cms.double(0.0239017055779) + ), + sv_etarel = cms.PSet( + median = cms.double(-0.00247404468246), + norm_factor = cms.double(8.44460188362) + ), + sv_mass = cms.PSet( + median = cms.double(1.3346953392), + norm_factor = cms.double(0.309230848837) + ), + sv_normchi2 = cms.PSet( + median = cms.double(0.806915462017), + norm_factor = cms.double(0.724496098658) + ), + sv_ntracks = cms.PSet( + median = cms.double(3.0), + norm_factor = cms.double(0.5) + ), + sv_phirel = cms.PSet( + median = cms.double(0.000502154347487), + norm_factor = cms.double(8.73243388771) + ), + sv_pt_log = cms.PSet( + median = cms.double(3.78325366974), + norm_factor = cms.double(0.692538144148) + ) + ), + var_length = cms.uint32(7), + var_names = cms.vstring( + 'sv_pt_log', + 'sv_mass', + 'sv_phirel', + 'sv_etarel', + 'sv_abseta', + 'sv_ntracks', + 'sv_normchi2', + 'sv_dxy', + 'sv_dxysig', + 'sv_d3d', + 'sv_d3dsig', + 'sv_costhetasvpv' + ) + ), + sv_mask = cms.PSet( + input_shape = cms.vuint32(1, 1, 7), + var_infos = cms.PSet( + sv_mask = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(1.0) + ) + ), + var_length = cms.uint32(7), + var_names = cms.vstring('sv_mask') + ), + sv_points = cms.PSet( + input_shape = cms.vuint32(1, 2, 7), + var_infos = cms.PSet( + sv_etarel = cms.PSet( + median = cms.double(-0.00247404468246), + norm_factor = cms.double(8.44460188362) + ), + sv_phirel = cms.PSet( + median = cms.double(0.000502154347487), + norm_factor = cms.double(8.73243388771) + ) + ), + var_length = cms.uint32(7), + var_names = cms.vstring( + 'sv_phirel', + 'sv_etarel' + ) + ) +) diff --git a/RecoBTag/MXNet/python/pfMassDecorrelatedParticleNetDiscriminatorsJetTags_cfi.py b/RecoBTag/MXNet/python/pfMassDecorrelatedParticleNetDiscriminatorsJetTags_cfi.py new file mode 100644 index 0000000000000..a51a454bac61b --- /dev/null +++ b/RecoBTag/MXNet/python/pfMassDecorrelatedParticleNetDiscriminatorsJetTags_cfi.py @@ -0,0 +1,50 @@ +import FWCore.ParameterSet.Config as cms + +pfMassDecorrelatedParticleNetDiscriminatorsJetTags = cms.EDProducer( + 'BTagProbabilityToDiscriminator', + discriminators = cms.VPSet( + cms.PSet( + name = cms.string('XbbvsQCD'), + numerator = cms.VInputTag( + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probXbb'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probXbb'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDbb'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDcc'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDb'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDc'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDothers'), + ), + ), + cms.PSet( + name = cms.string('XccvsQCD'), + numerator = cms.VInputTag( + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probXcc'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probXcc'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDbb'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDcc'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDb'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDc'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDothers'), + ), + ), + cms.PSet( + name = cms.string('XqqvsQCD'), + numerator = cms.VInputTag( + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probXqq'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probXqq'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDbb'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDcc'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDb'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDc'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDothers'), + ), + ), + + ) + ) diff --git a/RecoBTag/MXNet/python/pfParticleNetDiscriminatorsJetTags_cfi.py b/RecoBTag/MXNet/python/pfParticleNetDiscriminatorsJetTags_cfi.py new file mode 100644 index 0000000000000..9a9554e336707 --- /dev/null +++ b/RecoBTag/MXNet/python/pfParticleNetDiscriminatorsJetTags_cfi.py @@ -0,0 +1,99 @@ +import FWCore.ParameterSet.Config as cms + +pfParticleNetDiscriminatorsJetTags = cms.EDProducer( + 'BTagProbabilityToDiscriminator', + discriminators = cms.VPSet( + cms.PSet( + name = cms.string('TvsQCD'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetJetTags', 'probTbcq'), + cms.InputTag('pfParticleNetJetTags', 'probTbqq'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetJetTags', 'probTbcq'), + cms.InputTag('pfParticleNetJetTags', 'probTbqq'), + cms.InputTag('pfParticleNetJetTags', 'probQCDbb'), + cms.InputTag('pfParticleNetJetTags', 'probQCDcc'), + cms.InputTag('pfParticleNetJetTags', 'probQCDb'), + cms.InputTag('pfParticleNetJetTags', 'probQCDc'), + cms.InputTag('pfParticleNetJetTags', 'probQCDothers'), + ), + ), + cms.PSet( + name = cms.string('WvsQCD'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetJetTags', 'probWcq'), + cms.InputTag('pfParticleNetJetTags', 'probWqq'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetJetTags', 'probWcq'), + cms.InputTag('pfParticleNetJetTags', 'probWqq'), + cms.InputTag('pfParticleNetJetTags', 'probQCDbb'), + cms.InputTag('pfParticleNetJetTags', 'probQCDcc'), + cms.InputTag('pfParticleNetJetTags', 'probQCDb'), + cms.InputTag('pfParticleNetJetTags', 'probQCDc'), + cms.InputTag('pfParticleNetJetTags', 'probQCDothers'), + ), + ), + cms.PSet( + name = cms.string('ZvsQCD'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetJetTags', 'probZbb'), + cms.InputTag('pfParticleNetJetTags', 'probZcc'), + cms.InputTag('pfParticleNetJetTags', 'probZqq'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetJetTags', 'probZbb'), + cms.InputTag('pfParticleNetJetTags', 'probZcc'), + cms.InputTag('pfParticleNetJetTags', 'probZqq'), + cms.InputTag('pfParticleNetJetTags', 'probQCDbb'), + cms.InputTag('pfParticleNetJetTags', 'probQCDcc'), + cms.InputTag('pfParticleNetJetTags', 'probQCDb'), + cms.InputTag('pfParticleNetJetTags', 'probQCDc'), + cms.InputTag('pfParticleNetJetTags', 'probQCDothers'), + ), + ), + cms.PSet( + name = cms.string('ZbbvsQCD'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetJetTags', 'probZbb'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetJetTags', 'probZbb'), + cms.InputTag('pfParticleNetJetTags', 'probQCDbb'), + cms.InputTag('pfParticleNetJetTags', 'probQCDcc'), + cms.InputTag('pfParticleNetJetTags', 'probQCDb'), + cms.InputTag('pfParticleNetJetTags', 'probQCDc'), + cms.InputTag('pfParticleNetJetTags', 'probQCDothers'), + ), + ), + cms.PSet( + name = cms.string('HbbvsQCD'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetJetTags', 'probHbb'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetJetTags', 'probHbb'), + cms.InputTag('pfParticleNetJetTags', 'probQCDbb'), + cms.InputTag('pfParticleNetJetTags', 'probQCDcc'), + cms.InputTag('pfParticleNetJetTags', 'probQCDb'), + cms.InputTag('pfParticleNetJetTags', 'probQCDc'), + cms.InputTag('pfParticleNetJetTags', 'probQCDothers'), + ), + ), + cms.PSet( + name = cms.string('H4qvsQCD'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetJetTags', 'probHqqqq'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetJetTags', 'probHqqqq'), + cms.InputTag('pfParticleNetJetTags', 'probQCDbb'), + cms.InputTag('pfParticleNetJetTags', 'probQCDcc'), + cms.InputTag('pfParticleNetJetTags', 'probQCDb'), + cms.InputTag('pfParticleNetJetTags', 'probQCDc'), + cms.InputTag('pfParticleNetJetTags', 'probQCDothers'), + ), + ), + ) + ) diff --git a/RecoBTag/MXNet/python/pfParticleNet_cff.py b/RecoBTag/MXNet/python/pfParticleNet_cff.py new file mode 100644 index 0000000000000..b7d3061c4bc18 --- /dev/null +++ b/RecoBTag/MXNet/python/pfParticleNet_cff.py @@ -0,0 +1,47 @@ +import FWCore.ParameterSet.Config as cms + +from RecoBTag.FeatureTools.pfParticleNetTagInfos_cfi import pfParticleNetTagInfos +from RecoBTag.MXNet.pfParticleNetJetTags_cfi import pfParticleNetJetTags as _pfParticleNetJetTags +from RecoBTag.MXNet.Parameters.ParticleNet.V00.pfParticleNetPreprocessParams_cfi import pfParticleNetPreprocessParams +from RecoBTag.MXNet.Parameters.ParticleNet.V00.pfMassDecorrelatedParticleNetPreprocessParams_cfi import pfMassDecorrelatedParticleNetPreprocessParams +from RecoBTag.MXNet.pfParticleNetDiscriminatorsJetTags_cfi import pfParticleNetDiscriminatorsJetTags +from RecoBTag.MXNet.pfMassDecorrelatedParticleNetDiscriminatorsJetTags_cfi import pfMassDecorrelatedParticleNetDiscriminatorsJetTags + +pfParticleNetJetTags = _pfParticleNetJetTags.clone( + preprocessParams = pfParticleNetPreprocessParams, + model_path = 'RecoBTag/Combined/data/ParticleNet/V00/ParticleNet-symbol.json', + param_path = 'RecoBTag/Combined/data/ParticleNet/V00/ParticleNet-0000.params', + debugMode = False, # debug +) + +pfMassDecorrelatedParticleNetJetTags = _pfParticleNetJetTags.clone( + preprocessParams = pfMassDecorrelatedParticleNetPreprocessParams, + model_path = 'RecoBTag/Combined/data/ParticleNet-MD/V00/ParticleNet-symbol.json', + param_path = 'RecoBTag/Combined/data/ParticleNet-MD/V00/ParticleNet-0000.params', + flav_names = cms.vstring("probXbb", "probXcc", "probXqq", "probQCDbb", "probQCDcc", "probQCDb", "probQCDc", "probQCDothers"), + debugMode = False, # debug +) + +from CommonTools.PileupAlgos.Puppi_cff import puppi +from PhysicsTools.PatAlgos.slimming.primaryVertexAssociation_cfi import primaryVertexAssociation + +# This task is not used, useful only if we run it from RECO jets (RECO/AOD) +pfParticleNetTask = cms.Task(puppi, primaryVertexAssociation, pfParticleNetTagInfos, + pfParticleNetJetTags, pfMassDecorrelatedParticleNetJetTags, pfParticleNetDiscriminatorsJetTags) + +# declare all the discriminators +# nominal: probs +_pfParticleNetJetTagsProbs = ['pfParticleNetJetTags:' + flav_name + for flav_name in pfParticleNetJetTags.flav_names] +# nominal: meta-taggers +_pfParticleNetJetTagsMetaDiscrs = ['pfParticleNetDiscriminatorsJetTags:' + disc.name.value() + for disc in pfParticleNetDiscriminatorsJetTags.discriminators] +# mass-decorrelated: probs +_pfMassDecorrelatedParticleNetJetTagsProbs = ['pfMassDecorrelatedParticleNetJetTags:' + flav_name + for flav_name in pfMassDecorrelatedParticleNetJetTags.flav_names] +# mass-decorrelated: meta-taggers +_pfMassDecorrelatedParticleNetJetTagsMetaDiscrs = ['pfMassDecorrelatedParticleNetDiscriminatorsJetTags:' + disc.name.value() + for disc in pfMassDecorrelatedParticleNetDiscriminatorsJetTags.discriminators] + +_pfParticleNetJetTagsAll = _pfParticleNetJetTagsProbs + _pfParticleNetJetTagsMetaDiscrs + \ + _pfMassDecorrelatedParticleNetJetTagsProbs + _pfMassDecorrelatedParticleNetJetTagsMetaDiscrs From f465b350361c83ddb99ec3043da6603ec303c985 Mon Sep 17 00:00:00 2001 From: Huilin Qu Date: Fri, 7 Feb 2020 18:11:41 +0100 Subject: [PATCH 2/9] Fix NaN. --- .../plugins/ParticleNetTagInfoProducer.cc | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/RecoBTag/FeatureTools/plugins/ParticleNetTagInfoProducer.cc b/RecoBTag/FeatureTools/plugins/ParticleNetTagInfoProducer.cc index b7ad415649dd7..893cc957848ba 100644 --- a/RecoBTag/FeatureTools/plugins/ParticleNetTagInfoProducer.cc +++ b/RecoBTag/FeatureTools/plugins/ParticleNetTagInfoProducer.cc @@ -337,12 +337,12 @@ void ParticleNetTagInfoProducer::fillParticleFeatures(DeepBoostedJetFeatures &ft TrackInfoBuilder trkinfo(track_builder_); trkinfo.buildTrackInfo(&(*cand), jet_dir, jet_ref_track_dir, *pv_); - fts.fill("pfcand_btagEtaRel", trkinfo.getTrackEtaRel()); - fts.fill("pfcand_btagPtRatio", trkinfo.getTrackPtRatio()); - fts.fill("pfcand_btagPParRatio", trkinfo.getTrackPParRatio()); - fts.fill("pfcand_btagSip3dVal", trkinfo.getTrackSip3dVal()); - fts.fill("pfcand_btagSip3dSig", trkinfo.getTrackSip3dSig()); - fts.fill("pfcand_btagJetDistVal", trkinfo.getTrackJetDistVal()); + fts.fill("pfcand_btagEtaRel", catch_infs(trkinfo.getTrackEtaRel())); + fts.fill("pfcand_btagPtRatio", catch_infs(trkinfo.getTrackPtRatio())); + fts.fill("pfcand_btagPParRatio", catch_infs(trkinfo.getTrackPParRatio())); + fts.fill("pfcand_btagSip3dVal", catch_infs(trkinfo.getTrackSip3dVal())); + fts.fill("pfcand_btagSip3dSig", catch_infs(trkinfo.getTrackSip3dSig())); + fts.fill("pfcand_btagJetDistVal", catch_infs(trkinfo.getTrackJetDistVal())); } else { fts.fill("pfcand_normchi2", 999); From cb8bd7bcae3a77a63897157d39738ed2edb9fa24 Mon Sep 17 00:00:00 2001 From: Huilin Qu Date: Fri, 7 Feb 2020 18:12:14 +0100 Subject: [PATCH 3/9] Add ParticleNet to MiniAOD sequence. --- PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py b/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py index 37dd166d7f2b6..2e09e4703ff07 100644 --- a/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py +++ b/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py @@ -43,6 +43,7 @@ def applyDeepBtagging( process, postfix="" ) : delattr(process, 'selectedUpdatedPatJetsSlimmedDeepFlavour'+postfix) from RecoBTag.ONNXRuntime.pfDeepBoostedJet_cff import _pfDeepBoostedJetTagsAll as pfDeepBoostedJetTagsAll + from RecoBTag.MXNet.pfParticleNet_cff import _pfParticleNetJetTagsAll as pfParticleNetJetTagsAll # update slimmed jets to include particle-based deep taggers (keep same name) # make clone for DeepTags-less slimmed AK8 jets, so output name is preserved @@ -60,7 +61,7 @@ def applyDeepBtagging( process, postfix="" ) : 'pfMassIndependentDeepDoubleCvLJetTags:probHcc', 'pfMassIndependentDeepDoubleCvBJetTags:probHbb', 'pfMassIndependentDeepDoubleCvBJetTags:probHcc', - ) + pfDeepBoostedJetTagsAll + ) + pfDeepBoostedJetTagsAll + pfParticleNetJetTagsAll ) updateJetCollection( process, From 7a7c0a709044971aff40017b19eb7c9e57be3e99 Mon Sep 17 00:00:00 2001 From: Huilin Qu Date: Mon, 10 Feb 2020 04:31:19 -0800 Subject: [PATCH 4/9] Add a test cfg. --- RecoBTag/MXNet/test/test_particle_net_cfg.py | 70 ++++++++++++++++++++ 1 file changed, 70 insertions(+) create mode 100644 RecoBTag/MXNet/test/test_particle_net_cfg.py diff --git a/RecoBTag/MXNet/test/test_particle_net_cfg.py b/RecoBTag/MXNet/test/test_particle_net_cfg.py new file mode 100644 index 0000000000000..263c43d4d17cb --- /dev/null +++ b/RecoBTag/MXNet/test/test_particle_net_cfg.py @@ -0,0 +1,70 @@ +import FWCore.ParameterSet.Config as cms +from PhysicsTools.PatAlgos.tools.helpers import getPatAlgosToolsTask + +from FWCore.ParameterSet.VarParsing import VarParsing +options = VarParsing('analysis') +options.inputFiles = '/store/mc/RunIIFall17MiniAODv2/TTToHadronic_TuneCP5_13TeV-powheg-pythia8/MINIAODSIM/PU2017_12Apr2018_94X_mc2017_realistic_v14-v1/90000/DCFE3F5F-AE42-E811-B6DB-008CFAF72A64.root' +options.maxEvents = 1000 +options.parseArguments() + +process = cms.Process("PATtest") + +## MessageLogger +process.load("FWCore.MessageLogger.MessageLogger_cfi") +process.MessageLogger.cerr.FwkReport.reportEvery = 100 + + +## Options and Output Report +process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(True) ) + +## Source +process.source = cms.Source("PoolSource", + fileNames=cms.untracked.vstring(options.inputFiles) +) +## Maximal Number of Events +process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(options.maxEvents)) + +## 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:phase1_2017_realistic') +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 +from RecoBTag.MXNet.pfParticleNet_cff import _pfParticleNetJetTagsAll as pfParticleNetJetTagsAll + +updateJetCollection( + process, + jetSource = cms.InputTag('slimmedJetsAK8'), + pvSource = cms.InputTag('offlineSlimmedPrimaryVertices'), + svSource = cms.InputTag('slimmedSecondaryVertices'), + rParam = 0.8, + jetCorrections = ('AK8PFPuppi', cms.vstring(['L2Relative', 'L3Absolute']), 'None'), + btagDiscriminators = pfParticleNetJetTagsAll + ) + +from Configuration.EventContent.EventContent_cff import MINIAODSIMEventContent +process.out.outputCommands.append('keep *_slimmedJetsAK8*_*_*') +process.out.outputCommands.append('keep *_offlineSlimmedPrimaryVertices*_*_*') +process.out.outputCommands.append('keep *_slimmedSecondaryVertices*_*_*') +process.out.outputCommands.append('keep *_selectedPatJets*_*_*') +process.out.outputCommands.append('keep *_selectedUpdatedPatJets*_*_*') +process.out.outputCommands.append('keep *_updatedPatJets*_*_*') + +process.out.fileName = 'test_particle_net_MINIAODSIM.root' From 567839af882e5b53771bc6a368eb20c68404912f Mon Sep 17 00:00:00 2001 From: Huilin Qu Date: Thu, 13 Feb 2020 09:28:20 -0800 Subject: [PATCH 5/9] Change ParticleNet model paths. --- RecoBTag/MXNet/plugins/ParticleNetJetTagsProducer.cc | 4 ++-- RecoBTag/MXNet/python/pfParticleNet_cff.py | 8 ++++---- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/RecoBTag/MXNet/plugins/ParticleNetJetTagsProducer.cc b/RecoBTag/MXNet/plugins/ParticleNetJetTagsProducer.cc index f0da617c46032..a6bb1df842789 100644 --- a/RecoBTag/MXNet/plugins/ParticleNetJetTagsProducer.cc +++ b/RecoBTag/MXNet/plugins/ParticleNetJetTagsProducer.cc @@ -149,9 +149,9 @@ void ParticleNetJetTagsProducer::fillDescriptions(edm::ConfigurationDescriptions preprocessParams.setAllowAnything(); desc.add("preprocessParams", preprocessParams); desc.add("model_path", - edm::FileInPath("RecoBTag/Combined/data/DeepBoostedJet/V01/full/resnet-symbol.json")); + edm::FileInPath("RecoBTag/Combined/data/ParticleNetAK8/General/V00/ParticleNet-symbol.json")); desc.add("param_path", - edm::FileInPath("RecoBTag/Combined/data/DeepBoostedJet/V01/full/resnet-0000.params")); + edm::FileInPath("RecoBTag/Combined/data/ParticleNetAK8/General/V00/ParticleNet-0000.params")); desc.add>( "flav_names", std::vector{ diff --git a/RecoBTag/MXNet/python/pfParticleNet_cff.py b/RecoBTag/MXNet/python/pfParticleNet_cff.py index b7d3061c4bc18..ca72c0c096828 100644 --- a/RecoBTag/MXNet/python/pfParticleNet_cff.py +++ b/RecoBTag/MXNet/python/pfParticleNet_cff.py @@ -9,15 +9,15 @@ pfParticleNetJetTags = _pfParticleNetJetTags.clone( preprocessParams = pfParticleNetPreprocessParams, - model_path = 'RecoBTag/Combined/data/ParticleNet/V00/ParticleNet-symbol.json', - param_path = 'RecoBTag/Combined/data/ParticleNet/V00/ParticleNet-0000.params', + model_path = 'RecoBTag/Combined/data/ParticleNetAK8/General/V00/ParticleNet-symbol.json', + param_path = 'RecoBTag/Combined/data/ParticleNetAK8/General/V00/ParticleNet-0000.params', debugMode = False, # debug ) pfMassDecorrelatedParticleNetJetTags = _pfParticleNetJetTags.clone( preprocessParams = pfMassDecorrelatedParticleNetPreprocessParams, - model_path = 'RecoBTag/Combined/data/ParticleNet-MD/V00/ParticleNet-symbol.json', - param_path = 'RecoBTag/Combined/data/ParticleNet-MD/V00/ParticleNet-0000.params', + model_path = 'RecoBTag/Combined/data/ParticleNetAK8/MD-2prong/V00/ParticleNet-symbol.json', + param_path = 'RecoBTag/Combined/data/ParticleNetAK8/MD-2prong/V00/ParticleNet-0000.params', flav_names = cms.vstring("probXbb", "probXcc", "probXqq", "probQCDbb", "probQCDcc", "probQCDb", "probQCDc", "probQCDothers"), debugMode = False, # debug ) From 878def8eb60a8777fd7540f81c345d2d87d26567 Mon Sep 17 00:00:00 2001 From: Huilin Qu Date: Thu, 13 Feb 2020 18:54:24 +0100 Subject: [PATCH 6/9] Apply code checks. --- RecoBTag/MXNet/plugins/ParticleNetJetTagsProducer.cc | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/RecoBTag/MXNet/plugins/ParticleNetJetTagsProducer.cc b/RecoBTag/MXNet/plugins/ParticleNetJetTagsProducer.cc index a6bb1df842789..4ce122e31d489 100644 --- a/RecoBTag/MXNet/plugins/ParticleNetJetTagsProducer.cc +++ b/RecoBTag/MXNet/plugins/ParticleNetJetTagsProducer.cc @@ -148,10 +148,10 @@ void ParticleNetJetTagsProducer::fillDescriptions(edm::ConfigurationDescriptions edm::ParameterSetDescription preprocessParams; preprocessParams.setAllowAnything(); desc.add("preprocessParams", preprocessParams); - desc.add("model_path", - edm::FileInPath("RecoBTag/Combined/data/ParticleNetAK8/General/V00/ParticleNet-symbol.json")); - desc.add("param_path", - edm::FileInPath("RecoBTag/Combined/data/ParticleNetAK8/General/V00/ParticleNet-0000.params")); + desc.add( + "model_path", edm::FileInPath("RecoBTag/Combined/data/ParticleNetAK8/General/V00/ParticleNet-symbol.json")); + desc.add( + "param_path", edm::FileInPath("RecoBTag/Combined/data/ParticleNetAK8/General/V00/ParticleNet-0000.params")); desc.add>( "flav_names", std::vector{ From 4d8bfcb461e8314ed0f38cf3bf19d40433c26ab2 Mon Sep 17 00:00:00 2001 From: Huilin Qu Date: Thu, 27 Feb 2020 01:12:46 +0100 Subject: [PATCH 7/9] Address review comments. --- .../plugins/ParticleNetTagInfoProducer.cc | 5 +-- ...r.cc => BoostedJetMXNetJetTagsProducer.cc} | 41 +++++++++---------- RecoBTag/MXNet/plugins/BuildFile.xml | 2 +- RecoBTag/MXNet/python/pfParticleNet_cff.py | 11 +++-- 4 files changed, 27 insertions(+), 32 deletions(-) rename RecoBTag/MXNet/plugins/{ParticleNetJetTagsProducer.cc => BoostedJetMXNetJetTagsProducer.cc} (86%) diff --git a/RecoBTag/FeatureTools/plugins/ParticleNetTagInfoProducer.cc b/RecoBTag/FeatureTools/plugins/ParticleNetTagInfoProducer.cc index 893cc957848ba..5fc369370cc2d 100644 --- a/RecoBTag/FeatureTools/plugins/ParticleNetTagInfoProducer.cc +++ b/RecoBTag/FeatureTools/plugins/ParticleNetTagInfoProducer.cc @@ -144,8 +144,7 @@ void ParticleNetTagInfoProducer::fillDescriptions(edm::ConfigurationDescriptions void ParticleNetTagInfoProducer::produce(edm::Event &iEvent, const edm::EventSetup &iSetup) { auto output_tag_infos = std::make_unique(); - edm::Handle> jets; - iEvent.getByToken(jet_token_, jets); + auto jets = iEvent.getHandle(jet_token_); iEvent.getByToken(vtx_token_, vtxs_); if (vtxs_->empty()) { @@ -218,7 +217,6 @@ void ParticleNetTagInfoProducer::fillParticleFeatures(DeepBoostedJetFeatures &ft GlobalVector jet_ref_track_dir(jet.px(), jet.py(), jet.pz()); const float etasign = jet.eta() > 0 ? 1 : -1; - std::map puppi_wgt_cache; auto puppiWgt = [&](const reco::CandidatePtr &cand) { const auto *pack_cand = dynamic_cast(&(*cand)); const auto *reco_cand = dynamic_cast(&(*cand)); @@ -235,7 +233,6 @@ void ParticleNetTagInfoProducer::fillParticleFeatures(DeepBoostedJetFeatures &ft throw edm::Exception(edm::errors::InvalidReference) << "Cannot convert to either pat::PackedCandidate or " "reco::PFCandidate"; } - puppi_wgt_cache[cand.key()] = wgt; return wgt; }; diff --git a/RecoBTag/MXNet/plugins/ParticleNetJetTagsProducer.cc b/RecoBTag/MXNet/plugins/BoostedJetMXNetJetTagsProducer.cc similarity index 86% rename from RecoBTag/MXNet/plugins/ParticleNetJetTagsProducer.cc rename to RecoBTag/MXNet/plugins/BoostedJetMXNetJetTagsProducer.cc index 4ce122e31d489..64d116103c760 100644 --- a/RecoBTag/MXNet/plugins/ParticleNetJetTagsProducer.cc +++ b/RecoBTag/MXNet/plugins/BoostedJetMXNetJetTagsProducer.cc @@ -49,10 +49,10 @@ struct PreprocessParams { } }; -class ParticleNetJetTagsProducer : public edm::stream::EDProducer> { +class BoostedJetMXNetJetTagsProducer : public edm::stream::EDProducer> { public: - explicit ParticleNetJetTagsProducer(const edm::ParameterSet &, const MXBlockCache *); - ~ParticleNetJetTagsProducer() override; + explicit BoostedJetMXNetJetTagsProducer(const edm::ParameterSet &, const MXBlockCache *); + ~BoostedJetMXNetJetTagsProducer() override; static void fillDescriptions(edm::ConfigurationDescriptions &); @@ -63,9 +63,7 @@ class ParticleNetJetTagsProducer : public edm::stream::EDProducer TagInfoCollection; typedef reco::JetTagCollection JetTagCollection; - void beginStream(edm::StreamID) override {} void produce(edm::Event &, const edm::EventSetup &) override; - void endStream() override {} std::vector center_norm_pad(const std::vector &input, float center, @@ -88,7 +86,8 @@ class ParticleNetJetTagsProducer : public edm::stream::EDProducer(iConfig.getParameter("src"))), flav_names_(iConfig.getParameter>("flav_names")), debug_(iConfig.getUntrackedParameter("debugMode", false)) { @@ -139,9 +138,9 @@ ParticleNetJetTagsProducer::ParticleNetJetTagsProducer(const edm::ParameterSet & } } -ParticleNetJetTagsProducer::~ParticleNetJetTagsProducer() {} +BoostedJetMXNetJetTagsProducer::~BoostedJetMXNetJetTagsProducer() {} -void ParticleNetJetTagsProducer::fillDescriptions(edm::ConfigurationDescriptions &descriptions) { +void BoostedJetMXNetJetTagsProducer::fillDescriptions(edm::ConfigurationDescriptions &descriptions) { // pfParticleNetJetTags edm::ParameterSetDescription desc; desc.add("src", edm::InputTag("pfParticleNetTagInfos")); @@ -161,10 +160,10 @@ void ParticleNetJetTagsProducer::fillDescriptions(edm::ConfigurationDescriptions }); desc.addOptionalUntracked("debugMode", false); - descriptions.add("pfParticleNetJetTags", desc); + descriptions.addWithDefaultLabel(desc); } -std::unique_ptr ParticleNetJetTagsProducer::initializeGlobalCache(const edm::ParameterSet &iConfig) { +std::unique_ptr BoostedJetMXNetJetTagsProducer::initializeGlobalCache(const edm::ParameterSet &iConfig) { // get the model files std::string model_file = iConfig.getParameter("model_path").fullPath(); std::string param_file = iConfig.getParameter("param_path").fullPath(); @@ -175,13 +174,13 @@ std::unique_ptr ParticleNetJetTagsProducer::initializeGlobalCache( return std::unique_ptr(cache); } -void ParticleNetJetTagsProducer::globalEndJob(const MXBlockCache *cache) { +void BoostedJetMXNetJetTagsProducer::globalEndJob(const MXBlockCache *cache) { if (cache->block != nullptr) { delete cache->block; } } -void ParticleNetJetTagsProducer::produce(edm::Event &iEvent, const edm::EventSetup &iSetup) { +void BoostedJetMXNetJetTagsProducer::produce(edm::Event &iEvent, const edm::EventSetup &iSetup) { edm::Handle tag_infos; iEvent.getByToken(src_, tag_infos); @@ -236,13 +235,13 @@ void ParticleNetJetTagsProducer::produce(edm::Event &iEvent, const edm::EventSet } } -std::vector ParticleNetJetTagsProducer::center_norm_pad(const std::vector &input, - float center, - float norm_factor, - unsigned target_length, - float pad_value, - float min, - float max) { +std::vector BoostedJetMXNetJetTagsProducer::center_norm_pad(const std::vector &input, + float center, + float norm_factor, + unsigned target_length, + float pad_value, + float min, + float max) { // do variable shifting/scaling/padding/clipping in one go assert(min <= pad_value && pad_value <= max); @@ -254,7 +253,7 @@ std::vector ParticleNetJetTagsProducer::center_norm_pad(const std::vector return out; } -void ParticleNetJetTagsProducer::make_inputs(const reco::DeepBoostedJetTagInfo &taginfo) { +void BoostedJetMXNetJetTagsProducer::make_inputs(const reco::DeepBoostedJetTagInfo &taginfo) { for (unsigned igroup = 0; igroup < input_names_.size(); ++igroup) { const auto &group_name = input_names_[igroup]; auto &group_values = data_[igroup]; @@ -284,4 +283,4 @@ void ParticleNetJetTagsProducer::make_inputs(const reco::DeepBoostedJetTagInfo & } //define this as a plug-in -DEFINE_FWK_MODULE(ParticleNetJetTagsProducer); +DEFINE_FWK_MODULE(BoostedJetMXNetJetTagsProducer); diff --git a/RecoBTag/MXNet/plugins/BuildFile.xml b/RecoBTag/MXNet/plugins/BuildFile.xml index ff17f046f6995..b6d6eaed37b09 100644 --- a/RecoBTag/MXNet/plugins/BuildFile.xml +++ b/RecoBTag/MXNet/plugins/BuildFile.xml @@ -1,6 +1,6 @@ - + diff --git a/RecoBTag/MXNet/python/pfParticleNet_cff.py b/RecoBTag/MXNet/python/pfParticleNet_cff.py index ca72c0c096828..d380953030d22 100644 --- a/RecoBTag/MXNet/python/pfParticleNet_cff.py +++ b/RecoBTag/MXNet/python/pfParticleNet_cff.py @@ -1,25 +1,24 @@ import FWCore.ParameterSet.Config as cms from RecoBTag.FeatureTools.pfParticleNetTagInfos_cfi import pfParticleNetTagInfos -from RecoBTag.MXNet.pfParticleNetJetTags_cfi import pfParticleNetJetTags as _pfParticleNetJetTags +from RecoBTag.MXNet.boostedJetMXNetJetTagsProducer_cfi import boostedJetMXNetJetTagsProducer from RecoBTag.MXNet.Parameters.ParticleNet.V00.pfParticleNetPreprocessParams_cfi import pfParticleNetPreprocessParams from RecoBTag.MXNet.Parameters.ParticleNet.V00.pfMassDecorrelatedParticleNetPreprocessParams_cfi import pfMassDecorrelatedParticleNetPreprocessParams from RecoBTag.MXNet.pfParticleNetDiscriminatorsJetTags_cfi import pfParticleNetDiscriminatorsJetTags from RecoBTag.MXNet.pfMassDecorrelatedParticleNetDiscriminatorsJetTags_cfi import pfMassDecorrelatedParticleNetDiscriminatorsJetTags -pfParticleNetJetTags = _pfParticleNetJetTags.clone( +pfParticleNetJetTags = boostedJetMXNetJetTagsProducer.clone( preprocessParams = pfParticleNetPreprocessParams, model_path = 'RecoBTag/Combined/data/ParticleNetAK8/General/V00/ParticleNet-symbol.json', param_path = 'RecoBTag/Combined/data/ParticleNetAK8/General/V00/ParticleNet-0000.params', - debugMode = False, # debug ) -pfMassDecorrelatedParticleNetJetTags = _pfParticleNetJetTags.clone( +pfMassDecorrelatedParticleNetJetTags = boostedJetMXNetJetTagsProducer.clone( preprocessParams = pfMassDecorrelatedParticleNetPreprocessParams, model_path = 'RecoBTag/Combined/data/ParticleNetAK8/MD-2prong/V00/ParticleNet-symbol.json', param_path = 'RecoBTag/Combined/data/ParticleNetAK8/MD-2prong/V00/ParticleNet-0000.params', - flav_names = cms.vstring("probXbb", "probXcc", "probXqq", "probQCDbb", "probQCDcc", "probQCDb", "probQCDc", "probQCDothers"), - debugMode = False, # debug + flav_names = ["probXbb", "probXcc", "probXqq", "probQCDbb", "probQCDcc", + "probQCDb", "probQCDc", "probQCDothers"], ) from CommonTools.PileupAlgos.Puppi_cff import puppi From d1af63d520c6ad319cc6e58c81369b44276e899b Mon Sep 17 00:00:00 2001 From: Huilin Qu Date: Tue, 3 Mar 2020 22:20:38 +0100 Subject: [PATCH 8/9] Simply preprocess params. --- ...rrelatedParticleNetPreprocessParams_cfi.py | 246 ------------------ .../V00/pfParticleNetPreprocessParams_cfi.py | 28 ++ RecoBTag/MXNet/python/pfParticleNet_cff.py | 3 +- 3 files changed, 29 insertions(+), 248 deletions(-) delete mode 100644 RecoBTag/MXNet/python/Parameters/ParticleNet/V00/pfMassDecorrelatedParticleNetPreprocessParams_cfi.py diff --git a/RecoBTag/MXNet/python/Parameters/ParticleNet/V00/pfMassDecorrelatedParticleNetPreprocessParams_cfi.py b/RecoBTag/MXNet/python/Parameters/ParticleNet/V00/pfMassDecorrelatedParticleNetPreprocessParams_cfi.py deleted file mode 100644 index cdf1c024843ec..0000000000000 --- a/RecoBTag/MXNet/python/Parameters/ParticleNet/V00/pfMassDecorrelatedParticleNetPreprocessParams_cfi.py +++ /dev/null @@ -1,246 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -pfMassDecorrelatedParticleNetPreprocessParams = cms.PSet( - input_names = cms.vstring( - 'pf_points', - 'pf_features', - 'pf_mask', - 'sv_points', - 'sv_features', - 'sv_mask' - ), - pf_features = cms.PSet( - input_shape = cms.vuint32(1, 20, 100), - var_infos = cms.PSet( - pfcand_VTX_ass = cms.PSet( - median = cms.double(7.0), - norm_factor = cms.double(1.0) - ), - pfcand_abseta = cms.PSet( - median = cms.double(0.570207834244), - norm_factor = cms.double(1.65039794176) - ), - pfcand_btagEtaRel = cms.PSet( - median = cms.double(1.02164459229), - norm_factor = cms.double(0.450494647657) - ), - pfcand_btagJetDistVal = cms.PSet( - median = cms.double(-8.01788191893e-05), - norm_factor = cms.double(172.900234853) - ), - pfcand_btagPParRatio = cms.PSet( - median = cms.double(0.777632951736), - norm_factor = cms.double(1.28595373661) - ), - pfcand_btagPtRatio = cms.PSet( - median = cms.double(0.00793754169717), - norm_factor = cms.double(4.41778965372) - ), - pfcand_btagSip3dSig = cms.PSet( - median = cms.double(0.0), - norm_factor = cms.double(0.871534329165) - ), - pfcand_btagSip3dVal = cms.PSet( - median = cms.double(0.0), - norm_factor = cms.double(252.165554148) - ), - pfcand_charge = cms.PSet( - median = cms.double(0.0), - norm_factor = cms.double(1.0) - ), - pfcand_dxy = cms.PSet( - median = cms.double(0.0), - norm_factor = cms.double(473.799859238) - ), - pfcand_dxysig = cms.PSet( - median = cms.double(0.0), - norm_factor = cms.double(1.66318902024) - ), - pfcand_dz = cms.PSet( - median = cms.double(0.0), - norm_factor = cms.double(297.458232668) - ), - pfcand_dzsig = cms.PSet( - median = cms.double(0.0), - norm_factor = cms.double(1.38690098449) - ), - pfcand_e_log_nopuppi = cms.PSet( - median = cms.double(1.42155307531), - norm_factor = cms.double(0.519927136489) - ), - pfcand_etarel = cms.PSet( - median = cms.double(-0.00481873401441), - norm_factor = cms.double(4.44798275517) - ), - pfcand_lostInnerHits = cms.PSet( - median = cms.double(-1.0), - norm_factor = cms.double(1.0) - ), - pfcand_normchi2 = cms.PSet( - median = cms.double(3.0), - norm_factor = cms.double(0.00100401606426) - ), - pfcand_phirel = cms.PSet( - median = cms.double(-0.000108399453893), - norm_factor = cms.double(4.39792304438) - ), - pfcand_pt_log_nopuppi = cms.PSet( - median = cms.double(1.12241530418), - norm_factor = cms.double(0.514354843556) - ), - pfcand_quality = cms.PSet( - median = cms.double(5.0), - norm_factor = cms.double(0.2) - ) - ), - var_length = cms.uint32(100), - var_names = cms.vstring( - 'pfcand_pt_log_nopuppi', - 'pfcand_e_log_nopuppi', - 'pfcand_etarel', - 'pfcand_phirel', - 'pfcand_abseta', - 'pfcand_charge', - 'pfcand_VTX_ass', - 'pfcand_lostInnerHits', - 'pfcand_normchi2', - 'pfcand_quality', - 'pfcand_dz', - 'pfcand_dzsig', - 'pfcand_dxy', - 'pfcand_dxysig', - 'pfcand_btagEtaRel', - 'pfcand_btagPtRatio', - 'pfcand_btagPParRatio', - 'pfcand_btagSip3dVal', - 'pfcand_btagSip3dSig', - 'pfcand_btagJetDistVal' - ) - ), - pf_mask = cms.PSet( - input_shape = cms.vuint32(1, 1, 100), - var_infos = cms.PSet( - pfcand_mask = cms.PSet( - median = cms.double(0.0), - norm_factor = cms.double(1.0) - ) - ), - var_length = cms.uint32(100), - var_names = cms.vstring('pfcand_mask') - ), - pf_points = cms.PSet( - input_shape = cms.vuint32(1, 2, 100), - var_infos = cms.PSet( - pfcand_etarel = cms.PSet( - median = cms.double(-0.00481873401441), - norm_factor = cms.double(4.44798275517) - ), - pfcand_phirel = cms.PSet( - median = cms.double(-0.000108399453893), - norm_factor = cms.double(4.39792304438) - ) - ), - var_length = cms.uint32(100), - var_names = cms.vstring( - 'pfcand_etarel', - 'pfcand_phirel' - ) - ), - sv_features = cms.PSet( - input_shape = cms.vuint32(1, 12, 7), - var_infos = cms.PSet( - sv_abseta = cms.PSet( - median = cms.double(0.549196600914), - norm_factor = cms.double(1.59394768801) - ), - sv_costhetasvpv = cms.PSet( - median = cms.double(0.999762713909), - norm_factor = cms.double(183.233393766) - ), - sv_d3d = cms.PSet( - median = cms.double(0.551342129707), - norm_factor = cms.double(0.223128153806) - ), - sv_d3dsig = cms.PSet( - median = cms.double(8.35655975342), - norm_factor = cms.double(0.0238999954695) - ), - sv_dxy = cms.PSet( - median = cms.double(0.421502441168), - norm_factor = cms.double(0.312218277088) - ), - sv_dxysig = cms.PSet( - median = cms.double(8.34426879883), - norm_factor = cms.double(0.0239017055779) - ), - sv_etarel = cms.PSet( - median = cms.double(-0.00247404468246), - norm_factor = cms.double(8.44460188362) - ), - sv_mass = cms.PSet( - median = cms.double(1.3346953392), - norm_factor = cms.double(0.309230848837) - ), - sv_normchi2 = cms.PSet( - median = cms.double(0.806915462017), - norm_factor = cms.double(0.724496098658) - ), - sv_ntracks = cms.PSet( - median = cms.double(3.0), - norm_factor = cms.double(0.5) - ), - sv_phirel = cms.PSet( - median = cms.double(0.000502154347487), - norm_factor = cms.double(8.73243388771) - ), - sv_pt_log = cms.PSet( - median = cms.double(3.78325366974), - norm_factor = cms.double(0.692538144148) - ) - ), - var_length = cms.uint32(7), - var_names = cms.vstring( - 'sv_pt_log', - 'sv_mass', - 'sv_phirel', - 'sv_etarel', - 'sv_abseta', - 'sv_ntracks', - 'sv_normchi2', - 'sv_dxy', - 'sv_dxysig', - 'sv_d3d', - 'sv_d3dsig', - 'sv_costhetasvpv' - ) - ), - sv_mask = cms.PSet( - input_shape = cms.vuint32(1, 1, 7), - var_infos = cms.PSet( - sv_mask = cms.PSet( - median = cms.double(0.0), - norm_factor = cms.double(1.0) - ) - ), - var_length = cms.uint32(7), - var_names = cms.vstring('sv_mask') - ), - sv_points = cms.PSet( - input_shape = cms.vuint32(1, 2, 7), - var_infos = cms.PSet( - sv_etarel = cms.PSet( - median = cms.double(-0.00247404468246), - norm_factor = cms.double(8.44460188362) - ), - sv_phirel = cms.PSet( - median = cms.double(0.000502154347487), - norm_factor = cms.double(8.73243388771) - ) - ), - var_length = cms.uint32(7), - var_names = cms.vstring( - 'sv_phirel', - 'sv_etarel' - ) - ) -) diff --git a/RecoBTag/MXNet/python/Parameters/ParticleNet/V00/pfParticleNetPreprocessParams_cfi.py b/RecoBTag/MXNet/python/Parameters/ParticleNet/V00/pfParticleNetPreprocessParams_cfi.py index 8985e567ca12e..7194a0cc2f294 100644 --- a/RecoBTag/MXNet/python/Parameters/ParticleNet/V00/pfParticleNetPreprocessParams_cfi.py +++ b/RecoBTag/MXNet/python/Parameters/ParticleNet/V00/pfParticleNetPreprocessParams_cfi.py @@ -269,3 +269,31 @@ ) ) ) + +pfMassDecorrelatedParticleNetPreprocessParams = pfParticleNetPreprocessParams.clone( + pf_features = pfParticleNetPreprocessParams.pf_features.clone( + input_shape = [1, 20, 100], + var_names = [ + 'pfcand_pt_log_nopuppi', + 'pfcand_e_log_nopuppi', + 'pfcand_etarel', + 'pfcand_phirel', + 'pfcand_abseta', + 'pfcand_charge', + 'pfcand_VTX_ass', + 'pfcand_lostInnerHits', + 'pfcand_normchi2', + 'pfcand_quality', + 'pfcand_dz', + 'pfcand_dzsig', + 'pfcand_dxy', + 'pfcand_dxysig', + 'pfcand_btagEtaRel', + 'pfcand_btagPtRatio', + 'pfcand_btagPParRatio', + 'pfcand_btagSip3dVal', + 'pfcand_btagSip3dSig', + 'pfcand_btagJetDistVal' + ] + ) +) diff --git a/RecoBTag/MXNet/python/pfParticleNet_cff.py b/RecoBTag/MXNet/python/pfParticleNet_cff.py index d380953030d22..604cdf8dced5e 100644 --- a/RecoBTag/MXNet/python/pfParticleNet_cff.py +++ b/RecoBTag/MXNet/python/pfParticleNet_cff.py @@ -2,8 +2,7 @@ from RecoBTag.FeatureTools.pfParticleNetTagInfos_cfi import pfParticleNetTagInfos from RecoBTag.MXNet.boostedJetMXNetJetTagsProducer_cfi import boostedJetMXNetJetTagsProducer -from RecoBTag.MXNet.Parameters.ParticleNet.V00.pfParticleNetPreprocessParams_cfi import pfParticleNetPreprocessParams -from RecoBTag.MXNet.Parameters.ParticleNet.V00.pfMassDecorrelatedParticleNetPreprocessParams_cfi import pfMassDecorrelatedParticleNetPreprocessParams +from RecoBTag.MXNet.Parameters.ParticleNet.V00.pfParticleNetPreprocessParams_cfi import pfParticleNetPreprocessParams, pfMassDecorrelatedParticleNetPreprocessParams from RecoBTag.MXNet.pfParticleNetDiscriminatorsJetTags_cfi import pfParticleNetDiscriminatorsJetTags from RecoBTag.MXNet.pfMassDecorrelatedParticleNetDiscriminatorsJetTags_cfi import pfMassDecorrelatedParticleNetDiscriminatorsJetTags From 3c9ce7f25fce7f9fd68393f8480cd84f9600774d Mon Sep 17 00:00:00 2001 From: Huilin Qu Date: Thu, 5 Mar 2020 02:06:42 +0100 Subject: [PATCH 9/9] Merge TagInfo producers. --- .../plugins/DeepBoostedJetTagInfoProducer.cc | 64 +-- .../plugins/ParticleNetTagInfoProducer.cc | 403 ------------------ RecoBTag/MXNet/python/pfParticleNet_cff.py | 6 +- 3 files changed, 45 insertions(+), 428 deletions(-) delete mode 100644 RecoBTag/FeatureTools/plugins/ParticleNetTagInfoProducer.cc diff --git a/RecoBTag/FeatureTools/plugins/DeepBoostedJetTagInfoProducer.cc b/RecoBTag/FeatureTools/plugins/DeepBoostedJetTagInfoProducer.cc index 8269ac0fce189..0ac16c7ed8c71 100644 --- a/RecoBTag/FeatureTools/plugins/DeepBoostedJetTagInfoProducer.cc +++ b/RecoBTag/FeatureTools/plugins/DeepBoostedJetTagInfoProducer.cc @@ -46,6 +46,7 @@ class DeepBoostedJetTagInfoProducer : public edm::stream::EDProducer<> { const double jet_radius_; const double min_jet_pt_; const double min_pt_for_track_properties_; + const bool use_puppiP4_; edm::EDGetTokenT> jet_token_; edm::EDGetTokenT vtx_token_; @@ -83,10 +84,13 @@ const std::vector DeepBoostedJetTagInfoProducer::particle_features_ "pfcand_dphidphi", "pfcand_dxydxy", "pfcand_dzdz", "pfcand_dxydz", "pfcand_dphidxy", "pfcand_dlambdadz", "pfcand_btagEtaRel", "pfcand_btagPtRatio", "pfcand_btagPParRatio", "pfcand_btagSip2dVal", "pfcand_btagSip2dSig", "pfcand_btagSip3dVal", - "pfcand_btagSip3dSig", "pfcand_btagJetDistVal", + "pfcand_btagSip3dSig", "pfcand_btagJetDistVal", "pfcand_mask", "pfcand_pt_log_nopuppi", + "pfcand_e_log_nopuppi" + }; const std::vector DeepBoostedJetTagInfoProducer::sv_features_{ + "sv_mask", "sv_phirel", "sv_etarel", "sv_deltaR", @@ -108,6 +112,7 @@ DeepBoostedJetTagInfoProducer::DeepBoostedJetTagInfoProducer(const edm::Paramete : jet_radius_(iConfig.getParameter("jet_radius")), min_jet_pt_(iConfig.getParameter("min_jet_pt")), min_pt_for_track_properties_(iConfig.getParameter("min_pt_for_track_properties")), + use_puppiP4_(iConfig.getParameter("use_puppiP4")), jet_token_(consumes>(iConfig.getParameter("jets"))), vtx_token_(consumes(iConfig.getParameter("vertices"))), sv_token_(consumes(iConfig.getParameter("secondary_vertices"))), @@ -138,6 +143,7 @@ void DeepBoostedJetTagInfoProducer::fillDescriptions(edm::ConfigurationDescripti desc.add("jet_radius", 0.8); desc.add("min_jet_pt", 150); desc.add("min_pt_for_track_properties", -1); + desc.add("use_puppiP4", true); desc.add("vertices", edm::InputTag("offlinePrimaryVertices")); desc.add("secondary_vertices", edm::InputTag("inclusiveCandidateSecondaryVertices")); desc.add("pf_candidates", edm::InputTag("particleFlow")); @@ -150,8 +156,7 @@ void DeepBoostedJetTagInfoProducer::fillDescriptions(edm::ConfigurationDescripti void DeepBoostedJetTagInfoProducer::produce(edm::Event &iEvent, const edm::EventSetup &iSetup) { auto output_tag_infos = std::make_unique(); - edm::Handle> jets; - iEvent.getByToken(jet_token_, jets); + auto jets = iEvent.getHandle(jet_token_); iEvent.getByToken(vtx_token_, vtxs_); if (vtxs_->empty()) { @@ -259,11 +264,17 @@ void DeepBoostedJetTagInfoProducer::fillParticleFeatures(DeepBoostedJetFeatures // get the original reco/packed candidate not scaled by the puppi weight daughters.push_back(pfcands_->ptrAt(cand.key())); } - // sort by Puppi-weighted pt - std::sort( - daughters.begin(), daughters.end(), [&puppi_wgt_cache](const reco::CandidatePtr &a, const reco::CandidatePtr &b) { - return puppi_wgt_cache.at(a.key()) * a->pt() > puppi_wgt_cache.at(b.key()) * b->pt(); - }); + if (use_puppiP4_) { + // sort by Puppi-weighted pt + std::sort(daughters.begin(), + daughters.end(), + [&puppi_wgt_cache](const reco::CandidatePtr &a, const reco::CandidatePtr &b) { + return puppi_wgt_cache.at(a.key()) * a->pt() > puppi_wgt_cache.at(b.key()) * b->pt(); + }); + } else { + // sort by original pt (not Puppi-weighted) + std::sort(daughters.begin(), daughters.end(), [](const auto &a, const auto &b) { return a->pt() > b->pt(); }); + } // reserve space for (const auto &name : particle_features_) { @@ -279,7 +290,7 @@ void DeepBoostedJetTagInfoProducer::fillParticleFeatures(DeepBoostedJetFeatures const auto *packed_cand = dynamic_cast(&(*cand)); const auto *reco_cand = dynamic_cast(&(*cand)); - auto puppiP4 = puppi_wgt_cache.at(cand.key()) * cand->p4(); + auto candP4 = use_puppiP4_ ? puppi_wgt_cache.at(cand.key()) * cand->p4() : cand->p4(); if (packed_cand) { float hcal_fraction = 0.; if (packed_cand->pdgId() == 1 || packed_cand->pdgId() == 130) { @@ -343,14 +354,18 @@ void DeepBoostedJetTagInfoProducer::fillParticleFeatures(DeepBoostedJetFeatures // basic kinematics fts.fill("pfcand_puppiw", puppi_wgt_cache.at(cand.key())); - fts.fill("pfcand_phirel", reco::deltaPhi(puppiP4, jet)); - fts.fill("pfcand_etarel", etasign * (puppiP4.eta() - jet.eta())); - fts.fill("pfcand_deltaR", reco::deltaR(puppiP4, jet)); - fts.fill("pfcand_abseta", std::abs(puppiP4.eta())); + fts.fill("pfcand_phirel", reco::deltaPhi(candP4, jet)); + fts.fill("pfcand_etarel", etasign * (candP4.eta() - jet.eta())); + fts.fill("pfcand_deltaR", reco::deltaR(candP4, jet)); + fts.fill("pfcand_abseta", std::abs(candP4.eta())); + + fts.fill("pfcand_ptrel_log", catch_infs(std::log(candP4.pt() / jet.pt()), -99)); + fts.fill("pfcand_erel_log", catch_infs(std::log(candP4.energy() / jet.energy()), -99)); + fts.fill("pfcand_pt_log", catch_infs(std::log(candP4.pt()), -99)); - fts.fill("pfcand_ptrel_log", catch_infs(std::log(puppiP4.pt() / jet.pt()), -99)); - fts.fill("pfcand_erel_log", catch_infs(std::log(puppiP4.energy() / jet.energy()), -99)); - fts.fill("pfcand_pt_log", catch_infs(std::log(puppiP4.pt()), -99)); + fts.fill("pfcand_mask", 1); + fts.fill("pfcand_pt_log_nopuppi", catch_infs(std::log(cand->pt()), -99)); + fts.fill("pfcand_e_log_nopuppi", catch_infs(std::log(cand->energy()), -99)); double minDR = 999; for (const auto &sv : *svs_) { @@ -390,14 +405,14 @@ void DeepBoostedJetTagInfoProducer::fillParticleFeatures(DeepBoostedJetFeatures TrackInfoBuilder trkinfo(track_builder_); trkinfo.buildTrackInfo(&(*cand), jet_dir, jet_ref_track_dir, *pv_); - fts.fill("pfcand_btagEtaRel", trkinfo.getTrackEtaRel()); - fts.fill("pfcand_btagPtRatio", trkinfo.getTrackPtRatio()); - fts.fill("pfcand_btagPParRatio", trkinfo.getTrackPParRatio()); - fts.fill("pfcand_btagSip2dVal", trkinfo.getTrackSip2dVal()); - fts.fill("pfcand_btagSip2dSig", trkinfo.getTrackSip2dSig()); - fts.fill("pfcand_btagSip3dVal", trkinfo.getTrackSip3dVal()); - fts.fill("pfcand_btagSip3dSig", trkinfo.getTrackSip3dSig()); - fts.fill("pfcand_btagJetDistVal", trkinfo.getTrackJetDistVal()); + fts.fill("pfcand_btagEtaRel", catch_infs(trkinfo.getTrackEtaRel())); + fts.fill("pfcand_btagPtRatio", catch_infs(trkinfo.getTrackPtRatio())); + fts.fill("pfcand_btagPParRatio", catch_infs(trkinfo.getTrackPParRatio())); + fts.fill("pfcand_btagSip2dVal", catch_infs(trkinfo.getTrackSip2dVal())); + fts.fill("pfcand_btagSip2dSig", catch_infs(trkinfo.getTrackSip2dSig())); + fts.fill("pfcand_btagSip3dVal", catch_infs(trkinfo.getTrackSip3dVal())); + fts.fill("pfcand_btagSip3dSig", catch_infs(trkinfo.getTrackSip3dSig())); + fts.fill("pfcand_btagJetDistVal", catch_infs(trkinfo.getTrackJetDistVal())); } else { fts.fill("pfcand_normchi2", 999); @@ -445,6 +460,7 @@ void DeepBoostedJetTagInfoProducer::fillSVFeatures(DeepBoostedJetFeatures &fts, for (const auto *sv : jetSVs) { // basic kinematics + fts.fill("sv_mask", 1); fts.fill("sv_phirel", reco::deltaPhi(*sv, jet)); fts.fill("sv_etarel", etasign * (sv->eta() - jet.eta())); fts.fill("sv_deltaR", reco::deltaR(*sv, jet)); diff --git a/RecoBTag/FeatureTools/plugins/ParticleNetTagInfoProducer.cc b/RecoBTag/FeatureTools/plugins/ParticleNetTagInfoProducer.cc deleted file mode 100644 index 5fc369370cc2d..0000000000000 --- a/RecoBTag/FeatureTools/plugins/ParticleNetTagInfoProducer.cc +++ /dev/null @@ -1,403 +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/ParameterSet/interface/ParameterSet.h" -#include "FWCore/Utilities/interface/StreamID.h" - -#include "DataFormats/Candidate/interface/Candidate.h" - -#include "DataFormats/PatCandidates/interface/Jet.h" -#include "DataFormats/PatCandidates/interface/PackedCandidate.h" - -#include "RecoBTag/FeatureTools/interface/TrackInfoBuilder.h" -#include "RecoBTag/FeatureTools/interface/deep_helpers.h" -#include "TrackingTools/Records/interface/TransientTrackRecord.h" - -#include "DataFormats/Candidate/interface/VertexCompositePtrCandidate.h" -#include "DataFormats/VertexReco/interface/VertexFwd.h" - -#include "DataFormats/BTauReco/interface/DeepBoostedJetTagInfo.h" - -using namespace btagbtvdeep; - -class ParticleNetTagInfoProducer : public edm::stream::EDProducer<> { -public: - explicit ParticleNetTagInfoProducer(const edm::ParameterSet &); - ~ParticleNetTagInfoProducer() override; - - static void fillDescriptions(edm::ConfigurationDescriptions &descriptions); - -private: - typedef std::vector DeepBoostedJetTagInfoCollection; - typedef reco::VertexCompositePtrCandidateCollection SVCollection; - typedef reco::VertexCollection VertexCollection; - typedef edm::View CandidateView; - - void beginStream(edm::StreamID) override {} - void produce(edm::Event &, const edm::EventSetup &) override; - void endStream() override {} - - void fillParticleFeatures(DeepBoostedJetFeatures &fts, const reco::Jet &jet); - void fillSVFeatures(DeepBoostedJetFeatures &fts, const reco::Jet &jet); - - const double jet_radius_; - const double min_jet_pt_; - const double min_pt_for_track_properties_; - - edm::EDGetTokenT> jet_token_; - edm::EDGetTokenT vtx_token_; - edm::EDGetTokenT sv_token_; - edm::EDGetTokenT pfcand_token_; - - bool use_puppi_value_map_; - bool use_pvasq_value_map_; - - edm::EDGetTokenT> puppi_value_map_token_; - edm::EDGetTokenT> pvasq_value_map_token_; - edm::EDGetTokenT> pvas_token_; - - edm::Handle vtxs_; - edm::Handle svs_; - edm::Handle pfcands_; - edm::ESHandle track_builder_; - edm::Handle> puppi_value_map_; - edm::Handle> pvasq_value_map_; - edm::Handle> pvas_; - - const static std::vector particle_features_; - const static std::vector sv_features_; - const reco::Vertex *pv_ = nullptr; -}; - -const std::vector ParticleNetTagInfoProducer::particle_features_{ - "pfcand_mask", "pfcand_VTX_ass", "pfcand_lostInnerHits", "pfcand_quality", - "pfcand_charge", "pfcand_isEl", "pfcand_isMu", "pfcand_isChargedHad", - "pfcand_isGamma", "pfcand_isNeutralHad", "pfcand_phirel", "pfcand_etarel", - "pfcand_abseta", "pfcand_pt_log_nopuppi", "pfcand_e_log_nopuppi", "pfcand_normchi2", - "pfcand_dz", "pfcand_dzsig", "pfcand_dxy", "pfcand_dxysig", - "pfcand_btagEtaRel", "pfcand_btagPtRatio", "pfcand_btagPParRatio", "pfcand_btagSip3dVal", - "pfcand_btagSip3dSig", "pfcand_btagJetDistVal", -}; - -const std::vector ParticleNetTagInfoProducer::sv_features_{ - "sv_mask", - "sv_phirel", - "sv_etarel", - "sv_abseta", - "sv_mass", - "sv_pt_log", - "sv_ntracks", - "sv_normchi2", - "sv_dxy", - "sv_dxysig", - "sv_d3d", - "sv_d3dsig", - "sv_costhetasvpv", -}; - -ParticleNetTagInfoProducer::ParticleNetTagInfoProducer(const edm::ParameterSet &iConfig) - : jet_radius_(iConfig.getParameter("jet_radius")), - min_jet_pt_(iConfig.getParameter("min_jet_pt")), - min_pt_for_track_properties_(iConfig.getParameter("min_pt_for_track_properties")), - jet_token_(consumes>(iConfig.getParameter("jets"))), - vtx_token_(consumes(iConfig.getParameter("vertices"))), - sv_token_(consumes(iConfig.getParameter("secondary_vertices"))), - pfcand_token_(consumes(iConfig.getParameter("pf_candidates"))), - use_puppi_value_map_(false), - use_pvasq_value_map_(false) { - const auto &puppi_value_map_tag = iConfig.getParameter("puppi_value_map"); - if (!puppi_value_map_tag.label().empty()) { - puppi_value_map_token_ = consumes>(puppi_value_map_tag); - use_puppi_value_map_ = true; - } - - const auto &pvas_tag = iConfig.getParameter("vertex_associator"); - if (!pvas_tag.label().empty()) { - pvasq_value_map_token_ = consumes>(pvas_tag); - pvas_token_ = consumes>(pvas_tag); - use_pvasq_value_map_ = true; - } - - produces(); -} - -ParticleNetTagInfoProducer::~ParticleNetTagInfoProducer() {} - -void ParticleNetTagInfoProducer::fillDescriptions(edm::ConfigurationDescriptions &descriptions) { - // pfParticleNetTagInfos - edm::ParameterSetDescription desc; - desc.add("jet_radius", 0.8); - desc.add("min_jet_pt", 150); - desc.add("min_pt_for_track_properties", -1); - desc.add("vertices", edm::InputTag("offlinePrimaryVertices")); - desc.add("secondary_vertices", edm::InputTag("inclusiveCandidateSecondaryVertices")); - desc.add("pf_candidates", edm::InputTag("particleFlow")); - desc.add("jets", edm::InputTag("ak8PFJetsPuppi")); - desc.add("puppi_value_map", edm::InputTag("puppi")); - desc.add("vertex_associator", edm::InputTag("primaryVertexAssociation", "original")); - descriptions.add("pfParticleNetTagInfos", desc); -} - -void ParticleNetTagInfoProducer::produce(edm::Event &iEvent, const edm::EventSetup &iSetup) { - auto output_tag_infos = std::make_unique(); - - auto jets = iEvent.getHandle(jet_token_); - - iEvent.getByToken(vtx_token_, vtxs_); - if (vtxs_->empty()) { - // produce empty TagInfos in case no primary vertex - iEvent.put(std::move(output_tag_infos)); - return; // exit event - } - // primary vertex - pv_ = &vtxs_->at(0); - - iEvent.getByToken(sv_token_, svs_); - - iEvent.getByToken(pfcand_token_, pfcands_); - - iSetup.get().get("TransientTrackBuilder", track_builder_); - - if (use_puppi_value_map_) { - iEvent.getByToken(puppi_value_map_token_, puppi_value_map_); - } - - if (use_pvasq_value_map_) { - iEvent.getByToken(pvasq_value_map_token_, pvasq_value_map_); - iEvent.getByToken(pvas_token_, pvas_); - } - - for (std::size_t jet_n = 0; jet_n < jets->size(); jet_n++) { - const auto &jet = (*jets)[jet_n]; - edm::RefToBase jet_ref(jets, jet_n); - - // create jet features - DeepBoostedJetFeatures features; - // declare all the feature variables (init as empty vector) - for (const auto &name : particle_features_) { - features.add(name); - } - for (const auto &name : sv_features_) { - features.add(name); - } - - // fill values only if above pt threshold and has daughters, otherwise left - // empty - bool fill_vars = true; - if (jet.pt() < min_jet_pt_) - fill_vars = false; - if (jet.numberOfDaughters() == 0) - fill_vars = false; - - if (fill_vars) { - fillParticleFeatures(features, jet); - fillSVFeatures(features, jet); - - features.check_consistency(particle_features_); - features.check_consistency(sv_features_); - } - - // this should always be done even if features are not filled - output_tag_infos->emplace_back(features, jet_ref); - } - - iEvent.put(std::move(output_tag_infos)); -} - -void ParticleNetTagInfoProducer::fillParticleFeatures(DeepBoostedJetFeatures &fts, const reco::Jet &jet) { - // do nothing if jet does not have constituents - if (jet.numberOfDaughters() == 0) - return; - - // some jet properties - math::XYZVector jet_dir = jet.momentum().Unit(); - GlobalVector jet_ref_track_dir(jet.px(), jet.py(), jet.pz()); - const float etasign = jet.eta() > 0 ? 1 : -1; - - auto puppiWgt = [&](const reco::CandidatePtr &cand) { - const auto *pack_cand = dynamic_cast(&(*cand)); - const auto *reco_cand = dynamic_cast(&(*cand)); - float wgt = 1.; - if (pack_cand) { - wgt = pack_cand->puppiWeight(); - } else if (reco_cand) { - if (use_puppi_value_map_) { - wgt = (*puppi_value_map_)[cand]; - } else { - throw edm::Exception(edm::errors::InvalidReference) << "Puppi value map is missing"; - } - } else { - throw edm::Exception(edm::errors::InvalidReference) << "Cannot convert to either pat::PackedCandidate or " - "reco::PFCandidate"; - } - return wgt; - }; - - std::vector daughters; - for (const auto &cand : jet.daughterPtrVector()) { - // remove particles w/ extremely low puppi weights - if ((puppiWgt(cand)) < 0.01) - continue; - // get the original reco/packed candidate not scaled by the puppi weight - daughters.push_back(pfcands_->ptrAt(cand.key())); - } - // sort by original pt (not Puppi-weighted) - std::sort(daughters.begin(), daughters.end(), [](const auto &a, const auto &b) { return a->pt() > b->pt(); }); - - // reserve space - for (const auto &name : particle_features_) { - fts.reserve(name, daughters.size()); - } - - auto useTrackProperties = [&](const reco::PFCandidate *reco_cand) { - const auto *trk = reco_cand->bestTrack(); - return trk != nullptr && trk->pt() > min_pt_for_track_properties_; - }; - - for (const auto &cand : daughters) { - const auto *packed_cand = dynamic_cast(&(*cand)); - const auto *reco_cand = dynamic_cast(&(*cand)); - - if (packed_cand) { - fts.fill("pfcand_VTX_ass", packed_cand->pvAssociationQuality()); - fts.fill("pfcand_lostInnerHits", packed_cand->lostInnerHits()); - fts.fill("pfcand_quality", packed_cand->bestTrack() ? packed_cand->bestTrack()->qualityMask() : 0); - - fts.fill("pfcand_charge", packed_cand->charge()); - fts.fill("pfcand_isEl", std::abs(packed_cand->pdgId()) == 11); - fts.fill("pfcand_isMu", std::abs(packed_cand->pdgId()) == 13); - fts.fill("pfcand_isChargedHad", std::abs(packed_cand->pdgId()) == 211); - fts.fill("pfcand_isGamma", std::abs(packed_cand->pdgId()) == 22); - fts.fill("pfcand_isNeutralHad", std::abs(packed_cand->pdgId()) == 130); - - // impact parameters - fts.fill("pfcand_dz", catch_infs(packed_cand->dz())); - fts.fill("pfcand_dzsig", packed_cand->bestTrack() ? catch_infs(packed_cand->dz() / packed_cand->dzError()) : 0); - fts.fill("pfcand_dxy", catch_infs(packed_cand->dxy())); - fts.fill("pfcand_dxysig", - packed_cand->bestTrack() ? catch_infs(packed_cand->dxy() / packed_cand->dxyError()) : 0); - - } else if (reco_cand) { - // get vertex association quality - int pv_ass_quality = 0; // fallback value - float vtx_ass = 0; - if (use_pvasq_value_map_) { - pv_ass_quality = (*pvasq_value_map_)[cand]; - const reco::VertexRef &PV_orig = (*pvas_)[cand]; - vtx_ass = vtx_ass_from_pfcand(*reco_cand, pv_ass_quality, PV_orig); - } else { - throw edm::Exception(edm::errors::InvalidReference) << "Vertex association missing"; - } - - fts.fill("pfcand_VTX_ass", vtx_ass); - fts.fill("pfcand_lostInnerHits", useTrackProperties(reco_cand) ? lost_inner_hits_from_pfcand(*reco_cand) : 0); - fts.fill("pfcand_quality", useTrackProperties(reco_cand) ? quality_from_pfcand(*reco_cand) : 0); - - fts.fill("pfcand_charge", reco_cand->charge()); - fts.fill("pfcand_isEl", std::abs(reco_cand->pdgId()) == 11); - fts.fill("pfcand_isMu", std::abs(reco_cand->pdgId()) == 13); - fts.fill("pfcand_isChargedHad", std::abs(reco_cand->pdgId()) == 211); - fts.fill("pfcand_isGamma", std::abs(reco_cand->pdgId()) == 22); - fts.fill("pfcand_isNeutralHad", std::abs(reco_cand->pdgId()) == 130); - - // impact parameters - const auto *trk = reco_cand->bestTrack(); - float dz = trk ? trk->dz(pv_->position()) : 0; - float dxy = trk ? trk->dxy(pv_->position()) : 0; - fts.fill("pfcand_dz", catch_infs(dz)); - fts.fill("pfcand_dzsig", trk ? catch_infs(dz / trk->dzError()) : 0); - fts.fill("pfcand_dxy", catch_infs(dxy)); - fts.fill("pfcand_dxysig", trk ? catch_infs(dxy / trk->dxyError()) : 0); - } - - // basic kinematics - fts.fill("pfcand_mask", 1); - fts.fill("pfcand_phirel", reco::deltaPhi(*cand, jet)); - fts.fill("pfcand_etarel", etasign * (cand->eta() - jet.eta())); - fts.fill("pfcand_abseta", std::abs(cand->eta())); - - fts.fill("pfcand_pt_log_nopuppi", catch_infs(std::log(cand->pt()), -99)); - fts.fill("pfcand_e_log_nopuppi", catch_infs(std::log(cand->energy()), -99)); - - // track info - const reco::Track *trk = nullptr; - if (packed_cand) { - trk = packed_cand->bestTrack(); - } else if (reco_cand && useTrackProperties(reco_cand)) { - trk = reco_cand->bestTrack(); - } - if (trk) { - fts.fill("pfcand_normchi2", catch_infs(std::floor(trk->normalizedChi2()))); - - TrackInfoBuilder trkinfo(track_builder_); - trkinfo.buildTrackInfo(&(*cand), jet_dir, jet_ref_track_dir, *pv_); - fts.fill("pfcand_btagEtaRel", catch_infs(trkinfo.getTrackEtaRel())); - fts.fill("pfcand_btagPtRatio", catch_infs(trkinfo.getTrackPtRatio())); - fts.fill("pfcand_btagPParRatio", catch_infs(trkinfo.getTrackPParRatio())); - fts.fill("pfcand_btagSip3dVal", catch_infs(trkinfo.getTrackSip3dVal())); - fts.fill("pfcand_btagSip3dSig", catch_infs(trkinfo.getTrackSip3dSig())); - fts.fill("pfcand_btagJetDistVal", catch_infs(trkinfo.getTrackJetDistVal())); - } else { - fts.fill("pfcand_normchi2", 999); - - fts.fill("pfcand_btagEtaRel", 0); - fts.fill("pfcand_btagPtRatio", 0); - fts.fill("pfcand_btagPParRatio", 0); - fts.fill("pfcand_btagSip3dVal", 0); - fts.fill("pfcand_btagSip3dSig", 0); - fts.fill("pfcand_btagJetDistVal", 0); - } - } -} - -void ParticleNetTagInfoProducer::fillSVFeatures(DeepBoostedJetFeatures &fts, const reco::Jet &jet) { - std::vector jetSVs; - for (const auto &sv : *svs_) { - if (reco::deltaR2(sv, jet) < jet_radius_ * jet_radius_) { - jetSVs.push_back(&sv); - } - } - // sort by dxy significance - std::sort(jetSVs.begin(), - jetSVs.end(), - [&](const reco::VertexCompositePtrCandidate *sva, const reco::VertexCompositePtrCandidate *svb) { - return sv_vertex_comparator(*sva, *svb, *pv_); - }); - - // reserve space - for (const auto &name : sv_features_) { - fts.reserve(name, jetSVs.size()); - } - - const float etasign = jet.eta() > 0 ? 1 : -1; - - for (const auto *sv : jetSVs) { - // basic kinematics - fts.fill("sv_mask", 1); - fts.fill("sv_phirel", reco::deltaPhi(*sv, jet)); - fts.fill("sv_etarel", etasign * (sv->eta() - jet.eta())); - fts.fill("sv_abseta", std::abs(sv->eta())); - fts.fill("sv_mass", sv->mass()); - fts.fill("sv_pt_log", catch_infs(std::log(sv->pt()), -99)); - - // sv properties - fts.fill("sv_ntracks", sv->numberOfDaughters()); - fts.fill("sv_normchi2", catch_infs(sv->vertexNormalizedChi2())); - - const auto &dxy = vertexDxy(*sv, *pv_); - fts.fill("sv_dxy", dxy.value()); - fts.fill("sv_dxysig", dxy.significance()); - - const auto &d3d = vertexD3d(*sv, *pv_); - fts.fill("sv_d3d", d3d.value()); - fts.fill("sv_d3dsig", d3d.significance()); - - fts.fill("sv_costhetasvpv", vertexDdotP(*sv, *pv_)); - } -} - -// define this as a plug-in -DEFINE_FWK_MODULE(ParticleNetTagInfoProducer); diff --git a/RecoBTag/MXNet/python/pfParticleNet_cff.py b/RecoBTag/MXNet/python/pfParticleNet_cff.py index 604cdf8dced5e..b97d1fb164a02 100644 --- a/RecoBTag/MXNet/python/pfParticleNet_cff.py +++ b/RecoBTag/MXNet/python/pfParticleNet_cff.py @@ -1,11 +1,15 @@ import FWCore.ParameterSet.Config as cms -from RecoBTag.FeatureTools.pfParticleNetTagInfos_cfi import pfParticleNetTagInfos +from RecoBTag.FeatureTools.pfDeepBoostedJetTagInfos_cfi import pfDeepBoostedJetTagInfos from RecoBTag.MXNet.boostedJetMXNetJetTagsProducer_cfi import boostedJetMXNetJetTagsProducer from RecoBTag.MXNet.Parameters.ParticleNet.V00.pfParticleNetPreprocessParams_cfi import pfParticleNetPreprocessParams, pfMassDecorrelatedParticleNetPreprocessParams from RecoBTag.MXNet.pfParticleNetDiscriminatorsJetTags_cfi import pfParticleNetDiscriminatorsJetTags from RecoBTag.MXNet.pfMassDecorrelatedParticleNetDiscriminatorsJetTags_cfi import pfMassDecorrelatedParticleNetDiscriminatorsJetTags +pfParticleNetTagInfos = pfDeepBoostedJetTagInfos.clone( + use_puppiP4 = False +) + pfParticleNetJetTags = boostedJetMXNetJetTagsProducer.clone( preprocessParams = pfParticleNetPreprocessParams, model_path = 'RecoBTag/Combined/data/ParticleNetAK8/General/V00/ParticleNet-symbol.json',