Neuron.h

#pragma once
 
 
#include <stdio.h>
#include <assert.h>
#include <iostream>
#include <ctgmath>
#include <cstdlib>
#include <cstdio>
#include <cassert>
#include <fstream>
#include <iostream>
#include <math.h>
#include <fstream>
#include <iostream>
#include <string>
#include <numeric>
#include <vector>
 
 
using namespace std;
 
class Neuron {
public:
 
    Neuron(int _nInputs);
    ~Neuron();
 
    enum biasInitMethod { B_NONE = 0, B_RANDOM = 1 };
    enum weightInitMethod { W_ZEROS = 0, W_ONES = 1, W_RANDOM = 2, W_ONES_NORM = 3, W_RANDOM_NORM = 5,  };
    enum actMethod {Act_Sigmoid = 1, Act_Tanh = 2, Act_ReLU = 3, Act_NONE = 0};
    enum whichError {onBackwardError = 0, onMidError = 1, onForwardError = 2};
 
    void initNeuron(int _neuronIndex, int _layerIndex, weightInitMethod _wim, biasInitMethod _bim, actMethod _am);
 
    void setLearningRate(double _learningRate, double _b_learningRate);
 
    void setInput(int _index, double _value);
 
    void propInputs(int _index, double _value);
 
    int calcOutput(int _layerHasReported);
 
    void setError(double _value);
 
    double getError();
 
    void updateWeights();
    
    inline double doActivation(const double sum) const {
        switch(actMet){
        case Act_Sigmoid:
            return (1/(1+(exp(-sum)))) - 0.5;
        case Act_Tanh:
            return tanh(sum);
        case Act_ReLU:
            if (sum > 0) return sum; else return 0;
        case Act_NONE:
            return sum;
        }
        return sum;
    }
 
    inline double doActivationPrime(const double input) const {
        switch(actMet){
        case Act_Sigmoid:
            return 1 * (0.5 + doActivation(input)) * (0.5 - doActivation(input));
        case Act_Tanh:
            return 1 - pow (tanh(input), 2);
        case Act_ReLU:
            if (sum > 0) return 1; else return 0;
        case Act_NONE:
            return 1;
        }
        return 1;
    }
 
    inline void setBackpropError(const double upstreamDeltaErrorSum) {
        error = doActivationPrime(getSumOutput()) * upstreamDeltaErrorSum;
    }
 
    inline double getOutput() {
        return output;
    }
 
    inline double getSumOutput() {
        return sum;
    }
 
    double getWeights(int _inputIndex);
 
    double getInitWeights(int _inputIndex);
 
    double getWeightChange();
 
    double getMaxWeight(){
        return maxWeight;
    }
    
    double getMinWeight(){
        return minWeight;
    }
 
    double getSumWeight(){
        return weightSum;
    }
 
    double getWeightDistance();
    
    int getnInputs();
 
    void saveWeights();
 
    void printNeuron();
 
    inline void setWeight(int _index, double _weight) {
        assert((_index >= 0) && (_index < nInputs));
        weights[_index] = _weight;
    }
 
private:
    // initialisation:
    int nInputs = 0;
    int myLayerIndex = 0;
    int myNeuronIndex = 0;
    double *initialWeights = 0;
 
    double w_learningRate = 0;
    double b_learningRate = 0;
    
    int iHaveReported = 0;
 
    double bias = 0;
    double sum = 0;
    double output = 0;
 
    //learning:
    double backwardsCoeff = 0;
    double midCoeff = 0;
    double forwardCoeff = 0;
    double globalCoeff = 0;
    double *weights = 0;
    double *inputs = 0;
    double weightSum = 0;
    double maxWeight = 1;
    double minWeight = 1;
    double weightChange=0;
    double weightsDifference = 0;
    int actMet = 0;
 
    double error = 0;
};