Wrapper around lwtnn to compute the output score of a neural network. More...

#include <TauJetRNN.h>

Inheritance diagram for TauJetRNN:

Collaboration diagram for TauJetRNN:

Classes
struct	Config

Public Member Functions
	TauJetRNN (const std::string &filename, const Config &config, bool useTRT)
	~TauJetRNN ()
float	compute (const xAOD::TauJet &tau, const std::vector< const xAOD::TauTrack * > &tracks, const std::vector< xAOD::CaloVertexedTopoCluster > &clusters) const
bool	calculateInputVariables (const xAOD::TauJet &tau, const std::vector< const xAOD::TauTrack * > &tracks, const std::vector< xAOD::CaloVertexedTopoCluster > &clusters, std::map< std::string, std::map< std::string, double > > &scalarInputs, std::map< std::string, std::map< std::string, std::vector< double > > > &vectorInputs) const
const TauJetRNNUtils::VarCalc *	variable_calculator () const
	operator bool () const
void	setLevel (MSG::Level lvl)
	Change the current logging level.
Functions providing the same interface as AthMessaging
bool	msgLvl (const MSG::Level lvl) const
	Test the output level of the object.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.

Private Types
using	VariableMap = std::map<std::string, double>
using	VectorMap = std::map<std::string, std::vector<double>>
using	InputMap = std::map<std::string, VariableMap>
using	InputSequenceMap = std::map<std::string, VectorMap>

Private Member Functions
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
const Config	m_config
std::unique_ptr< const lwt::LightweightGraph >	m_graph
std::vector< std::string >	m_scalar_inputs
std::vector< std::string >	m_track_inputs
std::vector< std::string >	m_cluster_inputs
std::unique_ptr< TauJetRNNUtils::VarCalc >	m_var_calc
bool	m_useTRT = true
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging)

Detailed Description

Wrapper around lwtnn to compute the output score of a neural network.

Configures the network and computes the network outputs given the input objects. Retrieval of input variables is handled internally.

Author: C. Deutsch; W. Davey

Definition at line 34 of file TauJetRNN.h.

Member Typedef Documentation

◆ InputMap

using TauJetRNN::InputMap = std::map<std::string, VariableMap>

private

Definition at line 77 of file TauJetRNN.h.

◆ InputSequenceMap

using TauJetRNN::InputSequenceMap = std::map<std::string, VectorMap>

private

Definition at line 78 of file TauJetRNN.h.

◆ VariableMap

using TauJetRNN::VariableMap = std::map<std::string, double>

private

Definition at line 74 of file TauJetRNN.h.

◆ VectorMap

using TauJetRNN::VectorMap = std::map<std::string, std::vector<double>>

private

Definition at line 75 of file TauJetRNN.h.

Constructor & Destructor Documentation

◆ TauJetRNN()

TauJetRNN::TauJetRNN	(	const std::string &	filename,
		const Config &	config,
		bool	useTRT )

Definition at line 17 of file TauJetRNN.cxx.

  : asg::AsgMessaging("TauJetRNN"), m_config(config), m_graph(nullptr), m_useTRT(useTRT) {
    // Load the json file defining the network
    std::ifstream input_file(filename);
    lwt::GraphConfig lwtnn_config;
    try {
        lwtnn_config = lwt::parse_json_graph(input_file);
    } catch (const std::logic_error &e) {
        ATH_MSG_ERROR("Error parsing network config: " << e.what());
        throw;
    }
 
    // Search for input layer names specified in 'config'
    auto node_is_scalar = [&config](const lwt::InputNodeConfig &in_node) {
        return in_node.name == config.input_layer_scalar;
    };
    auto node_is_track = [&config](const lwt::InputNodeConfig &in_node) {
        return in_node.name == config.input_layer_tracks;
    };
    auto node_is_cluster = [&config](const lwt::InputNodeConfig &in_node) {
        return in_node.name == config.input_layer_clusters;
    };
 
    auto scalar_node = std::find_if(lwtnn_config.inputs.cbegin(),
                                    lwtnn_config.inputs.cend(),
                                    node_is_scalar);
 
    auto track_node = std::find_if(lwtnn_config.input_sequences.cbegin(),
                                   lwtnn_config.input_sequences.cend(),
                                   node_is_track);
 
    auto cluster_node = std::find_if(lwtnn_config.input_sequences.cbegin(),
                                     lwtnn_config.input_sequences.cend(),
                                     node_is_cluster);
 
    // Check which input layers were found
    auto has_scalar_node = scalar_node != lwtnn_config.inputs.cend();
    auto has_track_node = track_node != lwtnn_config.input_sequences.cend();
    auto has_cluster_node = cluster_node != lwtnn_config.input_sequences.cend();
 
    // Fill the variable names of each input layer into the corresponding vector
    if (has_scalar_node) {
        for (const auto &in : scalar_node->variables) {
            m_scalar_inputs.push_back(in.name);
        }
    }
 
    if (has_track_node) {
        for (const auto &in : track_node->variables) {
            m_track_inputs.push_back(in.name);
        }
    }
 
    if (has_cluster_node) {
        for (const auto &in : cluster_node->variables) {
            m_cluster_inputs.push_back(in.name);
        }
    }
 
    // Configure the network
    try {
        m_graph = std::make_unique<lwt::LightweightGraph>(
            lwtnn_config, config.output_layer);
    } catch (const lwt::NNConfigurationException &e) {
        ATH_MSG_ERROR(e.what());
        throw;
    }
 
    // Load the variable calculator
    m_var_calc = TauJetRNNUtils::get_calculator(m_scalar_inputs, m_track_inputs, m_cluster_inputs, m_useTRT);
}

◆ ~TauJetRNN()

TauJetRNN::~TauJetRNN ( )

Definition at line 89 of file TauJetRNN.cxx.

89{}

Member Function Documentation

◆ calculateInputVariables()

bool TauJetRNN::calculateInputVariables	(	const xAOD::TauJet &	tau,
		const std::vector< const xAOD::TauTrack * > &	tracks,
		const std::vector< xAOD::CaloVertexedTopoCluster > &	clusters,
		std::map< std::string, std::map< std::string, double > > &	scalarInputs,
		std::map< std::string, std::map< std::string, std::vector< double > > > &	vectorInputs ) const

Definition at line 105 of file TauJetRNN.cxx.

                                                                                               {
    scalarInputs.clear();
    vectorInputs.clear();
    // Populate input (sequence) map with input variables
    for (const auto &varname : m_scalar_inputs) {
        if (!m_var_calc->compute(varname, tau,
                                 scalarInputs[m_config.input_layer_scalar][varname])) {
            ATH_MSG_WARNING("Error computing '" << varname
                            << "' returning default");
            return false;
        }
    }
 
    for (const auto &varname : m_track_inputs) {
        if (!m_var_calc->compute(varname, tau, tracks,
                                 vectorInputs[m_config.input_layer_tracks][varname])) {
            ATH_MSG_WARNING("Error computing '" << varname
                            << "' returning default");
            return false;
        }
    }
 
    for (const auto &varname : m_cluster_inputs) {
        if (!m_var_calc->compute(varname, tau, clusters,
                                 vectorInputs[m_config.input_layer_clusters][varname])) {
            ATH_MSG_WARNING("Error computing '" << varname
                            << "' returning default");
            return false;
        }
    }
    return true;
}

◆ compute()

float TauJetRNN::compute	(	const xAOD::TauJet &	tau,
		const std::vector< const xAOD::TauTrack * > &	tracks,
		const std::vector< xAOD::CaloVertexedTopoCluster > &	clusters ) const

