serializatioin / deserialization and tests

tests/activation.cpp

@@ -3,15 +3,17 @@
 #include <NeuralNetwork/ActivationFunction/HyperbolicTangent.h>
 #include <NeuralNetwork/ActivationFunction/Linear.h>
 
-#include <iostream>
+#include <NeuralNetwork/Network.h>
+
 #include <cassert>
-#include <chrono>
 
 union {
     __m128 v;    // SSE 4 x float vector
     float a[4];  // scalar array of 4 floats
 } U;
 
+NEURAL_NETWORK_INIT();
+
 int main() {
 	{
 		NeuralNetwork::ActivationFunction::Heaviside h(1.0);
@@ -68,5 +70,34 @@ int main() {
 		assert(s(1.0) < 0.7001);
 	}
 
+	{
+		NeuralNetwork::ActivationFunction::Linear l(2.5);
+		const std::string tmp = l.serialize().serialize();
+		NeuralNetwork::ActivationFunction::ActivationFunction* deserialized = NeuralNetwork::ActivationFunction::Factory::deserialize(l.serialize()).release();
+		assert(tmp == deserialized->serialize().serialize());
+		delete deserialized;
+	}
+	{
+		NeuralNetwork::ActivationFunction::Heaviside l(2.5);
+		const std::string tmp = l.serialize().serialize();
+		NeuralNetwork::ActivationFunction::ActivationFunction* deserialized = NeuralNetwork::ActivationFunction::Factory::deserialize(l.serialize()).release();
+		assert(tmp == deserialized->serialize().serialize());
+		delete deserialized;
+	}
+	{
+		NeuralNetwork::ActivationFunction::HyperbolicTangent l(2.5);
+		const std::string tmp = l.serialize().serialize();
+		NeuralNetwork::ActivationFunction::ActivationFunction* deserialized = NeuralNetwork::ActivationFunction::Factory::deserialize(l.serialize()).release();
+		assert(tmp == deserialized->serialize().serialize());
+		delete deserialized;
+	}
+	{
+		NeuralNetwork::ActivationFunction::Sigmoid l(2.5);
+		const std::string tmp = l.serialize().serialize();
+		NeuralNetwork::ActivationFunction::ActivationFunction* deserialized = NeuralNetwork::ActivationFunction::Factory::deserialize(l.serialize()).release();
+		assert(tmp == deserialized->serialize().serialize());
+		delete deserialized;
+	}
+
 	return 0;
 }

tests/basis.cpp

@@ -1,10 +1,15 @@
 #include <NeuralNetwork/BasisFunction/Linear.h>
 #include <NeuralNetwork/BasisFunction/Product.h>
+#include <NeuralNetwork/BasisFunction/Radial.h>
+
+#include <NeuralNetwork/Network.h>
 
 #include <iostream>
 #include <cassert>
 #include <chrono>
 
+NEURAL_NETWORK_INIT();
+
 int main() {
 	{
 		NeuralNetwork::BasisFunction::Linear l;
@@ -38,4 +43,28 @@ int main() {
 		assert(l(w,i) > 0.05999);
 		assert(l(w,i) < 0.06001);
 	}
+
+	{
+		NeuralNetwork::BasisFunction::Linear l;
+		std::string tmp = l.serialize().serialize();
+		NeuralNetwork::BasisFunction::BasisFunction *deserialized =NeuralNetwork::BasisFunction::Factory::deserialize(l.serialize()).release();
+		assert(tmp==deserialized->serialize().serialize());
+		delete deserialized;
+	}
+
+	{
+		NeuralNetwork::BasisFunction::Product l;
+		std::string tmp = l.serialize().serialize();
+		NeuralNetwork::BasisFunction::BasisFunction *deserialized =NeuralNetwork::BasisFunction::Factory::deserialize(l.serialize()).release();
+		assert(tmp==deserialized->serialize().serialize());
+		delete deserialized;
+	}
+
+	{
+		NeuralNetwork::BasisFunction::Radial l;
+		std::string tmp = l.serialize().serialize();
+		NeuralNetwork::BasisFunction::BasisFunction *deserialized =NeuralNetwork::BasisFunction::Factory::deserialize(l.serialize()).release();
+		assert(tmp==deserialized->serialize().serialize());
+		delete deserialized;
+	}
 }

tests/feedforward.cpp

@@ -4,6 +4,7 @@
 #include <iostream>
 
 int main() {
+	std::string serialized;
 	{	// XOR problem
 		NeuralNetwork::FeedForward::Network n(2);
 		NeuralNetwork::ActivationFunction::Sigmoid a(-1);
@@ -42,6 +43,31 @@ int main() {
 			std::vector<float> ret =n.computeOutput({0,0});
 			assert(ret[0] < 0.5);
 		}
+		serialized = n.serialize().serialize();
+	}
+	{
+		NeuralNetwork::FeedForward::Network *deserialized=NeuralNetwork::FeedForward::Network::Factory::deserialize(serialized).release();
+
+		{
+			std::vector<float> ret =deserialized->computeOutput({1,1});
+			assert(ret[0] < 0.5);
+		}
+
+		{
+			std::vector<float> ret =deserialized->computeOutput({0,1});
+			assert(ret[0] > 0.5);
+		}
+
+		{
+			std::vector<float> ret =deserialized->computeOutput({1,0});
+			assert(ret[0] > 0.5);
+		}
+
+		{
+			std::vector<float> ret =deserialized->computeOutput({0,0});
+			assert(ret[0] < 0.5);
+		}
+		delete deserialized;
 	}
 }
 

tests/recurrent.cpp

@@ -17,4 +17,16 @@ int main() {
 		float res= a.computeOutput({1,0.7})[0];
 		assert(res >  solutions[i]*0.999 && res < solutions[i]*1.001);
 	}
+
+	std::string str = a.stringify();
+	std::cout << str << std::endl;;
+
+	//deserialize and check it!
+	NeuralNetwork::Recurrent::Network *deserialized = (NeuralNetwork::Recurrent::Network::Factory::deserialize(str).release());
+	for(size_t i=0;i<solutions.size();i++) {
+		float res= a.computeOutput({1,0.7})[0];
+		float resDeserialized= deserialized->computeOutput({1,0.7})[0];
+		assert(fabs(resDeserialized-res) < 0.01);
+	}
+	delete deserialized;
 }