GRLNeuro Class Reference

Class to represent the GRL Neuro. More...

#include <GRLNeuro.h>

Classes
struct	Parameters
	Struct to keep neurotrigger parameters. More...

Public Member Functions
	GRLNeuro ()
	Default constructor.
virtual	~GRLNeuro ()
	Default destructor.
void	initialize (const Parameters &p)
	Set parameters and get some network independent parameters.
GRLMLP &	operator[] (unsigned index)
	return reference to a neural network
const GRLMLP &	operator[] (unsigned index) const
	return const reference to a neural network
unsigned	nSectors () const
	return number of neural networks
void	save (const std::string &filename, const std::string &arrayname="MLPs")
	Save MLPs to file.
bool	load (unsigned isector, const std::string &wfilename, const std::string &bfilename)
	Load MLPs from file.
bool	load (unsigned isector, std::vector< float > weight, std::vector< float > bias)
	Load MLPs from file.
float	runMLP (unsigned isector, const std::vector< float > &input)
	Run an expert MLP.

Private Attributes
std::vector< GRLMLP >	m_MLPs = {}
	List of networks.

Detailed Description

Class to represent the GRL Neuro.

The Neurotrigger consists of one or several Multi Layer Perceptrons. The input values are calculated from ECLTRG cluster and a 2D track estimate. The output is a scaled estimate of the judgement.

See also

GRLNeuro Modules:

GRLTrainerModule for preparing training data and training,

GRLNeuro for loading trained networks and using them.

Definition at line 35 of file GRLNeuro.h.

Constructor & Destructor Documentation

GRLNeuro()

GRLNeuro ( )

inline

Default constructor.

Definition at line 71 of file GRLNeuro.h.

{}

~GRLNeuro()

virtual ~GRLNeuro ( )

inlinevirtual

Default destructor.

Definition at line 74 of file GRLNeuro.h.

{}

Member Function Documentation

initialize()

void initialize

(

const Parameters &

p

)

Set parameters and get some network independent parameters.

Definition at line 284 of file GRLNeuro.cc.

{
  // check parameters
  bool okay = true;
  // ensure that length of lists matches number of sectors
  if (p.nHidden.size() != 1 && p.nHidden.size() != p.nMLP) {
    B2ERROR("Number of nHidden lists should be 1 or " << p.nMLP);
    okay = false;
  }
  if (p.outputScale.size() != 1 && p.outputScale.size() != p.nMLP) {
    B2ERROR("Number of outputScale lists should be 1 or " << p.nMLP);
    okay = false;
  }
  // ensure that number of target nodes is valid
  unsigned short nTarget = int(p.targetresult);
  if (nTarget < 1) {
    B2ERROR("No outputs! Turn on targetresult.");
    okay = false;
  }
  for (unsigned iScale = 0; iScale < p.outputScale.size(); ++iScale) {
    if (p.outputScale[iScale].size() != 2 * nTarget) {
      B2ERROR("outputScale should be exactly " << 2 * nTarget << " values");
      okay = false;
    }
  }
 
  if (!okay) return;
  // initialize MLPs
  m_MLPs.clear();
  for (unsigned iMLP = 0; iMLP < p.nMLP; ++iMLP) {
    //get indices for sector parameters
    unsigned short nInput = p.i_cdc_sector[iMLP] + p.i_ecl_sector[iMLP];
    vector<float> nhidden =  p.nHidden[iMLP];
    vector<unsigned short> nNodes = {nInput};
    for (unsigned iHid = 0; iHid < nhidden.size(); ++iHid) {
      if (p.multiplyHidden) {
        nNodes.push_back(nhidden[iHid] * nNodes[0]);
      } else {
        nNodes.push_back(nhidden[iHid]);
      }
    }
    nNodes.push_back(nTarget);
    unsigned short targetVars = int(p.targetresult);
    vector<float> outputScale = (p.outputScale.size() == 1) ? p.outputScale[0] : p.outputScale[iMLP];
    m_MLPs.push_back(GRLMLP(nNodes, targetVars, outputScale));
  }
}

load() [1/2]

bool load	(	unsigned	isector,
		const std::string &	wfilename,
		const std::string &	bfilename )

Load MLPs from file.

Parameters

isector	index of the MLP
wfilename	name of the TFile to read from
bfilename	name of the TObjArray holding the MLPs in the file

