gum::learning::genericBNLearner::Database Class Reference

a helper to easily read databases More...

#include <genericBNLearner.h>

Collaboration diagram for gum::learning::genericBNLearner::Database:

Public Member Functions
template<typename GUM_SCALAR >
	Database (const std::string &filename, const BayesNet< GUM_SCALAR > &bn, const std::vector< std::string > &missing_symbols)
Constructors / Destructors
	Database (const std::string &file, const std::vector< std::string > &missing_symbols)
	default constructor More...
	Database (const DatabaseTable<> &db)
	default constructor More...
	Database (const std::string &filename, Database &score_database, const std::vector< std::string > &missing_symbols)
	constructor for the aprioris More...
template<typename GUM_SCALAR >
	Database (const std::string &filename, const gum::BayesNet< GUM_SCALAR > &bn, const std::vector< std::string > &missing_symbols)
	constructor with a BN providing the variables of interest More...
	Database (const Database &from)
	copy constructor More...
	Database (Database &&from)
	move constructor More...
	~Database ()
	destructor More...
Operators
Database &	operator= (const Database &from)
	copy operator More...
Database &	operator= (Database &&from)
	move operator More...
Accessors / Modifiers
DBRowGeneratorParser &	parser ()
	returns the parser for the database More...
const std::vector< std::size_t > &	domainSizes () const
	returns the domain sizes of the variables More...
const std::vector< std::string > &	names () const
	returns the names of the variables in the database More...
NodeId	idFromName (const std::string &var_name) const
	returns the node id corresponding to a variable name More...
const std::string &	nameFromId (NodeId id) const
	returns the variable name corresponding to a given node id More...
const DatabaseTable &	databaseTable () const
	returns the internal database table More...
void	setDatabaseWeight (const double new_weight)
	assign a weight to all the rows of the database so that the sum of their weights is equal to new_weight More...
const Bijection< NodeId, std::size_t > &	nodeId2Columns () const
	returns the mapping between node ids and their columns in the database More...
const std::vector< std::string > &	missingSymbols () const
	returns the set of missing symbols taken into account More...

Protected Attributes
DatabaseTable	__database
	the database itself More...
DBRowGeneratorParser *	__parser {nullptr}
	the parser used for reading the database More...
std::vector< std::size_t >	__domain_sizes
	the domain sizes of the variables (useful to speed-up computations) More...
Bijection< NodeId, std::size_t >	__nodeId2cols
	a bijection assigning to each variable name its NodeId More...
Size	__max_threads_number {1}
	the max number of threads authorized More...
Size	__min_nb_rows_per_thread {100}
	the minimal number of rows to parse (on average) by thread More...

Detailed Description

a helper to easily read databases

Definition at line 131 of file genericBNLearner.h.

Constructor & Destructor Documentation

Database() [1/7]

gum::learning::genericBNLearner::Database::Database ( const std::string &  file, const std::vector< std::string > &  missing_symbols  )

explicit

default constructor

Parameters

file	the name of the CSV file containing the data
missing_symbols	the set of symbols in the CSV file that correspond to missing data

Definition at line 64 of file genericBNLearner.cpp.

                                                      :
        Database(genericBNLearner::__readFile(filename, missing_symbols)) {}

Database() [2/7]

gum::learning::genericBNLearner::Database::Database ( const DatabaseTable<> &  db )

explicit

default constructor

Parameters

db	an already initialized database table that is used to fill the Database

Definition at line 47 of file genericBNLearner.cpp.

References __database, __domain_sizes, __nodeId2cols, __parser, gum::learning::DatabaseTable< ALLOC >::domainSizes(), gum::learning::IDatabaseTable< T_DATA, ALLOC >::handler(), gum::BijectionImplementation< T1, T2, Alloc, Gen >::insert(), and gum::learning::IDatabaseTable< T_DATA, ALLOC >::variableNames().

                                                                :
        __database(db) {
      // get the variables names
      const auto&       var_names = __database.variableNames();
      const std::size_t nb_vars = var_names.size();
      for (auto dom : __database.domainSizes())
        __domain_sizes.push_back(dom);
      for (std::size_t i = 0; i < nb_vars; ++i) {
        __nodeId2cols.insert(NodeId(i), i);
      }

      // create the parser
      __parser =
         new DBRowGeneratorParser<>(__database.handler(), DBRowGeneratorSet<>());
    }

Here is the call graph for this function:

Database() [3/7]

gum::learning::genericBNLearner::Database::Database	(	const std::string &	filename,
		Database &	score_database,
		const std::vector< std::string > &	missing_symbols
	)

