GRLNeuro Class Reference

Class to represent the GRL Neuro. More...

#include <GRLNeuro.h>

Collaboration diagram for GRLNeuro:

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 > warray, std::vector< float > barray)
std::vector< 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 34 of file GRLNeuro.h.

Constructor & Destructor Documentation

GRLNeuro()

GRLNeuro ( )

inline

Default constructor.

Definition at line 100 of file GRLNeuro.h.

{}

~GRLNeuro()

virtual ~GRLNeuro ( )

inlinevirtual

Default destructor.

Definition at line 103 of file GRLNeuro.h.

{}

Member Function Documentation

initialize()

void initialize

(

const Parameters &

p

)

Set parameters and get some network independent parameters.

Definition at line 248 of file GRLNeuro.cc.

{
  using std::vector;
 
  B2DEBUG(10, "GRLNeuro::initialize: nMLP=" << p.nMLP);
 
  // ------------------------------------------------------------------
  // Basic parameter validation (fatal in initialize)
  // ------------------------------------------------------------------
 
  if (p.nHidden.size() != 1 && p.nHidden.size() != p.nMLP) {
    B2FATAL("Number of nHidden lists should be 1 or " << p.nMLP);
  }
 
  // ------------------------------------------------------------------
  // Comprehensive parameter-size validation
  // ------------------------------------------------------------------
 
  auto check_size = [&](const auto & v, const char* name) {
    const size_t s = v.size();
    if (s != 1 && s != static_cast<size_t>(p.nMLP)) {
      B2FATAL(std::string(name) + " size (" + std::to_string(s)
              + ") != 1 and != nMLP (" + std::to_string(p.nMLP) + ")");
    }
  };
 
  // sector / structure parameters
  check_size(p.i_cdc_sector, "i_cdc_sector");
  check_size(p.i_ecl_sector, "i_ecl_sector");
  check_size(p.nHidden, "nHidden");
  check_size(p.nn_thres, "nn_thres");
 
  // bias
  check_size(p.total_bit_bias, "total_bit_bias");
  check_size(p.int_bit_bias, "int_bit_bias");
  check_size(p.is_signed_bias, "is_signed_bias");
  check_size(p.rounding_bias, "rounding_bias");
  check_size(p.saturation_bias, "saturation_bias");
 
  // accumulator
  check_size(p.total_bit_accum, "total_bit_accum");
  check_size(p.int_bit_accum, "int_bit_accum");
  check_size(p.is_signed_accum, "is_signed_accum");
  check_size(p.rounding_accum, "rounding_accum");
  check_size(p.saturation_accum, "saturation_accum");
 
  // weights
  check_size(p.total_bit_weight, "total_bit_weight");
  check_size(p.int_bit_weight, "int_bit_weight");
  check_size(p.is_signed_weight, "is_signed_weight");
  check_size(p.rounding_weight, "rounding_weight");
  check_size(p.saturation_weight, "saturation_weight");
 
  // relu
  check_size(p.total_bit_relu, "total_bit_relu");
  check_size(p.int_bit_relu, "int_bit_relu");
  check_size(p.is_signed_relu, "is_signed_relu");
  check_size(p.rounding_relu, "rounding_relu");
  check_size(p.saturation_relu, "saturation_relu");
 
  // generic
  check_size(p.total_bit, "total_bit");
  check_size(p.int_bit, "int_bit");
  check_size(p.is_signed, "is_signed");
  check_size(p.rounding, "rounding");
  check_size(p.saturation, "saturation");
 
  // inputs
  check_size(p.W_input, "W_input");
  check_size(p.I_input, "I_input");
 
  // ------------------------------------------------------------------
  // Initialize MLPs
  // ------------------------------------------------------------------
 
  m_MLPs.clear();
  m_MLPs.reserve(p.nMLP);
 
  for (unsigned iMLP = 0; iMLP < p.nMLP; ++iMLP) {
 
    // helper: broadcast if size == 1
    auto pick = [&](const auto & container) -> const auto& {
      return (container.size() == 1) ? container[0] : container[iMLP];
    };
 
    unsigned short i_cdc = static_cast<unsigned short>(pick(p.i_cdc_sector));
    unsigned short i_ecl = static_cast<unsigned short>(pick(p.i_ecl_sector));
    unsigned short nInput = static_cast<unsigned short>(i_cdc + i_ecl);
 
    // nHidden: vector<vector<float>>
    const vector<float>& nhidden = pick(p.nHidden);
    vector<unsigned short> nNodes = { nInput };
 
    for (unsigned iHid = 0; iHid < nhidden.size(); ++iHid) {
      if (p.multiplyHidden) {
        nNodes.push_back(static_cast<unsigned short>(nhidden[iHid] * nNodes[0]));
      } else {
        nNodes.push_back(static_cast<unsigned short>(nhidden[iHid]));
      }
    }
    nNodes.push_back(static_cast<float>(pick(p.nOutput)));
 
    GRLMLP grlmlp_temp(nNodes);
 
    // bias
    grlmlp_temp.set_total_bit_bias(pick(p.total_bit_bias));
    grlmlp_temp.set_int_bit_bias(pick(p.int_bit_bias));
    grlmlp_temp.set_is_signed_bias(pick(p.is_signed_bias));
    grlmlp_temp.set_rounding_bias(pick(p.rounding_bias));
    grlmlp_temp.set_saturation_bias(pick(p.saturation_bias));
 
    // accumulator
    grlmlp_temp.set_total_bit_accum(pick(p.total_bit_accum));
    grlmlp_temp.set_int_bit_accum(pick(p.int_bit_accum));
    grlmlp_temp.set_is_signed_accum(pick(p.is_signed_accum));
    grlmlp_temp.set_rounding_accum(pick(p.rounding_accum));
    grlmlp_temp.set_saturation_accum(pick(p.saturation_accum));
 
    // weights
    grlmlp_temp.set_total_bit_weight(pick(p.total_bit_weight));
    grlmlp_temp.set_int_bit_weight(pick(p.int_bit_weight));
    grlmlp_temp.set_is_signed_weight(pick(p.is_signed_weight));
    grlmlp_temp.set_rounding_weight(pick(p.rounding_weight));
    grlmlp_temp.set_saturation_weight(pick(p.saturation_weight));
 
    // relu
    grlmlp_temp.set_total_bit_relu(pick(p.total_bit_relu));
    grlmlp_temp.set_int_bit_relu(pick(p.int_bit_relu));
    grlmlp_temp.set_is_signed_relu(pick(p.is_signed_relu));
    grlmlp_temp.set_rounding_relu(pick(p.rounding_relu));
    grlmlp_temp.set_saturation_relu(pick(p.saturation_relu));
 
    // generic
    grlmlp_temp.set_total_bit(pick(p.total_bit));
    grlmlp_temp.set_int_bit(pick(p.int_bit));
    grlmlp_temp.set_is_signed(pick(p.is_signed));
    grlmlp_temp.set_rounding(pick(p.rounding));
    grlmlp_temp.set_saturation(pick(p.saturation));
 
    // inputs
    grlmlp_temp.set_W_input(pick(p.W_input));
    grlmlp_temp.set_I_input(pick(p.I_input));
 
    //threshold
    grlmlp_temp.set_nn_thres(pick(p.nn_thres));
 
    m_MLPs.push_back(std::move(grlmlp_temp));
  }
 
  B2DEBUG(10, "GRLNeuro::initialize finished. created "
          << m_MLPs.size() << " MLP(s).");
}

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 545 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.n_weights_cal()) {
          B2ERROR("Number of weights is not equal to registered architecture!");
          return false;
        } else expert.set_weights(warray);
        if (barray.size() != expert.n_bias_cal()) {
          B2ERROR("Number of bias is not equal to registered architecture!");
          return false;
        }
 
        expert.set_weights(warray);
        expert.set_bias(barray);
        return true;
      }
    }
  }
}

