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:

feedforward_closedloop_learning.py

Public Member Functions

Static Public Attributes

Properties