The class uses a neural network to find a probability distribution of arrival times for a sextet of APX25 signal samples. More...

#include <NNWaveFitter.h>

Public Types
typedef std::pair< double, double >	nnBoundsType
	Bounds type used to hold network parameter bounds used in training the network.

Public Member Functions
	NNWaveFitter (std::string xmlData="")
	Constructor constructs the wavefitter from data in xml file.

void	setNetwrok (const std::string &xmlData)
	Set proper network definition file.

std::shared_ptr< nnFitterBinData >	getFit (const apvSamples &samples, double tau)
	Fitting method Send data and get rseult structure.

const NNWaveFitTool &	getFitTool () const
	Get a handle to a NNWaveFit object.

const nnFitterBinData &	getBinCenters () const
	Get bin times of the network output.

const nnFitterBins &	getBins () const
	Get bins of netwrok output.

nnBoundsType	getWaveWidthBounds () const
	Get width bounds Width bounds are minimum and maximum width used in training the network.

nnBoundsType	getAmplitudeBounds () const
	Get amplitude bounds.

nnBoundsType	getTimeShiftBounds () const
	Get time shift bounds.

bool	isValid () const
	Is this fitter working? Return false if the fitter was not initialized properly.

bool	checkCoefficients (const std::string &dumpname, double tol=1.0e-10)
	Check NN data against a dump from Python.

Private Types
typedef std::function< double(double)>	activationType
	Activation functions type.

typedef std::map< size_t, std::pair< Eigen::MatrixXd, Eigen::VectorXd > >	networkWeightsType
	We use map to store network layers since we don't know if we'll be reading them in correct order.

typedef std::vector< Eigen::VectorXd >	layerStatesType
	Storage for internal states.

Private Member Functions
Eigen::VectorXd	softmax (const Eigen::VectorXd &input)
	Softmax function, normalization for the network's output layer.

int	readNetworkData (const std::string &xmlFileName)
	The method that actually reads the xml file.

Private Attributes
activationType	relu
	Rectifier activation.

activationType	sigmoid
	Sigmoid activation.

bool	m_isValid
	true if fitter was properly initialized

std::size_t	m_nLayers
	number of NN layers, read from xml

nnFitterBinData	m_binCenters
	centers of NN time bins

nnFitterBins	m_bins
	NN time bin boundaries.

layerStatesType	m_layerStates
	vectors of layer states

std::vector< std::size_t >	m_layerSizes
	NN layer sizes.

networkWeightsType	m_networkCoefs
	NN weights and intercepts.

activationType	m_activation
	Network activation function.

nnBoundsType	m_amplitudeBounds
	Amplitude range of the network.

nnBoundsType	m_waveWidthBounds
	Waveform width range of the network.

nnBoundsType	m_timeShiftBounds
	Time shift range of the network.

TauEncoder	m_tauCoder
	Tau encoder class instance to scale tau values.

WaveformShape	m_wave
	Wave function used in training the network.

std::shared_ptr< NNWaveFitTool >	m_fitTool
	FitterTool object allowing calculations on network fits.

Detailed Description

The class uses a neural network to find a probability distribution of arrival times for a sextet of APX25 signal samples.

The input to the network are sample S/N ratios, i.e., we expect sigma^2 = 1, plus width of the waveform from calibration data. The network(s) is currently trained using Python's scikit-learn package and results are saved in a PMML-like xml file. The NNWaveFitter reads the contents of this xml and on request provides the following data to the calling routine:

Signal's arrival time estimate and its error,
Signal's amplitude and its error,
chi2 of the fit
(Binned) probability distribution for arrival time.

The network is a multiclass classifier and the time bin probabilities are its main output. Time and amplitude are calculated from this distribution. The probability distribution is useful by itself in background suppression and u/v hit pairing.

