nnet Namespace Reference

Classes
struct	activ_config
struct	layer_config

Enumerations
enum	io_type { io_parallel = 0, io_serial }

Functions
template<class data_T , class res_T , typename CONFIG_T >
void	compute_layer (data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out], typename CONFIG_T::weight_t weights[CONFIG_T::n_in *CONFIG_T::n_out], typename CONFIG_T::bias_t biases[CONFIG_T::n_out])
float	exp_fcn_float (float input)
template<typename CONFIG_T , int N_TABLE>
void	init_exp_table (typename CONFIG_T::table_t table_out[N_TABLE])
template<typename CONFIG_T , int N_TABLE>
void	init_invert_table (typename CONFIG_T::table_t table_out[N_TABLE])
template<class res_T , typename CONFIG_T , int N_TABLE>
void	init_sigmoid_table (res_T table_out[N_TABLE])
template<typename CONFIG_T , int N_TABLE>
void	init_tanh_table (typename CONFIG_T::table_t table_out[N_TABLE])
template<class data_T , class res_T , typename CONFIG_T >
void	linear (data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_in])
template<class data_T , class res_T , typename CONFIG_T >
void	relu (data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_in])
template<class data_T , class res_T , typename CONFIG_T >
void	relu6 (data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_in])
template<class data_T , class res_T , int MAX_INT, typename CONFIG_T >
void	relu_max (data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_in])
template<class data_T , class res_T , typename CONFIG_T >
void	sigmoid (data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_in])
template<class out_T >
out_T	sigmoid_fcn_float (float input)
template<class data_T , class res_T , typename CONFIG_T >
void	softmax (data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_in])
template<class data_T , class res_T , typename CONFIG_T >
void	tanh (data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_in])

Enumeration Type Documentation

io_type

enum nnet::io_type

Enumerator
io_parallel
io_serial

Definition at line 28 of file nnet_common.h.

{ io_parallel = 0, io_serial };

Function Documentation

compute_layer()

template<class data_T , class res_T , typename CONFIG_T >

void nnet::compute_layer	(	data_T	data[CONFIG_T::n_in],
		res_T	res[CONFIG_T::n_out],
		typename CONFIG_T::weight_t	weights[CONFIG_T::n_in *CONFIG_T::n_out],
		typename CONFIG_T::bias_t	biases[CONFIG_T::n_out]
	)

Definition at line 50 of file nnet_layer.h.

References utilities::cache(), data, DIV_ROUNDUP, cuy::ii, findQualityFiles::jj, VarParsing::mult, and hltDeepSecondaryVertexTagInfosPFPuppi_cfi::weights.

                                                                    {
    unsigned cycle_factor = DIV_ROUNDUP(CONFIG_T::n_in * CONFIG_T::n_out, CONFIG_T::reuse_factor);
    typename CONFIG_T::weight_t mult[CONFIG_T::n_in * CONFIG_T::n_out];
    /*
    if(CONFIG_T::use_lowlatency) { 
      int multiplier_limit  = ceil(float(CONFIG_T::n_in*CONFIG_T::n_out) / float(CONFIG_T::reuse_factor)) - floor(float(CONFIG_T::n_zeros) / float(CONFIG_T::reuse_factor));
    } 
    */
    typename CONFIG_T::accum_t acc[CONFIG_T::n_out];
    for (unsigned iacc = 0; iacc < CONFIG_T::n_out; iacc++) {
      acc[iacc] = (typename CONFIG_T::accum_t)biases[iacc];
    }
    unsigned rufactor = CONFIG_T::reuse_factor;
    if (CONFIG_T::use_lowlatency) {
      rufactor = CONFIG_T::n_in;
      cycle_factor = CONFIG_T::n_out;
    }
    data_T cache;
    for (unsigned ii = 0; ii < rufactor; ii++) {
      if (CONFIG_T::use_lowlatency) {
        cache = data[ii];
      }
      for (unsigned jj = 0; jj < cycle_factor; jj++) {
        unsigned windex = ii * cycle_factor + jj;
        unsigned index = windex / CONFIG_T::n_out;
        if (windex > CONFIG_T::n_in * CONFIG_T::n_out - 1)
          continue;
        if (CONFIG_T::use_lowlatency) {
          mult[windex] = cache * (weights[windex]);
        } else {
          int aindex = windex / CONFIG_T::n_in;
          acc[aindex] += data[index] * weights[windex];
        }
      }
    }
    if (CONFIG_T::use_lowlatency) {
      // Accumulate multiplication result
      for (unsigned ii = 0; ii < CONFIG_T::n_in; ii++) {
        for (unsigned jj = 0; jj < CONFIG_T::n_out; jj++) {
          int index = ii * CONFIG_T::n_out + jj;
          acc[jj] += mult[index];
        }
      }
    }
    for (unsigned ires = 0; ires < CONFIG_T::n_out; ires++) {
      res[ires] = (res_T)(acc[ires]);
    }
  }

