PIDNeuralNetwork Class Reference

Class to call PID neural network. More...

#include <PIDNeuralNetwork.h>

Public Member Functions
	PIDNeuralNetwork ()
	Constructor with default paramenter-set name.
	PIDNeuralNetwork (const std::string &parameterName)
	Constructor with given paramenter-set name.
	PIDNeuralNetwork (PIDNeuralNetwork &&other)
	Move constructor.
std::map< int, double >	predict (std::vector< float > inputs) const
	Predict neural-network output for all implemented hypotheses using the given inputs.
size_t	getInputSize () const
	Get number of inputs.
const std::vector< std::string > &	getInputBasf2Names () const
	Get names of input variables in the basf2 naming scheme, which may be different from the one in the payload.
const std::vector< int > &	getOutputSpeciesPdg () const
	Get the list of pdg codes of species hypotheses, for which the network predicts the probability in the order defined by the network output layer.
const std::string &	getPIDNeuralNetworkParametersName () const
	Get the name of the used neural network.
bool	hasPdgCode (const int pdg, const bool throwException=false) const
const std::string &	getExtraInfoName (const int pdg) const

Private Member Functions
void	loadParametersFromDB ()
	Load neural-network parameters with name m_pidNeuralNetworkParametersName from the conditions data base.
void	check ()
	Check that Neural Network can be evaluated, e.g.

Private Attributes
std::string	m_pidNeuralNetworkParametersName = "PIDNeuralNetworkParameters"
	name of the parameter set
std::unique_ptr< DBObjPtr< PIDNeuralNetworkParameters > >	m_pidNeuralNetworkParametersDB
	db object for the parameter set
std::unique_ptr< const fdeep::model >	m_model
	frugally-deep neural network
std::vector< std::string >	m_inputBasf2Names
	list of input names of input variables in the basf2 naming scheme
std::map< int, std::string >	m_extraInfoNames
	map from PDG code to extraInfo name that stores the output of this network

Detailed Description

Class to call PID neural network.

Definition at line 32 of file PIDNeuralNetwork.h.

Constructor & Destructor Documentation

PIDNeuralNetwork() [1/3]

PIDNeuralNetwork ( )

inline

Constructor with default paramenter-set name.

Definition at line 39 of file PIDNeuralNetwork.h.

                      :
      m_pidNeuralNetworkParametersDB(nullptr),
      m_model(nullptr)
    {
      loadParametersFromDB();
      check();
    };

PIDNeuralNetwork() [2/3]

PIDNeuralNetwork ( const std::string &  parameterName )

inline

Constructor with given paramenter-set name.

Definition at line 51 of file PIDNeuralNetwork.h.

                                                    :
      m_pidNeuralNetworkParametersName(parameterName),
      m_pidNeuralNetworkParametersDB(nullptr),
      m_model(nullptr)
    {
      loadParametersFromDB();
      check();
    }

PIDNeuralNetwork() [3/3]

PIDNeuralNetwork ( PIDNeuralNetwork &&  other )

inline

Move constructor.

Definition at line 63 of file PIDNeuralNetwork.h.

                                              :
      m_pidNeuralNetworkParametersName(std::move(other.m_pidNeuralNetworkParametersName)),
      m_pidNeuralNetworkParametersDB(std::move(other.m_pidNeuralNetworkParametersDB)),
      m_model(std::move(other.m_model)),
      m_inputBasf2Names(std::move(other.m_inputBasf2Names)),
      m_extraInfoNames(std::move(other.m_extraInfoNames))
    {
    }

Member Function Documentation

check()

void check ( )

inlineprivate

Check that Neural Network can be evaluated, e.g.

that all required inputs exist

Definition at line 143 of file PIDNeuralNetwork.h.

{
  for (const auto& name : getInputBasf2Names()) {
    if (!Variable::Manager::Instance().getVariable(name))
      B2FATAL("PID neural network needs input '" + name + "', but this input is not available!");
  }
 
}

getExtraInfoName()

const std::string & getExtraInfoName ( const int  pdg ) const

inline

Parameters

pdg	pdg code of hypothesis

Returns