constructor for the aprioris

We must ensure that the variables of the Database are identical to those of the score database (else the countings used by the scores might be erroneous). However, we allow the variables to be ordered differently in the two databases: variables with the same name in both databases are supposed to be the same.

Parameters

file	the name of the CSV file containing the data
score_database	the main database used for the learning
missing_symbols	the set of symbols in the CSV file that correspond to missing data

Definition at line 70 of file genericBNLearner.cpp.

References gum::learning::genericBNLearner::__checkFileName(), __database, __domain_sizes, __nodeId2cols, __parser, databaseTable(), gum::learning::DatabaseTable< ALLOC >::domainSizes(), gum::learning::IDBInitializer< ALLOC >::fillDatabase(), GUM_ERROR, gum::learning::IDatabaseTable< T_DATA, ALLOC >::handler(), gum::HashTable< Key, Val, Alloc >::insert(), gum::learning::DatabaseTable< ALLOC >::insertTranslator(), gum::learning::IDatabaseTable< T_DATA, ALLOC >::nbVariables(), nodeId2Columns(), gum::learning::DatabaseTable< ALLOC >::variable(), gum::learning::IDBInitializer< ALLOC >::variableNames(), and gum::learning::IDatabaseTable< T_DATA, ALLOC >::variableNames().

                                                      {
      // assign to each column name in the CSV file its column
      genericBNLearner::__checkFileName(CSV_filename);
      DBInitializerFromCSV<> initializer(CSV_filename);
      const auto&            apriori_names = initializer.variableNames();
      std::size_t            apriori_nb_vars = apriori_names.size();
      HashTable< std::string, std::size_t > apriori_names2col(apriori_nb_vars);
      for (std::size_t i = std::size_t(0); i < apriori_nb_vars; ++i)
        apriori_names2col.insert(apriori_names[i], i);

      // check that there are at least as many variables in the a priori
      // database as those in the score_database
      if (apriori_nb_vars < score_database.__database.nbVariables()) {
        GUM_ERROR(InvalidArgument,
                  "the a apriori database has fewer variables "
                  "than the observed database");
      }

      // get the mapping from the columns of score_database to those of
      // the CSV file
      const std::vector< std::string >& score_names =
         score_database.databaseTable().variableNames();
      const std::size_t                     score_nb_vars = score_names.size();
      HashTable< std::size_t, std::size_t > mapping(score_nb_vars);
      for (std::size_t i = std::size_t(0); i < score_nb_vars; ++i) {
        try {
          mapping.insert(i, apriori_names2col[score_names[i]]);
        } catch (Exception&) {
          GUM_ERROR(MissingVariableInDatabase,
                    "Variable "
                       << score_names[i]
                       << " of the observed database does not belong to the "
                       << "apriori database");
        }
      }

      // create the translators for CSV database
      for (std::size_t i = std::size_t(0); i < score_nb_vars; ++i) {
        const Variable& var = score_database.databaseTable().variable(i);
        __database.insertTranslator(var, mapping[i], missing_symbols);
      }

      // fill the database
      initializer.fillDatabase(__database);

      // get the domain sizes of the variables
      for (auto dom : __database.domainSizes())
        __domain_sizes.push_back(dom);

      // compute the mapping from node ids to column indices
      __nodeId2cols = score_database.nodeId2Columns();

      // create the parser
      __parser =
         new DBRowGeneratorParser<>(__database.handler(), DBRowGeneratorSet<>());
    }

Here is the call graph for this function:

Database() [4/7]

template<typename GUM_SCALAR >

gum::learning::genericBNLearner::Database::Database	(	const std::string &	filename,
		const gum::BayesNet< GUM_SCALAR > &	bn,
		const std::vector< std::string > &	missing_symbols
	)

constructor with a BN providing the variables of interest

Parameters

file	the name of the CSV file containing the data
bn	a Bayesian network indicating which variables of the CSV file are used for learning
missing_symbols	the set of symbols in the CSV file that correspond to missing data

Database() [5/7]

gum::learning::genericBNLearner::Database::Database

(

const Database &

from

)

copy constructor

Definition at line 131 of file genericBNLearner.cpp.

References __database, __parser, and gum::learning::IDatabaseTable< T_DATA, ALLOC >::handler().

                                                           :
        __database(from.__database), __domain_sizes(from.__domain_sizes),
        __nodeId2cols(from.__nodeId2cols) {
      // create the parser
      __parser =
         new DBRowGeneratorParser<>(__database.handler(), DBRowGeneratorSet<>());
    }

Here is the call graph for this function:

Database() [6/7]

