serializatioin / deserialization and tests

src/NeuralNetwork/FeedForward/Layer.cpp

@@ -1,5 +1,7 @@
 #include <NeuralNetwork/FeedForward/Layer.h>
 
+SIMPLEJSON_REGISTER_FINISH(NeuralNetwork::FeedForward::Layer::Factory, NeuralNetwork::FeedForward::Layer,NeuralNetwork::FeedForward::Layer::deserialize)
+
 void NeuralNetwork::FeedForward::Layer::solve(const std::vector<float> &input, std::vector<float> &output) {
 	output.resize(neurons.size());
 
@@ -8,17 +10,22 @@ void NeuralNetwork::FeedForward::Layer::solve(const std::vector<float> &input, s
 	}
 }
 
-void NeuralNetwork::FeedForward::Layer::stringify(std::ostream &out) const  {
-	out << "{"  << std::endl;
-	out << "\t \"class\": \"NeuralNetwork::FeedForward::Layer\"," << std::endl;
-	out << "\t \"neurons\": ["  << std::endl;
-	bool first=true;
-	for(auto &neuron: neurons) {
-		if(!first)
-			out << ", ";
-		out << neuron->stringify();
-		first=false;
+SimpleJSON::Type::Object NeuralNetwork::FeedForward::Layer::serialize() const {
+	std::vector<SimpleJSON::Value> neuronsSerialized;
+	for(std::size_t i=0;i<neurons.size();i++) {
+		neuronsSerialized.push_back(neurons[i]->serialize());
 	}
-	out << "]";
-	out << "}";
+	return {{"class", "NeuralNetwork::FeedForward::Layer"},
+			{"neurons" , neuronsSerialized}
+	};
 }
+
+std::unique_ptr<NeuralNetwork::FeedForward::Layer> NeuralNetwork::FeedForward::Layer::deserialize(const SimpleJSON::Type::Object &obj) {
+	NeuralNetwork::FeedForward::Layer *layer= new NeuralNetwork::FeedForward::Layer();
+	for(auto& neuron: obj["neurons"].as<SimpleJSON::Type::Array>()) {
+		layer->neurons.push_back(NeuralNetwork::NeuronInterface::Factory::deserialize(neuron.as<SimpleJSON::Type::Object>()).release());
+	}
+	return std::unique_ptr<Layer>(layer);
+}
+
+

src/NeuralNetwork/FeedForward/Network.cpp

@@ -1,5 +1,7 @@
 #include <NeuralNetwork/FeedForward/Network.h>
 
+SIMPLEJSON_REGISTER_FINISH(NeuralNetwork::FeedForward::Network::Factory, NeuralNetwork::FeedForward::Network,NeuralNetwork::FeedForward::Network::deserialize)
+
 std::vector<float> NeuralNetwork::FeedForward::Network::computeOutput(const std::vector<float>& input) {
 	std::vector<float> partialInput(input.size()+1);
 	std::vector<float> partialOutput;
@@ -30,4 +32,18 @@ void NeuralNetwork::FeedForward::Network::randomizeWeights() {
 		}
 	}
 
-}
+}
+
+std::unique_ptr<NeuralNetwork::FeedForward::Network> NeuralNetwork::FeedForward::Network::deserialize(const SimpleJSON::Type::Object &obj) {
+	NeuralNetwork::FeedForward::Network* network= new NeuralNetwork::FeedForward::Network();
+	for(auto layers:network->layers) {
+		delete layers;
+	}
+	network->layers.clear();
+
+	for(auto& layerObject: obj["layers"].as<SimpleJSON::Type::Array>()) {
+		network->layers.push_back(NeuralNetwork::FeedForward::Layer::Factory::deserialize(layerObject.as<SimpleJSON::Type::Object>()).release());
+	}
+	return std::unique_ptr<Network>(network);
+}
+

src/NeuralNetwork/IMPL.cpp

