aureservoir.py

一个人工神经网络的程序。 文档等说明参见http://aureservoir.sourceforge.net/

        """
        return _aureservoir.SingleESN_post(*args)

    def getSize(*args):
        """
        getSize(self) -> int

        reservoir size (nr of neurons) 
        """
        return _aureservoir.SingleESN_getSize(*args)

    def getInputs(*args):
        """
        getInputs(self) -> int

        nr of inputs to the reservoir 
        """
        return _aureservoir.SingleESN_getInputs(*args)

    def getOutputs(*args):
        """
        getOutputs(self) -> int

        nr of outputs from the reservoir 
        """
        return _aureservoir.SingleESN_getOutputs(*args)

    def getNoise(*args):
        """
        getNoise(self) -> double

        current noise level 
        """
        return _aureservoir.SingleESN_getNoise(*args)

    def getInitParam(*args):
        """
        getInitParam(self, InitParameter key) -> float

        returns an initialization parametern from the parameter map

        Parameters:
        -----------

        key:  the requested parameter

        the value of the parameter 
        """
        return _aureservoir.SingleESN_getInitParam(*args)

    def getInitAlgorithm(*args):
        """
        getInitAlgorithm(self) -> int

        initialization algorithm 
        """
        return _aureservoir.SingleESN_getInitAlgorithm(*args)

    def getTrainAlgorithm(*args):
        """
        getTrainAlgorithm(self) -> int

        training algorithm 
        """
        return _aureservoir.SingleESN_getTrainAlgorithm(*args)

    def getSimAlgorithm(*args):
        """
        getSimAlgorithm(self) -> int

        simulation algorithm 
        """
        return _aureservoir.SingleESN_getSimAlgorithm(*args)

    def getReservoirAct(*args):
        """
        getReservoirAct(self) -> int

        reservoir activation function 
        """
        return _aureservoir.SingleESN_getReservoirAct(*args)

    def getOutputAct(*args):
        """
        getOutputAct(self) -> int

        output activation function 
        """
        return _aureservoir.SingleESN_getOutputAct(*args)

    def getWin(*args):
        """
        getWin(self, float mtx)

        get pointer to input weight matrix data and dimensions (neurons x
        inputs) WARNING:  This data is in fortran style column major storage !

        """
        return _aureservoir.SingleESN_getWin(*args)

    def getWback(*args):
        """
        getWback(self, float mtx)

        get pointer to feedback weight matrix data and dimensions (neurons x
        outputs) WARNING:  This data is in fortran style column major storage
        ! 
        """
        return _aureservoir.SingleESN_getWback(*args)

    def getWout(*args):
        """
        getWout(self, float mtx)

        get pointer to output weight matrix data and dimensions (outputs x
        neurons+inputs) WARNING:  This data is in fortran style column major
        storage ! 
        """
        return _aureservoir.SingleESN_getWout(*args)

    def getX(*args):
        """
        getX(self, float vec)

        get pointer to internal state vector x data and length 
        """
        return _aureservoir.SingleESN_getX(*args)

    def getW(*args):
        """
        getW(self, float wmtx)

        throw ( AUExcept)
        Copies data of the sparse reservoir weight matrix into a dense C-style
        matrix. Memory of the C array must be allocated before!

        Parameters:
        -----------

        wmtx:  pointer to matrix of size (neurons_ x neurons_) 
        """
        return _aureservoir.SingleESN_getW(*args)

    def getDelays(*args):
        """
        getDelays(self, float wmtx)

        throw (
        AUExcept) query the trained delays in delay&sum readout See:  class
        SimFilterDS and copies the data into a C-style matrix

        Memory of the C array must be allocated before!

        Parameters:
        -----------

        wmtx:  matrix with delay form neurons+inputs to all outputs size =
        (output x neurons+inputs) 
        """
        return _aureservoir.SingleESN_getDelays(*args)

    def setInitAlgorithm(*args):
        """
        setInitAlgorithm(self, InitAlgorithm alg=INIT_STD)
        setInitAlgorithm(self)

        throw (
        AUExcept) set initialization algorithm 
        """
        return _aureservoir.SingleESN_setInitAlgorithm(*args)

    def setTrainAlgorithm(*args):
        """
        setTrainAlgorithm(self, TrainAlgorithm alg=TRAIN_LEASTSQUARE)
        setTrainAlgorithm(self)

        throw (
        AUExcept) set training algorithm 
        """
        return _aureservoir.SingleESN_setTrainAlgorithm(*args)

    def setSimAlgorithm(*args):
        """
        setSimAlgorithm(self, SimAlgorithm alg=SIM_STD)
        setSimAlgorithm(self)

        throw (
        AUExcept) set simulation algorithm 
        """
        return _aureservoir.SingleESN_setSimAlgorithm(*args)

    def setSize(*args):
        """
        setSize(self, int neurons=10)
        setSize(self)

        throw ( AUExcept)
        set reservoir size (nr of neurons) 
        """
        return _aureservoir.SingleESN_setSize(*args)

    def setInputs(*args):
        """
        setInputs(self, int inputs=1)
        setInputs(self)

        throw (
        AUExcept) set nr of inputs to the reservoir 
        """
        return _aureservoir.SingleESN_setInputs(*args)

    def setOutputs(*args):
        """
        setOutputs(self, int outputs=1)
        setOutputs(self)

        throw (
        AUExcept) set nr of outputs from the reservoir 
        """
        return _aureservoir.SingleESN_setOutputs(*args)

    def setNoise(*args):
        """
        setNoise(self, double noise)

        throw ( AUExcept)
        set noise level for training/simulation algorithm

        Parameters:
        -----------

        noise:  with uniform distribution within [-noise|+noise] 
        """
        return _aureservoir.SingleESN_setNoise(*args)

    def setInitParam(*args):
        """
        setInitParam(self, InitParameter key, float value=0.)
        setInitParam(self, InitParameter key)

        set initialization parameter 
        """
        return _aureservoir.SingleESN_setInitParam(*args)

    def setReservoirAct(*args):
        """
        setReservoirAct(self, ActivationFunction f=ACT_TANH)
        setReservoirAct(self)

        throw (
        AUExcept) set reservoir activation function 
        """
        return _aureservoir.SingleESN_setReservoirAct(*args)

    def setOutputAct(*args):
        """
        setOutputAct(self, ActivationFunction f=ACT_LINEAR)
        setOutputAct(self)

        throw (
        AUExcept) set output activation function 
        """
        return _aureservoir.SingleESN_setOutputAct(*args)

    def setWin(*args):
        """
        setWin(self, float inmtx)

        throw ( AUExcept)
        set input weight matrix C-style interface (neurons x inputs) (data
        will be copied into a FLENS matrix)

        Parameters:
        -----------

        inmtx:  pointer to win matrix in row major storage 
        """
        return _aureservoir.SingleESN_setWin(*args)

    def setW(*args):
        """
        setW(self, float inmtx)

        throw ( AUExcept) set
        reservoir weight matrix C-style interface (neurons x neurons) (data
        will be copied into a FLENS matrix)

        Parameters:
        -----------

        inmtx:  pointer to a dense reservoir matrix in row major storage 
        """
        return _aureservoir.SingleESN_setW(*args)

    def setWback(*args):
        """
        setWback(self, float inmtx)

        throw ( AUExcept)
        set feedback weight matrix C-style interface (neurons x outputs) (data
        will be copied into a FLENS matrix)

        Parameters:
        -----------

        inmtx:  pointer to wback matrix in row major storage 
        """
        return _aureservoir.SingleESN_setWback(*args)

    def setWout(*args):
        """
        setWout(self, float inmtx)

        throw ( AUExcept)
        set output weight matrix C-style interface (outputs x neurons+inputs)
        (data will be copied into a FLENS matrix)

        Parameters:
        -----------

        inmtx:  pointer to wout matrix in row major storage 
        """
        return _aureservoir.SingleESN_setWout(*args)

    def setX(*args):
        """
        setX(self, float invec)

        throw ( AUExcept) set
        internal state vector C-style interface (size = neurons) (data will be
        copied into a FLENS matrix)

        Parameters:
        -----------

        invec:  pointer to state vector 
        """
        return _aureservoir.SingleESN_setX(*args)

    def setLastOutput(*args):
        """
        setLastOutput(self, float last)

        throw (
        AUExcept) set last output, stored by the simulation algorithm needed
        in singleStep simulation with feedback

        Parameters:
        -----------

        last:  vector with size = outputs 
        """
        return _aureservoir.SingleESN_setLastOutput(*args)

SingleESN_swigregister = _aureservoir.SingleESN_swigregister
SingleESN_swigregister(SingleESN)

CONNECTIVITY = _aureservoir.CONNECTIVITY
ALPHA = _aureservoir.ALPHA
IN_CONNECTIVITY = _aureservoir.IN_CONNECTIVITY
IN_SCALE = _aureservoir.IN_SCALE
IN_SHIFT = _aureservoir.IN_SHIFT
FB_CONNECTIVITY = _aureservoir.FB_CONNECTIVITY
FB_SCALE = _aureservoir.FB_SCALE
FB_SHIFT = _aureservoir.FB_SHIFT
LEAKING_RATE = _aureservoir.LEAKING_RATE
TIKHONOV_FACTOR = _aureservoir.TIKHONOV_FACTOR
DS_USE_CROSSCORR = _aureservoir.DS_USE_CROSSCORR
DS_USE_GCC = _aureservoir.DS_USE_GCC
DS_MAXDELAY = _aureservoir.DS_MAXDELAY
IP_LEARNRATE = _aureservoir.IP_LEARNRATE
IP_MEAN = _aureservoir.IP_MEAN
IP_VAR = _aureservoir.IP_VAR
INIT_STD = _aureservoir.INIT_STD
SIM_STD = _aureservoir.SIM_STD
SIM_SQUARE = _aureservoir.SIM_SQUARE
SIM_LI = _aureservoir.SIM_LI
SIM_BP = _aureservoir.SIM_BP
SIM_FILTER = _aureservoir.SIM_FILTER
SIM_FILTER2 = _aureservoir.SIM_FILTER2
SIM_FILTER_DS = _aureservoir.SIM_FILTER_DS
TRAIN_PI = _aureservoir.TRAIN_PI
TRAIN_LS = _aureservoir.TRAIN_LS
TRAIN_RIDGEREG = _aureservoir.TRAIN_RIDGEREG
TRAIN_DS_PI = _aureservoir.TRAIN_DS_PI
ACT_LINEAR = _aureservoir.ACT_LINEAR
ACT_TANH = _aureservoir.ACT_TANH
ACT_TANH2 = _aureservoir.ACT_TANH2
ACT_SIGMOID = _aureservoir.ACT_SIGMOID