Feedforward Closedloop Learning
feedforward_closedloop_learning.Layer Class Reference
Inheritance diagram for feedforward_closedloop_learning.Layer:
Collaboration diagram for feedforward_closedloop_learning.Layer:

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: