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

Modification of BackPropagation added, some fixes and refactoring

Browse Source
This commit is contained in:
Shin
2014-11-11 22:06:16 +01:00
parent 42af5a4d2b
commit efbc8a4d1a
21 changed files with 588 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
src/NeuronNetwork/FeedForwardQuick.cpp
View File

@@ -35,7 +35,8 @@ FeedForwardNetworkQuick::~FeedForwardNetworkQuick()
{
for (size_t j=0;j<layerSizes[i];j++)
{
delete[] weights[i][j];
if(j!=0)
delete[] weights[i][j];
}
delete[] weights[i];
delete[] potentials[i];
@@ -71,20 +72,20 @@ Solution FeedForwardNetworkQuick::solve(const Problem& p)
for(register size_t i=0;i<layers;i++)
{
double* newSolution= sums[i+1];//new bool[layerSizes[i]];
for(register size_t j=1;j<layerSizes[i];j++)
for( size_t j=1;j<layerSizes[i];j++)
{
register double q=sol[0]*weights[i][j][0];
for(register size_t k=1;k<prevSize;k++)
newSolution[j]=sol[0]*weights[i][j][0];
register size_t k;
for(k=1;k<prevSize;k++)
{
if(i==0)
{
q+=sol[k]*weights[i][j][k];
newSolution[j]+=sol[k]*weights[i][j][k];
}else
{
q+=(1.0/(1.0+exp(-lambda*sol[k])))*weights[i][j][k];
newSolution[j]+=(1.0/(1.0+exp(-lambda*sol[k])))*weights[i][j][k];
}
}
newSolution[j]=q;
}
prevSize=layerSizes[i];
sol=newSolution;

2
src/NeuronNetwork/FeedForwardQuick.h
View File

@@ -99,7 +99,7 @@ namespace NeuronNetwork
weights[i][j]= new double[prev_size];
for(int k=0;k<prev_size;k++)
{
weights[i][j][k]=0.5-((double)(rand()%1000))/1000.0;
weights[i][j][k]=1.0-((double)(rand()%2001))/1000.0;
}
}
i++;

31
src/NeuronNetwork/Learning/BackPropagation.cpp
View File

@@ -5,16 +5,6 @@ Shin::NeuronNetwork::Learning::BackPropagation::BackPropagation(FeedForwardNetwo
}
double Shin::NeuronNetwork::Learning::BackPropagation::calculateError(const Shin::NeuronNetwork::Solution& expectation, const Shin::NeuronNetwork::Solution& solution)
{
register double a=0;
for (size_t i=0;i<expectation.size();i++)
{
a+=pow(expectation[i]-solution[i],2)/2;
}
return a;
}
void Shin::NeuronNetwork::Learning::BackPropagation::propagate(const Shin::NeuronNetwork::Solution& expectation)
{
double **deltas;
@@ -51,8 +41,10 @@ void Shin::NeuronNetwork::Learning::BackPropagation::propagate(const Shin::Neuro
max=network[i]->size();
else
max=network[i-1]->size();
for(size_t j=1;j<network[i]->size();j++)
size_t j=1;
int size=network[i]->size();
for(j=1;j<size;j++)
{
network[i]->operator[](j)->setWeight(0,network[i]->operator[](j)->getWeight(0)+deltas[i][j]*learningCoeficient);
for(size_t k=1;k<max;k++)
@@ -75,8 +67,19 @@ double Shin::NeuronNetwork::Learning::BackPropagation::teach(const Shin::NeuronN
{
Shin::NeuronNetwork::Solution a=network.solve(p);
double error=calculateError(solution,a);
propagate(solution);
std::vector<double> s;
if(entropy)
{
for(size_t i=0;i<solution.size();i++)
{
s.push_back(solution[i]*((double)(990+(rand()%21))/1000.0));
}
propagate(s);
}else
{
propagate(solution);
}
// std::cerr << "error: " << error << "\n";

6
src/NeuronNetwork/Learning/BackPropagation.h
View File

@@ -24,12 +24,14 @@ namespace Learning
{
public:
BackPropagation(FeedForwardNetworkQuick &n);
double calculateError(const Solution &expectation,const Solution &solution);
void propagate(const Shin::NeuronNetwork::Solution& expectation);
virtual void propagate(const Shin::NeuronNetwork::Solution& expectation);
double teach(const Shin::NeuronNetwork::Problem &p,const Solution &solution);
void setLearningCoeficient (double);
void allowEntropy() {entropy=1;}
protected:
double learningCoeficient=0.4;
bool entropy=1;
};
}
}

1
src/NeuronNetwork/Learning/OpticalBackPropagation Symbolic link
View File

@@ -0,0 +1 @@
./OpticalBackPropagation.h

65
src/NeuronNetwork/Learning/OpticalBackPropagation.cpp Normal file
View File

@@ -0,0 +1,65 @@
#include "./OpticalBackPropagation"
Shin::NeuronNetwork::Learning::OpticalBackPropagation::OpticalBackPropagation(FeedForwardNetworkQuick &n): BackPropagation(n)
{
}
void Shin::NeuronNetwork::Learning::OpticalBackPropagation::propagate(const Shin::NeuronNetwork::Solution& expectation)
{
double **deltas;
deltas=new double*[network.size()];
for(int i=(int)network.size()-1;i>=0;i--)
{
deltas[i]=new double[network[i]->size()];
deltas[i][0]=0.0;
if(i==(int)network.size()-1)
{
for(size_t j=1;j<network[i]->size();j++)
{
register double tmp=(expectation[j-1]-network[i]->operator[](j)->output());
deltas[i][j]= (1+exp(tmp*tmp))*network[i]->operator[](j)->derivatedOutput();
if(tmp <0)
{
deltas[i][j]=-deltas[i][j];
}
}
}else
{
for(size_t j=1;j<network[i]->size();j++)
{
register double deltasWeight = 0;
for(size_t k=1;k<network[i+1]->size();k++)
{
deltasWeight+=deltas[i+1][k]*network[i+1]->operator[](k)->getWeight(j);
}
deltas[i][j]=deltasWeight*network[i]->operator[](j)->derivatedOutput();
}
}
}
for(size_t i=0;i<network.size();i++)
{
size_t max;
if(i==0)
max=network[i]->size();
else
max=network[i-1]->size();
for(size_t j=1;j<network[i]->size();j++)
{
network[i]->operator[](j)->setWeight(0,network[i]->operator[](j)->getWeight(0)+deltas[i][j]*learningCoeficient);
for(size_t k=1;k<max;k++)
{
network[i]->operator[](j)->setWeight(k,
network[i]->operator[](j)->getWeight(k)+learningCoeficient* deltas[i][j]*
(i==0? network.sums[0][k]:(double)network[i-1]->operator[](k)->output()));
}
}
}
for(size_t i=0;i<network.size();i++)
{
delete[] deltas[i];
}
delete[] deltas;
}

33
src/NeuronNetwork/Learning/OpticalBackPropagation.h Normal file
View File

@@ -0,0 +1,33 @@
#ifndef _OPT_BACK_PROPAGATION_H_
#define _OPT_BACK_PROPAGATION_H_
#include <math.h>
#include <cstddef>
#include "../Solution.h"
#include "../FeedForwardQuick.h"
#include "BackPropagation"
/*
* http://proceedings.informingscience.org/InSITE2005/P106Otai.pdf
*
*
*/
namespace Shin
{
namespace NeuronNetwork
{
namespace Learning
{
class OpticalBackPropagation : public BackPropagation
{
public:
OpticalBackPropagation(FeedForwardNetworkQuick &n);
virtual void propagate(const Shin::NeuronNetwork::Solution& expectation) override;
protected:
};
}
}
}
#endif

63
src/NeuronNetwork/Learning/Reinforcement.cpp
View File

@@ -2,10 +2,10 @@
Shin::NeuronNetwork::Learning::Reinforcement::Reinforcement(Shin::NeuronNetwork::FeedForwardNetworkQuick& n): Unsupervised(n), p(n)
{
p.setLearningCoeficient(4.5);
p.setLearningCoeficient(9);
}
void Shin::NeuronNetwork::Learning::Reinforcement::setQualityFunction(std::function< double(const Solution &s) > f)
void Shin::NeuronNetwork::Learning::Reinforcement::setQualityFunction(std::function< double(const Problem&,const Solution&) > f)
{
qualityFunction=f;
}
@@ -13,7 +13,7 @@ void Shin::NeuronNetwork::Learning::Reinforcement::setQualityFunction(std::funct
double Shin::NeuronNetwork::Learning::Reinforcement::learn(const Shin::NeuronNetwork::Problem& problem)
{
Solution s=network.solve(problem);
double quality=qualityFunction(s);
double quality=qualityFunction(problem,s);
std::vector<double> q;
for(register size_t j=0;j<s.size();j++)
{
@@ -35,57 +35,12 @@ double Shin::NeuronNetwork::Learning::Reinforcement::learn(const Shin::NeuronNet
return quality;
}
void Shin::NeuronNetwork::Learning::Reinforcement::propagate(const Shin::NeuronNetwork::Solution& expectation,bool random)
double Shin::NeuronNetwork::Learning::Reinforcement::learnSet(const std::vector< Shin::NeuronNetwork::Problem* >& problems)
{
double **deltas;
deltas=new double*[network.size()];
for(int i=(int)network.size()-1;i>=0;i--)
double err=0;
for(Shin::NeuronNetwork::Problem *pr:problems)
{
deltas[i]=new double[network[i]->size()];
deltas[i][0]=0.0;
if(i==(int)network.size()-1)
{
for(size_t j=1;j<network[i]->size();j++)
{
deltas[i][j]= (expectation[j-1]-network[i]->operator[](j)->output())*network[i]->operator[](j)->derivatedOutput();
// std::cerr << "X "<< deltas[i][j] <" Z ";
}
}else
{
for(size_t j=1;j<network[i]->size();j++)
{
register double deltasWeight = 0;
for(size_t k=1;k<network[i+1]->size();k++)
{
deltasWeight+=deltas[i+1][k]*network[i+1]->operator[](k)->getWeight(j);
}
deltas[i][j]=deltasWeight*network[i]->operator[](j)->derivatedOutput();
}
}
err+=learn(*pr);
}
for(size_t i=0;i<network.size();i++)
{
size_t max;
if(i==0)
max=network[i]->size();
else
max=network[i-1]->size();
for(size_t j=1;j<network[i]->size();j++)
{
network[i]->operator[](j)->setWeight(0,network[i]->operator[](j)->getWeight(0)+deltas[i][j]*learningCoeficient);
for(size_t k=1;k<max;k++)
{
network[i]->operator[](j)->setWeight(k,
network[i]->operator[](j)->getWeight(k)+learningCoeficient* deltas[i][j]*
(i==0? network.sums[0][k]:(double)network[i-1]->operator[](k)->output()));
}
}
}
for(size_t i=0;i<network.size();i++)
{
delete[] deltas[i];
}
delete[] deltas;
}
return err/problems.size();
}

7
src/NeuronNetwork/Learning/Reinforcement.h
View File

@@ -27,13 +27,14 @@ namespace Learning
public:
Reinforcement(FeedForwardNetworkQuick &n);
void setQualityFunction(std::function<double(const Solution &s)>);
void setQualityFunction(std::function<double(const Problem&,const Solution&)>);
double learn(const Shin::NeuronNetwork::Problem &p);
void propagate(const Shin::NeuronNetwork::Solution& expectation,bool random=0);
double learnSet(const std::vector<Shin::NeuronNetwork::Problem*> &);
void setCoef(double q) {p.setLearningCoeficient(q);}
inline BackPropagation& getPropagator() {return p;}
protected:
double learningCoeficient=3;
std::function<double(const Solution &s)> qualityFunction=nullptr;
std::function<double(const Problem&,const Solution&)> qualityFunction=nullptr;
BackPropagation p;
};
}

21
src/NeuronNetwork/Learning/Supervised.cpp
View File

@@ -4,6 +4,27 @@ Shin::NeuronNetwork::Learning::Supervised::Supervised(Shin::NeuronNetwork::FeedF
}
double Shin::NeuronNetwork::Learning::Supervised::calculateError(const Shin::NeuronNetwork::Solution& expectation, const Shin::NeuronNetwork::Solution& solution)
{
register double a=0;
for (size_t i=0;i<expectation.size();i++)
{
a+=pow(expectation[i]-solution[i],2)/2;
}
return a;
}
double Shin::NeuronNetwork::Learning::Supervised::teachSet(std::vector< Shin::NeuronNetwork::Problem* >& p, std::vector< Shin::NeuronNetwork::Solution* >& solution)
{
double error=0;
for (register size_t i=0;i<p.size();i++)
{
error+=teach(*p[i],*solution[i]);
}
return error;
}
void Shin::NeuronNetwork::Learning::Supervised::debugOn()
{
debug=1;

3
src/NeuronNetwork/Learning/Supervised.h
View File

@@ -19,8 +19,9 @@ namespace Learning
Supervised() =delete;
Supervised(FeedForwardNetworkQuick &n);
virtual ~Supervised() {};
virtual double calculateError(const Solution &expectation,const Solution &solution)=0;
double calculateError(const Solution &expectation,const Solution &solution);
virtual double teach(const Shin::NeuronNetwork::Problem &p,const Solution &solution)=0;
double teachSet(std::vector<Shin::NeuronNetwork::Problem*> &p,std::vector<Shin::NeuronNetwork::Solution*> &solution);
void debugOn();
void debugOff();
protected:

5
src/NeuronNetwork/Makefile
View File

@@ -1,5 +1,6 @@
OBJFILES= Neuron.o Network.o FeedForward.o FeedForwardQuick.o \
Learning/Supervised.o Learning/Unsupervised.o Learning/Reinforcement.o Learning/BackPropagation.o \
OBJFILES= Neuron.o Network.o FeedForward.o FeedForwardQuick.o\
Learning/Supervised.o Learning/BackPropagation.o Learning/OpticalBackPropagation.o\
Learning/Unsupervised.o Learning/Reinforcement.o\
Solution.o Problem.o
LIBNAME=NeuronNetwork

2
src/NeuronNetwork/Problem.h
View File

@@ -14,8 +14,8 @@ namespace NeuronNetwork
Problem();
virtual ~Problem(){};
operator std::vector<bool>() const;
protected:
virtual std::vector<bool> representation() const =0;
protected:
private:
};
}