gum::learning::genericBNLearner::Database::Database

(

Database &&

from

)

move constructor

Definition at line 140 of file genericBNLearner.cpp.

References __database, __parser, and gum::learning::IDatabaseTable< T_DATA, ALLOC >::handler().

                                                      :
        __database(std::move(from.__database)),
        __domain_sizes(std::move(from.__domain_sizes)),
        __nodeId2cols(std::move(from.__nodeId2cols)) {
      // create the parser
      __parser =
         new DBRowGeneratorParser<>(__database.handler(), DBRowGeneratorSet<>());
    }

Here is the call graph for this function:

~Database()

gum::learning::genericBNLearner::Database::~Database

(

)

destructor

Definition at line 150 of file genericBNLearner.cpp.

References __parser, and operator=().

{ delete __parser; }

Here is the call graph for this function:

Database() [7/7]

template<typename GUM_SCALAR >

gum::learning::genericBNLearner::Database::Database	(	const std::string &	filename,
		const BayesNet< GUM_SCALAR > &	bn,
		const std::vector< std::string > &	missing_symbols
	)

Definition at line 30 of file genericBNLearner_tpl.h.

References gum::learning::genericBNLearner::__checkFileName(), __database, __domain_sizes, __nodeId2cols, __parser, gum::DAGmodel::dag(), gum::learning::DatabaseTable< ALLOC >::domainSizes(), gum::learning::IDBInitializer< ALLOC >::fillDatabase(), GUM_ERROR, gum::learning::IDatabaseTable< T_DATA, ALLOC >::handler(), gum::BijectionImplementation< T1, T2, Alloc, Gen >::insert(), gum::HashTable< Key, Val, Alloc >::insert(), gum::learning::DatabaseTable< ALLOC >::insertTranslator(), gum::Variable::name(), gum::BayesNet< GUM_SCALAR >::variable(), and gum::learning::IDBInitializer< ALLOC >::variableNames().

                                                      {
      // assign to each column name in the database its position
      genericBNLearner::__checkFileName(filename);
      DBInitializerFromCSV<> initializer(filename);
      const auto&            xvar_names = initializer.variableNames();
      std::size_t            nb_vars = xvar_names.size();
      HashTable< std::string, std::size_t > var_names(nb_vars);
      for (std::size_t i = std::size_t(0); i < nb_vars; ++i)
        var_names.insert(xvar_names[i], i);

      // we use the bn to insert the translators into the database table
      std::vector< NodeId > nodes;
      nodes.reserve(bn.dag().sizeNodes());
      for (const auto node : bn.dag())
        nodes.push_back(node);
      std::sort(nodes.begin(), nodes.end());
      try {
        std::size_t i = std::size_t(0);
        for (auto node : nodes) {
          const Variable& var = bn.variable(node);
          __database.insertTranslator(var, var_names[var.name()], missing_symbols);
          __nodeId2cols.insert(NodeId(node), i++);
        }
      } catch (NotFound&) {
        GUM_ERROR(MissingVariableInDatabase,
                  "the database does not contain variable ");
      }

      // fill the database
      initializer.fillDatabase(__database);

      // get the domain sizes of the variables
      for (auto dom : __database.domainSizes())
        __domain_sizes.push_back(dom);

      // create the parser
      __parser =
         new DBRowGeneratorParser<>(__database.handler(), DBRowGeneratorSet<>());
    }

Here is the call graph for this function:

Member Function Documentation

__BNVars()

template<typename GUM_SCALAR >

BayesNet< GUM_SCALAR > gum::learning::genericBNLearner::Database::__BNVars ( ) const

private

Definition at line 75 of file genericBNLearner_tpl.h.

References __database, gum::BayesNet< GUM_SCALAR >::add(), gum::learning::IDatabaseTable< T_DATA, ALLOC >::nbVariables(), and gum::learning::DatabaseTable< ALLOC >::variable().

                                                                    {
      BayesNet< GUM_SCALAR > bn;
      const std::size_t      nb_vars = __database.nbVariables();
      for (std::size_t i = 0; i < nb_vars; ++i) {
        const DiscreteVariable& var =
           dynamic_cast< const DiscreteVariable& >(__database.variable(i));
        bn.add(var);
      }
      return bn;
    }

Here is the call graph for this function:

databaseTable()

INLINE const DatabaseTable & gum::learning::genericBNLearner::Database::databaseTable

(

)

const

returns the internal database table

Definition at line 90 of file genericBNLearner_inl.h.

References __database.

