class TMultiLayerPerceptron: public TObject

 Default constructor

 The network is described by a simple string:
 The input/output layers are defined by giving
 the branch names separated by comas.
 Hidden layers are just described by the number of neurons.
 The layers are separated by colons.
 Ex: "x,y:10:5:f"
 The output can be prepended by '@' if the variable has to be
 normalized.
 The output can be followed by '!' to use Softmax neurons for the
 output layer only.
 Ex: "x,y:10:5:c1,c2,c3!"
 Input and outputs are taken from the TTree given as second argument.
 training and test are the two TEventLists defining events
 to be used during the neural net training.
 Both the TTree and the TEventLists  can be defined in the constructor,
 or later with the suited setter method.

 The network is described by a simple string:
 The input/output layers are defined by giving
 the branch names separated by comas.
 Hidden layers are just described by the number of neurons.
 The layers are separated by colons.
 Ex: "x,y:10:5:f"
 The output can be prepended by '@' if the variable has to be
 normalized.
 The output can be followed by '!' to use Softmax neurons for the
 output layer only.
 Ex: "x,y:10:5:c1,c2,c3!"
 Input and outputs are taken from the TTree given as second argument.
 training and test are the two TEventLists defining events
 to be used during the neural net training.
 Both the TTree and the TEventLists  can be defined in the constructor,
 or later with the suited setter method.

 The network is described by a simple string:
 The input/output layers are defined by giving
 the branch names separated by comas.
 Hidden layers are just described by the number of neurons.
 The layers are separated by colons.
 Ex: "x,y:10:5:f"
 The output can be prepended by '@' if the variable has to be
 normalized.
 The output can be followed by '!' to use Softmax neurons for the
 output layer only.
 Ex: "x,y:10:5:c1,c2,c3!"
 Input and outputs are taken from the TTree given as second argument.
 training and test are two cuts (see TTreeFormula) defining events
 to be used during the neural net training and testing.
 Example: "Entry$%2", "(Entry$+1)%2".
 Both the TTree and the cut can be defined in the constructor,
 or later with the suited setter method.

 The network is described by a simple string:
 The input/output layers are defined by giving
 the branch names separated by comas.
 Hidden layers are just described by the number of neurons.
 The layers are separated by colons.
 Ex: "x,y:10:5:f"
 The output can be prepended by '@' if the variable has to be
 normalized.
 The output can be followed by '!' to use Softmax neurons for the
 output layer only.
 Ex: "x,y:10:5:c1,c2,c3!"
 Input and outputs are taken from the TTree given as second argument.
 training and test are two cuts (see TTreeFormula) defining events
 to be used during the neural net training and testing.
 Example: "Entry$%2", "(Entry$+1)%2".
 Both the TTree and the cut can be defined in the constructor,
 or later with the suited setter method.

 Destructor

 Set the data source

 Set the event weight

 Sets the Training dataset.
 Those events will be used for the minimization

 Sets the Test dataset.
 Those events will not be used for the minimization but for control

 Sets the Training dataset.
 Those events will be used for the minimization.
 Note that the tree must be already defined.

 Sets the Test dataset.
 Those events will not be used for the minimization but for control.
 Note that the tree must be already defined.

 Sets the learning method.
 Available methods are: kStochastic, kBatch,
 kSteepestDescent, kRibierePolak, kFletcherReeves and kBFGS.
 (look at the constructor for the complete description
 of learning methods and parameters)

 Sets Eta - used in stochastic minimisation
 (look at the constructor for the complete description
 of learning methods and parameters)

 Sets Epsilon - used in stochastic minimisation
 (look at the constructor for the complete description
 of learning methods and parameters)

 Sets Delta - used in stochastic minimisation
 (look at the constructor for the complete description
 of learning methods and parameters)

 Sets EtaDecay - Eta *= EtaDecay at each epoch
 (look at the constructor for the complete description
 of learning methods and parameters)

 Sets Tau - used in line search
 (look at the constructor for the complete description
 of learning methods and parameters)

 Sets number of epochs between two resets of the
 search direction to the steepest descent.
 (look at the constructor for the complete description
 of learning methods and parameters)

 Load an entry into the network

 Train the network.
 nEpoch is the number of iterations.
 option can contain:
 - "text" (simple text output)
 - "graph" (evoluting graphical training curves)
 - "update=X" (step for the text/graph output update)
 - "+" will skip the randomisation and start from the previous values.
 - "current" (draw in the current canvas)
 - "minErrorTrain" (stop when NN error on the training sample gets below minE
 - "minErrorTest" (stop when NN error on the test sample gets below minE
 All combinations are available.

 Computes the output for a given event.
 Look at the output neuron designed by index.

 Error on the output for a given event

 Error on the whole dataset

 Error on the output for a given event

 Cross entropy error for sigmoid output neurons, for a given event

 Cross entropy error for a softmax output neuron, for a given event

 Compute the DEDw = sum on all training events of dedw for each weight
 normalized by the number of events.

 Randomize the weights

 Connects the TTree to Neurons in input and output
 layers. The formulas associated to each neuron are created
 and reported to the network formula manager.
 By default, the branch is not normalised since this would degrade
 performance for classification jobs.
 Normalisation can be requested by putting '@' in front of the formula.

 Expand the structure of the first layer

 Instanciates the network from the description

 Instanciates the neurons in input
 Inputs are normalised and the type is set to kOff
 (simple forward of the formula value)

 Builds hidden layers.

 Builds a hidden layer, updates the number of layers.

 Builds the output layer
 Neurons are linear combinations of input, by defaul.
 If the structure ends with "!", neurons are set up for classification,
 ie. with a sigmoid (1 neuron) or softmax (more neurons) activation function.

 Draws the neural net output
 It produces an histogram with the output for the two datasets.
 Index is the number of the desired output neuron.
 "option" can contain:
 - test or train to select a dataset
 - comp to produce a X-Y comparison plot
 - nocanv to not create a new TCanvas for the plot

 Dumps the weights to a text file.
 Set filename to "-" (default) to dump to the standard output

 Loads the weights from a text file conforming to the format
 defined by DumpWeights.

 Returns the Neural Net for a given set of input parameters
 #parameters must equal #input neurons

 Exports the NN as a function for any non-ROOT-dependant code
 Supported languages are: only C++ , FORTRAN and Python (yet)
 This feature is also usefull if you want to plot the NN as
 a function (TF1 or TF2).

 Shuffle the Int_t index[n] in input.
 Input:
   index: the array to shuffle
   n: the size of the array
 Output:
   index: the shuffled indexes
 This method is used for stochastic training

 One step for the stochastic method
 buffer should contain the previous dw vector and will be updated

 One step for the batch (stochastic) method.
 DEDw should have been updated before calling this.

 Sets the weights to a point along a line
 Weights are set to [origin + (dist * dir)].

 Sets the search direction to steepest descent.

 Search along the line defined by direction.
 buffer is not used but is updated with the new dw
 so that it can be used by a later stochastic step.
 It returns true if the line search fails.

 Sets the search direction to conjugate gradient direction
 beta should be:
  ||g_{(t+1)}||^2 / ||g_{(t)}||^2                   (Fletcher-Reeves)
  g_{(t+1)} (g_{(t+1)}-g_{(t)}) / ||g_{(t)}||^2     (Ribiere-Polak)

 Computes the hessian matrix using the BFGS update algorithm.
 from gamma (g_{(t+1)}-g_{(t)}) and delta (w_{(t+1)}-w_{(t)}).
 It returns true if such a direction could not be found
 (if gamma and delta are orthogonal).

 Sets the gamma (g_{(t+1)}-g_{(t)}) and delta (w_{(t+1)}-w_{(t)}) vectors
 Gamma is computed here, so ComputeDEDw cannot have been called before,
 and delta is a direct translation of buffer into a TMatrixD.

 scalar product between gradient and direction
 = derivative along direction

 Computes the direction for the BFGS algorithm as the product
 between the Hessian estimate (bfgsh) and the dir.

 Draws the network structure.
 Neurons are depicted by a blue disk, and synapses by
 lines connecting neurons.
 The line width is proportionnal to the weight.