Returns

true if the MLPs were loaded correctly

Definition at line 528 of file GRLNeuro.cc.

{
  if (weightfilename.size() < 1) {
    B2ERROR("Could not load Neurotrigger weights from database!");
    return false;
  } else if (biasfilename.size() < 1) {
    B2ERROR("Could not load Neurotrigger bias from database!");
    return false;
  } else {
    std::ifstream wfile(weightfilename);
    if (!wfile.is_open()) {
      B2WARNING("Could not open file " << weightfilename);
      return false;
    } else {
      std::ifstream bfile(biasfilename);
      if (!bfile.is_open()) {
        B2WARNING("Could not open file " << biasfilename);
        return false;
      } else {
        GRLMLP& expert = m_MLPs[isector];
        std::vector<float> warray;
        std::vector<float> barray;
        warray.clear();
        barray.clear();
 
        float element;
        while (wfile >> element) {
          warray.push_back(element);
        }
        while (bfile >> element) {
          barray.push_back(element);
        }
 
        if (warray.size() != expert.nWeightsCal()) {
          B2ERROR("Number of weights is not equal to registered architecture!");
          return false;
        } else expert.setWeights(warray);
        if (barray.size() != expert.nBiasCal()) {
          B2ERROR("Number of bias is not equal to registered architecture!");
          return false;
        }
 
        expert.setWeights(warray);
        expert.setBias(barray);
        return true;
      }
    }
  }
}

load() [2/2]

bool load	(	unsigned	isector,
		std::vector< float >	weight,
		std::vector< float >	bias )

Load MLPs from file.

Parameters

isector	index of the MLP
weight	array from database
bias	array from database

Returns

true if the MLPs were loaded correctly

Definition at line 578 of file GRLNeuro.cc.

{
  GRLMLP& expert = m_MLPs[isector];
  expert.setWeights(warray);
  expert.setBias(barray);
  return true;
}

nSectors()

unsigned nSectors ( ) const

inline

return number of neural networks

Definition at line 84 of file GRLNeuro.h.

{ return m_MLPs.size(); }

operator[]() [1/2]

GRLMLP & operator[] ( unsigned index )

inline

return reference to a neural network

Definition at line 80 of file GRLNeuro.h.

{ return m_MLPs[index]; }

operator[]() [2/2]

const GRLMLP & operator[] ( unsigned index ) const

inline

return const reference to a neural network

Definition at line 82 of file GRLNeuro.h.

{ return m_MLPs[index]; }

runMLP()

float runMLP	(	unsigned	isector,
		const std::vector< float > &	input )

Run an expert MLP.

Parameters

isector	index of the MLP
input	vector of input values

Returns

output values (classifier)

Definition at line 387 of file GRLNeuro.cc.