load() [2/2]

bool load	(	unsigned	isector,
		std::vector< float >	warray,
		std::vector< float >	barray )

Definition at line 595 of file GRLNeuro.cc.

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

nSectors()

unsigned nSectors ( ) const

inline

return number of neural networks

Definition at line 113 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 109 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 111 of file GRLNeuro.h.

{ return m_MLPs[index]; }

runMLP()

std::vector< 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 404 of file GRLNeuro.cc.

{
  const GRLMLP& expert = m_MLPs[isector];
  vector<float> weights = expert.get_weights();
  vector<float> bias = expert.get_bias();
  vector<int> total_bit_bias = expert.get_total_bit_bias();
  vector<int> int_bit_bias = expert.get_int_bit_bias();
  vector<bool> is_signed_bias = expert.get_is_signed_bias();
  vector<int> rounding_bias = expert.get_rounding_bias();
  vector<int> saturation_bias = expert.get_saturation_bias();
  vector<int> total_bit_accum = expert.get_total_bit_accum();
  vector<int> int_bit_accum = expert.get_int_bit_accum();
  vector<bool> is_signed_accum = expert.get_is_signed_accum();
  vector<int> rounding_accum = expert.get_rounding_accum();
  vector<int> saturation_accum = expert.get_saturation_accum();
  vector<int> total_bit_weight = expert.get_total_bit_weight();
  vector<int> int_bit_weight = expert.get_int_bit_weight();
  vector<bool> is_signed_weight = expert.get_is_signed_weight();
  vector<int> rounding_weight = expert.get_rounding_weight();
  vector<int> saturation_weight = expert.get_saturation_weight();
  vector<int> total_bit_relu = expert.get_total_bit_relu();
  vector<int> int_bit_relu = expert.get_int_bit_relu();
  vector<bool> is_signed_relu = expert.get_is_signed_relu();
  vector<int> rounding_relu = expert.get_rounding_relu();
  vector<int> saturation_relu = expert.get_saturation_relu();
  vector<int> total_bit = expert.get_total_bit();
  vector<int> int_bit = expert.get_int_bit();
  vector<bool> is_signed = expert.get_is_signed();
  vector<int> rounding = expert.get_rounding();
  vector<int> saturation = expert.get_saturation();
  vector<vector<int>> W_input = expert.get_W_input();
  vector<vector<int>> I_input = expert.get_I_input();
 
 
  //input layer
  vector<float> layerinput = input;
 
  // quantizer the inputs
  for (size_t i = 0; i < layerinput.size(); ++i) {
 
    int W_arr[24] = { 12, 12, 11, 11, 8, 8, 7, 7, 5, 6, 6, 6, 8, 8, 6, 5, 4, 5, 7, 7, 6, 4, 5, 5 };
    int I_arr[24] = { 12, 12, 11, 11, 10, 9, 7, 7, 7, 7, 7, 7, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9 };
    if (i != 23) {
      layerinput[i] = sim_input_layer_t(layerinput[i]);
      layerinput[i] = sim_ap_dense_0_iq(layerinput[i], W_arr[i], I_arr[i]);
 
    } else layerinput[i] = 0;
  }
 
  //hidden layer and output layer
  vector<float> layeroutput = {};
  unsigned num_layers = expert.get_number_of_layers();
 
  //output layer
  vector<float> final_fixed = {};
 
  unsigned num_total_neurons = 0;
  unsigned iw = 0;
  for (unsigned i_layer = 0; i_layer < num_layers - 1; i_layer++) {
    //read bias
    unsigned num_neurons = expert.get_number_of_nodes_layer(i_layer + 1);
    layeroutput.clear();
    layeroutput.assign(num_neurons, 0.);
    layeroutput.shrink_to_fit();
 
    for (unsigned io = 0; io < num_neurons; ++io) {
      float bias_raw = bias[io + num_total_neurons];
      float bias_fixed   = sim_fixed(bias_raw, total_bit_bias[i_layer], int_bit_bias[i_layer], is_signed_bias[i_layer],
                                     rounding_bias[i_layer], saturation_bias[i_layer]);
      float bias_contrib = sim_fixed(bias_fixed, total_bit_accum[i_layer], int_bit_accum[i_layer], is_signed_accum[i_layer],
                                     rounding_accum[i_layer], saturation_accum[i_layer]);
      layeroutput[io] = bias_contrib;
 
    }
    num_total_neurons += num_neurons;
 
    //input*weight
    unsigned num_inputs = layerinput.size();
    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_fixed(weight_raw, total_bit_weight[i_layer], int_bit_weight[i_layer], is_signed_weight[i_layer],
                                       rounding_weight[i_layer], saturation_weight[i_layer]);
        float product = input_val * weight_fixed;
        float contrib = sim_fixed(product, total_bit_accum[i_layer], int_bit_accum[i_layer], is_signed_accum[i_layer],
                                  rounding_accum[i_layer], saturation_accum[i_layer]);
        layeroutput[io] += contrib;
        ++iw;
      }
    }
    //     input*weight done
    if (i_layer < num_layers - 2) {
      //relu
      for (unsigned io = 0; io < num_neurons; ++io) {
        float fixed_val = sim_fixed(layeroutput[io], total_bit[i_layer], int_bit[i_layer], is_signed[i_layer], rounding[i_layer],
                                    saturation[i_layer]);
        float relu_val = (fixed_val > 0) ? fixed_val : 0;
        layeroutput[io] = sim_fixed(relu_val, total_bit_relu[i_layer], int_bit_relu[i_layer], is_signed_relu[i_layer],
                                    rounding_relu[i_layer], saturation_relu[i_layer]);
      }
 
 
      //input to next layer
      layerinput.clear();
      layerinput.assign(num_neurons, 0);
      layerinput.shrink_to_fit();
 
      for (unsigned i = 0; i < num_neurons; ++i) {
 
        layerinput[i] = sim_ap_fixed(layeroutput[i], W_input[i_layer][i], I_input[i_layer][i], false, 1, 4, 0);
 
      }
      if (i_layer == 0) {}
      else if (i_layer == 1) {
 
        layerinput[1] = 0;
        layerinput[10] = 0;
        layerinput[18] = 0;
 
      } else if (i_layer == 2) {
        layerinput[2] = 0;
        layerinput[16] = 0;
 
      }
 
 
    } else {
 
      // ===  HLS result_t: ap_fixed<19,5,AP_RND,AP_SAT_SYM,0> ===
      unsigned num_final_fixed = layeroutput.size();
      for (unsigned io = 0; io < num_final_fixed; ++io) {
        final_fixed.push_back(sim_result_t(layeroutput[io]));
      }
 
    }
  }
  return final_fixed;
}

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 137 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