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

Public Member Functions

def __init__ (self, "int" _nInputs)
 
"void" calcOutput (self)
 
"void" doLearning (self)
 
"void" doMaxDet (self)
 
"void" initWeights (self, *args)
 
"void" setActivationFunction (self, "Neuron::ActivationFunction" _activationFunction)
 
"double" dActivation (self)
 
"double" getMinWeightValue (self)
 
"double" getMaxWeightValue (self)
 
"double" getWeightDistanceFromInitialWeights (self)
 
"double" getOutput (self)
 
"double" getSum (self)
 
"double" getWeight (self, "int" _index)
 
"void" setWeight (self, "int" _index, "double" _weight)
 
"void" setError (self, "double" _error)
 
"double" getError (self)
 
"void" setInput (self, "int" _index, "double" _value)
 
"double" getInput (self, "int" _index)
 
"double" getBiasWeight (self)
 
"void" setBiasWeight (self, "double" _biasweight)
 
"void" setBias (self, "double" _bias)
 
"void" setLearningRate (self, "double" _learningrate)
 
"void" setMomentum (self, "double" _momentum)
 
"void" setDecay (self, "double" _decay)
 
"double" getDecay (self)
 
"int" getNinputs (self)
 
"void" setGeometry (self, "int" _width, "int" _height)
 
"void" setMask (self, *args)
 
"unsigned char" getMask (self, *args)
 
"double" getSumOfSquaredWeightVector (self)
 
"double" getEuclideanNormOfWeightVector (self)
 
"double" getManhattanNormOfWeightVector (self)
 
"double" getInfinityNormOfWeightVector (self)
 
"double" getAverageOfWeightVector (self)
 
"void" normaliseWeights (self, "double" norm)
 
"void" saveInitialWeights (self)
 
"void" setDebugInfo (self, "int" _layerIndex, "int" _neuronIndex)
 
"void" setStep (self, "long" _step)
 

Static Public Member Functions

"void *" calcOutputThread ("void *" object)
 
"void *" doLearningThread ("void *" object)
 
"void *" doMaxDetThread ("void *" object)
 

Static Public Attributes

 MAX_OUTPUT_RANDOM = _feedforward_closedloop_learning.Neuron_MAX_OUTPUT_RANDOM
 
 MAX_WEIGHT_RANDOM = _feedforward_closedloop_learning.Neuron_MAX_WEIGHT_RANDOM
 
 MAX_OUTPUT_CONST = _feedforward_closedloop_learning.Neuron_MAX_OUTPUT_CONST
 
 CONST_WEIGHTS = _feedforward_closedloop_learning.Neuron_CONST_WEIGHTS
 
 LINEAR = _feedforward_closedloop_learning.Neuron_LINEAR
 
 TANH = _feedforward_closedloop_learning.Neuron_TANH
 
 RELU = _feedforward_closedloop_learning.Neuron_RELU
 
 REMAXLU = _feedforward_closedloop_learning.Neuron_REMAXLU
 
 TANHLIMIT = _feedforward_closedloop_learning.Neuron_TANHLIMIT
 

Properties

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

Detailed Description

Proxy of C++ Neuron class.

Constructor & Destructor Documentation

◆ __init__()

def feedforward_closedloop_learning.Neuron.__init__ (   self,
"int"  _nInputs 
)
__init__(Neuron self, int _nInputs) -> Neuron

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

Member Function Documentation

◆ calcOutput()

"void" feedforward_closedloop_learning.Neuron.calcOutput (   self)
calcOutput(Neuron self)

◆ calcOutputThread()

"void *" feedforward_closedloop_learning.Neuron.calcOutputThread ( "void *"  object)
static
calcOutputThread(void * object) -> void *

Parameters
----------
object: void *

◆ dActivation()

"double" feedforward_closedloop_learning.Neuron.dActivation (   self)
dActivation(Neuron self) -> double

◆ doLearning()

"void" feedforward_closedloop_learning.Neuron.doLearning (   self)
doLearning(Neuron self)

◆ doLearningThread()

"void *" feedforward_closedloop_learning.Neuron.doLearningThread ( "void *"  object)
static
doLearningThread(void * object) -> void *

Parameters
----------
object: void *

◆ doMaxDet()

"void" feedforward_closedloop_learning.Neuron.doMaxDet (   self)
doMaxDet(Neuron self)

◆ doMaxDetThread()

"void *" feedforward_closedloop_learning.Neuron.doMaxDetThread ( "void *"  object)
static
doMaxDetThread(void * object) -> void *

Parameters
----------
object: void *

◆ getAverageOfWeightVector()

"double" feedforward_closedloop_learning.Neuron.getAverageOfWeightVector (   self)
getAverageOfWeightVector(Neuron self) -> double

◆ getBiasWeight()

"double" feedforward_closedloop_learning.Neuron.getBiasWeight (   self)
getBiasWeight(Neuron self) -> double

◆ getDecay()

"double" feedforward_closedloop_learning.Neuron.getDecay (   self)
getDecay(Neuron self) -> double

◆ getError()

"double" feedforward_closedloop_learning.Neuron.getError (   self)
getError(Neuron self) -> double

◆ getEuclideanNormOfWeightVector()

"double" feedforward_closedloop_learning.Neuron.getEuclideanNormOfWeightVector (   self)
getEuclideanNormOfWeightVector(Neuron self) -> double

◆ getInfinityNormOfWeightVector()

"double" feedforward_closedloop_learning.Neuron.getInfinityNormOfWeightVector (   self)
getInfinityNormOfWeightVector(Neuron self) -> double