Definition at line 91 of file TauJetRNN.cxx.

                                                                                       {
    InputMap scalarInputs;
    InputSequenceMap vectorInputs;
    if (!calculateInputVariables(tau, tracks, clusters, scalarInputs, vectorInputs)) {
        return -1111.0;
    }
    // Compute the network outputs
    const auto outputs = m_graph->compute(scalarInputs, vectorInputs);
    // Return value of the output neuron
    return outputs.at(m_config.output_node);
}

◆ initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

◆ msg() [1/2]

MsgStream & asg::AsgMessaging::msg ( ) const

inherited

The standard message stream.

Returns: A reference to the default message stream of this object.

Definition at line 49 of file AsgMessaging.cxx.

                                      {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg();
#else // not XAOD_STANDALONE
      return m_msg;
#endif // not XAOD_STANDALONE
   }

◆ msg() [2/2]

MsgStream & asg::AsgMessaging::msg ( const MSG::Level lvl ) const

inherited

The standard message stream.

Parameters

lvl	The message level to set the stream to

Returns: A reference to the default message stream, set to level "lvl"

Definition at line 57 of file AsgMessaging.cxx.

                                                          {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg( lvl );
#else // not XAOD_STANDALONE
      m_msg << lvl;
      return m_msg;
#endif // not XAOD_STANDALONE
   }

◆ msgLvl()

bool asg::AsgMessaging::msgLvl ( const MSG::Level lvl ) const

inherited

Test the output level of the object.

Parameters

lvl	The message level to test against

Returns: boolean Indicting if messages at given level will be printed; true If messages at level "lvl" will be printed

Definition at line 41 of file AsgMessaging.cxx.

                                                       {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msgLvl( lvl );
#else // not XAOD_STANDALONE
      return m_msg.msgLevel( lvl );
#endif // not XAOD_STANDALONE
   }

◆ operator bool()

TauJetRNN::operator bool ( ) const

inlineexplicit

Definition at line 68 of file TauJetRNN.h.

                                   {
        return static_cast<bool>(m_graph);
    }

◆ setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

◆ variable_calculator()

const TauJetRNNUtils::VarCalc * TauJetRNN::variable_calculator ( ) const

inline

Definition at line 64 of file TauJetRNN.h.

                                                             {
        return m_var_calc.get();
    }

Member Data Documentation

◆ ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

◆ m_cluster_inputs

std::vector<std::string> TauJetRNN::m_cluster_inputs

private

Definition at line 87 of file TauJetRNN.h.

◆ m_config

const Config TauJetRNN::m_config

private

Definition at line 81 of file TauJetRNN.h.

◆ m_graph

std::unique_ptr<const lwt::LightweightGraph> TauJetRNN::m_graph

private

Definition at line 82 of file TauJetRNN.h.

◆ m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

135{ nullptr };

◆ m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

138{ MSG::NIL };

◆ m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

◆ m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

◆ m_scalar_inputs

std::vector<std::string> TauJetRNN::m_scalar_inputs

private

Definition at line 85 of file TauJetRNN.h.

◆ m_track_inputs

std::vector<std::string> TauJetRNN::m_track_inputs

private

Definition at line 86 of file TauJetRNN.h.

◆ m_useTRT

bool TauJetRNN::m_useTRT = true

private

Definition at line 92 of file TauJetRNN.h.

◆ m_var_calc

std::unique_ptr<TauJetRNNUtils::VarCalc> TauJetRNN::m_var_calc

private

Definition at line 90 of file TauJetRNN.h.

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

Classes

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ InputMap

◆ InputSequenceMap

◆ VariableMap

◆ VectorMap

Constructor & Destructor Documentation

◆ TauJetRNN()

◆ ~TauJetRNN()

Member Function Documentation

◆ calculateInputVariables()

◆ compute()

◆ initMessaging()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ operator bool()

◆ setLevel()

◆ variable_calculator()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ m_cluster_inputs

◆ m_config

◆ m_graph

◆ m_imsg

◆ m_lvl

◆ m_msg_tls

◆ m_nm

◆ m_scalar_inputs

◆ m_track_inputs

◆ m_useTRT

◆ m_var_calc