exp_fcn_float()

float nnet::exp_fcn_float ( float  input )

inline

Definition at line 134 of file nnet_activation.h.

References JetChargeProducer_cfi::exp, and input.

Referenced by init_exp_table().

{ return exp(input); }

init_exp_table()

template<typename CONFIG_T , int N_TABLE>

void nnet::init_exp_table

(

typename CONFIG_T::table_t

table_out[N_TABLE]

)

Definition at line 137 of file nnet_activation.h.

References exp_fcn_float(), dqmMemoryStats::float, cuy::ii, and P2L1HTMHTEmu::N_TABLE.

                                                                   {
    for (unsigned ii = 0; ii < N_TABLE; ii++) {
      // First, convert from table index to X-value (signed 8-bit, range -8 to +8)
      float in_val = 2 * 8.0 * (ii - float(N_TABLE) / 2.0) / float(N_TABLE);
      // Next, compute lookup table function
      typename CONFIG_T::table_t real_val = exp_fcn_float(in_val);
      //std::cout << "Lookup table In Value: " << in_val << " Result: " << real_val << std::endl;
      table_out[ii] = real_val;
    }
  }

init_invert_table()

template<typename CONFIG_T , int N_TABLE>

void nnet::init_invert_table

(

typename CONFIG_T::table_t

table_out[N_TABLE]

)

Definition at line 149 of file nnet_activation.h.

References dqmMemoryStats::float, cuy::ii, and P2L1HTMHTEmu::N_TABLE.

                                                                      {
    // Inversion function:
    //   result = 1/x
    for (unsigned ii = 0; ii < N_TABLE; ii++) {
      // First, convert from table index to X-value (signed 8-bit, range 0 to +64)
      float in_val = 64.0 * ii / float(N_TABLE);
      // Next, compute lookup table function
      if (in_val > 0.0)
        table_out[ii] = 1.0 / in_val;
      else
        table_out[ii] = 0.0;
    }
  }

init_sigmoid_table()

template<class res_T , typename CONFIG_T , int N_TABLE>

void nnet::init_sigmoid_table

(

res_T

table_out[N_TABLE]

)

Definition at line 98 of file nnet_activation.h.

References dqmMemoryStats::float, cuy::ii, and P2L1HTMHTEmu::N_TABLE.

                                                    {
    // Default logistic sigmoid function:
    //   result = 1/(1+e^(-x))
    for (unsigned ii = 0; ii < N_TABLE; ii++) {
      // First, convert from table index to X-value (signed 8-bit, range -8 to +8)
      float in_val = 2 * 8.0 * (ii - float(N_TABLE) / 2.0) / float(N_TABLE);
      // Next, compute lookup table function
      res_T real_val = sigmoid_fcn_float<res_T>(in_val);
      //std::cout << "Lookup table In Value: " << in_val << " Result: " << real_val << std::endl;
      table_out[ii] = (res_T)real_val;
    }
  }

init_tanh_table()

template<typename CONFIG_T , int N_TABLE>

void nnet::init_tanh_table

(

typename CONFIG_T::table_t

table_out[N_TABLE]

)

Definition at line 214 of file nnet_activation.h.

References dqmMemoryStats::float, cuy::ii, P2L1HTMHTEmu::N_TABLE, and tanh().

                                                                    {
    // Implement tanh lookup
    for (unsigned ii = 0; ii < N_TABLE; ii++) {
      // First, convert from table index to X-value (signed 8-bit, range -4 to +4)
      float in_val = 2 * 4.0 * (ii - float(N_TABLE) / 2.0) / float(N_TABLE);
      // Next, compute lookup table function
      typename CONFIG_T::table_t real_val = tanh(in_val);
      //std::cout << "Tanh:  Lookup table Index: " <<  ii<< " In Value: " << in_val << " Result: " << real_val << std::endl;
      table_out[ii] = real_val;
    }
  }