name of the extra info that stores the probability of the given pdg code

Definition at line 117 of file PIDNeuralNetwork.h.

{return m_extraInfoNames.at(pdg);}

getInputBasf2Names()

const std::vector< std::string > & getInputBasf2Names ( ) const

inline

Get names of input variables in the basf2 naming scheme, which may be different from the one in the payload.

Returns

const std::vector<const std::string>& input variables

Definition at line 90 of file PIDNeuralNetwork.h.

{ return m_inputBasf2Names; }

getInputSize()

size_t getInputSize ( ) const

inline

Get number of inputs.

Returns

size_t number of inputs

Definition at line 84 of file PIDNeuralNetwork.h.

{ return (*m_pidNeuralNetworkParametersDB)->getInputSize(); }

getOutputSpeciesPdg()

const std::vector< int > & getOutputSpeciesPdg ( ) const

inline

Get the list of pdg codes of species hypotheses, for which the network predicts the probability in the order defined by the network output layer.

Returns

const std::vector<int>& list of pdg codes of hypotheses predicted by the network

Definition at line 97 of file PIDNeuralNetwork.h.

{return (*m_pidNeuralNetworkParametersDB)->getOutputSpeciesPdg();}

getPIDNeuralNetworkParametersName()

const std::string & getPIDNeuralNetworkParametersName ( ) const

inline

Get the name of the used neural network.

Returns

const std::string& name of the used neural network

Definition at line 103 of file PIDNeuralNetwork.h.

{return m_pidNeuralNetworkParametersName;}

hasPdgCode()

bool hasPdgCode ( const int  pdg, const bool  throwException = false  ) const

inline

Parameters

pdg	pdg code of hypothesis
throwException	throw exception if pdg code is not predicted

Returns

true if neural network predicts probability for the given hypothesis

false if neural network does not predict probability for the given hypothesis

Definition at line 111 of file PIDNeuralNetwork.h.

{return (*m_pidNeuralNetworkParametersDB)->hasPdgCode(pdg, throwException);}

loadParametersFromDB()

void loadParametersFromDB ( )

private

Load neural-network parameters with name m_pidNeuralNetworkParametersName from the conditions data base.

Definition at line 17 of file PIDNeuralNetwork.cc.

{
  m_pidNeuralNetworkParametersDB = std::make_unique<DBObjPtr<PIDNeuralNetworkParameters>>(m_pidNeuralNetworkParametersName);
 
  if (!(*m_pidNeuralNetworkParametersDB))
    B2FATAL("The dbobject PIDNeuralNetworkParameters, " << m_pidNeuralNetworkParametersName <<
            ", could not be found! It is necessary for the neural network based PID variables.");
 
  m_model = std::make_unique<fdeep::model>(fdeep::read_model_from_string((*m_pidNeuralNetworkParametersDB)->getModelDefinition(),
                                           false,
  [](const std::string&) {}  // disable logger
                                                                        ));
 
  // Rename some of the input variables such that they match the basf2 internal names
  // This is needed for backwards compatibility with older payloads where the input variable names are different from the basf2 internal names
  std::map<std::string, std::string> inputNameMap; // maps old -> new names
  for (const Const::EDetector& detector : Const::PIDDetectorSet::set()) {
    for (const auto& hypeType : Const::chargedStableSet) {
      const auto oldName = "pidLogLikelihood_Of_" + std::to_string(abs(hypeType.getPDGCode())) + "_From_" + Const::parseDetectors(
                             detector);
      const auto newName = "pidLogLikelihoodValueExpert(" + std::to_string(abs(hypeType.getPDGCode())) + ',' + Const::parseDetectors(
                             detector) + ")";
      inputNameMap[oldName] = newName;
    }
  }
  inputNameMap["momentum"] = "p";
 
  // Build list of input variable names in Basf2 naming scheme
  m_inputBasf2Names.reserve(getInputSize());
  for (std::string name : (*m_pidNeuralNetworkParametersDB)->getInputNames()) {
    const auto itr = inputNameMap.find(name);
    if (itr != inputNameMap.end()) name = itr->second;
    m_inputBasf2Names.push_back(name);
  }
 
  // Build extraInfo names for this network for all predicted PDG codes
  for (const auto outputPdgCode : getOutputSpeciesPdg()) {
    m_extraInfoNames[outputPdgCode] = "pidNeuralNetworkValueExpert(" + std::to_string(outputPdgCode) \
                                      + "," + m_pidNeuralNetworkParametersName + ")";
  }
}

