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(){throw new
InstantiationException();};
protected:
std::vector<Neuron*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(const std::string& name);
void registerNeuronFactory( NeuronClassFactory*
factory)
{
_neuronRegistry[factory->name()]=factory;
}
void registerLayerFactory( LayerClassFactory* factory)
{
_layerRegistry[factory->name()]=factory;
}
Layer* getLayer (const std::string& lName, const
std::string& nName,
int n);
protected:
std::map<std::string,NeuronClassFactory*>
_neuronRegistry;
std::map<std::string, LayerClassFactory*>
_layerRegistry;
NeuronFactoryWrapper<SigmoidNeuron>
sigmoidFactory;
NeuronFactoryWrapper<LinearNeuron>
linearFactory;
LayerFactoryWrapper<OffLineLayeroffFactory;
LayerFactoryWrapper<OnLineLayeronFactory;
};
}
/* ------Factory.h--------*/
#include "Neuron.h"
#include "Layer.h"
namespace Mnetlib
{
class NeuronClassFactory
{
public:
virtual ~NeuronClassFactory(){};
virtual Neuron* create()=0;
virtual std::string name()=0;
};
template < class T >
class NeuronFactoryWrapper : public NeuronClassFactory
{
public:
virtual ~NeuronFactoryWrapper(){};
virtual Neuron* create(){ return T::create();}
virtual std::string name(){ return T::name();}
};
class LayerClassFactory
{
public:
virtual ~LayerClassFactory(){};
virtual Layer* create()=0;
virtual std::string name()=0;
};
template < class T >
class LayerFactoryWrapper : public LayerClassFactory
{
public:
virtual ~LayerFactoryWrapper(){};
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??
