lsmtopology.h

amygdata的神经网络算法源代码

/***************************************************************************
                          lsmtopology.h  -  description
                             -------------------
    begin                : Wed Mar 30 2005
    copyright            : (C) 2005 by Rudiger Koch
    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 AMYGDALALSMTOPOLOGY_H
#define AMYGDALALSMTOPOLOGY_H

#include <topology.h>
#include <amygdala/factory.h>

#include <string>
#include <vector>

namespace Amygdala {

class SpikeInput;
class InputNeuron;

/**
The Liquid State Machine as published by Maass, Markram and Natschlaeger

@author Rudiger Koch
*/
class LSMTopology : public Topology
{
public:
    typedef TopologyFactory<LSMTopology> Factory;

    virtual ~LSMTopology();
    
    /** connectivity parameters  for all possible combinations of inhibitory / excitatory */
    typedef struct { float EE; float EI; float IE; float II; } EIS;
    typedef union { struct EIS; float EIV[4]; } EI;
    
/** Make the cube (or liquid) of the LSM */
    void MakeCube(const std::string & nType, unsigned int x, unsigned int y, unsigned int z);
    void MakeCube(NFactory* nf, NeuronProperties* np, unsigned int x, unsigned int y, unsigned int z);
/** Connect the cube */
    void Connect(const float lambda,
                 const EI & A,
                 const EI & delay,
                 const EI & C,
                 const EI & U,
                 const EI & D,
                 const EI & F,
                 const std::string & sType,
				 const float likelyhood = 0.2);
    Topology * MakeInput(SpikeInput * sInput, unsigned int iNeurons);
    Topology * MakeReadout(const std::string & nType, unsigned int iNeurons);
    Topology * MakeReadout(NFactory* nf, NeuronProperties* np, unsigned int iNeurons);

    enum IOGROUPS {INPUTGROUP=1, OUTPUTGROUP, HIDDENGROUP };

    class Output : public Topology {
        Output();
    public:
        Output(std::string name);
        ~Output();  
        //void MakeReadout(const std::string & nType, unsigned int X, unsigned int Y, unsigned int oNeurons);
    };
    class Input : public Topology {
        friend class LSMTopology;
        Input();
    public:
        Input(std::string name);
        ~Input();  
        //void MakeInput(SpikeInput * sInput, unsigned int X, unsigned int Y, unsigned int Z, unsigned int iNeurons);
    protected:
        InputNeuron * MakeInputNeuron(int x, int y, int z);
    };

protected:
    LSMTopology();
    LSMTopology(std::string name);
    
    std::vector<Output*> output;
    std::vector<Input*> input;
    int X, Y, Z;
    int lastInX, lastInY, lastInZ, lastInSide;
    int lastOutX, lastOutY, lastOutZ;

private:
    friend class Network;
    template<class topology>
    friend class TopologyFactory;
};

namespace Factory {
    static LSMTopology::Factory MakeLSMTopology;
}

};  // namespace Amygdala

#endif