{
 
 
  const GRLMLP& expert = m_MLPs[isector];
  vector<float> weights = expert.getWeights();
  vector<float> bias = expert.getBias();
  vector<float> layerinput = input;
 
  vector<float> layeroutput2 = {};
  vector<float> layeroutput3 = {};
  vector<float> layeroutput4 = {};

  for (size_t i = 0; i < layerinput.size(); ++i) {
    layerinput[i] = sim_fix_input_layer_t(layerinput[i]);
  }
  layeroutput2.clear();
  layeroutput2.assign(expert.getNumberOfNodesLayer(2), 0.);
 
  unsigned num_inputs = layerinput.size();
  unsigned num_neurons = expert.getNumberOfNodesLayer(2);  // 64
  for (unsigned io = 0; io < num_neurons; ++io) {
    float bias_raw = bias[io];
    float bias_fixed = sim_fix_dense_0_bias_t(bias_raw);
    float bias_contrib = sim_fix_dense_0_accum_t(bias_fixed);
    layeroutput2[io] = bias_contrib;
  }
 
  unsigned iw = 0;
//  input*weight
  for (unsigned ii = 0; ii < num_inputs; ++ii) {
    float input_val = layerinput[ii];
    for (unsigned io = 0; io < num_neurons; ++io) {
      float weight_raw = weights[iw];
      float weight_fixed = sim_fix_dense_0_weight_t(weight_raw);
      float product = input_val * weight_fixed;
      float contrib = sim_fix_dense_0_accum_t(product);
 
      layeroutput2[io] += contrib;
 
      ++iw;
    }
  }
 
 
//apply activation function, ReLU for hidden layer and output layer
// === dense_0_t + ReLU  ===
  std::vector<float> layeroutput2_fixed_relu(num_neurons);
 
  for (unsigned io = 0; io < num_neurons; ++io) {
    // dense_0_t）
    float fixed_val = sim_fix_dense_0_t(layeroutput2[io]);
 
    // ReLU
    float relu_val = (fixed_val > 0) ? fixed_val : 0;
 
    layeroutput2_fixed_relu[io] = relu_val;
 
  }
 
  std::vector<float> dense1_input(64);
  for (unsigned i = 0; i < 64; ++i) {
    dense1_input[i] = sim_dense_1_input_quant(i, layeroutput2_fixed_relu[i]);
  }
 
  layeroutput3.clear();
  layeroutput3.assign(expert.getNumberOfNodesLayer(1), 0.);
  unsigned num_inputs_1 = layeroutput2_fixed_relu.size();
  unsigned num_neurons_1 = expert.getNumberOfNodesLayer(2);
  for (unsigned io = 64; io < num_neurons_1 + 64; ++io) {
    float bias_raw = bias[io];
    float bias_fixed = sim_fix_dense_1_bias_t(bias_raw);
    float bias_contrib = sim_fix_dense_1_accum_t(bias_fixed);
    layeroutput3[io - 64] = bias_contrib;
 
  }
 
 
  for (unsigned ii = 0; ii < num_inputs_1; ++ii) {
    float input_val = dense1_input[ii];
    for (unsigned io = 0; io < num_neurons_1; ++io) {
 
      float weight_raw = weights[iw];
 
      float weight_fixed = sim_fix_dense_1_weight_t(weight_raw);
      float product = input_val * weight_fixed;
      float contrib = sim_fix_dense_1_accum_t(product);
 
      layeroutput3[io] += contrib;
      ++iw;
    }
  }
 
 
  std::vector<float> layeroutput3_fixed_relu(num_neurons);
 
 
  for (unsigned io = 0; io < num_neurons_1; ++io) {
    float fixed_val = sim_fix_dense_1_t(layeroutput3[io]);
    // ReLU
    float relu_val = (fixed_val > 0) ? fixed_val : 0;
 
    layeroutput3_fixed_relu[io] = relu_val;
 
  }
  std::vector<float> dense2_input(64);
  for (unsigned i = 0; i < 64; ++i) {
    dense2_input[i] = sim_dense_2_input_quant(i, layeroutput3_fixed_relu[i]);
  }
  layeroutput4.clear();
  layeroutput4.assign(expert.getNumberOfNodesLayer(3), 0.);
 
  unsigned num_inputs_2 = layeroutput2_fixed_relu.size();
  unsigned num_neurons_2 = expert.getNumberOfNodesLayer(3);
  for (unsigned io = 128; io < num_neurons_2 + 128; ++io) {
    float bias_raw = bias[io];
    float bias_fixed = sim_fix_dense_2_bias_t(bias_raw);
    float bias_contrib = sim_fix_dense_2_accum_t(bias_fixed);
    layeroutput4[io - 128] = bias_contrib;
 
  }
 
  for (unsigned ii = 0; ii < num_inputs_2; ++ii) {
    float input_val = dense2_input[ii];
    for (unsigned io = 0; io < num_neurons_2; ++io) {
      float weight_raw = weights[iw];
      float weight_fixed = sim_fix_dense_2_weight_t(weight_raw);
      float product = input_val * weight_fixed;
      float contrib = sim_fix_dense_2_accum_t(product);
 
      layeroutput4[io] += contrib;
 
      ++iw;
    }
  }
  return layeroutput4[0];
 
}

save()

void save	(	const std::string &	filename,
		const std::string &	arrayname = "MLPs" )

Save MLPs to file.

Parameters

filename	name of the TFile to write to
arrayname	name of the TObjArray holding the MLPs in the file

Member Data Documentation

m_MLPs

std::vector<GRLMLP> m_MLPs = {}

private

List of networks.

Definition at line 114 of file GRLNeuro.h.

{};

---

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

• trg/grl/include/GRLNeuro.h
• trg/grl/src/GRLNeuro.cc