Observables - Revision history

Admin at 08:03, 17 March 2014

2014-03-17T08:03:25Z

Tdhaene: /* AdaptiveModelBuilder */

2008-06-13T16:51:24Z

AdaptiveModelBuilder

← Older revision		Revision as of 16:51, 13 June 2008
Line 68:		Line 68:

	The Adaptive Model Builder provides two methods:		The Adaptive Model Builder provides two methods:
	* (~~AMB~~) registerObserver( (~~AMB~~) self, (string) tag, (string) x_name, (string) description, (Observable cell array) observables );		* <code>(AdaptiveModelBuilder) registerObserver( (AdaptiveModelBuilder) self, (string) tag, (string) x_name, (string) description, (Observable cell array) observables );</code>
	* (~~AMB~~) observe( (~~AMB) self~~, (string) tag, (double) x_value, (void*) object );		* <code>(AdaptiveModelBuilder) observe( (AdaptiveModelBuilderself, (string) tag, (double) x_value, (void*) object );</code>
	~~where AMB is short for AdaptiveModelBuilder...~~

	The constructor of a xxxModelBuilder can register a new timestamp (tag) at which it wants to do profiling in the future. Example tags are:		The constructor of a xxxModelBuilder can register a new timestamp (tag) at which it wants to do profiling in the future. Example tags are:
Line 80:		Line 79:
	`x_name' is a string name for the x-axis of the plot. `description' is a description of the plot. The last parameter of <code>registerObserver()</code> is a list of [[Observables]].		`x_name' is a string name for the x-axis of the plot. `description' is a description of the plot. The last parameter of <code>registerObserver()</code> is a list of [[Observables]].

	<code>observe()</code> is called each time a new row has to be added to the profiler or when the last row has to be updated (the ~~AMB~~ keeps track of the last x_value's passed). A call to <code>observe()</code> makes the ~~AMB~~ browse through its registered `tag's looking for all matches. For each match, and each Observable, the Observable is called on the `object' parameter, and (if the observable returns data) its corresponding profiler gets updated.		<code>observe()</code> is called each time a new row has to be added to the profiler or when the last row has to be updated (the AdaptiveModelBuilder keeps track of the last x_value's passed). A call to <code>observe()</code> makes the AdaptiveModelBuilder browse through its registered `tag's looking for all matches. For each match, and each Observable, the Observable is called on the `object' parameter, and (if the observable returns data) its corresponding profiler gets updated.

Tdhaene: /* SimpleObservable */

2008-06-13T16:49:30Z

SimpleObservable

← Older revision		Revision as of 16:49, 13 June 2008
Line 54:		Line 54:
	<code>getColumns()</code> returns a struct array with names [name_1, ..., name_`numColumns'] and suitable descriptions.		<code>getColumns()</code> returns a struct array with names [name_1, ..., name_`numColumns'] and suitable descriptions.

	As an example, following extract of <code>~~PolynomialInterface~~::getObservables()</code> constructs an Observable which processes only ~~PolynomialModels~~, and has as a functor an implicit function which extract the config.parameters.weights field.		As an example, following extract of <code>RationalInterface::getObservables()</code> constructs an Observable which processes only RationalModels, and has as a functor an implicit function which extract the <code>config.parameters.weights</code> field.

	<code>		<code>

Tdhaene: /* SimpleObservable */

2008-06-13T16:43:53Z

SimpleObservable

← Older revision		Revision as of 16:43, 13 June 2008
Line 45:		Line 45:
	== SimpleObservable ==		== SimpleObservable ==

	Most Observables are quite simple, e.g. they just extract a field from a model object. Therefore, we have the SimpleObservable class, it has following methods:		Most Observables are quite simple, e.g. they just extract a field from a model object. Therefore, we have the <code>SimpleObservable</code> class, it has following methods:
	* SimpleObservable( name, description, classtype, functor [, numColumns] ). If numColumns unspecified, use 1.		* <code>SimpleObservable( name, description, classtype, functor [, numColumns] )</code>. If <code>numColumns</code> unspecified, use 1.
	* (struct) getColumns( void )		* <code>(struct) getColumns( void )</code>
	* (vector) process( (void*) object )		* <code>(vector) process( (void*) object )</code>

	process() checks whether the object passed is of type `classtype'. If not, it returns []. Else, it returns `feval( functor, object )'.		<code>process()</code> checks whether the object passed is of type '<code>classtype</code>'. If not, it returns []. Else, it returns '<code>feval( functor, object )</code>'.

	getColumns() returns a struct array with names [name_1, ..., name_`numColumns'] and suitable descriptions.		<code>getColumns()</code> returns a struct array with names [name_1, ..., name_`numColumns'] and suitable descriptions.

	As an example, following extract of PolynomialInterface::getObservables() constructs an Observable which processes only PolynomialModels, and has as a functor an implicit function which extract the config.parameters.weights field.		As an example, following extract of <code>PolynomialInterface::getObservables()</code> constructs an Observable which processes only PolynomialModels, and has as a functor an implicit function which extract the config.parameters.weights field.

	<code>		<code>

Tdhaene: /* Observable */

2008-06-13T16:41:39Z

Observable

← Older revision		Revision as of 16:41, 13 June 2008
Line 29:		Line 29:

	The <code>Observable</code> class is just an `abstract' base class corresponding to `a thing that can be observed'. It has following methods:		The <code>Observable</code> class is just an `abstract' base class corresponding to `a thing that can be observed'. It has following methods:
	<code>		* <code>Observable( (string) name, (string) description )</code>. The constructor (doh)
	* Observable( (string) name, (string) description ). The constructor (doh)		* <code>(string) getName( void ) { return name; }</code>
	* (string) getName( void ) { return name; }		* <code>(string) getDescription( void ) { return description; }</code>
	* (string) getDescription( void ) { return description; }		* <code>(struct) getColumns( void )</code>
	* (struct) getColumns( void )		* <code>(vector) process( (void*) object )</code>
	* (vector) process( (void*) object )
	</code>

	<code>getColumns()</code> returns names and descriptions for the outputs of this observable. For example, suppose we work in input dimension 3: An Observable that extracts the weight parameters out of a rational model, returns names [weight1, weight2, weight3] and suitable descriptions.		<code>getColumns()</code> returns names and descriptions for the outputs of this observable. For example, suppose we work in input dimension 3: An Observable that extracts the weight parameters out of a rational model, returns names [weight1, weight2, weight3] and suitable descriptions.

Tdhaene: /* Observable */

2008-06-13T16:40:42Z

Observable

← Older revision		Revision as of 16:40, 13 June 2008
Line 28:		Line 28:
	== Observable ==		== Observable ==

	The Observable class is just an `abstract' base class corresponding to `a thing that can be observed'. It has following methods:		The <code>Observable</code> class is just an `abstract' base class corresponding to `a thing that can be observed'. It has following methods:
			<code>
	* Observable( (string) name, (string) description ). The constructor (doh)		* Observable( (string) name, (string) description ). The constructor (doh)
	* (string) getName( void ) { return name; }		* (string) getName( void ) { return name; }
Line 34:		Line 35:
	* (struct) getColumns( void )		* (struct) getColumns( void )
	* (vector) process( (void*) object )		* (vector) process( (void*) object )
			</code>

	getColumns() returns names and descriptions for the outputs of this observable. For example, suppose we work in input dimension 3: An Observable that extracts the weight parameters out of a ~~polynomial~~ model, returns names [weight1, weight2, weight3] and suitable descriptions.		<code>getColumns()</code> returns names and descriptions for the outputs of this observable. For example, suppose we work in input dimension 3: An Observable that extracts the weight parameters out of a rational model, returns names [weight1, weight2, weight3] and suitable descriptions.
	The return type of getColumns() is a struct array with 2 fields, `name' and `description'.		The return type of <code>getColumns()</code> is a struct array with 2 fields, '<code>name</code>' and '<code>description</code>'.

	process() processes the object (e.g. a model) out of which something has to be extracted (e.g. the weights) and returns the extracted values. It is mandatory the length of the double vector returned matches the number of columns returned by getColumns(). If it is impossible to extract the data from the model, process() SHOULD return an empty vector []		<code>process()</code> processes the object (e.g. a model) out of which something has to be extracted (e.g. the weights) and returns the extracted values. It is mandatory the length of the double vector returned matches the number of columns returned by <code>getColumns()</code>. If it is impossible to extract the data from the model, <code>process()</code> SHOULD return an empty vector []

	Things will become clearer as you read on!		Things will become clearer as you read on!

Tdhaene: /* General */

2008-06-13T16:38:15Z

General

← Older revision		Revision as of 16:38, 13 June 2008
Line 8:		Line 8:
	* A complete generation has been built for the genetic model builder		* A complete generation has been built for the genetic model builder

	The observables are currently split into two groups, observables on a model, and observables on a batch (or generation) of models.		The observables are currently split into two groups, observables on a '''model''', and observables on a '''batch''' (or generation) of models.

	Examples of the first kind are:		Examples of the first kind are:
	* Weights, flags and percentage for rational models		* Weights, flags and percentage for rational models
Line 16:		Line 17:
	* Spread (= largest/average/smallest value) of model parameters for a generation		* Spread (= largest/average/smallest value) of model parameters for a generation
	* Distribution of different model types in a generation when using the heterogeneous model interface		* Distribution of different model types in a generation when using the heterogeneous model interface


	To accommodate this framework, a few key components have been implemented:		To accommodate this framework, a few key components have been implemented:

Tdhaene: /* General */

2008-06-13T16:37:41Z

General

← Older revision		Revision as of 16:37, 13 June 2008
Line 1:		Line 1:
	== General ==		== General ==

	This page explains the observables framework. It is designed to profile certain model parameter properties at certain timestamps during the adaptive modeling process.		This page explains the '''observables framework'''. It is designed to profile certain model parameter properties at certain timestamps during the adaptive modeling process.

	Example timestamps are		Example timestamps are:
	* A new best model has been constructed		* A new best model has been constructed
	* A new model has been constructed for the sequential model builder		* A new model has been constructed for the sequential model builder
	* A complete generation has been built for the genetic model builder		* A complete generation has been built for the genetic model builder

	The observables currently split into two groups, observables on a model, and observables on a batch (or generation) of models. Examples of the first kind are:		The observables are currently split into two groups, observables on a model, and observables on a batch (or generation) of models.
	* Weights, flags and percentage for ~~polynomial~~ models		Examples of the first kind are:
	* Kernel parameter (=spread) for a RBFNN model		* Weights, flags and percentage for rational models
	Examples of the second kind are		* Kernel parameter (= spread) for a RBFNN model
			Examples of the second kind are:
	* Model parameters of the best model in a generation		* Model parameters of the best model in a generation
	* Spread (=largest/average/smallest value) of model parameters for a generation		* Spread (= largest/average/smallest value) of model parameters for a generation
	* Distribution of different model types in a generation when using the heterogeneous ~~modelinterface~~		* Distribution of different model types in a generation when using the heterogeneous model interface

	To accommodate this framework, a few key components have been implemented:		To accommodate this framework, a few key components have been implemented:
	* The getObservables() member function that each model interface should implement. This method returns a cell array of Observable objects.		* The <code>getObservables()</code> member function that each model interface should implement. This method returns a cell array of Observable objects.
	* The getBatchObservables() member function of BatchInterface (superclass of GeneticInterface). This method return a cell array of observable objects on a Batch/Generation of models.		* The <code>getBatchObservables()</code> member function of <code>BatchInterface</code> (superclass of <code>GeneticInterface</code>). This method return a cell array of observable objects on a Batch/Generation of models.
	* The methods registerObserver() and observe() of the AdaptiveModelBuilder base class		* The methods <code>registerObserver()</code> and <code>observe()</code> of the <code>AdaptiveModelBuilder</code> base class.

	The sequel will elaborate on all different classes and components.		The sequel will elaborate on all different classes and components.

Tdhaene at 14:03, 13 June 2008

2008-06-13T14:03:53Z

New page

== General ==

This page explains the observables framework. It is designed to profile certain model parameter properties at certain timestamps during the adaptive modeling process.

Example timestamps are
* A new best model has been constructed
* A new model has been constructed for the sequential model builder
* A complete generation has been built for the genetic model builder

The observables currently split into two groups, observables on a model, and observables on a batch (or generation) of models. Examples of the first kind are:
* Weights, flags and percentage for polynomial models
* Kernel parameter (=spread) for a RBFNN model
Examples of the second kind are
* Model parameters of the best model in a generation
* Spread (=largest/average/smallest value) of model parameters for a generation
* Distribution of different model types in a generation when using the heterogeneous modelinterface

To accommodate this framework, a few key components have been implemented:
* The getObservables() member function that each model interface should implement. This method returns a cell array of Observable objects.
* The getBatchObservables() member function of BatchInterface (superclass of GeneticInterface). This method return a cell array of observable objects on a Batch/Generation of models.
* The methods registerObserver() and observe() of the AdaptiveModelBuilder base class

The sequel will elaborate on all different classes and components.

== Observable ==

The Observable class is just an `abstract' base class corresponding to `a thing that can be observed'. It has following methods:
* Observable( (string) name, (string) description ). The constructor (doh)
* (string) getName( void ) { return name; }
* (string) getDescription( void ) { return description; }
* (struct) getColumns( void )
* (vector) process( (void*) object )

getColumns() returns names and descriptions for the outputs of this observable. For example, suppose we work in input dimension 3: An Observable that extracts the weight parameters out of a polynomial model, returns names [weight1, weight2, weight3] and suitable descriptions.
The return type of getColumns() is a struct array with 2 fields, `name' and `description'.

process() processes the object (e.g. a model) out of which something has to be extracted (e.g. the weights) and returns the extracted values. It is mandatory the length of the double vector returned matches the number of columns returned by getColumns(). If it is impossible to extract the data from the model, process() SHOULD return an empty vector []

Things will become clearer as you read on!

== SimpleObservable ==

Most Observables are quite simple, e.g. they just extract a field from a model object. Therefore, we have the SimpleObservable class, it has following methods:
* SimpleObservable( name, description, classtype, functor [, numColumns] ). If numColumns unspecified, use 1.
* (struct) getColumns( void )
* (vector) process( (void*) object )

process() checks whether the object passed is of type `classtype'. If not, it returns []. Else, it returns `feval( functor, object )'.

getColumns() returns a struct array with names [name_1, ..., name_`numColumns'] and suitable descriptions.

As an example, following extract of PolynomialInterface::getObservables() constructs an Observable which processes only PolynomialModels, and has as a functor an implicit function which extract the config.parameters.weights field.

<code>
SimpleObservable(
'weight', ...
'The weight for a variable of a polynomial interpolant', ...
'PolynomialModel', ...
@(x) extractField( x, 'config.parameters.weights' ), ...
s.dimension );
</code>

== AdaptiveModelBuilder ==

The Adaptive Model Builder provides two methods:
* (AMB) registerObserver( (AMB) self, (string) tag, (string) x_name, (string) description, (Observable cell array) observables );
* (AMB) observe( (AMB) self, (string) tag, (double) x_value, (void*) object );
where AMB is short for AdaptiveModelBuilder...

The constructor of a xxxModelBuilder can register a new timestamp (tag) at which it wants to do profiling in the future. Example tags are:
* best (AdaptiveModelBuilder) -> The model parameters for each new best model
* iteration (SequentialModelBuilder) -> The model parameters for each model built
* batch (BatchModelBuilder) -> Model parameters of the best model in each batch
* ...

`x_name' is a string name for the x-axis of the plot. `description' is a description of the plot. The last parameter of <code>registerObserver()</code> is a list of [[Observables]].

<code>observe()</code> is called each time a new row has to be added to the profiler or when the last row has to be updated (the AMB keeps track of the last x_value's passed). A call to <code>observe()</code> makes the AMB browse through its registered `tag's looking for all matches. For each match, and each Observable, the Observable is called on the `object' parameter, and (if the observable returns data) its corresponding profiler gets updated.

143.129.172.68: /* General */

2007-05-04T14:43:51Z

General

← Older revision		Revision as of 14:43, 4 May 2007
Line 22:		Line 22:

	The sequel will elaborate on all different classes and components.		The sequel will elaborate on all different classes and components.

			== Observable ==

			The Observable class is just an `abstract' base class corresponding to `a thing that can be observed'. It has following methods:
			* Observable( (string) name, (string) description ). The constructor (doh)
			* (string) getName( void ) { return name; }
			* (string) getDescription( void ) { return description; }
			* (struct) getColumns( void )
			* (vector) process( (void*) object )

			getColumns() returns names and descriptions for the outputs of this observable. For example, suppose we work in input dimension 3: An Observable that extracts the weight parameters out of a polynomial model, returns names [weight1, weight2, weight3] and suitable descriptions.
			The return type of getColumns() is a struct array with 2 fields, `name' and `description'.

			process() processes the object (e.g. a model) out of which something has to be extracted (e.g. the weights) and returns the extracted values. It is mandatory the length of the double vector returned matches the number of columns returned by getColumns(). If it is impossible to extract the data from the model, process() SHOULD return an empty vector []

			Things will become clearer as you read on!

			== SimpleObservable ==

			Most Observables are quite simple, e.g. they just extract a field from a model object. Therefore, we have the SimpleObservable class, it has following methods:
			* SimpleObservable( name, description, classtype, functor [, numColumns] ). If numColumns unspecified, use 1.
			* (struct) getColumns( void )
			* (vector) process( (void*) object )

			process() checks whether the object passed is of type `classtype'. If not, it returns []. Else, it returns `feval( functor, object )'.

			getColumns() returns a struct array with names [name_1, ..., name_`numColumns'] and suitable descriptions.

			As an example, following extract of PolynomialInterface::getObservables() constructs an Observable which processes only PolynomialModels, and has as a functor an implicit function which extract the config.parameters.weights field.

			== AdaptiveModelBuilder ==

← Older revision		Revision as of 08:03, 17 March 2014
Line 22:		Line 22:
	* The <code>getObservables()</code> member function that each model interface should implement. This method returns a cell array of Observable objects.		* The <code>getObservables()</code> member function that each model interface should implement. This method returns a cell array of Observable objects.
	* The <code>getBatchObservables()</code> member function of <code>BatchInterface</code> (superclass of <code>GeneticInterface</code>). This method return a cell array of observable objects on a Batch/Generation of models.		* The <code>getBatchObservables()</code> member function of <code>BatchInterface</code> (superclass of <code>GeneticInterface</code>). This method return a cell array of observable objects on a Batch/Generation of models.
	* The methods <code>registerObserver()</code> and <code>observe()</code> of the <code>~~AdaptiveModelBuilder~~</code> base class.		* The methods <code>registerObserver()</code> and <code>observe()</code> of the <code>ModelBuilder</code> base class.

	The sequel will elaborate on all different classes and components.		The sequel will elaborate on all different classes and components.
Line 65:		Line 65:
	</code>		</code>

	== ~~AdaptiveModelBuilder~~ ==		== ModelBuilder ==

	The Adaptive Model Builder provides two methods:		The Adaptive Model Builder provides two methods:
	* <code>(~~AdaptiveModelBuilder~~) registerObserver( (~~AdaptiveModelBuilder~~) self, (string) tag, (string) x_name, (string) description, (Observable cell array) observables );</code>		* <code>(ModelBuilder) registerObserver( (ModelBuilder) self, (string) tag, (string) x_name, (string) description, (Observable cell array) observables );</code>
	* <code>(~~AdaptiveModelBuilder~~) observe( (~~AdaptiveModelBuilderself~~, (string) tag, (double) x_value, (void*) object );</code>		* <code>(ModelBuilder) observe( (ModelBuilderself, (string) tag, (double) x_value, (void*) object );</code>

	The constructor of a xxxModelBuilder can register a new timestamp (tag) at which it wants to do profiling in the future. Example tags are:		The constructor of a xxxModelBuilder can register a new timestamp (tag) at which it wants to do profiling in the future. Example tags are:
	* best (~~AdaptiveModelBuilder~~) -> The model parameters for each new best model		* best (ModelBuilder) -> The model parameters for each new best model
	* iteration (SequentialModelBuilder) -> The model parameters for each model built		* iteration (SequentialModelBuilder) -> The model parameters for each model built
	* batch (BatchModelBuilder) -> Model parameters of the best model in each batch		* batch (BatchModelBuilder) -> Model parameters of the best model in each batch
Line 79:		Line 79:
	`x_name' is a string name for the x-axis of the plot. `description' is a description of the plot. The last parameter of <code>registerObserver()</code> is a list of [[Observables]].		`x_name' is a string name for the x-axis of the plot. `description' is a description of the plot. The last parameter of <code>registerObserver()</code> is a list of [[Observables]].

	<code>observe()</code> is called each time a new row has to be added to the profiler or when the last row has to be updated (the ~~AdaptiveModelBuilder~~ keeps track of the last x_value's passed). A call to <code>observe()</code> makes the ~~AdaptiveModelBuilder~~ browse through its registered `tag's looking for all matches. For each match, and each Observable, the Observable is called on the `object' parameter, and (if the observable returns data) its corresponding profiler gets updated.		<code>observe()</code> is called each time a new row has to be added to the profiler or when the last row has to be updated (the ModelBuilder keeps track of the last x_value's passed). A call to <code>observe()</code> makes the ModelBuilder browse through its registered `tag's looking for all matches. For each match, and each Observable, the Observable is called on the `object' parameter, and (if the observable returns data) its corresponding profiler gets updated.