Referenced by gum::learning::genericBNLearner::__createApriori(), gum::learning::genericBNLearner::__learnDAG(), gum::learning::genericBNLearner::__prepare_miic_3off2(), gum::learning::genericBNLearner::chi2(), Database(), gum::learning::genericBNLearner::database(), gum::learning::genericBNLearner::genericBNLearner(), gum::learning::genericBNLearner::hasMissingValues(), gum::learning::genericBNLearner::learnMixedStructure(), gum::learning::genericBNLearner::logLikelihood(), gum::learning::genericBNLearner::nbRows(), and gum::learning::genericBNLearner::useCrossValidationFold().

                                                               {
      return __database;
    }

Here is the caller graph for this function:

domainSizes()

INLINE const std::vector< std::size_t > & gum::learning::genericBNLearner::Database::domainSizes

(

)

const

returns the domain sizes of the variables

Definition at line 43 of file genericBNLearner_inl.h.

References __domain_sizes.

Referenced by gum::learning::genericBNLearner::domainSizes(), and gum::learning::genericBNLearner::nbCols().

                                                             {
      return __domain_sizes;
    }

Here is the caller graph for this function:

idFromName()

INLINE NodeId gum::learning::genericBNLearner::Database::idFromName

(

const std::string &

var_name

)

const

returns the node id corresponding to a variable name

Definition at line 63 of file genericBNLearner_inl.h.

References __database, __nodeId2cols, gum::learning::IDatabaseTable< T_DATA, ALLOC >::columnsFromVariableName(), gum::BijectionImplementation< T1, T2, Alloc, Gen >::first(), and GUM_ERROR.

