//
// neuralnetwork.cpp
// neuralnetwork
//
// Created by tianshuai on 7/13/15.
//

#include "neuralnetwork.h"

float Node::alpha = 0.40;
float Node::eta = 0.10;

Node::Node(int OutCount, int idx)
{
 for(int i = 0; i < OutCount; ++i)
 {
 Link con;
 con.DerivWeight = 0;
 con.weight = rand0to1();
 
 OutWeights.push_back(con);
 }
 
 index = idx;
}

void Node::FeedFwd(const std::vector<Node>& prevLevel)
{
 double v = 0.0;
 
 for(int n = 0; n < prevLevel.size(); ++n)
 {
 v += prevLevel[n].getOutValue() * prevLevel[n].OutWeights[index].weight;
 }
 
 setOut(TransFunc(v));
}

void Node::calcOutGradients(double GoalValue)
{
 double delta = GoalValue - OutValue;
 gradient = delta * TransFuncDer(OutValue);
}

double Node::sumDerivWeights(const std::vector<Node>& nextLevel) const
{
 /* Sum errors of the nodes */
 double DerivWeights = 0;
 
 for(int i = 0; i < nextLevel.size() - 1; ++i)
 {
 DerivWeights += OutWeights[i].weight * nextLevel[i].gradient;
 }
 
 return DerivWeights;
}

void Node::calcHiddenGradients(const std::vector<Node>& nextLevel)
{
 double DerivWeights = sumDerivWeights(nextLevel);
 gradient = DerivWeights * TransFuncDer(OutValue);
}

void Node::updateInWeights(std::vector<Node>& prevLevel)
{
 for(int i = 0; i < prevLevel.size(); ++i)
 {
 Node& Node = prevLevel[i];
 double oldDerivWeight = Node.OutWeights[index].DerivWeight;
 double newDerivWeight = eta * Node.OutValue * gradient + alpha * oldDerivWeight;
 
 Node.OutWeights[index].DerivWeight = newDerivWeight;
 Node.OutWeights[index].weight += newDerivWeight;
 }
}


NeuralNetwork::NeuralNetwork(const Topology& Topol)
{
 int levelCount = Topol.size();
 
 for(int levelNum = 0; levelNum < levelCount; ++levelNum)
 {
 levels.push_back(Level());
 int OutCount = levelNum == levelCount - 1 ? 0 : Topol[levelNum+1];
 /* question mark means 0 if else */
 
 Level& currentLevel = levels.back();
 
 for(int n = 0; n <= Topol[levelNum]; ++n)i
	{
 currentLevel.push_back(Node(OutCount, n));
 }
 
 currentLevel.back().setOut(1.0);
 }
 srand(time(NULL));
}

void NeuralNetwork::FeedForward(const Value& InVals)
{
 for(int i = 0; i < InVals.size(); ++i)
 {
 levels[0][i].setOut(InVals[i]);
 }
 
 for(int levelNum = 1; levelNum < levels.size(); ++levelNum)
 {
 Level& level = levels[levelNum];
 const Level& lastLevel = levels[levelNum - 1];
 
 for(int n = 0; n < level.size() - 1; ++n)
 {
 level[n].FeedFwd(lastLevel);
 }
 }
}

void NeuralNetwork::BackPropagation(const Value& Goal)
{
 /* Calc RMS error */
 Level& OutLevel = levels.back();
 
 error = 0.0;/* initialize */
 
 for(int i = 0; i < Goal.size(); ++i)
 {
 double delta = Goal[i] - OutLevel[i].getOutValue();
 error += delta * delta;
 }
 
 error = std::sqrt(error / Goal.size());
 
 /* current error */
 DisplayError = (DisplayError * DisplaySmoothingFactor + error) / (DisplaySmoothingFactor + 1.0);
 
 /* output gradient */
 for(int i = 0; i < OutLevel.size() - 1; ++i)
 {
 OutLevel[i].calcOutGradients(Goal[i]);
 }
 
 /* hidden gradients */
 for(int i = levels.size() - 2; i > 0; --i)
 {
 Level& level = levels[i];
 Level& nextLevel = levels[i+1];
 
 for(int j = 0; j < level.size(); ++j)
 {
 level[j].calcHiddenGradients(nextLevel);
 }
 }
 
 /* Update weights */
 for(int i = levels.size() - 1; i > 0; i--)
 {
 Level& level = levels[i];
 Level& prevLevel = levels[i-1];
 
 for(int j = 0; j < level.size() - 1; ++j)
 {
 level[j].updateInWeights(prevLevel);
 }
 }
}

void NeuralNetwork::getOutput(Value& results) const
{
 results.clear();
 const Level& OutLevel = levels.back();
 for(int i = 0; i < OutLevel.size() - 1; ++i)
 {
 results.push_back(OutLevel[i].getOutValue());
 }
}

void NeuralNetwork::train(Value&& In, Value&& Goal)
{
 FeedForward(In);
 BackPropagation(Goal);
}

Value NeuralNetwork::run(Value&& In)
{
 FeedForward(In);
 Value r;
 getOutput(r);
 return r;
}