DeepTauId Class Reference

Inheritance diagram for DeepTauId:

Public Member Functions
	DeepTauId (const edm::ParameterSet &cfg, const deep_tau::DeepTauCache *cache)
void	produce (edm::Event &event, const edm::EventSetup &es) override
Public Member Functions inherited from DeepTauIdBase< DeepTauIdWrapper >
	DeepTauIdBase (const edm::ParameterSet &cfg)
const std::map< BasicDiscriminator, size_t >	matchDiscriminatorIndices (edm::Event const &event, edm::EDGetTokenT< reco::TauDiscriminatorContainer > discriminatorContainerToken, std::vector< BasicDiscriminator > requiredDiscr)
Public Member Functions inherited from DeepTauIdWrapper
	DeepTauIdWrapper (const edm::ParameterSet &cfg)
Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< deep_tau::DeepTauCache > >
	EDProducer ()=default
	EDProducer (const EDProducer &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
static void	globalEndJob (const deep_tau::DeepTauCache *cache_)
static std::unique_ptr< deep_tau::DeepTauCache >	initializeGlobalCache (const edm::ParameterSet &cfg)
Static Public Member Functions inherited from DeepTauIdBase< DeepTauIdWrapper >
static void	fillDescriptionsHelper (edm::ParameterSetDescription &desc)
static const IDOutputCollection &	GetIDOutputs ()

Private Member Functions
void	checkInputs (const tensorflow::Tensor &inputs, const std::string &block_name, int n_inputs, const CellGrid *grid=nullptr) const
template<typename CandidateCastType , typename TauCastType >
void	createConvFeatures (const TauCastType &tau, const size_t tau_index, const edm::RefToBase< reco::BaseTau > tau_ref, const reco::Vertex &pv, double rho, const std::vector< pat::Electron > *electrons, const std::vector< pat::Muon > *muons, const edm::View< reco::Candidate > &pfCands, const CellGrid &grid, TauFunc tau_funcs, bool is_inner)
tensorflow::Tensor	getPartialPredictions (bool is_inner)
tensorflow::Tensor	getPredictions (edm::Event &event, edm::Handle< TauCollection > taus)
template<typename CandidateCastType , typename TauCastType >
void	getPredictionsV2 (TauCollection::const_reference &tau, const size_t tau_index, const edm::RefToBase< reco::BaseTau > tau_ref, const std::vector< pat::Electron > *electrons, const std::vector< pat::Muon > *muons, const edm::View< reco::Candidate > &pfCands, const reco::Vertex &pv, double rho, const edm::EventNumber_t &eventnr, std::vector< tensorflow::Tensor > &pred_vector, TauFunc tau_funcs)
void	saveInputs (const tensorflow::Tensor &inputs, const std::string &block_name, int n_inputs, const CellGrid *grid=nullptr)
void	setCellConvFeatures (tensorflow::Tensor &convTensor, const tensorflow::Tensor &features, unsigned batch_idx, int eta_index, int phi_index)

Private Attributes
const deep_tau::DeepTauCache *	cache_
std::array< std::unique_ptr< tensorflow::Tensor >, 2 >	convTensor_
std::array< std::unique_ptr< tensorflow::Tensor >, 2 >	eGammaTensor_
std::array< std::unique_ptr< tensorflow::Tensor >, 2 >	hadronsTensor_
std::array< std::unique_ptr< tensorflow::Tensor >, 2 >	muonTensor_
std::unique_ptr< tensorflow::Tensor >	tauBlockTensor_
std::array< std::unique_ptr< tensorflow::Tensor >, 2 >	zeroOutputTensor_

Additional Inherited Members
Public Types inherited from DeepTauIdBase< DeepTauIdWrapper >
using	BasicDiscriminator = deep_tau::BasicDiscriminator
using	CandidateCollection = edm::View< reco::Candidate >
using	Cutter = tau::TauWPThreshold
using	CutterPtr = std::unique_ptr< Cutter >
using	ElectronCollection = pat::ElectronCollection
using	IDOutputCollection = std::map< std::string, IDOutput >
using	LorentzVectorXYZ = ROOT::Math::LorentzVector< ROOT::Math::PxPyPzE4D< double > >
using	MuonCollection = pat::MuonCollection
using	TauCollection = edm::View< reco::BaseTau >
using	TauDiscriminator = reco::TauDiscriminatorContainer
using	TauRef = edm::Ref< TauCollection >
using	TauRefProd = edm::RefProd< TauCollection >
using	WPList = std::vector< CutterPtr >
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< deep_tau::DeepTauCache > >
using	CacheTypes = CacheContexts< T... >
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T... >
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::RunSummaryCache
Public Attributes inherited from DeepTauIdBase< DeepTauIdWrapper >
uint8_t	andPrediscriminants_
std::vector< TauDiscInfo< pat::PATTauDiscriminator > >	patPrediscriminants_
std::vector< TauDiscInfo< reco::PFTauDiscriminator > >	recoPrediscriminants_
Static Public Attributes inherited from DeepTauIdBase< DeepTauIdWrapper >
static constexpr float	default_value
Protected Member Functions inherited from DeepTauIdBase< DeepTauIdWrapper >
void	createEgammaBlockInputs (unsigned idx, const TauCastType &tau, const size_t tau_index, const edm::RefToBase< reco::BaseTau > tau_ref, const reco::Vertex &pv, double rho, const std::vector< pat::Electron > *electrons, const edm::View< reco::Candidate > &pfCands, const Cell &cell_map, TauFunc tau_funcs, bool is_inner, EgammaBlockType &egammaBlockInputs)
void	createHadronsBlockInputs (unsigned idx, const TauCastType &tau, const size_t tau_index, const edm::RefToBase< reco::BaseTau > tau_ref, const reco::Vertex &pv, double rho, const edm::View< reco::Candidate > &pfCands, const Cell &cell_map, TauFunc tau_funcs, bool is_inner, HadronBlockType &hadronBlockInputs)
void	createMuonBlockInputs (unsigned idx, const TauCastType &tau, const size_t tau_index, const edm::RefToBase< reco::BaseTau > tau_ref, const reco::Vertex &pv, double rho, const std::vector< pat::Muon > *muons, const edm::View< reco::Candidate > &pfCands, const Cell &cell_map, TauFunc tau_funcs, bool is_inner, MuonBlockType &muonBlockInputs)
void	createOutputs (edm::Event &event, const PredType &pred, edm::Handle< TauCollection > taus)
void	createTauBlockInputs (const TauCastType &tau, const size_t &tau_index, const edm::RefToBase< reco::BaseTau > tau_ref, const reco::Vertex &pv, double rho, TauFunc tau_funcs, TauBlockType &tauBlockInputs)
void	fillGrids (const TauCastType &tau, const Collection &objects, CellGrid &inner_grid, CellGrid &outer_grid)
void	loadPrediscriminants (edm::Event const &event, edm::Handle< TauCollection > const &taus)
Static Protected Member Functions inherited from DeepTauIdBase< DeepTauIdWrapper >
static void	calculateElectronClusterVars (const pat::Electron *ele, float &elecEe, float &elecEgamma)
static bool	calculateElectronClusterVarsV2 (const pat::Electron &ele, float &cc_ele_energy, float &cc_gamma_energy, int &cc_n_gamma)
static bool	calculateGottfriedJacksonAngleDifference (const TauCastType &tau, const size_t tau_index, double &gj_diff, TauFunc tau_funcs)
static float	calculateGottfriedJacksonAngleDifference (const TauCastType &tau, const size_t tau_index, TauFunc tau_funcs)
static const pat::Electron *	findMatchedElectron (const TauCastType &tau, const std::vector< pat::Electron > *electrons, double deltaR)
static double	getInnerSignalConeRadius (double pt)
static float	getValue (T value)
static float	getValueLinear (T value, float min_value, float max_value, bool positive)
static float	getValueNorm (T value, float mean, float sigma, float n_sigmas_max=5)
static bool	isAbove (double value, double min)
static bool	isInEcalCrack (double eta)
static void	processIsolationPFComponents (const TauCastType &tau, const CandidateCollection &candidates, LorentzVectorXYZ &p4, float &pt, float &d_eta, float &d_phi, float &m, float &n)
static void	processSignalPFComponents (const TauCastType &tau, const CandidateCollection &candidates, LorentzVectorXYZ &p4_inner, LorentzVectorXYZ &p4_outer, float &pt_inner, float &dEta_inner, float &dPhi_inner, float &m_inner, float &pt_outer, float &dEta_outer, float &dPhi_outer, float &m_outer, float &n_inner, float &n_outer)
Protected Attributes inherited from DeepTauIdBase< DeepTauIdWrapper >
std::map< BasicDiscriminator, size_t >	basicDiscrdR03IndexMap_
std::map< BasicDiscriminator, size_t >	basicDiscrIndexMap_
edm::EDGetTokenT< reco::TauDiscriminatorContainer >	basicTauDiscriminators_inputToken_
edm::EDGetTokenT< reco::TauDiscriminatorContainer >	basicTauDiscriminatorsdR03_inputToken_
const int	debug_level
const bool	disable_CellIndex_workaround_
const bool	disable_dxy_pca_
const bool	disable_hcalFraction_workaround_
bool	discrIndicesMapped_
edm::EDGetTokenT< std::vector< pat::Electron > >	electrons_token_
int	file_counter_
IDOutputCollection	idoutputs_
std::string	input_layer_
bool	is_first_block_
const bool	is_online_
std::ofstream *	json_file_
edm::EDGetTokenT< std::vector< pat::Muon > >	muons_token_
std::string	output_layer_
edm::EDGetTokenT< CandidateCollection >	pfcandToken_
edm::EDGetTokenT< edm::AssociationVector< reco::PFTauRefProd, std::vector< reco::PFTauTransverseImpactParameterRef > > >	pfTauTransverseImpactParameters_token_
const std::vector< BasicDiscriminator >	requiredBasicDiscriminators_
const std::vector< BasicDiscriminator >	requiredBasicDiscriminatorsdR03_
edm::EDGetTokenT< double >	rho_token_
const bool	save_inputs_
const std::map< std::pair< deep_tau::Scaling::FeatureT, bool >, deep_tau::Scaling::ScalingParams > *	scalingParamsMap_
const std::map< BasicDiscriminator, std::string >	stringFromDiscriminator_
const unsigned	sub_version_
std::vector< int >	tauInputs_indices_
edm::EDGetTokenT< TauCollection >	tausToken_
const unsigned	version_
edm::EDGetTokenT< reco::VertexCollection >	vtxToken_
std::map< std::string, WPList >	workingPoints_
const unsigned	year_
Static Protected Attributes inherited from DeepTauIdBase< DeepTauIdWrapper >
static constexpr float	pi

Detailed Description

Definition at line 78 of file DeepTauId.cc.

Constructor & Destructor Documentation

DeepTauId()

DeepTauId::DeepTauId ( const edm::ParameterSet &  cfg, const deep_tau::DeepTauCache *  cache  )

inlineexplicit

Definition at line 89 of file DeepTauId.cc.

References convTensor_, eGammaTensor_, getPartialPredictions(), hadronsTensor_, muonTensor_, dqmiodumpmetadata::n, setCellConvFeatures(), findQualityFiles::size, DeepTauIdBase< DeepTauIdWrapper >::sub_version_, tauBlockTensor_, DeepTauIdBase< DeepTauIdWrapper >::version_, and zeroOutputTensor_.

      : DeepTauIdBase<DeepTauIdWrapper>(cfg), cache_(cache) {
    if (version_ == 2) {
      using namespace dnn_inputs_v2;
      if (sub_version_ == 1) {
        tauBlockTensor_ = std::make_unique<tensorflow::Tensor>(
            tensorflow::DT_FLOAT, tensorflow::TensorShape{1, TauBlockInputs::NumberOfInputs});
      } else if (sub_version_ == 5) {
        tauBlockTensor_ = std::make_unique<tensorflow::Tensor>(
            tensorflow::DT_FLOAT,
            tensorflow::TensorShape{1,
                                    static_cast<int>(TauBlockInputs::NumberOfInputs) -
                                        static_cast<int>(TauBlockInputs::varsToDrop.size())});
      }

      for (size_t n = 0; n < 2; ++n) {
        const bool is_inner = n == 0;
        const auto n_cells = is_inner ? number_of_inner_cell : number_of_outer_cell;
        eGammaTensor_[is_inner] = std::make_unique<tensorflow::Tensor>(
            tensorflow::DT_FLOAT, tensorflow::TensorShape{1, 1, 1, EgammaBlockInputs::NumberOfInputs});
        muonTensor_[is_inner] = std::make_unique<tensorflow::Tensor>(
            tensorflow::DT_FLOAT, tensorflow::TensorShape{1, 1, 1, MuonBlockInputs::NumberOfInputs});
        hadronsTensor_[is_inner] = std::make_unique<tensorflow::Tensor>(
            tensorflow::DT_FLOAT, tensorflow::TensorShape{1, 1, 1, HadronBlockInputs::NumberOfInputs});
        convTensor_[is_inner] = std::make_unique<tensorflow::Tensor>(
            tensorflow::DT_FLOAT, tensorflow::TensorShape{1, n_cells, n_cells, number_of_conv_features});
        zeroOutputTensor_[is_inner] = std::make_unique<tensorflow::Tensor>(
            tensorflow::DT_FLOAT, tensorflow::TensorShape{1, 1, 1, number_of_conv_features});

        eGammaTensor_[is_inner]->flat<float>().setZero();
        muonTensor_[is_inner]->flat<float>().setZero();
        hadronsTensor_[is_inner]->flat<float>().setZero();

        setCellConvFeatures(*zeroOutputTensor_[is_inner], getPartialPredictions(is_inner), 0, 0, 0);
      }
    }
  }

Member Function Documentation

checkInputs()

void DeepTauId::checkInputs ( const tensorflow::Tensor &  inputs, const std::string &  block_name, int  n_inputs, const CellGrid *  grid = nullptr  ) const

inlineprivate

Definition at line 169 of file DeepTauId.cc.

References cms::cuda::assert(), gather_cfg::cout, DeepTauIdBase< DeepTauIdWrapper >::debug_level, PVValHelper::eta, Exception, alignBH_cfg::fixed, nano_mu_digi_cff::float, getRunAppsInfo::grid, input, PixelMapPlotter::inputs, edm::isNotFinite(), and phi.

Referenced by getPredictionsV2().

                                                                {
    if (debug_level >= 1) {
      std::cout << "<checkInputs>: block_name = " << block_name << std::endl;
      if (block_name == "input_tau") {
        for (int input_index = 0; input_index < n_inputs; ++input_index) {
          float input = inputs.matrix<float>()(0, input_index);
          if (edm::isNotFinite(input)) {
            throw cms::Exception("DeepTauId")
                << "in the " << block_name
                << ", input is not finite, i.e. infinite or NaN, for input_index = " << input_index;
          }
          if (debug_level >= 2) {
            std::cout << block_name << "[var = " << input_index << "] = " << std::setprecision(5) << std::fixed << input
                      << std::endl;
          }
        }
      } else {
        assert(grid);
        int n_eta, n_phi;
        if (block_name.find("input_inner") != std::string::npos) {
          n_eta = 5;
          n_phi = 5;
        } else if (block_name.find("input_outer") != std::string::npos) {
          n_eta = 10;
          n_phi = 10;
        } else
          assert(0);
        int eta_phi_index = 0;
        for (int eta = -n_eta; eta <= n_eta; ++eta) {
          for (int phi = -n_phi; phi <= n_phi; ++phi) {
            const CellIndex cell_index{eta, phi};
            const auto cell_iter = grid->find(cell_index);
            if (cell_iter != grid->end()) {
              for (int input_index = 0; input_index < n_inputs; ++input_index) {
                float input = inputs.tensor<float, 4>()(eta_phi_index, 0, 0, input_index);
                if (edm::isNotFinite(input)) {
                  throw cms::Exception("DeepTauId")
                      << "in the " << block_name << ", input is not finite, i.e. infinite or NaN, for eta = " << eta
                      << ", phi = " << phi << ", input_index = " << input_index;
                }
                if (debug_level >= 2) {
                  std::cout << block_name << "[eta = " << eta << "][phi = " << phi << "][var = " << input_index
                            << "] = " << std::setprecision(5) << std::fixed << input << std::endl;
                }
              }
              eta_phi_index += 1;
            }
          }
        }
      }
    }
  }

createConvFeatures()

template<typename CandidateCastType , typename TauCastType >

void DeepTauId::createConvFeatures ( const TauCastType &  tau, const size_t  tau_index, const edm::RefToBase< reco::BaseTau >  tau_ref, const reco::Vertex &  pv, double  rho, const std::vector< pat::Electron > *  electrons, const std::vector< pat::Muon > *  muons, const edm::View< reco::Candidate > &  pfCands, const CellGrid &  grid, TauFunc  tau_funcs, bool  is_inner  )

inlineprivate

Definition at line 538 of file DeepTauId.cc.

References convTensor_, gather_cfg::cout, DeepTauIdBase< DeepTauIdWrapper >::debug_level, eGammaTensor_, pwdgSkimBPark_cfi::electrons, PVValHelper::eta, getPartialPredictions(), getRunAppsInfo::grid, hadronsTensor_, heavyIonCSV_trainingSettings::idx, createfilelist::int, DiMuonV_cfg::muons, muonTensor_, phi, MetAnalyzer::pv(), rho, setCellConvFeatures(), metsig::tau, and zeroOutputTensor_.

                                         {
    if (debug_level >= 2) {
      std::cout << "<DeepTauId::createConvFeatures (is_inner = " << is_inner << ")>:" << std::endl;
      std::cout << "number of valid cells = " << grid.num_valid_cells() << std::endl;
    }

    const size_t n_valid_cells = grid.num_valid_cells();
    tensorflow::Tensor predTensor;
    tensorflow::Tensor& convTensor = *convTensor_.at(is_inner);

    //check if at least one input is there to
    //avoid calling TF with empty grid #TODO understand why the grid is empty
    if (n_valid_cells > 0) {
      eGammaTensor_[is_inner] = std::make_unique<tensorflow::Tensor>(
          tensorflow::DT_FLOAT,
          tensorflow::TensorShape{
              (long long int)grid.num_valid_cells(), 1, 1, dnn_inputs_v2::EgammaBlockInputs::NumberOfInputs});
      muonTensor_[is_inner] = std::make_unique<tensorflow::Tensor>(
          tensorflow::DT_FLOAT,
          tensorflow::TensorShape{
              (long long int)grid.num_valid_cells(), 1, 1, dnn_inputs_v2::MuonBlockInputs::NumberOfInputs});
      hadronsTensor_[is_inner] = std::make_unique<tensorflow::Tensor>(
          tensorflow::DT_FLOAT,
          tensorflow::TensorShape{
              (long long int)grid.num_valid_cells(), 1, 1, dnn_inputs_v2::HadronBlockInputs::NumberOfInputs});

      eGammaTensor_[is_inner]->flat<float>().setZero();
      muonTensor_[is_inner]->flat<float>().setZero();
      hadronsTensor_[is_inner]->flat<float>().setZero();

      unsigned idx = 0;
      for (int eta = -grid.maxEtaIndex(); eta <= grid.maxEtaIndex(); ++eta) {
        for (int phi = -grid.maxPhiIndex(); phi <= grid.maxPhiIndex(); ++phi) {
          if (debug_level >= 2) {
            std::cout << "processing ( eta = " << eta << ", phi = " << phi << " )" << std::endl;
          }
          const CellIndex cell_index{eta, phi};
          const auto cell_iter = grid.find(cell_index);
          if (cell_iter != grid.end()) {
            if (debug_level >= 2) {
              std::cout << " creating inputs for ( eta = " << eta << ", phi = " << phi << " ): idx = " << idx
                        << std::endl;
            }
            const Cell& cell = cell_iter->second;
            createEgammaBlockInputs<CandidateCastType>(idx,
                                                       tau,
                                                       tau_index,
                                                       tau_ref,
                                                       pv,
                                                       rho,
                                                       electrons,
                                                       pfCands,
                                                       cell,
                                                       tau_funcs,
                                                       is_inner,
                                                       *eGammaTensor_[is_inner]);
            createMuonBlockInputs<CandidateCastType>(
                idx, tau, tau_index, tau_ref, pv, rho, muons, pfCands, cell, tau_funcs, is_inner, *muonTensor_[is_inner]);
            createHadronsBlockInputs<CandidateCastType>(
                idx, tau, tau_index, tau_ref, pv, rho, pfCands, cell, tau_funcs, is_inner, *hadronsTensor_[is_inner]);
            idx += 1;
          } else {
            if (debug_level >= 2) {
              std::cout << " skipping creation of inputs, because ( eta = " << eta << ", phi = " << phi
                        << " ) is not in the grid !!" << std::endl;
            }
          }
        }
      }
      // Calling TF prediction only if n_valid_cells > 0
      predTensor = getPartialPredictions(is_inner);
    }

    unsigned idx = 0;
    for (int eta = -grid.maxEtaIndex(); eta <= grid.maxEtaIndex(); ++eta) {
      for (int phi = -grid.maxPhiIndex(); phi <= grid.maxPhiIndex(); ++phi) {
        const CellIndex cell_index{eta, phi};
        const int eta_index = grid.getEtaTensorIndex(cell_index);
        const int phi_index = grid.getPhiTensorIndex(cell_index);

        const auto cell_iter = grid.find(cell_index);
        if (cell_iter != grid.end()) {
          setCellConvFeatures(convTensor, predTensor, idx, eta_index, phi_index);
          idx += 1;
        } else {
          setCellConvFeatures(convTensor, *zeroOutputTensor_[is_inner], 0, eta_index, phi_index);
        }
      }
    }
  }

fillDescriptions()

static void DeepTauId::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

inlinestatic

Definition at line 80 of file DeepTauId.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, and DeepTauIdBase< DeepTauIdWrapper >::fillDescriptionsHelper().

                                                                           {
    edm::ParameterSetDescription desc;
    fillDescriptionsHelper(desc);
    desc.add<std::vector<std::string>>("graph_file",
                                       {"RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2017v2p6_e6.pb"});
    descriptions.add("DeepTau", desc);
  }

getPartialPredictions()

tensorflow::Tensor DeepTauId::getPartialPredictions ( bool  is_inner )

inlineprivate

Definition at line 512 of file DeepTauId.cc.

References cache_, eGammaTensor_, deep_tau::DeepTauCache::getSession(), hadronsTensor_, muonTensor_, and tensorflow::run().

Referenced by createConvFeatures(), and DeepTauId().

                                                        {
    std::vector<tensorflow::Tensor> pred_vector;
    if (is_inner) {
      tensorflow::run(&(cache_->getSession("inner")),
                      {
                          {"input_inner_egamma", *eGammaTensor_.at(is_inner)},
                          {"input_inner_muon", *muonTensor_.at(is_inner)},
                          {"input_inner_hadrons", *hadronsTensor_.at(is_inner)},
                      },
                      {"inner_all_dropout_4/Identity"},
                      &pred_vector);
    } else {
      tensorflow::run(&(cache_->getSession("outer")),
                      {
                          {"input_outer_egamma", *eGammaTensor_.at(is_inner)},
                          {"input_outer_muon", *muonTensor_.at(is_inner)},
                          {"input_outer_hadrons", *hadronsTensor_.at(is_inner)},
                      },
                      {"outer_all_dropout_4/Identity"},
                      &pred_vector);
    }

    return pred_vector.at(0);
  }

getPredictions()

tensorflow::Tensor DeepTauId::getPredictions ( edm::Event &  event, edm::Handle< TauCollection >  taus  )

inlineprivate

Definition at line 286 of file DeepTauId.cc.

References DeepTauIdBase< DeepTauIdWrapper >::andPrediscriminants_, DeepTauIdBase< DeepTauIdWrapper >::basicDiscrdR03IndexMap_, DeepTauIdBase< DeepTauIdWrapper >::basicDiscrIndexMap_, HLT_2024v14_cff::basicTauDiscriminators, DeepTauIdBase< DeepTauIdWrapper >::basicTauDiscriminators_inputToken_, HLT_2024v14_cff::basicTauDiscriminatorsdR03, DeepTauIdBase< DeepTauIdWrapper >::basicTauDiscriminatorsdR03_inputToken_, DeepTauIdBase< DeepTauIdWrapper >::discrIndicesMapped_, DeepTauIdBase< DeepTauIdWrapper >::electrons_token_, Exception, f, DeepTauIdBase< DeepTauIdWrapper >::is_online_, dqmdumpme::k, DeepTauIdBase< DeepTauIdWrapper >::matchDiscriminatorIndices(), DeepTauIdBase< DeepTauIdWrapper >::muons_token_, deep_tau::NumberOfOutputs, DeepTauIdBase< DeepTauIdWrapper >::patPrediscriminants_, DeepTauIdBase< DeepTauIdWrapper >::pfcandToken_, HLT_2024v14_cff::pfTauTransverseImpactParameters, DeepTauIdBase< DeepTauIdWrapper >::pfTauTransverseImpactParameters_token_, DeepTauIdBase< DeepTauIdWrapper >::recoPrediscriminants_, DeepTauIdBase< DeepTauIdWrapper >::requiredBasicDiscriminators_, DeepTauIdBase< DeepTauIdWrapper >::requiredBasicDiscriminatorsdR03_, rho, DeepTauIdBase< DeepTauIdWrapper >::rho_token_, Tau3MuMonitor_cff::taus, DeepTauIdBase< DeepTauIdWrapper >::version_, AlignmentTracksFromVertexSelector_cfi::vertices, and DeepTauIdBase< DeepTauIdWrapper >::vtxToken_.

Referenced by produce().

                                                                                  {
    // Empty dummy vectors
    const std::vector<pat::Electron> electron_collection_default;
    const std::vector<pat::Muon> muon_collection_default;
    const reco::TauDiscriminatorContainer basicTauDiscriminators_default;
    const reco::TauDiscriminatorContainer basicTauDiscriminatorsdR03_default;
    const edm::AssociationVector<reco::PFTauRefProd, std::vector<reco::PFTauTransverseImpactParameterRef>>
        pfTauTransverseImpactParameters_default;

    const std::vector<pat::Electron>* electron_collection;
    const std::vector<pat::Muon>* muon_collection;
    const reco::TauDiscriminatorContainer* basicTauDiscriminators;
    const reco::TauDiscriminatorContainer* basicTauDiscriminatorsdR03;
    const edm::AssociationVector<reco::PFTauRefProd, std::vector<reco::PFTauTransverseImpactParameterRef>>*
        pfTauTransverseImpactParameters;

    if (!is_online_) {
      electron_collection = &event.get(electrons_token_);
      muon_collection = &event.get(muons_token_);
      pfTauTransverseImpactParameters = &pfTauTransverseImpactParameters_default;
      basicTauDiscriminators = &basicTauDiscriminators_default;
      basicTauDiscriminatorsdR03 = &basicTauDiscriminatorsdR03_default;
    } else {
      electron_collection = &electron_collection_default;
      muon_collection = &muon_collection_default;
      pfTauTransverseImpactParameters = &event.get(pfTauTransverseImpactParameters_token_);
      basicTauDiscriminators = &event.get(basicTauDiscriminators_inputToken_);
      basicTauDiscriminatorsdR03 = &event.get(basicTauDiscriminatorsdR03_inputToken_);

      // Get indices for discriminators
      if (!discrIndicesMapped_) {
        basicDiscrIndexMap_ =
            matchDiscriminatorIndices(event, basicTauDiscriminators_inputToken_, requiredBasicDiscriminators_);
        basicDiscrdR03IndexMap_ =
            matchDiscriminatorIndices(event, basicTauDiscriminatorsdR03_inputToken_, requiredBasicDiscriminatorsdR03_);
        discrIndicesMapped_ = true;
      }
    }

    TauFunc tauIDs = {basicTauDiscriminators,
                      basicTauDiscriminatorsdR03,
                      pfTauTransverseImpactParameters,
                      basicDiscrIndexMap_,
                      basicDiscrdR03IndexMap_};

    edm::Handle<edm::View<reco::Candidate>> pfCands;
    event.getByToken(pfcandToken_, pfCands);

    edm::Handle<reco::VertexCollection> vertices;
    event.getByToken(vtxToken_, vertices);

    edm::Handle<double> rho;
    event.getByToken(rho_token_, rho);

    auto const& eventnr = event.id().event();

    tensorflow::Tensor predictions(tensorflow::DT_FLOAT, {static_cast<int>(taus->size()), deep_tau::NumberOfOutputs});

    for (size_t tau_index = 0; tau_index < taus->size(); ++tau_index) {
      const edm::RefToBase<reco::BaseTau> tauRef = taus->refAt(tau_index);

      std::vector<tensorflow::Tensor> pred_vector;

      bool passesPrediscriminants;
      if (is_online_) {
        passesPrediscriminants = tauIDs.passPrediscriminants<std::vector<TauDiscInfo<reco::PFTauDiscriminator>>>(
            recoPrediscriminants_, andPrediscriminants_, tauRef);
      } else {
        passesPrediscriminants = tauIDs.passPrediscriminants<std::vector<TauDiscInfo<pat::PATTauDiscriminator>>>(
            patPrediscriminants_, andPrediscriminants_, tauRef);
      }

      if (passesPrediscriminants) {
        if (version_ == 2) {
          if (is_online_) {
            getPredictionsV2<reco::PFCandidate, reco::PFTau>(taus->at(tau_index),
                                                             tau_index,
                                                             tauRef,
                                                             electron_collection,
                                                             muon_collection,
                                                             *pfCands,
                                                             vertices->at(0),
                                                             *rho,
                                                             eventnr,
                                                             pred_vector,
                                                             tauIDs);
          } else
            getPredictionsV2<pat::PackedCandidate, pat::Tau>(taus->at(tau_index),
                                                             tau_index,
                                                             tauRef,
                                                             electron_collection,
                                                             muon_collection,
                                                             *pfCands,
                                                             vertices->at(0),
                                                             *rho,
                                                             eventnr,
                                                             pred_vector,
                                                             tauIDs);
        } else {
          throw cms::Exception("DeepTauId") << "version " << version_ << " is not supported.";
        }

        for (int k = 0; k < deep_tau::NumberOfOutputs; ++k) {
          const float pred = pred_vector[0].flat<float>()(k);
          if (!(pred >= 0 && pred <= 1))
            throw cms::Exception("DeepTauId")
                << "invalid prediction = " << pred << " for tau_index = " << tau_index << ", pred_index = " << k;
          predictions.matrix<float>()(tau_index, k) = pred;
        }
      } else {
        // This else statement was added as a part of the DeepTau@HLT development. It does not affect the current state
        // of offline DeepTauId code as there the preselection is not used (it was added in the DeepTau@HLT). It returns
        // default values for deepTau score if the preselection failed. Before this statement the values given for this tau
        // were random. k == 2 corresponds to the tau score and all other k values to e, mu and jets. By defining in this way
        // the final score is -1.
        for (int k = 0; k < deep_tau::NumberOfOutputs; ++k) {
          predictions.matrix<float>()(tau_index, k) = (k == 2) ? -1.f : 2.f;
        }
      }
    }
    return predictions;
  }

getPredictionsV2()

template<typename CandidateCastType , typename TauCastType >

void DeepTauId::getPredictionsV2 ( TauCollection::const_reference &  tau, const size_t  tau_index, const edm::RefToBase< reco::BaseTau >  tau_ref, const std::vector< pat::Electron > *  electrons, const std::vector< pat::Muon > *  muons, const edm::View< reco::Candidate > &  pfCands, const reco::Vertex &  pv, double  rho, const edm::EventNumber_t &  eventnr, std::vector< tensorflow::Tensor > &  pred_vector, TauFunc  tau_funcs  )

inlineprivate

Definition at line 410 of file DeepTauId.cc.

References cms::cuda::assert(), cache_, checkInputs(), convTensor_, gather_cfg::cout, DeepTauIdBase< DeepTauIdWrapper >::debug_level, DeepTauIdBase< DeepTauIdWrapper >::disable_CellIndex_workaround_, eGammaTensor_, pwdgSkimBPark_cfi::electrons, DeepTauIdBase< DeepTauIdWrapper >::file_counter_, DeepTauIdBase< DeepTauIdWrapper >::fillGrids(), deep_tau::DeepTauCache::getSession(), hadronsTensor_, heavyIonCSV_trainingSettings::idx, DeepTauIdBase< DeepTauIdWrapper >::is_first_block_, DeepTauIdBase< DeepTauIdWrapper >::json_file_, label, DiMuonV_cfg::muons, muonTensor_, deep_tau::NumberOfOutputs, rho, tensorflow::run(), DeepTauIdBase< DeepTauIdWrapper >::save_inputs_, saveInputs(), AlCaHLTBitMon_QueryRunRegistry::string, metsig::tau, tauBlockTensor_, and to_string().

                                           {
    using namespace dnn_inputs_v2;
    if (debug_level >= 2) {
      std::cout << "<DeepTauId::getPredictionsV2 (moduleLabel = " << moduleDescription().moduleLabel()
                << ")>:" << std::endl;
      std::cout << " tau: pT = " << tau.pt() << ", eta = " << tau.eta() << ", phi = " << tau.phi()
                << ", eventnr = " << eventnr << std::endl;
    }
    CellGrid inner_grid(number_of_inner_cell, number_of_inner_cell, 0.02, 0.02, disable_CellIndex_workaround_);
    CellGrid outer_grid(number_of_outer_cell, number_of_outer_cell, 0.05, 0.05, disable_CellIndex_workaround_);
    fillGrids(dynamic_cast<const TauCastType&>(tau), *electrons, inner_grid, outer_grid);
    fillGrids(dynamic_cast<const TauCastType&>(tau), *muons, inner_grid, outer_grid);
    fillGrids(dynamic_cast<const TauCastType&>(tau), pfCands, inner_grid, outer_grid);

    tauBlockTensor_->flat<float>().setZero();
    createTauBlockInputs<CandidateCastType>(
        dynamic_cast<const TauCastType&>(tau), tau_index, tau_ref, pv, rho, tau_funcs, *tauBlockTensor_);
    checkInputs(*tauBlockTensor_, "input_tau", static_cast<int>(tauBlockTensor_->shape().dim_size(1)));
    createConvFeatures<CandidateCastType>(dynamic_cast<const TauCastType&>(tau),
                                          tau_index,
                                          tau_ref,
                                          pv,
                                          rho,
                                          electrons,
                                          muons,
                                          pfCands,
                                          inner_grid,
                                          tau_funcs,
                                          true);
    checkInputs(*eGammaTensor_[true], "input_inner_egamma", EgammaBlockInputs::NumberOfInputs, &inner_grid);
    checkInputs(*muonTensor_[true], "input_inner_muon", MuonBlockInputs::NumberOfInputs, &inner_grid);
    checkInputs(*hadronsTensor_[true], "input_inner_hadrons", HadronBlockInputs::NumberOfInputs, &inner_grid);
    createConvFeatures<CandidateCastType>(dynamic_cast<const TauCastType&>(tau),
                                          tau_index,
                                          tau_ref,
                                          pv,
                                          rho,
                                          electrons,
                                          muons,
                                          pfCands,
                                          outer_grid,
                                          tau_funcs,
                                          false);
    checkInputs(*eGammaTensor_[false], "input_outer_egamma", EgammaBlockInputs::NumberOfInputs, &outer_grid);
    checkInputs(*muonTensor_[false], "input_outer_muon", MuonBlockInputs::NumberOfInputs, &outer_grid);
    checkInputs(*hadronsTensor_[false], "input_outer_hadrons", HadronBlockInputs::NumberOfInputs, &outer_grid);

    if (save_inputs_) {
      std::string json_file_name = "DeepTauId_" + std::to_string(eventnr) + "_" + std::to_string(tau_index) + ".json";
      json_file_ = new std::ofstream(json_file_name.data());
      is_first_block_ = true;
      (*json_file_) << "{";
      saveInputs(*tauBlockTensor_, "input_tau", static_cast<int>(tauBlockTensor_->shape().dim_size(1)));
      saveInputs(*eGammaTensor_[true], "input_inner_egamma", EgammaBlockInputs::NumberOfInputs, &inner_grid);
      saveInputs(*muonTensor_[true], "input_inner_muon", MuonBlockInputs::NumberOfInputs, &inner_grid);
      saveInputs(*hadronsTensor_[true], "input_inner_hadrons", HadronBlockInputs::NumberOfInputs, &inner_grid);
      saveInputs(*eGammaTensor_[false], "input_outer_egamma", EgammaBlockInputs::NumberOfInputs, &outer_grid);
      saveInputs(*muonTensor_[false], "input_outer_muon", MuonBlockInputs::NumberOfInputs, &outer_grid);
      saveInputs(*hadronsTensor_[false], "input_outer_hadrons", HadronBlockInputs::NumberOfInputs, &outer_grid);
      (*json_file_) << "}";
      delete json_file_;
      ++file_counter_;
    }

    tensorflow::run(&(cache_->getSession("core")),
                    {{"input_tau", *tauBlockTensor_},
                     {"input_inner", *convTensor_.at(true)},
                     {"input_outer", *convTensor_.at(false)}},
                    {"main_output/Softmax"},
                    &pred_vector);
    if (debug_level >= 1) {
      std::cout << "output = { ";
      for (int idx = 0; idx < deep_tau::NumberOfOutputs; ++idx) {
        if (idx > 0)
          std::cout << ", ";
        std::string label;
        if (idx == 0)
          label = "e";
        else if (idx == 1)
          label = "mu";
        else if (idx == 2)
          label = "tau";
        else if (idx == 3)
          label = "jet";
        else
          assert(0);
        std::cout << label << " = " << pred_vector[0].flat<float>()(idx);
      }
      std::cout << " }" << std::endl;
    }
  }

globalEndJob()

static void DeepTauId::globalEndJob ( const deep_tau::DeepTauCache *  cache_ )

inlinestatic

Definition at line 166 of file DeepTauId.cc.

{}

initializeGlobalCache()

static std::unique_ptr<deep_tau::DeepTauCache> DeepTauId::initializeGlobalCache ( const edm::ParameterSet &  cfg )

inlinestatic

Definition at line 144 of file DeepTauId.cc.

References looper::cfg, mps_splice::entry, edm::FileInPath::fullPath(), HLT_2024v14_cff::graph_file, HLT_2024v14_cff::mem_mapped, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                               {
    const auto graph_name_vector = cfg.getParameter<std::vector<std::string>>("graph_file");
    std::map<std::string, std::string> graph_names;
    for (const auto& entry : graph_name_vector) {
      const size_t sep_pos = entry.find(':');
      std::string entry_name, graph_file;
      if (sep_pos != std::string::npos) {
        entry_name = entry.substr(0, sep_pos);
        graph_file = entry.substr(sep_pos + 1);
      } else {
        entry_name = "";
        graph_file = entry;
      }
      graph_file = edm::FileInPath(graph_file).fullPath();
      if (graph_names.count(entry_name))
        throw cms::Exception("DeepTauCache") << "Duplicated graph entries";
      graph_names[entry_name] = graph_file;
    }
    bool mem_mapped = cfg.getParameter<bool>("mem_mapped");
    return std::make_unique<deep_tau::DeepTauCache>(graph_names, mem_mapped);
  }

produce()

void DeepTauId::produce ( edm::Event &  event, const edm::EventSetup &  es  )

inlineoverride

Definition at line 127 of file DeepTauId.cc.

References DeepTauIdBase< DeepTauIdWrapper >::createOutputs(), getPredictions(), DeepTauIdBase< DeepTauIdWrapper >::loadPrediscriminants(), deep_tau::NumberOfOutputs, Tau3MuMonitor_cff::taus, and DeepTauIdBase< DeepTauIdWrapper >::tausToken_.

                                                                  {
    edm::Handle<TauCollection> taus;
    event.getByToken(tausToken_, taus);

    // store empty output collection(s) if tau collection is empty
    if (taus->empty()) {
      const tensorflow::Tensor emptyPrediction(tensorflow::DT_FLOAT, {0, deep_tau::NumberOfOutputs});
      createOutputs(event, emptyPrediction, taus);
      return;
    }

    loadPrediscriminants(event, taus);

    const tensorflow::Tensor& pred = getPredictions(event, taus);
    createOutputs(event, pred, taus);
  }

saveInputs()

void DeepTauId::saveInputs ( const tensorflow::Tensor &  inputs, const std::string &  block_name, int  n_inputs, const CellGrid *  grid = nullptr  )

inlineprivate

Definition at line 225 of file DeepTauId.cc.

References cms::cuda::assert(), gather_cfg::cout, DeepTauIdBase< DeepTauIdWrapper >::debug_level, PVValHelper::eta, nano_mu_digi_cff::float, getRunAppsInfo::grid, input, PixelMapPlotter::inputs, DeepTauIdBase< DeepTauIdWrapper >::is_first_block_, and phi.

Referenced by getPredictionsV2().

                                                         {
    if (debug_level >= 1) {
      std::cout << "<saveInputs>: block_name = " << block_name << std::endl;
    }
    if (!is_first_block_)
      (*json_file_) << ", ";
    (*json_file_) << "\"" << block_name << "\": [";
    if (block_name == "input_tau") {
      for (int input_index = 0; input_index < n_inputs; ++input_index) {
        float input = inputs.matrix<float>()(0, input_index);
        if (input_index != 0)
          (*json_file_) << ", ";
        (*json_file_) << input;
      }
    } else {
      assert(grid);
      int n_eta, n_phi;
      if (block_name.find("input_inner") != std::string::npos) {
        n_eta = 5;
        n_phi = 5;
      } else if (block_name.find("input_outer") != std::string::npos) {
        n_eta = 10;
        n_phi = 10;
      } else
        assert(0);
      int eta_phi_index = 0;
      for (int eta = -n_eta; eta <= n_eta; ++eta) {
        if (eta != -n_eta)
          (*json_file_) << ", ";
        (*json_file_) << "[";
        for (int phi = -n_phi; phi <= n_phi; ++phi) {
          if (phi != -n_phi)
            (*json_file_) << ", ";
          (*json_file_) << "[";
          const CellIndex cell_index{eta, phi};
          const auto cell_iter = grid->find(cell_index);
          for (int input_index = 0; input_index < n_inputs; ++input_index) {
            float input = 0.;
            if (cell_iter != grid->end()) {
              input = inputs.tensor<float, 4>()(eta_phi_index, 0, 0, input_index);
            }
            if (input_index != 0)
              (*json_file_) << ", ";
            (*json_file_) << input;
          }
          if (cell_iter != grid->end()) {
            eta_phi_index += 1;
          }
          (*json_file_) << "]";
        }
        (*json_file_) << "]";
      }
    }
    (*json_file_) << "]";
    is_first_block_ = false;
  }

setCellConvFeatures()

void DeepTauId::setCellConvFeatures ( tensorflow::Tensor &  convTensor, const tensorflow::Tensor &  features, unsigned  batch_idx, int  eta_index, int  phi_index  )

inlineprivate

Definition at line 639 of file DeepTauId.cc.

References lowptgsfeleseed::features(), nano_mu_digi_cff::float, and dqmiodumpmetadata::n.

Referenced by createConvFeatures(), and DeepTauId().

                                          {
    for (int n = 0; n < dnn_inputs_v2::number_of_conv_features; ++n) {
      convTensor.tensor<float, 4>()(0, eta_index, phi_index, n) = features.tensor<float, 4>()(batch_idx, 0, 0, n);
    }
  }

Member Data Documentation

cache_

const deep_tau::DeepTauCache* DeepTauId::cache_

private

Definition at line 650 of file DeepTauId.cc.

Referenced by getPartialPredictions(), and getPredictionsV2().

convTensor_

std::array<std::unique_ptr<tensorflow::Tensor>, 2> DeepTauId::convTensor_

private

Definition at line 653 of file DeepTauId.cc.

Referenced by createConvFeatures(), DeepTauId(), and getPredictionsV2().

eGammaTensor_

std::array<std::unique_ptr<tensorflow::Tensor>, 2> DeepTauId::eGammaTensor_

private

Definition at line 653 of file DeepTauId.cc.

Referenced by createConvFeatures(), DeepTauId(), getPartialPredictions(), and getPredictionsV2().

hadronsTensor_

std::array<std::unique_ptr<tensorflow::Tensor>, 2> DeepTauId::hadronsTensor_

private

Definition at line 653 of file DeepTauId.cc.

Referenced by createConvFeatures(), DeepTauId(), getPartialPredictions(), and getPredictionsV2().

muonTensor_

std::array<std::unique_ptr<tensorflow::Tensor>, 2> DeepTauId::muonTensor_

private

Definition at line 653 of file DeepTauId.cc.

Referenced by createConvFeatures(), DeepTauId(), getPartialPredictions(), and getPredictionsV2().

tauBlockTensor_

std::unique_ptr<tensorflow::Tensor> DeepTauId::tauBlockTensor_

private

Definition at line 652 of file DeepTauId.cc.

Referenced by DeepTauId(), and getPredictionsV2().

zeroOutputTensor_

std::array<std::unique_ptr<tensorflow::Tensor>, 2> DeepTauId::zeroOutputTensor_

private

Definition at line 653 of file DeepTauId.cc.

Referenced by createConvFeatures(), and DeepTauId().