◆ getInput()

"double" feedforward_closedloop_learning.Neuron.getInput (   self,
"int"  _index 
)
getInput(Neuron self, int _index) -> double

Parameters
----------
_index: int

◆ getManhattanNormOfWeightVector()

"double" feedforward_closedloop_learning.Neuron.getManhattanNormOfWeightVector (   self)
getManhattanNormOfWeightVector(Neuron self) -> double

◆ getMask()

"unsigned char" feedforward_closedloop_learning.Neuron.getMask (   self,
args 
)
getMask(Neuron self, int x, int y) -> unsigned char

Parameters
----------
x: int
y: int

getMask(Neuron self, int index) -> unsigned char

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

◆ getMaxWeightValue()

"double" feedforward_closedloop_learning.Neuron.getMaxWeightValue (   self)
getMaxWeightValue(Neuron self) -> double

◆ getMinWeightValue()

"double" feedforward_closedloop_learning.Neuron.getMinWeightValue (   self)
getMinWeightValue(Neuron self) -> double

◆ getNinputs()

"int" feedforward_closedloop_learning.Neuron.getNinputs (   self)
getNinputs(Neuron self) -> int

◆ getOutput()

"double" feedforward_closedloop_learning.Neuron.getOutput (   self)
getOutput(Neuron self) -> double

◆ getSum()

"double" feedforward_closedloop_learning.Neuron.getSum (   self)
getSum(Neuron self) -> double

◆ getSumOfSquaredWeightVector()

"double" feedforward_closedloop_learning.Neuron.getSumOfSquaredWeightVector (   self)
getSumOfSquaredWeightVector(Neuron self) -> double

◆ getWeight()

"double" feedforward_closedloop_learning.Neuron.getWeight (   self,
"int"  _index 
)
getWeight(Neuron self, int _index) -> double

Parameters
----------
_index: int

◆ getWeightDistanceFromInitialWeights()

"double" feedforward_closedloop_learning.Neuron.getWeightDistanceFromInitialWeights (   self)
getWeightDistanceFromInitialWeights(Neuron self) -> double

◆ initWeights()

"void" feedforward_closedloop_learning.Neuron.initWeights (   self,
args 
)
initWeights(Neuron self, double _max=1, int initBias=1, Neuron::WeightInitMethod _wm=MAX_OUTPUT_RANDOM)

Parameters
----------
_max: double
initBias: int
_wm: enum Neuron::WeightInitMethod

◆ normaliseWeights()

"void" feedforward_closedloop_learning.Neuron.normaliseWeights (   self,
"double"  norm 
)
normaliseWeights(Neuron self, double norm)

Parameters
----------
norm: double

◆ saveInitialWeights()

"void" feedforward_closedloop_learning.Neuron.saveInitialWeights (   self)
saveInitialWeights(Neuron self)

◆ setActivationFunction()

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

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

◆ setBias()

"void" feedforward_closedloop_learning.Neuron.setBias (   self,
"double"  _bias 
)
setBias(Neuron self, double _bias)

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

◆ setBiasWeight()

"void" feedforward_closedloop_learning.Neuron.setBiasWeight (   self,
"double"  _biasweight 
)
setBiasWeight(Neuron self, double _biasweight)

Parameters
----------
_biasweight: double

◆ setDebugInfo()

"void" feedforward_closedloop_learning.Neuron.setDebugInfo (   self,
"int"  _layerIndex,
"int"  _neuronIndex 
)
setDebugInfo(Neuron self, int _layerIndex, int _neuronIndex)

Parameters
----------
_layerIndex: int
_neuronIndex: int

◆ setDecay()

"void" feedforward_closedloop_learning.Neuron.setDecay (   self,
"double"  _decay 
)
setDecay(Neuron self, double _decay)

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

◆ setError()

"void" feedforward_closedloop_learning.Neuron.setError (   self,
"double"  _error 
)
setError(Neuron self, double _error)

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

◆ setGeometry()

"void" feedforward_closedloop_learning.Neuron.setGeometry (   self,
"int"  _width,
"int"  _height 
)
setGeometry(Neuron self, int _width, int _height)

Parameters
----------
_width: int
_height: int

◆ setInput()

"void" feedforward_closedloop_learning.Neuron.setInput (   self,
"int"  _index,
"double"  _value 
)
setInput(Neuron self, int _index, double _value)

Parameters
----------
_index: int
_value: double

◆ setLearningRate()

"void" feedforward_closedloop_learning.Neuron.setLearningRate (   self,
"double"  _learningrate 
)
setLearningRate(Neuron self, double _learningrate)

Parameters
----------
_learningrate: double

◆ setMask()

"void" feedforward_closedloop_learning.Neuron.setMask (   self,
args 
)
setMask(Neuron self, int x, int y, unsigned char c)

Parameters
----------
x: int
y: int
c: unsigned char

setMask(Neuron self, unsigned char c)

Parameters
----------
c: unsigned char

◆ setMomentum()

"void" feedforward_closedloop_learning.Neuron.setMomentum (   self,
"double"  _momentum 
)
setMomentum(Neuron self, double _momentum)

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

◆ setStep()

"void" feedforward_closedloop_learning.Neuron.setStep (   self,
"long"  _step 
)
setStep(Neuron self, long _step)

Parameters
----------
_step: long

◆ setWeight()

"void" feedforward_closedloop_learning.Neuron.setWeight (   self,
"int"  _index,
"double"  _weight 
)
setWeight(Neuron self, int _index, double _weight)

Parameters
----------
_index: int
_weight: double

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