Feedforward Closedloop Learning: feedforward_closedloop_learning.Layer Class Reference

Feedforward Closedloop Learning

Public Member Functions | Static Public Attributes | Properties | List of all members
feedforward_closedloop_learning.Layer Class Reference
Inheritance diagram for feedforward_closedloop_learning.Layer:
[legend]
Collaboration diagram for feedforward_closedloop_learning.Layer:
[legend]

## Public Member Functions
def | __init__ (self, "int" _nNeurons, "int" _nInputs)
"void" | calcOutputs (self)
"void" | doLearning (self)
"void" | setError (self, *args)
"void" | setErrors (self, "double *" _errors)
"double" | getError (self, "int" i)
"void" | setBias (self, "double" _bias)
"void" | setInput (self, "int" inputIndex, "double" input)
"void" | setInputs (self, "double *" _inputs)
"void" | setLearningRate (self, "double" _learningRate)
"void" | setActivationFunction (self, "Neuron::ActivationFunction" _activationFunction)
"void" | setMomentum (self, "double" _momentum)
"void" | setDecay (self, "double" _decay)
"void" | initWeights (self, *args)
"double" | getOutput (self, "int" index)
"Neuron *" | getNeuron (self, "int" index)
"int" | getNneurons (self)
"int" | getNinputs (self)
"void" | setConvolution (self, "int" width, "int" height)
"void" | setMaxDetLayer (self, "int" _m)
"void" | setNormaliseWeights (self, "Layer::WeightNormalisation" _normaliseWeights)
"void" | setDebugInfo (self, "int" layerIndex)
"void" | setStep (self, "long" step)
"double" | getWeightDistanceFromInitialWeights (self)
"void" | doNormaliseWeights (self)
"void" | setUseThreads (self, "int" _useThreads)
"int" | saveWeightMatrix (self, "char *" filename)

## Static Public Attributes
| WEIGHT_NORM_NONE = _feedforward_closedloop_learning.Layer_WEIGHT_NORM_NONE
| WEIGHT_NORM_LAYER_EUCLEDIAN = _feedforward_closedloop_learning.Layer_WEIGHT_NORM_LAYER_EUCLEDIAN
| WEIGHT_NORM_NEURON_EUCLEDIAN = _feedforward_closedloop_learning.Layer_WEIGHT_NORM_NEURON_EUCLEDIAN
| WEIGHT_NORM_LAYER_MANHATTAN = _feedforward_closedloop_learning.Layer_WEIGHT_NORM_LAYER_MANHATTAN
| WEIGHT_NORM_NEURON_MANHATTAN = _feedforward_closedloop_learning.Layer_WEIGHT_NORM_NEURON_MANHATTAN
| WEIGHT_NORM_LAYER_INFINITY = _feedforward_closedloop_learning.Layer_WEIGHT_NORM_LAYER_INFINITY
| WEIGHT_NORM_NEURON_INFINITY = _feedforward_closedloop_learning.Layer_WEIGHT_NORM_NEURON_INFINITY

## Properties
| thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

## Detailed Description

    Proxy of C++ Layer class.

## Constructor & Destructor Documentation

## ◆ __init__()

def feedforward_closedloop_learning.Layer.__init__ | ( |  | self,
|  | "int" | _nNeurons,
|  | "int" | _nInputs
| ) |  |

    __init__(Layer self, int _nNeurons, int _nInputs) -> Layer

    Parameters
    ----------
    _nNeurons: int
    _nInputs: int

## Member Function Documentation

## ◆ calcOutputs()

"void" feedforward_closedloop_learning.Layer.calcOutputs | ( |  | self | ) |

    calcOutputs(Layer self)

## ◆ doLearning()

"void" feedforward_closedloop_learning.Layer.doLearning | ( |  | self | ) |

    doLearning(Layer self)

## ◆ doNormaliseWeights()

"void" feedforward_closedloop_learning.Layer.doNormaliseWeights | ( |  | self | ) |

    doNormaliseWeights(Layer self)

## ◆ getError()

"double" feedforward_closedloop_learning.Layer.getError | ( |  | self,
|  | "int" | i
| ) |  |

    getError(Layer self, int i) -> double

    Parameters
    ----------
    i: int

## ◆ getNeuron()

"Neuron *" feedforward_closedloop_learning.Layer.getNeuron | ( |  | self,
|  | "int" | index
| ) |  |

    getNeuron(Layer self, int index) -> Neuron

    Parameters
    ----------
    index: int

## ◆ getNinputs()

"int" feedforward_closedloop_learning.Layer.getNinputs | ( |  | self | ) |

    getNinputs(Layer self) -> int

## ◆ getNneurons()

"int" feedforward_closedloop_learning.Layer.getNneurons | ( |  | self | ) |

    getNneurons(Layer self) -> int

## ◆ getOutput()

"double" feedforward_closedloop_learning.Layer.getOutput | ( |  | self,
|  | "int" | index
| ) |  |

    getOutput(Layer self, int index) -> double

    Parameters
    ----------
    index: int

## ◆ getWeightDistanceFromInitialWeights()

