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 > 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 107 of file GRLNeuro.h.

{}

~GRLNeuro()

virtual ~GRLNeuro ( )

inlinevirtual

Default destructor.

Definition at line 110 of file GRLNeuro.h.

{}

Member Function Documentation

initialize()

void initialize

(

const Parameters &

p

)

Set parameters and get some network independent parameters.

Definition at line 251 of file GRLNeuro.cc.

{
  using std::vector;
 
  // ------------------------------------------------------------------
  // 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);
  }
 
  if (p.outputScale.size() != 1 && p.outputScale.size() != p.nMLP) {
    B2FATAL("Number of outputScale lists should be 1 or " << p.nMLP);
  }
 
  unsigned short nTarget = static_cast<unsigned short>(p.targetresult);
  if (nTarget < 1) {
    B2FATAL("No outputs! Turn on targetresult.");
  }
 
  for (unsigned iScale = 0; iScale < p.outputScale.size(); ++iScale) {
    if (p.outputScale.at(iScale).size() != 2 * nTarget) {
      B2FATAL("outputScale should be exactly " << 2 * nTarget << " values");
    }
  }
 
  // ------------------------------------------------------------------
  // 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.outputScale, "outputScale");
 
  // 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");
  check_size(p.W_input_layer, "W_input_layer");
  check_size(p.I_input_layer, "I_input_layer");
 
  // ------------------------------------------------------------------
  // 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.at(0) : container.at(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.at(iHid) * nNodes.at(0)));
      } else {
        nNodes.push_back(static_cast<unsigned short>(nhidden.at(iHid)));
      }
    }
 
    nNodes.push_back(nTarget);
    unsigned short targetVars = static_cast<unsigned short>(p.targetresult);
 
    const vector<float>& outputScale = pick(p.outputScale);
 
    GRLMLP grlmlp_temp(nNodes, targetVars, outputScale);
 
    // 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));
    // input layer quantization parameters
    grlmlp_temp.set_W_input_layer(pick(p.W_input_layer));
    grlmlp_temp.set_I_input_layer(pick(p.I_input_layer));
 
    m_MLPs.push_back(std::move(grlmlp_temp));
  }
}

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 569 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.at(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 619 of file GRLNeuro.cc.

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

nSectors()

unsigned nSectors ( ) const

inline

return number of neural networks

Definition at line 120 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 116 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 118 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) - all 10 outputs for firmware compatibility

Definition at line 423 of file GRLNeuro.cc.