The input xml file has, with a few extensions, the official PMML format (http://dmg.org), which can be created and read by most machine learning libraries.

The fitter generates a NNWaveFit object to aid in computations with bin probabilities, such as shifting, multiplication, calculations of time shift, amplitude and their errors.

Definition at line 61 of file NNWaveFitter.h.

Member Typedef Documentation

◆ activationType

typedef std::function<double(double)> activationType

private

Activation functions type.

Definition at line 143 of file NNWaveFitter.h.

◆ layerStatesType

typedef std::vector<Eigen::VectorXd> layerStatesType

private

Storage for internal states.

Definition at line 177 of file NNWaveFitter.h.

◆ networkWeightsType

typedef std::map< size_t, std::pair< Eigen::MatrixXd, Eigen::VectorXd > > networkWeightsType

private

We use map to store network layers since we don't know if we'll be reading them in correct order.

Definition at line 174 of file NNWaveFitter.h.

◆ nnBoundsType

typedef std::pair<double, double> nnBoundsType

Bounds type used to hold network parameter bounds used in training the network.

Also, this is the range guaranteed network applicability.

Definition at line 70 of file NNWaveFitter.h.

Constructor & Destructor Documentation

◆ NNWaveFitter()

NNWaveFitter ( std::string xmlData = "" )

Constructor constructs the wavefitter from data in xml file.

Parameters

xmlData string containing the network definition xml tree

Definition at line 260 of file NNWaveFitter.cc.

{
  m_wave = w_betaprime;
  if (xmlData != "") setNetwrok(xmlData);
}

Member Function Documentation

◆ checkCoefficients()

bool checkCoefficients	(	const std::string &	dumpname,
		double	tol = `1.0e-10`
	)

Check NN data against a dump from Python.

Parameters

dumpname	Filename of a text dump of network coefficients.
tol	Tolerance for float comparisons

Returns: true if all comparisons pass.

Definition at line 192 of file NNWaveFitter.cc.

{
  bool result = true;
  ifstream dump(dumpname);
 
  // Read the dumpfile line by line and compare coefficients.
  string line;
  getline(dump, line); // Header
  // The dimension of the matrix is
  // (m_layerSizes[iLayer], m_layerSizes[iLayer-1])
  // and the dimension of the intercepts is
  // m_layerSizes[iLayer]
  for (size_t iLayer = 1; iLayer < m_nLayers; ++iLayer) {
    getline(dump, line); // Layer
    getline(dump, line); // Matrix
    // the matrix is m_networkCoefs[iLayer].first, and has
    // m_layerSizes[iLayer] rows with m_layerSizes[iLayer-1] entries
    // in a row (columns)
    for (size_t iRow = 0; iRow < m_layerSizes[iLayer]; ++iRow) {
      getline(dump, line);
      istringstream iline(line);
      for (size_t iCol = 0; iCol < m_layerSizes[iLayer - 1]; ++iCol) {
        double value = 0;
        iline >> value;
        if (fabs(value - m_networkCoefs[iLayer].first(iRow, iCol)) > tol) {
          B2DEBUG(90, "Mismatch in weights in layer: " << iLayer
                  << " row: " << iRow << " col: " << iCol
                  << " C++: " << m_networkCoefs[iLayer].first(iRow, iCol)
                  << " Python: " << value
                  << " Diff: " << m_networkCoefs[iLayer].first(iRow, iCol) - value
                 );
          result = false;
        }
      }
    }
 
    getline(dump, line); // Intercepts
    // this is m_networkCoefs[iLayer].second, and has m_layerSizes[iLayer]
    // numbers in a single row.
    getline(dump, line);
    istringstream iline(line);
    for (size_t iRow = 0; iRow < m_layerSizes[iLayer]; ++iRow) {
      double value = 0;
      iline >> value;
      if (fabs(value - m_networkCoefs[iLayer].second(iRow)) > tol) {
        B2DEBUG(90, "Mismatch in intercepts in layer: " << iLayer
                << " row: " << iRow
                << " C++: " << m_networkCoefs[iLayer].second(iRow)
                << " Python: " << value
                << " Diff: " << m_networkCoefs[iLayer].second(iRow) - value
               );
 
        result = false;
      }
    }
  }
  return result;
}

◆ getAmplitudeBounds()

nnBoundsType getAmplitudeBounds ( ) const

inline

Get amplitude bounds.

Returns: std::pair of amplitude bounds used in simulation

Definition at line 121 of file NNWaveFitter.h.

121{ return m_amplitudeBounds; }

Belle2::SVD::NNWaveFitter::m_amplitudeBounds

nnBoundsType m_amplitudeBounds

Amplitude range of the network.

Definition: NNWaveFitter.h:188

◆ getBinCenters()

const nnFitterBinData & getBinCenters ( ) const

inline

Get bin times of the network output.

Returns: array of mean bin times (averaged over training data), properly sorted.

Definition at line 104 of file NNWaveFitter.h.

104{ return m_binCenters; }

Belle2::SVD::NNWaveFitter::m_binCenters

nnFitterBinData m_binCenters

centers of NN time bins

Definition: NNWaveFitter.h:182

◆ getBins()

const nnFitterBins & getBins ( ) const

inline

Get bins of netwrok output.

Returns: array of bin edges (length of timebase + 1)

Definition at line 109 of file NNWaveFitter.h.

109{ return m_bins; }

Belle2::SVD::NNWaveFitter::m_bins

nnFitterBins m_bins

NN time bin boundaries.

Definition: NNWaveFitter.h:183

◆ getFit()

std::shared_ptr< nnFitterBinData > getFit	(	const apvSamples &	samples,
		double	tau
	)

Fitting method Send data and get rseult structure.

If the fitter is not properly initialized, empty structure with valid = false will be returned, no warning - warning is only given for unsuccessful initialization.

Parameters

samples	Array of 6 apv samples
tau	The wave width for the current strip (unencoded ns)

Returns: Pointer to array of bin probabilities.

Definition at line 267 of file NNWaveFitter.cc.

{
  // Create the fit result object
  std::shared_ptr<nnFitterBinData> result(new nnFitterBinData);
  if (!m_isValid) return result;
 
  copy(samples.begin(), samples.end(), &m_layerStates[0](0));
  // Add tau in the last input cell
  m_layerStates[0][samples.size()] = m_tauCoder.encodeTau(tau);
  ostringstream os;
  os << "Fitting with tau = " << tau << " encoded to " << m_tauCoder.encodeTau(tau) << endl
     << "Samples: ";
  copy(samples.begin(), samples.end(), ostream_iterator<double>(os, " "));
  os << endl;
  m_tauCoder.print(os);
  B2DEBUG(100, os.str());
  // Calculate network response
  os.str() = "";
  os << "Layer states: " << endl;
  for (size_t iLayer = 1; iLayer < m_nLayers; ++iLayer) {
    m_layerStates[iLayer] = (
                              m_networkCoefs[iLayer].first * m_layerStates[iLayer - 1]
                              + m_networkCoefs[iLayer].second
                            ).unaryExpr(relu);
    os << m_layerStates[iLayer] << endl;
  }
  B2DEBUG(100, os.str());
 
  // Output transformation 1: softmax normalization
 
  m_layerStates[m_nLayers - 1] = softmax(m_layerStates[m_nLayers - 1]);
 
  result->resize(m_layerStates[m_nLayers - 1].size());
  for (size_t i = 0; i < result->size(); ++i)
    (*result)[i] = m_layerStates[m_nLayers - 1][i];
 
  os.str() = "";
  os << "Result: " << endl;
  copy(result->begin(), result->end(), ostream_iterator<double>(os, " "));
  os << endl;
  B2DEBUG(100, os.str());
 
  return result;
}

◆ getFitTool()

const NNWaveFitTool & getFitTool ( ) const

inline

Get a handle to a NNWaveFit object.

The object provides a set of tools to maniulate probabilities and calculate things from probability distributions.

Definition at line 98 of file NNWaveFitter.h.

98{ return *m_fitTool; }

Belle2::SVD::NNWaveFitter::m_fitTool

std::shared_ptr< NNWaveFitTool > m_fitTool

FitterTool object allowing calculations on network fits.

Definition: NNWaveFitter.h:193

◆ getTimeShiftBounds()

nnBoundsType getTimeShiftBounds ( ) const

inline

Get time shift bounds.

Returns: std::pair of time shift bounds used in simulation

Definition at line 126 of file NNWaveFitter.h.

126{ return m_timeShiftBounds; }

Belle2::SVD::NNWaveFitter::m_timeShiftBounds

nnBoundsType m_timeShiftBounds

Time shift range of the network.

Definition: NNWaveFitter.h:190

◆ getWaveWidthBounds()

nnBoundsType getWaveWidthBounds ( ) const

inline

Get width bounds Width bounds are minimum and maximum width used in training the network.

The bounds are used to encode width on input to the fitter.

Definition at line 116 of file NNWaveFitter.h.

116{ return m_waveWidthBounds; }

Belle2::SVD::NNWaveFitter::m_waveWidthBounds

nnBoundsType m_waveWidthBounds

Waveform width range of the network.

Definition: NNWaveFitter.h:189

◆ isValid()

bool isValid ( ) const

inline

Is this fitter working? Return false if the fitter was not initialized properly.

Definition at line 131 of file NNWaveFitter.h.

131{ return m_isValid; }

◆ readNetworkData()

int readNetworkData ( const std::string & xmlFileName )

private

The method that actually reads the xml file.

Counting things in NN:

Parameters

xmlFileName Name of the source xml file with network data

Returns: 0: OK, -1: something went wrong.

Layers: input (hidden layers) output = n_hidden_lyaers + 2 = m_nLayers 0,1,2,... m_nLayers - 1. Layer sizes: input is 6, output is given by time binning in training, so we know terms 0 and m_nLayers - 1, and we can even establish hidden layer sizes beforehand from the repr of the classifier! Weights are about connections between layers, so we have w01, w12,.. w(m_nLayers-2)(m_nLayers-1) so we denote w1, w2, ... w(m_nLayers - 1) Intercepts are related to neurons where connections converge and activation is applied. So we have i1,...i(m_nLayers - 1).

Definition at line 36 of file NNWaveFitter.cc.

{
  using namespace boost::property_tree;
  using boost::property_tree::ptree;
 
  ptree propertyTree;
 
  try {
    B2DEBUG(400, "Reading xml");
    stringstream ss;
    ss << xmlData;
    read_xml(ss, propertyTree);
  } catch (const ptree_error& e) {
    B2ERROR("Failed to parse xml data: " << e.what());
  } catch (std::exception const& ex) {
    B2ERROR("STD excpetion " << ex.what() << " in parsing.");
    return -1;
  }
  // 1. Check that we have a classifier with relu activation.
  try {
    // 1a. Classifier
    string function_name = propertyTree.get<string>("PMML.NeuralNetwork.<xmlattr>.functionName");
    if (function_name != "classification") {
      B2ERROR("This is incorrect network, expected multiclass classifier.");
      return -1;
    }
    B2DEBUG(400, "Claasifier confirmed.");
    // 1b. Activation
    string activationFunction = propertyTree.get<string>("PMML.NeuralNetwork.<xmlattr>.activationFunction");
    if (activationFunction != "rectifier") {
      B2ERROR("Expected rectifier (relu) activation, found " << activationFunction << "instead.");
      return -1;
    }
    B2DEBUG(400, "Activation confirmed.");
    // 1c.Waveform type FIXME: no logic or checking here:
    string waveFormType = propertyTree.get<string>("PMML.MiningBuildTask.Training.Waveform");
    B2DEBUG(400, "Waveform set to " << waveFormType);
  } catch (const ptree_error& e) {
    B2ERROR("PropertyTree excpetion : " << e.what() << " in network check.");
    return -1;
  }
 
  // 2. Read network topology
  try {
    string pathString = "PMML.MiningBuildTask.NetworkParameters";
    map<size_t, size_t> m_layer_sizes_map;
    for (const auto& layer_tag : propertyTree.get_child(pathString)) {
      if (layer_tag.first == "<xmlattr>") continue;
      size_t layer_no = layer_tag.second.get<size_t>("<xmlattr>.number");
      size_t layer_size = layer_tag.second.get<size_t>("<xmlattr>.size");
      m_layer_sizes_map.insert(make_pair(layer_no, layer_size));
    }
    // Once we have layer sizes, we can set weight matrices and intercept
    // vectors to proper sizes.
    m_nLayers = m_layer_sizes_map.size();
    m_layerSizes.resize(m_nLayers);
    for (size_t iLayer = 0; iLayer < m_nLayers; ++iLayer)
      m_layerSizes[iLayer] = m_layer_sizes_map[iLayer];
    for (size_t iLayer = 1; iLayer < m_nLayers; ++iLayer) {
      m_networkCoefs.insert(make_pair(iLayer, make_pair(
                                        MatrixXd(m_layerSizes[iLayer], m_layerSizes[iLayer - 1]),
                                        VectorXd(m_layerSizes[iLayer])
                                      )
                                     ));
    }
    for (size_t iLayer = 0; iLayer < m_nLayers; ++iLayer)
      m_layerStates.push_back(VectorXd(m_layerSizes[iLayer]));
    B2DEBUG(400, "Network topology read.");
  } catch (const ptree_error& e) {
    B2ERROR("PropertyTree excpetion : " << e.what() << " when reading network topology.");
    return -1;
  }
 
  // Read training parameter bounds
  try {
    string pathString("PMML.MiningBuildTask.Training");
    for (const auto& param_tag : propertyTree.get_child(pathString)) {
      if (param_tag.first == "Parameter") {
        string valueString(param_tag.second.get<string>("<xmlattr>.value"));
        double low = param_tag.second.get<double>("<xmlattr>.low");
        double high = param_tag.second.get<double>("<xmlattr>.high");
        if (valueString == "amplitude") {
          m_amplitudeBounds.first =  low;
          m_amplitudeBounds.second = high;
        } else if (valueString == "t0") {
          m_timeShiftBounds.first = low * Unit::ns;
          m_timeShiftBounds.second = high * Unit::ns;
        } else if (valueString == "tau") {
          m_waveWidthBounds.first = low * Unit::ns;
          m_waveWidthBounds.second = high * Unit::ns;
        }
      }
    }
    // Set bounds in the tau encoder.
    // Tau bounds are raw values!
    m_tauCoder.setBounds(m_amplitudeBounds.first, m_amplitudeBounds.second,
                         m_waveWidthBounds.first, m_waveWidthBounds.second);
    B2DEBUG(400, "Read parameter bounds.");
  } catch (const ptree_error& e) {
    B2ERROR("PropertyTree excpetion: " << e.what() << " when reading parameter bounds.");
    return -1;
  }
 
  // Reading output binning.
  try {
    string pathString("PMML.DataDictionary.DataField");
    m_binCenters.resize(m_layerSizes[m_nLayers - 1]);
    m_bins.resize(m_layerSizes[m_nLayers - 1] + 1);
    for (const auto& value_tag : propertyTree.get_child(pathString)) {
      if (value_tag.first == "Value") {
        size_t i = value_tag.second.get<size_t>("<xmlattr>.value");
        if (i == 1) // numbering is from 1!
          m_bins[0] = value_tag.second.get<double>("<xmlattr>.lower") * Unit::ns;
        m_bins[i] = value_tag.second.get<double>("<xmlattr>.upper") * Unit::ns;
        m_binCenters[i - 1] = value_tag.second.get<double>("<xmlattr>.midpoint") * Unit::ns;
      }
    }
    m_fitTool = std::shared_ptr<NNWaveFitTool>(new NNWaveFitTool(m_bins, m_binCenters, WaveGenerator(m_wave)));
    B2DEBUG(400, "Outputs done.");
  } catch (const ptree_error& e) {
    B2ERROR("PropertyTree excpetion: " << e.what() << " when reading bin data.");
    return -1;
  }
 
  // Reading neurons.
  try {
    string pathString("PMML.NeuralNetwork");
    for (const auto& nl_tag : propertyTree.get_child(pathString)) {
      if (nl_tag.first != "NeuralLayer") continue;
      B2DEBUG(400, "Reading neural layers " << nl_tag.first << " " << nl_tag.second.size());
      for (const auto& neuron_tag : nl_tag.second) {
        if (neuron_tag.first != "Neuron") continue;
        double bias = neuron_tag.second.get<double>("<xmlattr>.bias");
        string sid = neuron_tag.second.get<string>("<xmlattr>.id");
        size_t layer = stoi(sid.substr(0, 1)); // !! Won't work with > 9 !!
        size_t pos = stoi(sid.substr(2, sid.size()));
        B2DEBUG(400, "Reading neurons " << layer << "/" << pos << " bias: " << bias);
        m_networkCoefs[layer].second(pos - 1) = bias;
        for (const auto& con_tag : neuron_tag.second) {
          if (con_tag.first != "Con") continue;
          double weight = con_tag.second.get<double>("<xmlattr>.weight");
          string sid2 = con_tag.second.get<string>("<xmlattr>.from");
          size_t pos2 = stoi(sid2.substr(sid2.find('/') + 1, sid2.size()));
          m_networkCoefs[layer].first(pos - 1, pos2 - 1) = weight;
          B2DEBUG(400, "Reading connections " << sid2 << " weight: " << weight);
        }
      }
    }
    B2DEBUG(400, "Neurons done.");
  } catch (const ptree_error& e) {
    B2ERROR("PropertyTree excpetion: " << e.what() << " when reading neurons.");
    return -1;
  }
  return 0;
}

◆ setNetwrok()

void setNetwrok ( const std::string & xmlData )

Set proper network definition file.

Parameters

xmlData string containing the network definition xml tree

Definition at line 251 of file NNWaveFitter.cc.

{
  if ((xmlData != "") && (readNetworkData(xmlData) == 0)) {
    m_isValid = true;
  } else m_isValid = false;
  // We don't issue any additional warnings here.
}

◆ softmax()

Eigen::VectorXd softmax ( const Eigen::VectorXd & input )

inlineprivate

Softmax function, normalization for the network's output layer.

This is a strange softmax that maps zero values back to zero, but this is what scikit-learn returns.

Definition at line 155 of file NNWaveFitter.h.

      {
        auto output = input.array().unaryExpr(
                        [](double x)->double { return ((x > 0.0) ? exp(x) : 0.0); }
                      );
        double norm = output.sum();
        return output / norm;
      }

Member Data Documentation

◆ m_activation

activationType m_activation

private

Network activation function.

Definition at line 187 of file NNWaveFitter.h.

◆ m_amplitudeBounds

nnBoundsType m_amplitudeBounds

private

Amplitude range of the network.

Definition at line 188 of file NNWaveFitter.h.

◆ m_binCenters

nnFitterBinData m_binCenters

private

centers of NN time bins

Definition at line 182 of file NNWaveFitter.h.

◆ m_bins

nnFitterBins m_bins

private

NN time bin boundaries.

Definition at line 183 of file NNWaveFitter.h.

◆ m_fitTool

std::shared_ptr<NNWaveFitTool> m_fitTool

private

FitterTool object allowing calculations on network fits.

Definition at line 193 of file NNWaveFitter.h.

◆ m_isValid

bool m_isValid

private

true if fitter was properly initialized

Definition at line 180 of file NNWaveFitter.h.

◆ m_layerSizes

std::vector<std::size_t> m_layerSizes

private

NN layer sizes.

Definition at line 185 of file NNWaveFitter.h.

◆ m_layerStates

layerStatesType m_layerStates

private

vectors of layer states

Definition at line 184 of file NNWaveFitter.h.

◆ m_networkCoefs

networkWeightsType m_networkCoefs

private

NN weights and intercepts.

Definition at line 186 of file NNWaveFitter.h.

◆ m_nLayers

std::size_t m_nLayers

private

number of NN layers, read from xml

Definition at line 181 of file NNWaveFitter.h.

◆ m_tauCoder

TauEncoder m_tauCoder

private

Tau encoder class instance to scale tau values.

Definition at line 191 of file NNWaveFitter.h.

◆ m_timeShiftBounds

nnBoundsType m_timeShiftBounds

private

Time shift range of the network.

Definition at line 190 of file NNWaveFitter.h.

◆ m_wave

WaveformShape m_wave

private

Wave function used in training the network.

Definition at line 192 of file NNWaveFitter.h.

◆ m_waveWidthBounds

nnBoundsType m_waveWidthBounds

private

Waveform width range of the network.

Definition at line 189 of file NNWaveFitter.h.

◆ relu

activationType relu

private

Initial value:

=

[](double x) -> double { return std::max(double(0.0), x); }

Rectifier activation.

Definition at line 145 of file NNWaveFitter.h.

◆ sigmoid

activationType sigmoid

private

Initial value:

=

[](double x) -> double { double e = std::exp(x); return e / (1.0 + e); }

Sigmoid activation.

Definition at line 148 of file NNWaveFitter.h.

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

svd/reconstruction/include/NNWaveFitter.h
svd/reconstruction/src/NNWaveFitter.cc

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ activationType

◆ layerStatesType

◆ networkWeightsType

◆ nnBoundsType

Constructor & Destructor Documentation

◆ NNWaveFitter()

Member Function Documentation

◆ checkCoefficients()

◆ getAmplitudeBounds()

◆ getBinCenters()

◆ getBins()

◆ getFit()

◆ getFitTool()

◆ getTimeShiftBounds()

◆ getWaveWidthBounds()

◆ isValid()

◆ readNetworkData()

◆ setNetwrok()

◆ softmax()

Member Data Documentation

◆ m_activation

◆ m_amplitudeBounds

◆ m_binCenters

◆ m_bins

◆ m_fitTool

◆ m_isValid

◆ m_layerSizes

◆ m_layerStates

◆ m_networkCoefs

◆ m_nLayers

◆ m_tauCoder

◆ m_timeShiftBounds

◆ m_wave

◆ m_waveWidthBounds

◆ relu

◆ sigmoid