statictrainer.h

amygdata的神经网络算法源代码

/***************************************************************************
                          statictrainer.h
                             -------------------
    begin                : Sat Mar 19 2005
    copyright            : (C) 2005 by Matt Grover
    email                : [e-mail]
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef STATICTRAINER_H
#define STATICTRAINER_H

#include <amygdala/trainer.h>
#include <amygdala/factory.h>
#include <amygdala/functionlookup.h>
#include <vector>


namespace Amygdala {
class StaticSynapse;

/**
  * @author Matt Grover <[e-mail]>
*/
class StaticHebbianTrainerProperties: public TrainerProperties
{
public:
    StaticHebbianTrainerProperties();
    StaticHebbianTrainerProperties(float synapticTimeConst,
                                    float synapticPotentiationConst,
                                    float synapticDepressionConst,
                                    float learningMax,
                                    float posLearningTimeConst,
                                    float negLearningTimeConst,
                                    float learningConst,
                                    unsigned int historySize);
    virtual ~StaticHebbianTrainerProperties() {}

    virtual StaticHebbianTrainerProperties* Copy();
    
    void SetLearningConstant(float lConst) { learningConst = lConst; }
    float GetLearningConstant() const { return learningConst; }

    void SetSynapticTimeConst(float synConst) { synTimeConst = synConst; }
    float GetSynapticTimeConst() const { return synTimeConst; }

    void SetSynapticPotentiationConst(float potConst) { synPotConst = potConst; }
    float GetSynapticPotentiationConst() const { return synPotConst; }

    void SetSynapticDepressionConst(float depConst) {synDepConst = depConst; }
    float GetSynapticDepressionConst() const { return synDepConst; }

    void SetLearningMax(float learnMax) { learningMax = learnMax; }
    float GetLearningMax() const { return learningMax; }

    void SetPositiveLearningConst(float posLearn) { posLearnTimeConst = posLearn; }
    float GetPositiveLearningConst() const { return posLearnTimeConst; }

    void SetNegativeLearningConst(float negLearn) { negLearnTimeConst = negLearn; }
    float GetNegativeLearningConst() const { return negLearnTimeConst; }

    void SetHistorySize(unsigned int size) { historySize = size; }
    unsigned int GetHistorySize() const { return historySize; }

    virtual void SetProperty(const std::string& name, const std::string& value);

    virtual std::map< std::string, std::string > GetPropertyMap() const;
protected:
    float synTimeConst;             // Synaptic time constant
    float synPotConst;              // Synaptic potentiation constant
    float synDepConst;              // Synaptic depression constant
    float learningMax;              // Relative time of max weight increase (ms)
    float posLearnTimeConst;        // Positive learning time const (t+) (ms)
    float negLearnTimeConst;        // Negative learning time const (t-) (ms)
    float learningConst;            // Learning constant
    unsigned int historySize;
};

class StaticTrainer : public Trainer {
public: 
    virtual ~StaticTrainer() = 0;

    virtual TrainerProperties* Properties();

    virtual void Train(StaticSynapse* syn, AmTimeInt lastTransmitTime, unsigned int lastHistIdx) = 0;

    virtual void ReportSpike(SpikingNeuron* nrn) = 0;

    virtual void PeriodicTrain() {}

    virtual const std::string TrainableType() const { return "Static"; }
protected:
	StaticTrainer(TrainerProperties& props, std::string name):Trainer(props, name) {}
};

class StaticHebbianTrainer : public StaticTrainer {
    template<class trainer, class trainerProperties>
    friend class TrainerFactory;
public:
    typedef TrainerFactory<StaticHebbianTrainer,StaticHebbianTrainerProperties> Factory;
	virtual ~StaticHebbianTrainer();

    StaticHebbianTrainerProperties* Properties() { return static_cast<StaticHebbianTrainerProperties*>(tprops); }

    virtual void Train(StaticSynapse* syn, AmTimeInt lastTransmitTime, unsigned int lastHistIdx);

    virtual void ReportSpike(SpikingNeuron* nrn);
protected:
	StaticHebbianTrainer(StaticHebbianTrainerProperties& props, std::string name);

    void InitLookup();
    TableProperties GetTableProps(unsigned int index);
    void MakeLookupTables();

    std::vector<AmTimeInt> spikeHistory;
    float learningMax;
    unsigned int histIdx;
    AmTimeInt lastSpikeTime;
    unsigned int windowWidth;
    float* weightDiffPreLookup;
    float* weightDiffPostLookup;
};

namespace Factory {
    static StaticHebbianTrainer::Factory MakeStaticHebbianTrainer;
}
}
#endif