cleaning + Network getter and setter for input / output size

src/NeuralNetwork/BasisFunction/Linear.cpp

@@ -1,12 +1,12 @@
 #include <NeuralNetwork/BasisFunction/Linear.h>
 
 float NeuralNetwork::BasisFunction::Linear::operator()(const std::vector<float> &weights, const std::vector<float> &input) const {
-	assert(input.size()== weights.size());
-	std::size_t inputSize=input.size();
+	assert(input.size() >= weights.size());
+	std::size_t weightsSize=weights.size();
 
 #ifdef USE_AVX
 
-	std::size_t alignedPrev=inputSize-inputSize%8;
+	std::size_t alignedPrev=weightsSize-weightsSize%8;
 
 	const float* weightsData=weights.data();
 	const float* inputData=input.data();
@@ -32,7 +32,7 @@ float NeuralNetwork::BasisFunction::Linear::operator()(const std::vector<float>
 #endif
 	}
 
-	for(size_t k=alignedPrev;k<inputSize;k++) {
+	for(size_t k=alignedPrev;k<weightsSize;k++) {
 #ifdef USE_FMA
 		partialSolution.avx=_mm256_fmadd_ps(_mm256_set_ps(weightsData[k],0,0,0,0,0,0,0),_mm256_set_ps(inputData[k],0,0,0,0,0,0,0),partialSolution.avx);
 #else
@@ -49,7 +49,7 @@ float NeuralNetwork::BasisFunction::Linear::operator()(const std::vector<float>
 
 #elif USE_SSE
 
-	std::size_t alignedPrev=inputSize-inputSize%4;
+	std::size_t alignedPrev=weightSize-weightSize%4;
 
 	const float* weightsData=weights.data();
 	const float* inputData=input.data();
@@ -61,7 +61,7 @@ float NeuralNetwork::BasisFunction::Linear::operator()(const std::vector<float>
 	partialSolution.sse=_mm_add_ps(partialSolution.sse,_mm_mul_ps(_mm_load_ps(weightsData+k),_mm_load_ps(inputData+k)));
 	}
 
-	for(register size_t k=alignedPrev;k<inputSize;k++) {
+	for(register size_t k=alignedPrev;k<weightSize;k++) {
 	partialSolution.sse=_mm_add_ps(partialSolution.sse,_mm_mul_ps(_mm_load_ss(weightsData+k),_mm_load_ss(inputData+k)));
 	}
 
@@ -76,7 +76,7 @@ float NeuralNetwork::BasisFunction::Linear::operator()(const std::vector<float>
 #else
 
 	register float tmp = 0;
-	for(size_t k=0;k<inputSize;k++) {
+	for(size_t k=0;k<weightSize;k++) {
 		tmp+=input[k]*weights[k];
 	}
 	return tmp;

src/NeuralNetwork/FeedForward/Network.cpp

@@ -39,11 +39,16 @@ std::unique_ptr<NeuralNetwork::FeedForward::Network> NeuralNetwork::FeedForward:
 	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());
 	}
+
+	network->_inputs=network->layers[0]->size()-1;
+	network->_outputs=network->layers.back()->size()-1;
+
 	return std::unique_ptr<Network>(network);
 }
 

src/NeuralNetwork/Recurrent/Network.cpp

@@ -5,7 +5,7 @@ SIMPLEJSON_REGISTER_FINISH(NeuralNetwork::Recurrent::Network::Factory, NeuralNet
 
 std::vector<float> NeuralNetwork::Recurrent::Network::computeOutput(const std::vector<float>& input, unsigned int iterations) {
 
-	assert(input.size() == inputSize);
+	assert(input.size() == _inputs);
 
 	if(outputs.size() != neurons.size()) {
 		outputs.resize(neurons.size());
@@ -16,7 +16,7 @@ std::vector<float> NeuralNetwork::Recurrent::Network::computeOutput(const std::v
 
 	std::vector<float> newOutputs(neurons.size());
 
-	for(size_t i=0;i<inputSize;i++) {
+	for(size_t i=0;i<_inputs;i++) {
 		outputs[i+1]=input[i];
 		newOutputs[i+1]=input[i];
 	}
@@ -26,15 +26,15 @@ std::vector<float> NeuralNetwork::Recurrent::Network::computeOutput(const std::v
 	std::size_t neuronsSize = neurons.size();
 
 	for(unsigned int iter=0;iter< iterations;iter++) {
-		for(size_t i=inputSize+1;i<neuronsSize;i++) {
+		for(size_t i=_inputs+1;i<neuronsSize;i++) {
 			newOutputs[i] = neurons[i]->operator()(outputs);
 		}
 		outputs.swap(newOutputs);
 	}
 
 	std::vector<float> ret;
-	for(size_t i=0;i<outputSize;i++) {
-		ret.push_back(neurons[i+inputSize+1]->output());
+	for(size_t i=0;i<_outputs;i++) {
+		ret.push_back(neurons[i+_inputs+1]->output());
 	}
 
 	return ret;
@@ -45,9 +45,7 @@ NeuralNetwork::Recurrent::Network NeuralNetwork::Recurrent::Network::connectWith
 }
 
 NeuralNetwork::Recurrent::Network& NeuralNetwork::Recurrent::Network::operator=(const NeuralNetwork::Recurrent::Network&r) {
-	inputSize=r.inputSize;
-	outputSize=r.outputSize;
-	outputs=r.outputs;
+	NeuralNetwork::Network::operator=(r);
 
 	for(std::size_t i=1;i<neurons.size();i++) {
 		delete neurons[i];
@@ -68,8 +66,8 @@ SimpleJSON::Type::Object NeuralNetwork::Recurrent::Network::serialize() const {
 	}
 	return {
 		{"class", "NeuralNetwork::Recurrent::Network"},
-		{"inputSize", inputSize},
-		{"outputSize", outputSize},
+		{"inputSize", _inputs},
+		{"outputSize", _outputs},
 		{"outputs", outputs},
 		{"neurons", neuronsSerialized}
 	};