linear()

template<class data_T , class res_T , typename CONFIG_T >

void nnet::linear	(	data_T	data[CONFIG_T::n_in],
		res_T	res[CONFIG_T::n_in]
	)

Definition at line 49 of file nnet_activation.h.

References data, and cuy::ii.

                                                                  {
    for (unsigned ii = 0; ii < CONFIG_T::n_in; ii++) {
      res[ii] = data[ii];
    }
  }

relu()

template<class data_T , class res_T , typename CONFIG_T >

void nnet::relu	(	data_T	data[CONFIG_T::n_in],
		res_T	res[CONFIG_T::n_in]
	)

Definition at line 59 of file nnet_activation.h.

References data, and cuy::ii.

                                                                {
    data_T datareg;
    for (unsigned ii = 0; ii < CONFIG_T::n_in; ii++) {
      datareg = data[ii];
      if (datareg > 0)
        res[ii] = datareg;
      else
        res[ii] = 0;
    }
  }

relu6()

template<class data_T , class res_T , typename CONFIG_T >

void nnet::relu6	(	data_T	data[CONFIG_T::n_in],
		res_T	res[CONFIG_T::n_in]
	)

Definition at line 85 of file nnet_activation.h.

References data.

                                                                 {
    relu_max<data_T, res_T, 6, CONFIG_T>(data, res);
  }

relu_max()

template<class data_T , class res_T , int MAX_INT, typename CONFIG_T >

void nnet::relu_max	(	data_T	data[CONFIG_T::n_in],
		res_T	res[CONFIG_T::n_in]
	)

Definition at line 71 of file nnet_activation.h.

References data, and cuy::ii.

                                                                    {
    data_T datareg;
    for (unsigned ii = 0; ii < CONFIG_T::n_in; ii++) {
      datareg = data[ii];
      if (datareg < 0)
        res[ii] = 0;
      else if (datareg > MAX_INT)
        res[ii] = MAX_INT;
      else
        res[ii] = datareg;
    }
  }

sigmoid()

template<class data_T , class res_T , typename CONFIG_T >

void nnet::sigmoid	(	data_T	data[CONFIG_T::n_in],
		res_T	res[CONFIG_T::n_in]
	)

Definition at line 112 of file nnet_activation.h.

References data, and cuy::ii.

                                                                   {
    // Initialize the lookup table
    res_T sigmoid_table[CONFIG_T::table_size];
    init_sigmoid_table<res_T, CONFIG_T, CONFIG_T::table_size>(sigmoid_table);

    // Index into the lookup table based on data
    int data_round;
    unsigned index;
    for (unsigned ii = 0; ii < CONFIG_T::n_in; ii++) {
      data_round = data[ii] * CONFIG_T::table_size / 16;
      index = data_round + 8 * CONFIG_T::table_size / 16;
      /*if (index < 0)
        index = 0;*/
      if (index > CONFIG_T::table_size - 1)
        index = CONFIG_T::table_size - 1;
      res[ii] = (res_T)sigmoid_table[index];
    }
  }

sigmoid_fcn_float()

template<class out_T >

out_T nnet::sigmoid_fcn_float ( float  input )

inline

Definition at line 93 of file nnet_activation.h.

References JetChargeProducer_cfi::exp, and input.

                                              {
    return 1.0 / (1 + exp(-input));
  }

softmax()

template<class data_T , class res_T , typename CONFIG_T >

void nnet::softmax	(	data_T	data[CONFIG_T::n_in],
		res_T	res[CONFIG_T::n_in]
	)

Definition at line 164 of file nnet_activation.h.

