shin/NeuralNetworkLib
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

new weights interface and addaption + mall tweaks

Browse Source
This commit is contained in:
Shin
2016-02-18 16:36:16 +01:00
parent 19253e975f
commit ec82018ef9
10 changed files with 101 additions and 99 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@@ -59,6 +59,8 @@ set (LIBRARY_SOURCES
add_library(NeuralNetwork STATIC ${LIBRARY_SOURCES})
link_libraries(NeuralNetwork pthread)
IF(BUILD_SHARED_LIBS)
add_library(NeuralNetworkShared SHARED ${LIBRARY_SOURCES})
set_target_properties(NeuralNetworkShared PROPERTIES OUTPUT_NAME NeuralNetwork)

3
README.md
View File

@@ -19,4 +19,5 @@ i5-5300U & 8GB ram
| FANN | 12.6 | | |
-------------------- | ---------------- | -------------- | -------------------- |
| 2016/02/07 initial | 8.27 sec | 7.15 sec | 6.00 sec |
| 2016/02/17 AVX | 5.53 sec | 4.68 s ec | 4.63 sec |
| 2016/02/17 AVX | 5.53 sec | 4.68 sec | 4.63 sec |
| 2016/02/17 weights | 5.53 sec | 4.68 sec | 3.02 sec |

91
include/NeuralNetwork/Neuron.h
View File

@@ -36,17 +36,28 @@ namespace NeuralNetwork
virtual std::string stringify(const std::string &prefix="") const =0;
/**
* @brief Gets weight
* @brief Returns weight
* @param n is neuron
*/
virtual float getWeight(const NeuronInterface &n) const =0;
virtual float weight(const NeuronInterface &n) const =0;
/**
* @brief Sets weight
* @param n is neuron
* @param w is new weight for input neuron n
* @brief Returns weight
* @param n is id of neuron
*/
virtual void setWeight(const NeuronInterface& n ,const float &w) =0;
virtual float weight(const std::size_t &n) const =0;
/**
* @brief Returns reference to weight
* @param n is neuron
*/
virtual float& weight(const NeuronInterface &n) =0;
/**
* @brief Returns reference to weight
* @param n is id of neuron
*/
virtual float& weight(const std::size_t &n) =0;
/**
* @brief Returns output of neuron
@@ -58,11 +69,6 @@ namespace NeuralNetwork
*/
virtual float value() const=0;
/**
* @brief Returns value for derivation of activation function
*/
// virtual float derivatedOutput() const=0;
/**
* @brief Function sets bias for neuron
* @param bias is new bias (initial value for neuron)
@@ -102,12 +108,12 @@ namespace NeuralNetwork
{
public:
Neuron(unsigned long _id=0, const ActivationFunction::ActivationFunction &activationFunction=ActivationFunction::Sigmoid(-4.9)):
NeuronInterface(), basis(new BasisFunction::Linear),
NeuronInterface(), id_(_id), basis(new BasisFunction::Linear),
activation(activationFunction.clone()),
id_(_id),weights(1),_output(0),_value(0) {
weights(1),_output(0),_value(0) {
}
Neuron(const Neuron &r): NeuronInterface(), basis(r.basis->clone()), activation(r.activation->clone()),id_(r.id_),
Neuron(const Neuron &r): NeuronInterface(), id_(r.id_), basis(r.basis->clone()), activation(r.activation->clone()),
weights(r.weights), _output(r._output), _value(r._value) {
}
@@ -116,38 +122,28 @@ namespace NeuralNetwork
delete activation;
};
virtual std::string stringify(const std::string &prefix="") const override;
Neuron operator=(const Neuron&) = delete;
Neuron& operator=(const Neuron&r) {
id_=r.id_;
weights=r.weights;
basis=r.basis->clone();
activation=r.activation->clone();
return *this;
}
virtual std::string stringify(const std::string &prefix="") const override;
virtual long unsigned int id() const override {
return id_;
};
/**
* @brief Gets weight
* @param n is neuron
*/
virtual float getWeight(const NeuronInterface &n) const override {
virtual float weight(const NeuronInterface &n) const override {
return weights[n.id()];
}
/**
* @brief Sets weight
* @param n is neuron
* @param w is new weight for input neuron n
*/
virtual void setWeight(const NeuronInterface& n ,const float &w) override {
if(weights.size()<n.id()+1) {
weights.resize(n.id()+1);
}
weights[n.id()]=w;
virtual float weight(const std::size_t &n) const override {
return weights[n];
}
virtual float& weight(const NeuronInterface &n) override {
return weights[n.id()];
}
virtual float& weight(const std::size_t &n) override {
return weights[n];
}
virtual void setInputSize(const std::size_t &size) override {
@@ -196,8 +192,7 @@ namespace NeuralNetwork
}
virtual Neuron* clone() const override {
Neuron *n = new Neuron;
*n=*this;
Neuron *n = new Neuron(*this);
return n;
}
@@ -209,12 +204,12 @@ namespace NeuralNetwork
return *activation;
}
const unsigned long id_;
protected:
BasisFunction::BasisFunction *basis;
ActivationFunction::ActivationFunction *activation;
unsigned long id_;
std::vector<float> weights;
float _output;
@@ -238,14 +233,16 @@ namespace NeuralNetwork
virtual float getBias() const override { return 0; };
virtual float getWeight(const NeuronInterface&) const override { return 0; }
float a=0.0;
virtual float& weight(const NeuronInterface &) override { return a; }
virtual float& weight(const std::size_t &) override { return a; }
virtual float weight(const NeuronInterface&) const override { return 0; }
virtual float weight(const std::size_t&) const override { return 0; }
virtual void setBias(const float&) override{ }
virtual float output() const override { return 1.0; };
virtual void setWeight(const NeuronInterface&, const float&) override { }
virtual std::string stringify(const std::string& prefix = "") const override { return prefix+"{ \"class\" : \"NeuralNetwork::BiasNeuron\" }"; }
virtual float value() const override { return 1.0; }
@@ -290,14 +287,16 @@ namespace NeuralNetwork
virtual float getBias() const override { return 0; };
virtual float getWeight(const NeuronInterface&) const override { return 0; }
float a=0.0;
virtual float& weight(const NeuronInterface &) override { return a; }
virtual float& weight(const std::size_t &) override { return a; }
virtual float weight(const NeuronInterface&) const override { return 0; }
virtual float weight(const std::size_t&) const override { return 0; }
virtual void setBias(const float&) override{ }
virtual float output() const override { return 1.0; };
virtual void setWeight(const NeuronInterface&, const float&) override { }
virtual std::string stringify(const std::string& prefix = "") const override { return prefix+"{ \"class\" : \"NeuralNetwork::InputNeuron\", \"id\": "+std::to_string(id_)+" }"; }
virtual float value() const override { return 1.0; }

5
include/NeuralNetwork/Recurrent/Network.h
View File

@@ -24,7 +24,7 @@ namespace Recurrent {
* @param _outputSize is size of output from network
* @param hiddenUnits is number of hiddenUnits to be created
*/
inline Network(size_t _inputSize, size_t _outputSize,size_t hiddenUnits=0):NeuralNetwork::Network(),inputSize(_inputSize),outputSize(_outputSize), neurons(0) {
inline Network(size_t _inputSize, size_t _outputSize,size_t hiddenUnits=0):NeuralNetwork::Network(),inputSize(_inputSize),outputSize(_outputSize), neurons(0),outputs(0) {
neurons.push_back(new NeuralNetwork::BiasNeuron());
for(size_t i=0;i<_inputSize;i++) {
@@ -78,7 +78,7 @@ namespace Recurrent {
neurons.push_back(new Neuron(neurons.size()));
NeuronInterface *newNeuron=neurons.back();
for(std::size_t i=0;i<neurons.size();i++) {
neurons[i]->setWeight(*newNeuron,0.0);
neurons[i]->setInputSize(newNeuron->id()+1);
}
return *newNeuron;
}
@@ -95,6 +95,7 @@ namespace Recurrent {
size_t outputSize=0;
std::vector<NeuronInterface*> neurons;
std::vector<float> outputs;
};
}
}

5
src/NeuralNetwork/FeedForward/Layer.cpp
View File

@@ -3,10 +3,9 @@
void NeuralNetwork::FeedForward::Layer::solve(const std::vector<float> &input, std::vector<float> &output) {
output.resize(neurons.size());
for(auto &neuron:neurons) {
output[neuron->id()]=neuron->operator()(input);
for(auto&neuron: neurons) {
output[neuron->id()] = neuron->operator()(input);
}
}
void NeuralNetwork::FeedForward::Layer::stringify(std::ostream &out) const {

25
src/NeuralNetwork/FeedForward/Network.cpp
View File

@@ -1,30 +1,21 @@
#include <NeuralNetwork/FeedForward/Network.h>
std::vector<float> NeuralNetwork::FeedForward::Network::computeOutput(const std::vector<float>& input) {
// this is here for simple swapping between input and output
std::vector<float> partial1=std::vector<float>(input.size()+1);
std::vector<float> partial2;
std::vector<float> *partialInputPtr = &partial1;
std::vector<float> *partialOutputPtr = &partial2;
std::vector<float> partialInput(input.size()+1);
std::vector<float> partialOutput;
// 0 is bias
partial1[0]=1.0;
partialInput[0]=1.0;
for(std::size_t i=0;i<input.size();i++) {
partial1[i+1]=input[i];
partialInput[i+1]=input[i];
}
for(std::size_t i=1;i<layers.size();i++) {
layers[i]->solve(*partialInputPtr,*partialOutputPtr);
std::swap(partialInputPtr,partialOutputPtr);
layers[i]->solve(partialInput,partialOutput);
partialInput.swap(partialOutput);
}
for(std::size_t i=0;i<partialInputPtr->size()-1;i++) {
partialInputPtr->operator[](i)=partialInputPtr->operator[](i+1);
}
partialInputPtr->resize(partialInputPtr->size()-1);
return std::vector<float>(*partialInputPtr);
return std::vector<float>(partialInput.begin()+1,partialInput.end());
}
void NeuralNetwork::FeedForward::Network::randomizeWeights() {
@@ -34,7 +25,7 @@ void NeuralNetwork::FeedForward::Network::randomizeWeights() {
for(std::size_t neuron=1; neuron < layer->size(); neuron ++ ) {
for(std::size_t prevNeuron=0; prevNeuron < prevLayer->size(); prevNeuron++) {
layer->operator[](neuron).setWeight(prevLayer->operator[](prevNeuron),1.0-static_cast<float>(rand()%2001)/1000.0);
layer->operator[](neuron).weight(prevNeuron)=1.0-static_cast<float>(rand()%2001)/1000.0;
}
}
}

9
src/NeuralNetwork/Learning/BackPropagation.cpp
View File

@@ -27,7 +27,7 @@ void NeuralNetwork::Learning::BackPropagation::teach(FeedForward::Network &netwo
for(std::size_t j=1;j<layer.size();j++) {
float deltasWeight = 0;
for(std::size_t k=1;k<network[layerIndex+1].size();k++) {
deltasWeight+=deltas[layerIndex+1][k]* network[layerIndex+1][k].getWeight(layer[j]);
deltasWeight+=deltas[layerIndex+1][k]* network[layerIndex+1][k].weight(j);
}
float newDelta=deltasWeight*layer[j].getActivationFunction().derivatedOutput(layer[j].value(),layer[j].output());
deltas[layerIndex][j]=newDelta;
@@ -41,12 +41,13 @@ void NeuralNetwork::Learning::BackPropagation::teach(FeedForward::Network &netwo
std::size_t max=prevLayer.size();
for(std::size_t j=1;j<layer.size();j++) {
layer[j].setWeight(prevLayer[0],layer[j].getWeight(prevLayer[0])+deltas[layerIndex][j]*learningCoefficient);
deltas[layerIndex][j]*=learningCoefficient;
layer[j].weight(0)+=deltas[layerIndex][j];
for(std::size_t k=1;k<max;k++) {
if(layerIndex==1) {
layer[j].setWeight(prevLayer[k], layer[j].getWeight(prevLayer[k])+learningCoefficient*deltas[layerIndex][j]*input[k-1]);
layer[j].weight(k)+=deltas[layerIndex][j]*input[k-1];
} else {
layer[j].setWeight(prevLayer[k], layer[j].getWeight(prevLayer[k])+learningCoefficient*deltas[layerIndex][j]*prevLayer[k].output());
layer[j].weight(k)+=deltas[layerIndex][j]*prevLayer[k].output();
}
}
}

34
src/NeuralNetwork/Recurrent/Network.cpp
View File

@@ -1,23 +1,31 @@
#include <NeuralNetwork/Recurrent/Network.h>
std::vector<float> NeuralNetwork::Recurrent::Network::computeOutput(const std::vector<float>& input, unsigned int iterations) {
//TODO: check inputSize
size_t neuronSize=neurons.size();
std::vector<float> outputs(neuronSize);
for(size_t i=0;i<inputSize;i++) {
outputs[i+1]=input[i];
assert(input.size() == inputSize);
if(outputs.size() != neurons.size()) {
outputs.resize(neurons.size());
for(auto &neuron:neurons) {
outputs[neuron->id()]=neuron->output();
}
}
std::vector<float> newOutputs(neurons.size());
for(size_t i=0;i<inputSize;i++) {
outputs[i+1]=input[i];
newOutputs[i+1]=input[i];
}
newOutputs[0]=neurons[0]->output();
std::size_t neuronsSize = neurons.size();
for(unsigned int iter=0;iter< iterations;iter++) {
for(size_t i=inputSize+1;i<neuronSize;i++) {
outputs[i]=neurons[i]->output();
}
// update neurons
for(size_t i=inputSize+1;i<neuronSize;i++) {
neurons[i]->operator()(outputs);
for(size_t i=inputSize+1;i<neuronsSize;i++) {
newOutputs[i] = neurons[i]->operator()(outputs);
}
outputs.swap(newOutputs);
}
std::vector<float> ret;

18
tests/feedforward.cpp
View File

@@ -10,17 +10,17 @@ int main() {
NeuralNetwork::FeedForward::Layer &hidden=n.appendLayer(2,a);
NeuralNetwork::FeedForward::Layer &out = n.appendLayer(1,a);
hidden[1].setWeight(n[0][0],7);
hidden[1].setWeight(n[0][1],-4.7);
hidden[1].setWeight(n[0][2],-4.7);
hidden[1].weight(n[0][0])=7;
hidden[1].weight(n[0][1])=-4.7;
hidden[1].weight(n[0][2])=-4.7;
hidden[2].setWeight(n[0][0],2.6);
hidden[2].setWeight(n[0][1],-6.4);
hidden[2].setWeight(n[0][2],-6.4);
hidden[2].weight(n[0][0])=2.6;
hidden[2].weight(n[0][1])=-6.4;
hidden[2].weight(n[0][2])=-6.4;
out[1].setWeight(hidden[0],-4.5);
out[1].setWeight(hidden[1],9.6);
out[1].setWeight(hidden[2],-6.8);
out[1].weight(hidden[0])=-4.5;
out[1].weight(hidden[1])=9.6;
out[1].weight(hidden[2])=-6.8;
{

8
tests/recurrent.cpp
View File

@@ -6,10 +6,10 @@
int main() {
NeuralNetwork::Recurrent::Network a(2,1,1);
a.getNeurons()[4]->setWeight(*a.getNeurons()[1],0.05);
a.getNeurons()[4]->setWeight(*a.getNeurons()[2],0.05);
a.getNeurons()[4]->setWeight(*a.getNeurons()[3],0.7);
a.getNeurons()[3]->setWeight(*a.getNeurons()[4],0.1);
a.getNeurons()[4]->weight(1)=0.05;
a.getNeurons()[4]->weight(2)=0.05;
a.getNeurons()[4]->weight(3)=0.7;
a.getNeurons()[3]->weight(4)=0.1;
std::vector <float> solutions({0.5,0.5732923,0.6077882,0.6103067,0.6113217,0.6113918,0.61142,0.6114219,0.6114227,0.6114227});