Feedforward Closedloop Learning: feedforward_closedloop_learning.Neuron Class Reference

Feedforward Closedloop Learning

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

## 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:

- feedforward_closedloop_learning.py