cleaning, prepred calling basis function

README.md

@@ -1,2 +1,3 @@
 Artifitial Neural Network Library
 =================================
+s

src/NeuralNetwork/FeedForward.cpp

@@ -6,7 +6,7 @@ FFLayer::~FFLayer()
 {
 	if(neurons!=nullptr)
 	{
-		for(size_t i=0;i<layerSize;i++)
+		for(size_t i=0;i<layerSize-1;i++)
 		{
 			delete neurons[i];
 		}
@@ -18,10 +18,10 @@ FFNeuron& FFLayer::operator[](const size_t& neuron)
 {
 	if(neurons==nullptr)
 	{
-		neurons=new FFNeuron*[layerSize];
+		neurons=new FFNeuron*[layerSize-1];
-		for(size_t i=0;i<layerSize;i++)
+		for(size_t i=1;i<layerSize;i++)
 		{
-			neurons[i]=new FFNeuron(weights[i],outputs[i],inputs[i],lambda,function);
+			neurons[i-1]=new FFNeuron(weights[i],outputs[i],inputs[i],lambda,function);
 		}
 	}
 
@@ -97,18 +97,22 @@ FeedForward::~FeedForward()
 		}
 		delete[] ffLayers;
 	}
+	delete basisFunction;
 }
 
 void FeedForward::solvePart(float *newSolution, register size_t begin, size_t end,size_t prevSize, float *sol,size_t layer)
 {
 	ActivationFunction::StreamingActivationFunction *function=dynamic_cast<ActivationFunction::StreamingActivationFunction*>(transfer[layer]);
-	if(prevSize >=4 && function !=nullptr)
+	BasisFunction::StreamingBasisFunction *bFunc=dynamic_cast<BasisFunction::StreamingBasisFunction*>(basisFunction);
-	{
+
-		__m128 partialSolution;
 	size_t alignedPrev=prevSize>16?(prevSize-(prevSize%16)):0;
+	__m128 partialSolution;
+
+	if(prevSize >=4 && function !=nullptr && bFunc != nullptr)
+	{
 		for( size_t j=begin;j<end;j++)
 		{
-			partialSolution=basisFunction(prevSize,weights[layer][j],sol,alignedPrev);
+			partialSolution=bFunc->operator()(prevSize,weights[layer][j],sol,alignedPrev);
 			_mm_store_ss(inputs[layer]+j,partialSolution);
 			partialSolution=function->operator()(partialSolution);
 			_mm_store_ss(newSolution+j,partialSolution);
@@ -117,11 +121,19 @@ void FeedForward::solvePart(float *newSolution, register size_t begin, size_t en
 	{
 		for( size_t j=begin;j<end;j++)
 		{
-			const float tmp=basisFunction(prevSize,weights[layer][j],sol);
+			if (bFunc !=nullptr && prevSize >=4)
+			{
+				partialSolution=bFunc->operator()(prevSize,weights[layer][j],sol,alignedPrev);
+				_mm_store_ss(inputs[layer]+j,partialSolution);
+				newSolution[j]=transfer[layer]->operator()(inputs[layer][j]);
+			}else 
+			{
+				const float tmp=basisFunction->operator()(prevSize,weights[layer][j],sol);
 				inputs[layer][j]=tmp;
 				newSolution[j]=transfer[layer]->operator()(tmp);
 			}
 		}
+	}
 }
 
 Shin::Solution FeedForward::solve(const Shin::Problem& p)

src/NeuralNetwork/FeedForward.h

@@ -7,7 +7,9 @@
 
 #include "ActivationFunction/Sigmoid.h"
 #include "ActivationFunction/ActivationFunction.h"
+
 #include "BasisFunction/BasisFunction.h"
+#include "BasisFunction/StreamingBasisFunction.h"
 #include "BasisFunction/FeedForward.h"
 
 #include <vector>
@@ -37,8 +39,8 @@ namespace NeuralNetwork
 			FFNeuron(const FFNeuron&) = delete;
 			FFNeuron& operator=(const FFNeuron&) = delete;
 
-			inline virtual float getWeight(const size_t& i ) const override { return weights[i];}
+			inline virtual float getWeight(const int& i ) const override { return weights[i+1];}
-			inline virtual void setWeight(const size_t& i,const float &p) override { weights[i]=p; }
+			inline virtual void setWeight(const int& i,const float &p) override { weights[i+1]=p; }
 
 			inline virtual float output() const override { return out; }
 			inline virtual float input() const override { return inputs; }
@@ -61,8 +63,8 @@ namespace NeuralNetwork
 			FFLayer(const FFLayer &) = delete;
 			FFLayer& operator=(const FFLayer &) = delete;
 
-			virtual FFNeuron& operator[](const size_t& layer) override;
+			virtual FFNeuron& operator[](const size_t& neuron) override;
-			inline virtual size_t size() const override {return layerSize;};
+			inline virtual size_t size() const override {return layerSize-1;};
 		protected:
 			ActivationFunction::ActivationFunction &function;
 			FFNeuron **neurons=nullptr;
@@ -125,11 +127,10 @@ namespace NeuralNetwork
 		private:
 			FFLayer **ffLayers=nullptr;
 			float ***weights=nullptr;
-			float **potentials=nullptr;
 			float **outputs=nullptr;
 			float **inputs=nullptr;
 			ActivationFunction::ActivationFunction **transfer=nullptr;
-			BasisFunction::FeedForward basisFunction =BasisFunction::FeedForward();
+			BasisFunction::BasisFunction *basisFunction = new BasisFunction::FeedForward();
 			size_t *layerSizes=nullptr;
 			size_t layers;/**< Number of layers */
 	};

src/NeuralNetwork/Neuron.h

@@ -17,14 +17,14 @@ namespace NeuralNetwork
 			 */
 			virtual ~Neuron() {};
 
-			virtual float getWeight(const size_t &w) const =0;
+			virtual float getWeight(const int &w) const =0;
 
 			/**
 			 * @brief Sets weight
 			 * @param i is number of neuron
 			 * @param p is new weight for input neuron i
 			 */
-			virtual void setWeight(const size_t& i ,const float &p) =0;
+			virtual void setWeight(const int& i ,const float &p) =0;
 
 			/**
 			 * @brief Returns output of neuron

tests/nn-05.cpp

@@ -10,8 +10,8 @@ int main()
 
 	srand(time(NULL));
 	NeuralNetwork::FeedForward ns({1,1});
-	ns[1][1].setWeight(0,0);
+	ns[1][0].setWeight(-1,0);
-	ns[1][1].setWeight(1,1);
+	ns[1][0].setWeight(0,1);
 
 	Shin::Solution ss =ns.solve(Shin::Problem({1}));
 
@@ -23,17 +23,17 @@ int main()
 
 	NeuralNetwork::FeedForward xorF({2,2,1},0.8);
 
-	xorF[1][1].setWeight(0,-6.06);
+	xorF[1][0].setWeight(-1,-6.06);
-	xorF[1][1].setWeight(1,-11.62);
+	xorF[1][0].setWeight(0,-11.62);
-	xorF[1][1].setWeight(2,10.99);
+	xorF[1][0].setWeight(1,10.99);
 
-	xorF[1][2].setWeight(0,-7.19);
+	xorF[1][1].setWeight(-1,-7.19);
-	xorF[1][2].setWeight(1,12.88);
+	xorF[1][1].setWeight(0,12.88);
-	xorF[1][2].setWeight(2,-13-13);
+	xorF[1][1].setWeight(1,-13-13);
 
-	xorF[2][1].setWeight(0,-6.56);
+	xorF[2][0].setWeight(-1,-6.56);
-	xorF[2][1].setWeight(1,13.34);
+	xorF[2][0].setWeight(0,13.34);
-	xorF[2][1].setWeight(2,-7.19);
+	xorF[2][0].setWeight(1,-7.19);
 
 	ss= xorF.solve(Shin::Problem({0,1}));