Referenced by gum::learning::genericBNLearner::addForbiddenArc(), gum::learning::genericBNLearner::addMandatoryArc(), gum::learning::genericBNLearner::eraseForbiddenArc(), gum::learning::genericBNLearner::eraseMandatoryArc(), gum::learning::genericBNLearner::idFromName(), and gum::learning::genericBNLearner::setSliceOrder().

                                                                               {
      try {
        const auto cols = __database.columnsFromVariableName(var_name);
        return __nodeId2cols.first(cols[0]);
      } catch (...) {
        GUM_ERROR(MissingVariableInDatabase,
                  "Variable " << var_name
                              << " could not be found in the database");
      }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

missingSymbols()

INLINE const std::vector< std::string > & gum::learning::genericBNLearner::Database::missingSymbols

(

)

const

returns the set of missing symbols taken into account

Definition at line 97 of file genericBNLearner_inl.h.

References __database, and gum::learning::IDatabaseTable< T_DATA, ALLOC >::missingSymbols().

Referenced by gum::learning::genericBNLearner::__createApriori().

                                                                {
      return __database.missingSymbols();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

nameFromId()

INLINE const std::string & gum::learning::genericBNLearner::Database::nameFromId

(

NodeId

id

)

const

returns the variable name corresponding to a given node id

Definition at line 77 of file genericBNLearner_inl.h.

References __database, __nodeId2cols, GUM_ERROR, gum::BijectionImplementation< T1, T2, Alloc, Gen >::second(), and gum::learning::IDatabaseTable< T_DATA, ALLOC >::variableName().

Referenced by gum::learning::genericBNLearner::nameFromId().

                                                                     {
      try {
        return __database.variableName(__nodeId2cols.second(id));
      } catch (...) {
        GUM_ERROR(MissingVariableInDatabase,
                  "Variable of Id " << id
                                    << " could not be found in the database");
      }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

names()

INLINE const std::vector< std::string > & gum::learning::genericBNLearner::Database::names

(

)

const

returns the names of the variables in the database

Definition at line 49 of file genericBNLearner_inl.h.

References __database, and gum::learning::IDatabaseTable< T_DATA, ALLOC >::variableNames().

Referenced by gum::learning::genericBNLearner::names().

                                                       {
      return __database.variableNames();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

nodeId2Columns()

INLINE const Bijection< NodeId, std::size_t > & gum::learning::genericBNLearner::Database::nodeId2Columns

(

)

const

returns the mapping between node ids and their columns in the database

Definition at line 103 of file genericBNLearner_inl.h.

References __nodeId2cols.

Referenced by gum::learning::genericBNLearner::__createApriori(), gum::learning::genericBNLearner::__createCorrectedMutualInformation(), gum::learning::genericBNLearner::__createParamEstimator(), gum::learning::genericBNLearner::__createScore(), and Database().

                                                                {
      return __nodeId2cols;
    }

Here is the caller graph for this function:

operator=() [1/2]

genericBNLearner::Database & gum::learning::genericBNLearner::Database::operator=

(

const Database &

from

)

copy operator

Definition at line 153 of file genericBNLearner.cpp.

References __database, __domain_sizes, __nodeId2cols, __parser, and gum::learning::IDatabaseTable< T_DATA, ALLOC >::handler().

Referenced by ~Database().

                                                                {
      if (this != &from) {
        delete __parser;
        __database = from.__database;
        __domain_sizes = from.__domain_sizes;
        __nodeId2cols = from.__nodeId2cols;

        // create the parser
        __parser =
           new DBRowGeneratorParser<>(__database.handler(), DBRowGeneratorSet<>());
      }

      return *this;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

operator=() [2/2]

genericBNLearner::Database & gum::learning::genericBNLearner::Database::operator=

(

Database &&

from

)

move operator

Definition at line 169 of file genericBNLearner.cpp.

References __database, __domain_sizes, __nodeId2cols, __parser, and gum::learning::IDatabaseTable< T_DATA, ALLOC >::handler().

                                                           {
      if (this != &from) {
        delete __parser;
        __database = std::move(from.__database);
        __domain_sizes = std::move(from.__domain_sizes);
        __nodeId2cols = std::move(from.__nodeId2cols);

        // create the parser
        __parser =
           new DBRowGeneratorParser<>(__database.handler(), DBRowGeneratorSet<>());
      }

      return *this;
    }

Here is the call graph for this function:

parser()

INLINE DBRowGeneratorParser & gum::learning::genericBNLearner::Database::parser

(

)

returns the parser for the database

Definition at line 37 of file genericBNLearner_inl.h.

References __parser.

Referenced by gum::learning::genericBNLearner::__createApriori(), gum::learning::genericBNLearner::__createCorrectedMutualInformation(), gum::learning::genericBNLearner::__createScore(), and gum::learning::genericBNLearner::useDatabaseRanges().

                                                                    {
      return *__parser;
    }

Here is the caller graph for this function:

setDatabaseWeight()

INLINE void gum::learning::genericBNLearner::Database::setDatabaseWeight

(

const double

new_weight

)

assign a weight to all the rows of the database so that the sum of their weights is equal to new_weight

assign new weight to the rows of the learning database

Definition at line 55 of file genericBNLearner_inl.h.

References __database, gum::learning::IDatabaseTable< T_DATA, ALLOC >::nbRows(), and gum::learning::IDatabaseTable< T_DATA, ALLOC >::setAllRowsWeight().

Referenced by gum::learning::genericBNLearner::setDatabaseWeight().

                                                                          {
      if (__database.nbRows() == std::size_t(0)) return;
      const double weight = new_weight / double(__database.nbRows());
      __database.setAllRowsWeight(weight);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

__database

DatabaseTable gum::learning::genericBNLearner::Database::__database

protected

the database itself

Definition at line 237 of file genericBNLearner.h.

Referenced by __BNVars(), Database(), databaseTable(), idFromName(), missingSymbols(), nameFromId(), names(), operator=(), and setDatabaseWeight().

__domain_sizes

std::vector< std::size_t > gum::learning::genericBNLearner::Database::__domain_sizes

protected

the domain sizes of the variables (useful to speed-up computations)

Definition at line 243 of file genericBNLearner.h.

Referenced by Database(), domainSizes(), and operator=().

__max_threads_number

Size gum::learning::genericBNLearner::Database::__max_threads_number {1}

protected

the max number of threads authorized

Definition at line 252 of file genericBNLearner.h.

__min_nb_rows_per_thread

Size gum::learning::genericBNLearner::Database::__min_nb_rows_per_thread {100}

protected

the minimal number of rows to parse (on average) by thread

Definition at line 256 of file genericBNLearner.h.

__nodeId2cols

Bijection< NodeId, std::size_t > gum::learning::genericBNLearner::Database::__nodeId2cols

protected

a bijection assigning to each variable name its NodeId

Definition at line 246 of file genericBNLearner.h.

Referenced by Database(), idFromName(), nameFromId(), nodeId2Columns(), and operator=().

__parser

DBRowGeneratorParser* gum::learning::genericBNLearner::Database::__parser {nullptr}

protected

the parser used for reading the database

Definition at line 240 of file genericBNLearner.h.

Referenced by Database(), operator=(), parser(), and ~Database().

---

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

• agrum/learning/BNLearnUtils/genericBNLearner.h
• agrum/learning/BNLearnUtils/genericBNLearner.cpp
• agrum/learning/BNLearnUtils/genericBNLearner_inl.h
• agrum/learning/BNLearnUtils/genericBNLearner_tpl.h