References data, cuy::ii, and findQualityFiles::jj.

                                                                   {
    // Initialize the lookup table
    typename CONFIG_T::table_t exp_table[CONFIG_T::table_size];
    init_exp_table<CONFIG_T, CONFIG_T::table_size>(exp_table);

    typename CONFIG_T::table_t invert_table[CONFIG_T::table_size];
    init_invert_table<CONFIG_T, CONFIG_T::table_size>(invert_table);

    // Index into the lookup table based on data for exponentials
    typename CONFIG_T::table_t exp_res[CONFIG_T::n_in];  // different, independent, fixed point precision
    typename CONFIG_T::table_t exp_diff_res[CONFIG_T::n_in]
                                           [CONFIG_T::n_in];  // different, independent, fixed point precision
    int data_round;
    int index;
    for (int ii = 0; ii < CONFIG_T::n_in; ii++) {
      exp_res[ii] = 0;
    }
    for (int ii = 0; ii < CONFIG_T::n_in; ii++) {
      for (int jj = 0; jj < CONFIG_T::n_in; jj++) {
        if (ii == jj)
          exp_diff_res[ii][jj] = 1;
        else {
          data_round = (data[jj] - data[ii]) * CONFIG_T::table_size / 16;
          index = data_round + 8 * CONFIG_T::table_size / 16;
          if (index < 0)
            index = 0;
          if (index > CONFIG_T::table_size - 1)
            index = CONFIG_T::table_size - 1;
          exp_diff_res[ii][jj] = exp_table[index];
        }
        exp_res[ii] += exp_diff_res[ii][jj];
      }
    }

    //Second loop to invert
    for (unsigned ii = 0; ii < CONFIG_T::n_in; ii++) {
      int exp_res_index = exp_res[ii] * CONFIG_T::table_size / 64;
      if (exp_res_index < 0)
        exp_res_index = 0;
      if (exp_res_index > CONFIG_T::table_size - 1)
        exp_res_index = CONFIG_T::table_size - 1;
      //typename CONFIG_T::table_t exp_res_invert = invert_table[exp_res_index];
      res[ii] = (res_T)invert_table[exp_res_index];
    }
  }

tanh()

template<class data_T , class res_T , typename CONFIG_T >

void nnet::tanh	(	data_T	data[CONFIG_T::n_in],
		res_T	res[CONFIG_T::n_in]
	)

Definition at line 227 of file nnet_activation.h.

References data, and cuy::ii.

Referenced by ZCountingElectrons::analyze(), HcalGeomCheck::analyze(), CSCGattiFunction::binValue(), HFRecoEcalCandidateAlgo::correctEPosition(), HcalHardcodeGeometryLoader::fillHE(), HcalFlexiHardcodeGeometryLoader::fillHE(), GflashHadronShowerProfile::fTanh(), FWExpressionValidator::FWExpressionValidator(), PythiaFilterIsolatedTrack::getDistInCM(), spr::getDistInCMatEcal(), spr::getDistInCMatHcal(), IsoTrig::getGoodTracks(), HFGflash::gfParameterization(), init_tanh_table(), reco::HcalIsolatedTrackCandidate::l1jetp(), CaloTowerHardcodeGeometryLoader::makeCell(), SiPixelDigitizerAlgorithm::missCalibrate(), reco::parser::tanh_f::operator()(), HFRecoEcalCandidateAlgo::produce(), L2MuonSeedGeneratorFromL1TkMu::produce(), CaloDualConeSelector< T >::selectCallback(), CaloConeSelector< T >::selectCallback(), GflashShowino::simulateFirstInteractionPoint(), QGLikelihoodCalculator::smearingFunction(), reco::isodeposit::Direction::theta(), and pat::PackedGenParticle::unpack().

                                                                {
    // Initialize the lookup table
    typename CONFIG_T::table_t tanh_table[CONFIG_T::table_size];
    init_tanh_table<CONFIG_T, CONFIG_T::table_size>(tanh_table);

    // Index into the lookup table based on data
    int data_round;
    int index;
    for (int ii = 0; ii < CONFIG_T::n_in; ii++) {
      data_round = data[ii] * CONFIG_T::table_size / 8;
      index = data_round + 4 * CONFIG_T::table_size / 8;
      //std::cout << "Input: "  << data[ii] << " Round: " << data_round << " Index: " << index << std::endl;
      if (index < 0)
        index = 0;
      if (index > CONFIG_T::table_size - 1)
        index = CONFIG_T::table_size - 1;
      res[ii] = (res_T)tanh_table[index];
    }
  }