I'm developing a pseudo-library for neural network. To simplify
librarary using i wont to implement a sistem to instantiate different
implementation of interface(Layer .h Neuron.h) passing a string to a
function of a ùregistry vlass that hold all sub-classes...
/* ------Neuron.h--------*/
#include <math.h>
namespace Mnetlib
{
class Neuron
{
public:
virtual ~Neuron(){};
virtual double Run(double arg)=0;
virtual double RunBack(double o,double e)=0;
protected:
double outvalue;
int mode;
double input;
};
/* ------Layer.h--------*/
#include <vector>
#include "Neuron.h"
#include "Exception. h"
namespace Mnetlib
{
class Layer
{
public:
/**
* Costruttore di base.
* @param n Numero di neuroni presenti nel layer.
*/
Layer(int n);
virtual ~Layer()=0;
virtual void backprop(){thro w new
InstantiationEx ception();};
protected:
std::vector<Neu ron*vect;
int num;
};
}
/* ------Registry.h--------*/
#include "NeuronLib. h"
#include "LayerLib.h "
#include "Factory.h"
#include <map>
namespace Mnetlib
{
class Registry
{
public:
Registry();
~Registry();
Neuron * getNewNeuron(co nst std::string& name);
void registerNeuronF actory( NeuronClassFact ory*
factory)
{
_neuronRegistry[factory->name()]=factory;
}
void registerLayerFa ctory( LayerClassFacto ry* factory)
{
_layerRegistry[factory->name()]=factory;
}
Layer* getLayer (const std::string& lName, const
std::string& nName,
int n);
protected:
std::map<std::s tring,NeuronCla ssFactory*>
_neuronRegistry ;
std::map<std::s tring, LayerClassFacto ry*>
_layerRegistry;
NeuronFactoryWr apper<SigmoidNe uron>
sigmoidFactory;
NeuronFactoryWr apper<LinearNeu ron>
linearFactory;
LayerFactoryWra pper<OffLineLay eroffFactory;
LayerFactoryWra pper<OnLineLaye ronFactory;
};
}
/* ------Factory.h--------*/
#include "Neuron.h"
#include "Layer.h"
namespace Mnetlib
{
class NeuronClassFact ory
{
public:
virtual ~NeuronClassFac tory(){};
virtual Neuron* create()=0;
virtual std::string name()=0;
};
template < class T >
class NeuronFactoryWr apper : public NeuronClassFact ory
{
public:
virtual ~NeuronFactoryW rapper(){};
virtual Neuron* create(){ return T::create();}
virtual std::string name(){ return T::name();}
};
class LayerClassFacto ry
{
public:
virtual ~LayerClassFact ory(){};
virtual Layer* create()=0;
virtual std::string name()=0;
};
template < class T >
class LayerFactoryWra pper : public LayerClassFacto ry
{
public:
virtual ~LayerFactoryWr apper(){};
virtual Layer* create(){ return T::create();}
virtual std::string name(){ return T::name();}
void build();
};
}
/* ------NeuronLib.h--------*/
#include "Neuron.h"
#include <string>
namespace Mnetlib
{
class LinearNeuron: public Neuron
{
public:
~LinearNeuron() {};
double Run(double arg);
double RunBack(double o,double e);
static LinearNeuron* create(){ return new LinearNeuron(); };
static std::string name(){ return "linear";} ;
};
class SigmoidNeuron: public Neuron
{
public:
~SigmoidNeuron( ){};
double Run(double arg);
double RunBack(double o,double e);
static SigmoidNeuron* create(){ return new SigmoidNeuron() ;};
static std::string name(){ return "sigmoid";} ;
};
}
/* ------LayerLib.h--------*/
#include <string>
#include "Layer.h"
namespace Mnetlib
{
class OnLineLayer : public Layer
{
public:
OnLineLayer(int n);
~OnLineLayer(){ };
static OnLineLayer* create(int n){ return new
OnLineLayer(n); };
static std::string name(){ return "online";} ;
void backprop();
};
class OffLineLayer : public Layer
{
public:
OffLineLayer();
~OffLineLayer() {};
static OffLineLayer* create(){ return new
OffLineLayer(); };
static std::string name(){ return "offline";} ;
void backprop();
};
}
This code only for instantiate an object via some line
Registry reg;
Layer* l= reg.getLayer ("offline", "linear", n);
But at this time i have proble with linking...and some other
inconveninet like ciclic include...
Anyone have a good idea to solve this question??