"double" feedforward_closedloop_learning.Layer.getWeightDistanceFromInitialWeights | ( |  | self | ) |

    getWeightDistanceFromInitialWeights(Layer self) -> double

## ◆ initWeights()

"void" feedforward_closedloop_learning.Layer.initWeights | ( |  | self,
|  | * | args
| ) |  |

    initWeights(Layer self, double _max=1, int initBiasWeight=1, Neuron::WeightInitMethod weightInitMethod=MAX_OUTPUT_RANDOM)

    Parameters
    ----------
    _max: double
    initBiasWeight: int
    weightInitMethod: enum Neuron::WeightInitMethod

## ◆ saveWeightMatrix()

"int" feedforward_closedloop_learning.Layer.saveWeightMatrix | ( |  | self,
|  | "char *" | filename
| ) |  |

    saveWeightMatrix(Layer self, char * filename) -> int

    Parameters
    ----------
    filename: char *

## ◆ setActivationFunction()

"void" feedforward_closedloop_learning.Layer.setActivationFunction | ( |  | self,
|  | "Neuron::ActivationFunction" | _activationFunction
| ) |  |

    setActivationFunction(Layer self, Neuron::ActivationFunction _activationFunction)

    Parameters
    ----------
    _activationFunction: enum Neuron::ActivationFunction

## ◆ setBias()

"void" feedforward_closedloop_learning.Layer.setBias | ( |  | self,
|  | "double" | _bias
| ) |  |

    setBias(Layer self, double _bias)

    Parameters
    ----------
    _bias: double

## ◆ setConvolution()

"void" feedforward_closedloop_learning.Layer.setConvolution | ( |  | self,
|  | "int" | width,
|  | "int" | height
| ) |  |

    setConvolution(Layer self, int width, int height)

    Parameters
    ----------
    width: int
    height: int

## ◆ setDebugInfo()

"void" feedforward_closedloop_learning.Layer.setDebugInfo | ( |  | self,
|  | "int" | layerIndex
| ) |  |

    setDebugInfo(Layer self, int layerIndex)

    Parameters
    ----------
    layerIndex: int

## ◆ setDecay()

"void" feedforward_closedloop_learning.Layer.setDecay | ( |  | self,
|  | "double" | _decay
| ) |  |

    setDecay(Layer self, double _decay)

    Parameters
    ----------
    _decay: double

## ◆ setError()

"void" feedforward_closedloop_learning.Layer.setError | ( |  | self,
|  | * | args
| ) |  |

    setError(Layer self, double _error)

    Parameters
    ----------
    _error: double

    setError(Layer self, int i, double _error)

    Parameters
    ----------
    i: int
    _error: double

## ◆ setErrors()

"void" feedforward_closedloop_learning.Layer.setErrors | ( |  | self,
|  | "double *" | _errors
| ) |  |

    setErrors(Layer self, double * _errors)

    Parameters
    ----------
    _errors: double *

## ◆ setInput()

"void" feedforward_closedloop_learning.Layer.setInput | ( |  | self,
|  | "int" | inputIndex,
|  | "double" | input
| ) |  |

    setInput(Layer self, int inputIndex, double input)

    Parameters
    ----------
    inputIndex: int
    input: double

## ◆ setInputs()

"void" feedforward_closedloop_learning.Layer.setInputs | ( |  | self,
|  | "double *" | _inputs
| ) |  |

    setInputs(Layer self, double * _inputs)

    Parameters
    ----------
    _inputs: double *

## ◆ setLearningRate()

"void" feedforward_closedloop_learning.Layer.setLearningRate | ( |  | self,
|  | "double" | _learningRate
| ) |  |

    setLearningRate(Layer self, double _learningRate)

    Parameters
    ----------
    _learningRate: double

## ◆ setMaxDetLayer()

"void" feedforward_closedloop_learning.Layer.setMaxDetLayer | ( |  | self,
|  | "int" | _m
| ) |  |

    setMaxDetLayer(Layer self, int _m)

    Parameters
    ----------
    _m: int

## ◆ setMomentum()

"void" feedforward_closedloop_learning.Layer.setMomentum | ( |  | self,
|  | "double" | _momentum
| ) |  |

    setMomentum(Layer self, double _momentum)

    Parameters
    ----------
    _momentum: double

## ◆ setNormaliseWeights()

"void" feedforward_closedloop_learning.Layer.setNormaliseWeights | ( |  | self,
|  | "Layer::WeightNormalisation" | _normaliseWeights
| ) |  |

    setNormaliseWeights(Layer self, Layer::WeightNormalisation _normaliseWeights)

    Parameters
    ----------
    _normaliseWeights: enum Layer::WeightNormalisation

## ◆ setStep()

"void" feedforward_closedloop_learning.Layer.setStep | ( |  | self,
|  | "long" | step
| ) |  |

    setStep(Layer self, long step)

    Parameters
    ----------
    step: long

## ◆ setUseThreads()

"void" feedforward_closedloop_learning.Layer.setUseThreads | ( |  | self,
|  | "int" | _useThreads
| ) |  |

    setUseThreads(Layer self, int _useThreads)

    Parameters
    ----------
    _useThreads: int

The documentation for this class was generated from the following file:

- feedforward_closedloop_learning.py