gum::learning::DBRowGeneratorParser< ALLOC > Class Template Reference

the class used to read a row in the database and to transform it into a set of DBRow instances that can be used for learning. More...

#include <agrum/tools/database/DBRowGeneratorParser.h>

Public Member Functions
Constructors / Destructors
	DBRowGeneratorParser (const typename DatabaseTable< ALLOC >::Handler &handler, const DBRowGeneratorSet< ALLOC > &generator_set, const allocator_type &alloc=allocator_type())
	default constructor More...
	DBRowGeneratorParser (const DBRowGeneratorParser< ALLOC > &from)
	copy constructor More...
	DBRowGeneratorParser (const DBRowGeneratorParser< ALLOC > &from, const allocator_type &alloc)
	copy constructor with a given allocator More...
	DBRowGeneratorParser (DBRowGeneratorParser< ALLOC > &&filter)
	move constructor More...
	DBRowGeneratorParser (DBRowGeneratorParser< ALLOC > &&filter, const allocator_type &alloc)
	move constructor with a given allocator More...
virtual DBRowGeneratorParser< ALLOC > *	clone () const
	virtual copy constructor More...
virtual DBRowGeneratorParser< ALLOC > *	clone (const allocator_type &alloc) const
	virtual copy constructor with a given allocator More...
virtual	~DBRowGeneratorParser ()
	destructor More...
Operators
DBRowGeneratorParser< ALLOC > &	operator= (const DBRowGeneratorParser< ALLOC > &from)
	copy operator More...
DBRowGeneratorParser< ALLOC > &	operator= (DBRowGeneratorParser< ALLOC > &&from)
	move operator More...
Accessors / Modifiers
bool	hasRows ()
	returns true if there are still rows that can be output by the DBRowGeneratorParser More...
const DBRow< DBTranslatedValue, ALLOC > &	row ()
	returns a new output row with its corresponding weight More...
void	reset ()
	resets the parser More...
DatabaseTable< ALLOC >::Handler &	handler ()
	returns the handler used by the parser More...
const DatabaseTable< ALLOC >::Handler &	handler () const
	returns the handler used by the parser More...
const DatabaseTable< ALLOC > &	database () const
	returns a reference on the database More...
DBRowGeneratorSet< ALLOC > &	generatorSet ()
	returns the generator set that is actually used More...
const DBRowGeneratorSet< ALLOC > &	generatorSet () const
	returns the generator set that is actually used More...
void	setRange (std::size_t begin, std::size_t end)
	sets the area in the database the handler will handle More...
void	setColumnsOfInterest (const std::vector< std::size_t, ALLOC< std::size_t >> &cols_of_interest)
	sets the columns of interest: the output DBRow needs only contain values fot these columns More...
void	setColumnsOfInterest (std::vector< std::size_t, ALLOC< std::size_t >> &&cols_of_interest)
	sets the columns of interest: the output DBRow needs only contain values fot these columns More...
template<typename GUM_SCALAR >
void	setBayesNet (const BayesNet< GUM_SCALAR > &new_bn)
	assign a new Bayes net to all the generators that depend on a BN More...
allocator_type	getAllocator () const
	returns the allocator used More...

Public Types
using	allocator_type = ALLOC< DBTranslatedValue >
	type for the allocators passed in arguments of methods More...

Detailed Description

template<template< typename > class ALLOC = std::allocator>
class gum::learning::DBRowGeneratorParser< ALLOC >

the class used to read a row in the database and to transform it into a set of DBRow instances that can be used for learning.

A DBRowGeneratorParser contains a handler on a DatabaseTable that enables it to parse DBRows contained in the DatabaseTable. It also contains a DBRowGeneratorSet that is used to create output rows for each parsed DBRow. Note that if the DBRowGeneratorSet is empty, then DBRowGeneratorParser simply outputs each parsed DBRow without additional processing. To understand the difference between a DBRowGeneratorParser and a DBRowGeneratorSet, the latter is designed to take as input only one DBRow instance and to produce some output DBRow instances, whereas the former is designed to parse the content of a DatabaseTable and to produce from them some output DBRow instances.

Usage example:

// create and fill a database
gum::learning::DatabaseTable<> database ( ... );
.....

// create a vector with the types of the columns of database 
const std::vector<gum::learning::DBTranslatedValueType>
  col_types ( 10, gum::learning::DBTranslatedValueType::DISCRETE );

// create a generator set
gum::learning::MyGenerator<>  generator1 ( col_types, 6 );
gum::learning::MyGenerator2<> generator2 ( col_types, 4 );
gum::learning::DBRowGeneratorSet<> genset;
genset.insertGenerator ( generator1 );
genset.insertGenerator ( generator2 );

// create the DBRowGeneratorParser
gum::learning::DBRowGeneratorParser<>
  parser ( database.handler (), genset );

// use the parser to parse all the database and to apply all the
// transformations induced by generator1 and generator2
while ( parser.hasRows () ) {
  const auto& dbrow = parser.row();
  // do something with dbrow
}

Definition at line 86 of file DBRowGeneratorParser.h.

Member Typedef Documentation

