TNeuron

class TNeuron : public TNamed

    protected:

          void AddPost(TSynapse*)
          void AddPre(TSynapse*)
      Double_t DSigmoid(Double_t x) const
      Double_t Sigmoid(Double_t x) const

    public:

                      TNeuron(TNeuron::NeuronType type = kSigmoid, const char* name, const char* title)
              virtual ~TNeuron()
       static TClass* Class()
                 void ForceExternalValue(Double_t value)
             Double_t GetBranch() const
             Double_t GetDeDw() const
             Double_t GetDEDw() const
             Double_t GetDerivative() const
             Double_t GetError() const
      const Double_t* GetNormalisation() const
            TSynapse* GetPost(Int_t n) const
            TSynapse* GetPre(Int_t n) const
             Double_t GetValue() const
             Double_t GetWeight() const
      virtual TClass* IsA() const
                 void SetDEDw(Double_t in)
                 void SetNewEvent() const
                 void SetNormalisation(Double_t mean, Double_t RMS)
                 void SetWeight(Double_t w)
         virtual void ShowMembers(TMemberInspector& insp, char* parent)
         virtual void Streamer(TBuffer& b)
                 void StreamerNVirtual(TBuffer& b)
        TTreeFormula* UseBranch(TTree*, const char*)

Data Members

    private:

                TObjArray fpre         pointers to the previous level in a network
                TObjArray fpost        pointers to the next level in a network
                 Double_t fWeight      weight used for computation
                 Double_t fNorm[2]     normalisation to mean=0, RMS=1.
      TNeuron::NeuronType fType        neuron type
            TTreeFormula* fFormula     ! formula to be used for inputs and outputs
                   Bool_t fNewValue    ! do we need to compute fValue again ?
                 Double_t fValue       ! buffer containing the last neuron output
                   Bool_t fNewDeriv    ! do we need to compute fDerivative again ?
                 Double_t fDerivative  ! buffer containing the last neuron derivative
                   Bool_t fNewDeDw     ! do we need to compute fDeDw again ?
                 Double_t fDeDw        ! buffer containing the last derivative of the error
                 Double_t fDEDw        ! buffer containing the sum over all examples of DeDw

    public:

      static const TNeuron::NeuronType kOff      
      static const TNeuron::NeuronType kLinear   
      static const TNeuron::NeuronType kSigmoid  
      static const TNeuron::NeuronType kTanh     
      static const TNeuron::NeuronType kGauss    

Class Description

 TNeuron

 This class decribes an elementary neuron, which is the basic
 element for a Neural Network.
 A network is built connecting neurons by synapses.
 There are different types of neurons: linear (a+bx),
 sigmoid (1/(1+exp(-x)), tanh or gaussian.
 In a Multi Layer Perceptron, the input layer is made of
 inactive neurons (returning the normalized input), hidden layers
 are made of sigmoids and output neurons are linear.

 This implementation contains several methods to compute the value,
 the derivative, the DeDw, ...
 Values are stored in local buffers. The SetNewEvent() method is
 there to inform buffered values are outdated.

 Usual constructor

 The Sigmoid.
 Fast computation of the values of the sigmoid function.
 Uses values of the function up  to the seventh order
 tabulated at 700 points.
 Values were computed in long double precision (16 bytes,
 precision to about 37 digits) on a hp computer.
 Some values were checked with Mathematica.
 Result should be correct to ~ 15 digits (about double
 precision)

 From the mlpfit package (J.Schwindling   20-Jul-1999)

 The Derivative of the Sigmoid.

 Adds a synapse to the neuron as an input
 This method is used by the TSynapse while
 connecting two neurons.

 Adds a synapse to the neuron as an output
 This method is used by the TSynapse while
 connecting two neurons.

 Sets a formula that can be used to make the neuron an input.
 The formula is automatically normalized to mean=0, RMS=1.
 This normalisation is used by GetValue() (input neurons)
 and GetError() (output neurons)

 Returns the formula value.

 Computes the output using the appropriate function and all
 the weighted inputs, or uses the branch as input.
 In that case, the branch normalisation is also used.

 computes the derivative for the appropriate function
 at the working point

 Computes the error for output neurons.
 Returns 0 for other neurons.

 Computes the derivative of the error wrt the neuron weight.

 Uses the branch type to force an external value.

 Sets the normalization variables.
 Any input neuron will return (branch-mean)/RMS.
 When UseBranch is called, mean and RMS are automatically set
 to the actual branch mean and RMS.

 Sets the neuron weight to w.
 The neuron weight corresponds to the bias in the
 linear combination of the inputs.

 Inform the neuron that inputs of the network have changed,
 so that the buffered values have to be recomputed.

 Sets the derivative of the total error wrt the neuron weight.

Inline Functions

                   void ~TNeuron()
              TSynapse* GetPre(Int_t n) const
              TSynapse* GetPost(Int_t n) const
               Double_t GetWeight() const
        const Double_t* GetNormalisation() const
               Double_t GetDEDw() const
                TClass* Class()
                TClass* IsA() const
                   void ShowMembers(TMemberInspector& insp, char* parent)
                   void Streamer(TBuffer& b)
                   void StreamerNVirtual(TBuffer& b)