@@ -0,0 +1,24 @@
+#include <NeuralNetwork/ActivationFunction/Heaviside.h>
+#include <NeuralNetwork/ActivationFunction/Linear.h>
+#include <NeuralNetwork/ActivationFunction/HyperbolicTangent.h>
+#include <NeuralNetwork/ActivationFunction/Sigmoid.h>
+
+NEURAL_NETWORK_REGISTER_ACTIVATION_FUNCTION_FINISH(NeuralNetwork::ActivationFunction::Heaviside, Heaviside::deserialize)
+NEURAL_NETWORK_REGISTER_ACTIVATION_FUNCTION_FINISH(NeuralNetwork::ActivationFunction::HyperbolicTangent, HyperbolicTangent::deserialize)
+NEURAL_NETWORK_REGISTER_ACTIVATION_FUNCTION_FINISH(NeuralNetwork::ActivationFunction::Linear, Linear::deserialize)
+NEURAL_NETWORK_REGISTER_ACTIVATION_FUNCTION_FINISH(NeuralNetwork::ActivationFunction::Sigmoid, Sigmoid::deserialize)
+
+#include <NeuralNetwork/BasisFunction/Linear.h>
+#include <NeuralNetwork/BasisFunction/Product.h>
+#include <NeuralNetwork/BasisFunction/Radial.h>
+
+NEURAL_NETWORK_REGISTER_BASIS_FUNCTION_FINISH(NeuralNetwork::BasisFunction::Linear, deserialize)
+NEURAL_NETWORK_REGISTER_BASIS_FUNCTION_FINISH(NeuralNetwork::BasisFunction::Product, deserialize)
+NEURAL_NETWORK_REGISTER_BASIS_FUNCTION_FINISH(NeuralNetwork::BasisFunction::Radial, deserialize)
+
+
+#include <NeuralNetwork/Network.h>
+
+bool NeuralNetwork::Network::loaded() {
+	return true;
+}

src/NeuralNetwork/Neuron.cpp

@@ -1,27 +1,35 @@
 #include <NeuralNetwork/Neuron.h>
 