allocator_type

template<template< typename > class ALLOC = std::allocator>

using gum::learning::DBRowGeneratorParser< ALLOC >::allocator_type = ALLOC<DBTranslatedValue>

type for the allocators passed in arguments of methods

Definition at line 90 of file DBRowGeneratorParser.h.

Constructor & Destructor Documentation

DBRowGeneratorParser() [1/5]

template<template< typename > class ALLOC = std::allocator>

gum::learning::DBRowGeneratorParser< ALLOC >::DBRowGeneratorParser	(	const typename DatabaseTable< ALLOC >::Handler &	handler,
		const DBRowGeneratorSet< ALLOC > &	generator_set,
		const allocator_type &	alloc = allocator_type()
	)

default constructor

DBRowGeneratorParser() [2/5]

template<template< typename > class ALLOC = std::allocator>

gum::learning::DBRowGeneratorParser< ALLOC >::DBRowGeneratorParser

(

const DBRowGeneratorParser< ALLOC > &

from

)

copy constructor

DBRowGeneratorParser() [3/5]

template<template< typename > class ALLOC = std::allocator>

gum::learning::DBRowGeneratorParser< ALLOC >::DBRowGeneratorParser	(	const DBRowGeneratorParser< ALLOC > &	from,
		const allocator_type &	alloc
	)

copy constructor with a given allocator

DBRowGeneratorParser() [4/5]

template<template< typename > class ALLOC = std::allocator>

gum::learning::DBRowGeneratorParser< ALLOC >::DBRowGeneratorParser

(

DBRowGeneratorParser< ALLOC > &&

filter

)

move constructor

DBRowGeneratorParser() [5/5]

template<template< typename > class ALLOC = std::allocator>

gum::learning::DBRowGeneratorParser< ALLOC >::DBRowGeneratorParser	(	DBRowGeneratorParser< ALLOC > &&	filter,
		const allocator_type &	alloc
	)

move constructor with a given allocator

~DBRowGeneratorParser()

template<template< typename > class ALLOC = std::allocator>

virtual gum::learning::DBRowGeneratorParser< ALLOC >::~DBRowGeneratorParser ( )

virtual

destructor

Member Function Documentation

clone() [1/2]

template<template< typename > class ALLOC = std::allocator>

virtual DBRowGeneratorParser<ALLOC>* gum::learning::DBRowGeneratorParser< ALLOC >::clone ( ) const

virtual

virtual copy constructor

clone() [2/2]

template<template< typename > class ALLOC = std::allocator>

virtual DBRowGeneratorParser<ALLOC>* gum::learning::DBRowGeneratorParser< ALLOC >::clone ( const allocator_type &  alloc ) const

virtual

virtual copy constructor with a given allocator

database()

template<template< typename > class ALLOC = std::allocator>

const DatabaseTable<ALLOC>& gum::learning::DBRowGeneratorParser< ALLOC >::database

(

)

const

returns a reference on the database

generatorSet() [1/2]

template<template< typename > class ALLOC = std::allocator>

DBRowGeneratorSet<ALLOC>& gum::learning::DBRowGeneratorParser< ALLOC >::generatorSet

(

)

returns the generator set that is actually used

generatorSet() [2/2]

template<template< typename > class ALLOC = std::allocator>

const DBRowGeneratorSet<ALLOC>& gum::learning::DBRowGeneratorParser< ALLOC >::generatorSet

(

)

const

returns the generator set that is actually used

getAllocator()

template<template< typename > class ALLOC = std::allocator>

allocator_type gum::learning::DBRowGeneratorParser< ALLOC >::getAllocator

(

)

const

returns the allocator used

handler() [1/2]

template<template< typename > class ALLOC = std::allocator>

DatabaseTable<ALLOC>::Handler& gum::learning::DBRowGeneratorParser< ALLOC >::handler

(

)

returns the handler used by the parser

handler() [2/2]

template<template< typename > class ALLOC = std::allocator>

const DatabaseTable<ALLOC>::Handler& gum::learning::DBRowGeneratorParser< ALLOC >::handler

(

)

const

returns the handler used by the parser

hasRows()

template<template< typename > class ALLOC = std::allocator>

bool gum::learning::DBRowGeneratorParser< ALLOC >::hasRows

(

)

returns true if there are still rows that can be output by the DBRowGeneratorParser

The usual way of calling this method is to encapsulate it into a while loop whose stopping condition is when the handler has no more rows. This loop shall be inside a try-catch statement that enables to stop properly the loop when the NotFound exception is raised. In most practical cases, this exception will never be raised, but if you use a row generator that enables to return 0 row (say, for instance an intelligent EM that does not return any row when there are too many missing data) and if the last rows of the database are such that this generator will return no row, then the exception will be raised. Actually, it is not efficient to parse all the database to detect such a case before trying to return the rows, especially because this situation is very unlikely to occur. So a correct code to use method row () is like:

