started the error calculation

Author: kretash

.gitignore

@@ -45,3 +45,6 @@ $RECYCLE.BIN/
 Network Trash Folder
 Temporary Items
 .apdisk
+
+vs2015
+bin

include/network.hh

@@ -36,6 +36,8 @@ private:
 	void _push( double value );
 	void _fire();
 
+   void _compute_error(double value);
+
 	double m_weight = 0.0;
 	std::shared_ptr<Node> m_link_to;
 	std::shared_ptr<Node> m_link_from;
@@ -55,15 +57,32 @@ private:
 	friend class Network;
 	friend class Link;
 
+   // pushes a value to the node. When all links have been pushed
+   // the node will fire the values forward.
 	void _push(double value);
 	double _sigmoid( double num );
 	void _fire();
 
+   // computes the error. similar to push but backwards.
+   void _compute_error(double value);
+
 	bool m_end_node = false;
+
+   // The last value fired forward.
+   double m_value = 0.0;
+   // the sum of all the values of fired to this node.
 	double m_synapse_sum = 0.0;
+
+   double m_error_sum = 0.0;
 	double m_delta = 0.0;
 	double m_bias = 0.0;
-	int32_t m_load = 0;
+
+   // When the load is equal to the number of back links the node will fire.
+	int32_t m_forward_load = 0;
+   // When the load is equal to the number of forward the node will fire back.
+   // Calculating the error made from the previous iteration.
+   int32_t m_backward_load = 0;
+
 	std::vector<std::shared_ptr<Link>> m_f_links;
 	std::vector<std::shared_ptr<Link>> m_b_links;
 

src/link.cc

@@ -12,4 +12,8 @@ void Link::_push( double value ) {
 
 void Link::_fire() {
 	m_link_to->_fire();
+}
+
+void Link::_compute_error(double value){
+   m_link_from->_compute_error( value * m_weight );
 }

src/main.cc

@@ -18,8 +18,6 @@ int main( int argc, char** argv ) {
 
 	std::shared_ptr<Network> network = std::make_shared<Network>( input_layer, output_layer );
 
-	auto r = network->activate( { 5,5 } );
-
 	// train the network - learn XOR
 	double learning_rate = 0.3;
 	for( uint32_t i = 0; i < 10000; ++i ) {

src/network.cc

@@ -35,16 +35,12 @@ void Network::propagate( double learning_rate, std::vector<double> results ) {
 	assert( results.size() == onodes.size() &&
 		"RESULTS MUST BE THE SIZE OF THE NODES IN THE OUTPUT LAYER" );
 
-	double error = 0.0;
 
 	for( size_t i = 0; i < onodes.size(); ++i ){
 
 		auto on = onodes[i];
-
 		double this_error = results[i] - on->m_synapse_sum;
-		on->m_delta = (1.0 - on->m_synapse_sum) * results[i] * this_error;
-		error += (0.5 * this_error * this_error );
-		
+      on->_compute_error(this_error);
 	}
 
 }

src/node.cc

@@ -10,8 +10,8 @@ void Node::add_b_link( std::shared_ptr<Link> link ) {
 
 void Node::_push( double value ) {
 	m_synapse_sum += value;
-	++m_load;
-	if( m_load == m_b_links.size() ){
+	++m_forward_load;
+	if( m_forward_load == m_b_links.size() ){
 		_fire();
 	}
 }
@@ -22,16 +22,34 @@ double  Node::_sigmoid( double num ) {
 }
 
 void Node::_fire( ){
-	if( m_end_node ){
-		return;
-	}
 
 	double v = _sigmoid( m_synapse_sum + m_bias);
+   m_value = v;
+
+	if( m_end_node )	return;
 
 	for( auto link : m_f_links ){
 		link->_push(v);
 	}
 
 	m_synapse_sum = 0;
-	m_load = 0;
+   m_forward_load = 0;
+}
+
+void Node::_compute_error(double value){
+
+   m_error_sum += value;
+
+   ++m_backward_load;
+   if( m_backward_load == m_f_links.size() ){
+
+      m_delta = ( 1.0 - m_value ) * m_value * value;
+
+      for( auto blinks : m_b_links ){
+         blinks->_compute_error(m_delta);
+      }
+
+      m_error_sum = 0.0;
+      m_backward_load = 0;
+   }
 }