-std::string NeuralNetwork::Neuron::stringify(const std::string &prefix) const {
-	std::ostringstream out;
-	out.precision(std::numeric_limits<float>::digits10+1);
+SIMPLEJSON_REGISTER_FINISH(NeuralNetwork::NeuronInterface::Factory, NeuralNetwork::Neuron, NeuralNetwork::Neuron::deserialize)
+SIMPLEJSON_REGISTER_FINISH(NeuralNetwork::NeuronInterface::Factory, NeuralNetwork::BiasNeuron, NeuralNetwork::BiasNeuron::deserialize)
+SIMPLEJSON_REGISTER_FINISH(NeuralNetwork::NeuronInterface::Factory, NeuralNetwork::InputNeuron, NeuralNetwork::InputNeuron::deserialize)
 
-	out << prefix << "{\n";
-	out << prefix << "\t\"class\": \"NeuralNetwork::Neuron\",\n";
-	out << prefix << "\t\"id\": " << id << ",\n";
-	out << prefix << "\t\"output\": " << output() << ",\n";
-	out << prefix << "\t\"value\": " << value() << ",\n";
-	out << prefix << "\t\"activationFunction\": " << activation->stringify() <<",\n";
-	out << prefix << "\t\"basisFunction\": " << basis->stringify() <<",\n";
-	out << prefix << "\t\"weights\": {";
-	bool first=true;
-	for(std::size_t j=0;j<weights.size();j++) {
-		if(weights[j]!= 0.0) {
-			if(!first)
-				out << ", ";
-			first=false;
-			out << "\"" << j << "\": " << weights[j];
-		}
+SimpleJSON::Type::Object NeuralNetwork::Neuron::serialize() const{
+	return {
+		{"class", "NeuralNetwork::Neuron"},
+		{"id", id},
+		{"output", output()},
+		{"value", value()},
+		{"activationFunction", *activation},
+		{"basisFunction", *basis},
+		{"weights", weights}
+	};
+}
+
+std::unique_ptr<NeuralNetwork::Neuron> NeuralNetwork::Neuron::deserialize(const SimpleJSON::Type::Object &obj) {
+	Neuron *neuron = new Neuron(obj["id"].as<int>());
+	neuron->_output=obj["output"].as<double>();
+	neuron->_value=obj["value"].as<double>();
+	delete neuron->activation;
+	delete neuron->basis;
+	neuron->activation=NeuralNetwork::ActivationFunction::Factory::deserialize(obj["activationFunction"].as<SimpleJSON::Type::Object>()).release();
+	neuron->basis=NeuralNetwork::BasisFunction::Factory::deserialize(obj["basisFunction"].as<SimpleJSON::Type::Object>()).release();
+	const SimpleJSON::Type::Array& weights=obj["weights"].as<SimpleJSON::Type::Array>();
+	neuron->weights.resize(weights.size());
+	for(std::size_t i=0;i<weights.size();i++) {
+		neuron->weights[i]=weights[i].as<double>();
 	}
-	out << "}\n";
-	out << prefix << "}";
-	return out.str();
-}
+	return std::unique_ptr<NeuralNetwork::Neuron>(neuron);
+}
+
+

src/NeuralNetwork/Recurrent/Network.cpp

@@ -1,4 +1,8 @@
 #include <NeuralNetwork/Recurrent/Network.h>
+#include <iostream>
+
+SIMPLEJSON_REGISTER_FINISH(NeuralNetwork::Recurrent::Network::Factory, NeuralNetwork::Recurrent::Network, NeuralNetwork::Recurrent::Network::deserialize)
+
 std::vector<float> NeuralNetwork::Recurrent::Network::computeOutput(const std::vector<float>& input, unsigned int iterations) {
 
 	assert(input.size() == inputSize);
@@ -36,29 +40,56 @@ std::vector<float> NeuralNetwork::Recurrent::Network::computeOutput(const std::v
 	return ret;
 }
 
-void NeuralNetwork::Recurrent::Network::stringify(std::ostream& out) const {
-	out <<std::setprecision(std::numeric_limits<float>::digits10+1);
-	out << "{\n";
-	out << "\t\"class\":\"NeuralNetwork::Recurrent::Network\",\n";
-	out << "\t\"size\":" << neurons.size() << ",\n";
-	out << "\t\"inputs\":" << inputSize << ",\n";
-	out << "\t\"outputs\":" << outputSize << ",\n";
-
-	out << "\t\"neurons\":[\n";
-
-	for(size_t i=0;i<neurons.size();i++) {
-		if(i!=0)
-			out << ",\n";
-		out << neurons[i]->stringify("\t\t");
-	}
-	out << "\n\t]\n";
-
-	out <<"}";
-}
-
 NeuralNetwork::Recurrent::Network NeuralNetwork::Recurrent::Network::connectWith(const NeuralNetwork::Recurrent::Network &r) const {
 
 }
+
+NeuralNetwork::Recurrent::Network& NeuralNetwork::Recurrent::Network::operator=(const NeuralNetwork::Recurrent::Network&r) {
+	inputSize=r.inputSize;
+	outputSize=r.outputSize;
+	outputs=r.outputs;
+
+	for(std::size_t i=1;i<neurons.size();i++) {
+		delete neurons[i];
+	}
+
+	neurons.resize(1);
+
+	for(std::size_t i=1;i<neurons.size();i++) {
+		neurons.push_back(r.neurons[i]->clone());
+	}
+	return *this;
+}
+
+SimpleJSON::Type::Object NeuralNetwork::Recurrent::Network::serialize() const {
+	std::vector<SimpleJSON::Value> neuronsSerialized;
+	for(auto &neuron: neurons) {
+		neuronsSerialized.push_back(neuron->serialize());
+	}
+	return {
+		{"class", "NeuralNetwork::Recurrent::Network"},
+		{"inputSize", inputSize},
+		{"outputSize", outputSize},
+		{"outputs", outputs},
+		{"neurons", neuronsSerialized}
+	};
+}
+
+std::unique_ptr<NeuralNetwork::Recurrent::Network> NeuralNetwork::Recurrent::Network::deserialize(const SimpleJSON::Type::Object &obj) {
+	const int inputSize=obj["inputSize"].as<int>();
+	const int outputSize=obj["outputSize"].as<int>();
+	NeuralNetwork::Recurrent::Network *net= new NeuralNetwork::Recurrent::Network(inputSize,outputSize,0) ;
+	for(auto &a: net->neurons) {
+		delete a;
+	}
+	net->neurons.clear();
+	for(const auto& neuronObj: obj["neurons"].as<SimpleJSON::Type::Array>()) {
+		NeuronInterface* neuron=Neuron::Neuron::Factory::deserialize(neuronObj.as<SimpleJSON::Type::Object>()).release();
+		net->neurons.push_back(neuron);
+	}
+	return std::unique_ptr<Network>(net);
+}
+
 /*
 NeuralNetwork::Recurrent::Network NeuralNetwork::Recurrent::Network::connectWith(const NeuralNetwork::Recurrent::Network &r) const {
 	if(outputSize!=r.inputSize) {