try {
  while ( parser.hasRows () ) {
    const auto& row = parser.row ();
    do_whatever_you_want_with_the_row... ;
  }
}
catch ( NotFound& ) { // stop, there are no more rows to process }

operator=() [1/2]

template<template< typename > class ALLOC = std::allocator>

DBRowGeneratorParser<ALLOC>& gum::learning::DBRowGeneratorParser< ALLOC >::operator=

(

const DBRowGeneratorParser< ALLOC > &

from

)

copy operator

operator=() [2/2]

template<template< typename > class ALLOC = std::allocator>

DBRowGeneratorParser<ALLOC>& gum::learning::DBRowGeneratorParser< ALLOC >::operator=

(

DBRowGeneratorParser< ALLOC > &&

from

)

move operator

reset()

template<template< typename > class ALLOC = std::allocator>

void gum::learning::DBRowGeneratorParser< ALLOC >::reset

(

)

resets the parser

row()

template<template< typename > class ALLOC = std::allocator>

const DBRow<DBTranslatedValue,ALLOC>& gum::learning::DBRowGeneratorParser< ALLOC >::row

(

)

returns a new output row with its corresponding weight

The usual way of calling this method is to encapsulate it into a while loop whose stopping condition is when the handler has no more rows. This loop shall be inside a try-catch statement that enables to stop properly the loop when the NotFound exception is raised. In most practical cases, this exception will never be raised, but if you use a row generator that enables to return 0 row (say, for instance an intelligent EM that does not return any row when there are too many missing data) and if the last rows of the database are such that this generator will return no row, then the exception will be raised. Actually, it is not efficient to parse all the database to detect such a case before trying to return the rows, especially because this situation is very unlikely to occur. So a correct code to use method row () is like:

try {
  while ( parser.hasRows () ) {
    const auto& row = parser.row ();
    do_whatever_you_want_with_the_row... ;
  }
}
catch ( NotFound& ) { // stop, there are no more rows to process }

setBayesNet()

template<template< typename > class ALLOC = std::allocator>

template<typename GUM_SCALAR >

void gum::learning::DBRowGeneratorParser< ALLOC >::setBayesNet

(

const BayesNet< GUM_SCALAR > &

new_bn

)

assign a new Bayes net to all the generators that depend on a BN

Typically, generators based on EM or K-means depend on a model to compute correctly their outputs. Method setBayesNet enables to update their BN model.

Warning

if one generator that relies on Bayes nets cannot be assigned new_bn, then no generator is updated and an exception is raised.

setColumnsOfInterest() [1/2]

template<template< typename > class ALLOC = std::allocator>

void gum::learning::DBRowGeneratorParser< ALLOC >::setColumnsOfInterest

(

const std::vector< std::size_t, ALLOC< std::size_t >> &

cols_of_interest

)

sets the columns of interest: the output DBRow needs only contain values fot these columns

This method is useful, e.g., for EM-like algorithms that need to know which unobserved variables/values need be filled.

Exceptions

OperationNotAllowed

is raised if the generator set has already started generating output rows and is currently in a state where the generation is not completed yet (i.e., we still need to call the generate() method to complete it).

setColumnsOfInterest() [2/2]

template<template< typename > class ALLOC = std::allocator>

void gum::learning::DBRowGeneratorParser< ALLOC >::setColumnsOfInterest

(

std::vector< std::size_t, ALLOC< std::size_t >> &&

cols_of_interest

)

sets the columns of interest: the output DBRow needs only contain values fot these columns

This method is useful, e.g., for EM-like algorithms that need to know which unobserved variables/values need be filled.

Exceptions

OperationNotAllowed

is raised if the generator set has already started generating output rows and is currently in a state where the generation is not completed yet (i.e., we still need to call the generate() method to complete it).

setRange()

template<template< typename > class ALLOC = std::allocator>

void gum::learning::DBRowGeneratorParser< ALLOC >::setRange	(	std::size_t	begin,
		std::size_t	end
	)

sets the area in the database the handler will handle

In addition to setting the area that will be parsed by the handler, this method makes the handler point to the beginning of the area.

Parameters

begin	the first row to be handled
end	the handler handles rows in interval [begin,end). Thus, the endth row is not included in the set of rows handled.

Warning

if begin is greater than end, these values are swapped.

Exceptions

NullElement	is raised if the handler does not point to any database
SizeError	is raised if end is greater than the number of rows of the database

Member Data Documentation

_generator_set_

template<template< typename > class ALLOC = std::allocator>

DBRowGeneratorSet<ALLOC> gum::learning::DBRowGeneratorParser< ALLOC >::_generator_set_

private

the set of DBRow generators (might be empty)

Definition at line 283 of file DBRowGeneratorParser.h.

_generator_size_

template<template< typename > class ALLOC = std::allocator>

std::size_t gum::learning::DBRowGeneratorParser< ALLOC >::_generator_size_

private

the size of the generator set

Definition at line 286 of file DBRowGeneratorParser.h.

_handler_

template<template< typename > class ALLOC = std::allocator>

DatabaseTable<ALLOC>::Handler gum::learning::DBRowGeneratorParser< ALLOC >::_handler_

private

the handler that is really used to parse the database

Definition at line 280 of file DBRowGeneratorParser.h.

---

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

• agrum/tools/database/DBRowGeneratorParser.h