{
  const GRLMLP& expert = m_MLPs.at(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 quantization parameters
  vector<vector<int>> W_input_layer = expert.get_W_input_layer();
  vector<vector<int>> I_input_layer = expert.get_I_input_layer();
 
  // Use actual input
  vector<float> layerinput = input;
 
  // Input layer quantization: firmware uses TWO steps:
  // Step 1: float -> input_layer_t (ap_fixed<13,13>) with AP_RND, AP_SAT_SYM
  // Step 2: input_layer_t -> dense_0_iq_t (per-input ap_fixed<W,I>) with AP_RND, AP_WRAP
 
  // First, quantize raw input to input_layer_t (ap_fixed<13,13>)
  // Firmware: ap_fixed<13,13> with AP_TRN (signed: floor toward -inf), AP_WRAP (defaults)
  for (size_t i = 0; i < layerinput.size(); ++i) {
    // AP_TRN for signed = floor (toward -inf), AP_WRAP
    layerinput.at(i) = sim_ap_fixed(layerinput.at(i), 13, 13, true, 3, 2,
                                    0);  // signed, quant_mode=3 (floor), overflow_mode=2 (AP_WRAP)
  }
 
  // Use the first layer's W/I for input quantization (dense_0_iq)
  const auto& w_layer = W_input_layer.at(0);
  const auto& i_layer = I_input_layer.at(0);
 
  // Step 2: dense_0_iq quantization with per-input W, I
  for (size_t i = 0; i < layerinput.size(); ++i) {
    // dense_0_iq quantization: signed, quant_mode=1 (AP_RND), overflow_mode=2 (AP_WRAP)
    layerinput.at(i) = sim_ap_fixed(layerinput.at(i), w_layer.at(i), i_layer.at(i), true, 1, 2, 0);
  }
 
  //hidden layer and output layer
  vector<float> layeroutput = {};
  unsigned num_layers = expert.get_number_of_layers();
 
  unsigned num_total_neurons = 0;
  unsigned iw = 0;
  for (unsigned iw_layer = 0; iw_layer < num_layers - 1; iw_layer++) {
    //read bias
    unsigned num_neurons = expert.get_number_of_nodes_layer(iw_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.at(io + num_total_neurons);
      float bias_fixed   = sim_ap_fixed(bias_raw, total_bit_bias.at(iw_layer), int_bit_bias.at(iw_layer), is_signed_bias.at(iw_layer),
                                        rounding_bias.at(iw_layer), saturation_bias.at(iw_layer), 0);
      float bias_contrib = sim_ap_fixed(bias_fixed, total_bit_accum.at(iw_layer), int_bit_accum.at(iw_layer),
                                        is_signed_accum.at(iw_layer),
                                        rounding_accum.at(iw_layer), saturation_accum.at(iw_layer), 0);
      layeroutput.at(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.at(ii);
      for (unsigned io = 0; io < num_neurons; ++io) {
        float weight_raw = weights.at(iw);
        float weight_fixed = sim_ap_fixed(weight_raw, total_bit_weight.at(iw_layer), int_bit_weight.at(iw_layer),
                                          is_signed_weight.at(iw_layer),
                                          rounding_weight.at(iw_layer), saturation_weight.at(iw_layer), 0);
        float product = input_val * weight_fixed;
        float contrib = sim_ap_fixed(product, total_bit_accum.at(iw_layer), int_bit_accum.at(iw_layer), is_signed_accum.at(iw_layer),
                                     rounding_accum.at(iw_layer), saturation_accum.at(iw_layer), 0);
        layeroutput.at(io) = sim_ap_fixed(layeroutput.at(io) + contrib, total_bit_accum.at(iw_layer), int_bit_accum.at(iw_layer),
                                          is_signed_accum.at(iw_layer), rounding_accum.at(iw_layer), saturation_accum.at(iw_layer), 0);
        ++iw;
      }
    }
    //     input*weight done
 
    if (iw_layer < num_layers - 2) {
      //relu
      for (unsigned io = 0; io < num_neurons; ++io) {
        float fixed_val = sim_ap_fixed(layeroutput.at(io), total_bit.at(iw_layer), int_bit.at(iw_layer), is_signed.at(iw_layer), 0,
                                       saturation.at(iw_layer), 0);
        float relu_val = (fixed_val > 0) ? fixed_val : 0;
        layeroutput.at(io) = sim_ap_fixed(relu_val, total_bit_relu.at(iw_layer), int_bit_relu.at(iw_layer), is_signed_relu.at(iw_layer),
                                          rounding_relu.at(iw_layer), saturation_relu.at(iw_layer), 0);
      }
      //input to next layer
      layerinput.clear();
      layerinput.assign(num_neurons, 0);
      layerinput.shrink_to_fit();
 
      for (unsigned i = 0; i < num_neurons; ++i) {
        // firmware: use ap_fixed with parameters from W_input/I_input
        // quant_mode=1 (AP_RND), overflow_mode=2 (AP_WRAP)
        // W=0 means this input is zeroed (sparse quantization)
        if (W_input.at(iw_layer).at(i) == 0) {
          layerinput.at(i) = 0.0f;
        } else {
          const bool iq_is_signed = (iw_layer != 3);  // dense_4_iq is ap_ufixed
          layerinput.at(i) = sim_ap_fixed(layeroutput.at(i), W_input.at(iw_layer).at(i), I_input.at(iw_layer).at(i), iq_is_signed, 1, 2, 0);
        }
      }
    } else {
      // Final output layer - return all 10 outputs
      // firmware: result_t is ap_fixed<19,10> with default AP_TRN (signed floor), AP_WRAP
      vector<float> final_output(10, 0.0f);
      for (unsigned io = 0; io < 10; ++io) {
        final_output.at(io) = sim_ap_fixed(layeroutput.at(io), 19, 10, true, 3, 2, 0);
      }
      return final_output;
    }
  }
 
  return vector<float>(10, 0.0f);
}

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