predict()

std::map< int, double > predict

(

std::vector< float >

inputs

)

const

Predict neural-network output for all implemented hypotheses using the given inputs.

Parameters

inputs

set of input variables

Returns

double probability of the asked particle-species hypothesis

std::map<int, double> map of pdg codes to the corresponding probabilities

Definition at line 60 of file PIDNeuralNetwork.cc.

{
 
  // apply cuts, ie. overwrite certain input values with index `inputSetIndex` with the value `setValue`
  // if the input with index `inputCutIndex` is in the range (`rangeStart`, `rangeEnd`)
  for (auto const& inputToCut : (*m_pidNeuralNetworkParametersDB)->getInputsToCut()) {
    const auto [inputSetIndex, inputCutIndex, rangeStart, rangeEnd, setValue] = inputToCut;
    if (!std::isnan(rangeStart) and !std::isnan(rangeEnd)) {
      if (input[inputCutIndex] >= rangeStart and input[inputCutIndex] <= rangeEnd)
        input[inputSetIndex] = setValue;
    } else if (!std::isnan(rangeStart)) {
      if (input[inputCutIndex] >= rangeStart)
        input[inputSetIndex] = setValue;
    } else if (!std::isnan(rangeEnd)) {
      if (input[inputCutIndex] <= rangeEnd)
        input[inputSetIndex] = setValue;
    }
  }
 
  // Normalize inputs
  // By definition, this has to be done after applying the cuts and before handling missing information
  for (size_t i = 0; i < input.size(); ++i) {
    input[i] = (input[i] - (*m_pidNeuralNetworkParametersDB)->getMeanValues()[i]) /
               (*m_pidNeuralNetworkParametersDB)->getStandardDeviations()[i];
  }
 
  // handle missing information
  for (auto const& index_value : (*m_pidNeuralNetworkParametersDB)->getHandleMissingInputs()) {
    const auto [index, value] = index_value;
    if (std::isnan(input[index])) input[index] = value;
  }
 
  // apply neural network
  const auto inputFdeep = fdeep::tensor(fdeep::tensor_shape(input.size()), input);
  const auto result = m_model->predict({inputFdeep});
 
  std::map<int, double> probabilities;
  for (const auto pdgCode : getOutputSpeciesPdg()) {
    const int outputIndex = (*m_pidNeuralNetworkParametersDB)->pdg2OutputIndex(pdgCode);
    probabilities[pdgCode] = result.front().get(fdeep::tensor_pos(outputIndex));
  }
  return probabilities;
}

Member Data Documentation

m_extraInfoNames

std::map<int, std::string> m_extraInfoNames

private

map from PDG code to extraInfo name that stores the output of this network

Definition at line 135 of file PIDNeuralNetwork.h.

m_inputBasf2Names

std::vector<std::string> m_inputBasf2Names

private

list of input names of input variables in the basf2 naming scheme

Definition at line 134 of file PIDNeuralNetwork.h.

m_model

std::unique_ptr<const fdeep::model> m_model

private

frugally-deep neural network

Definition at line 133 of file PIDNeuralNetwork.h.

m_pidNeuralNetworkParametersDB

std::unique_ptr<DBObjPtr<PIDNeuralNetworkParameters> > m_pidNeuralNetworkParametersDB

private

db object for the parameter set

Definition at line 132 of file PIDNeuralNetwork.h.

m_pidNeuralNetworkParametersName

std::string m_pidNeuralNetworkParametersName = "PIDNeuralNetworkParameters"

private

name of the parameter set

Definition at line 131 of file PIDNeuralNetwork.h.

---

The documentation for this class was generated from the following files:

• analysis/utility/include/PIDNeuralNetwork.h
• analysis/utility/src/PIDNeuralNetwork.cc