a helper to easily read databases More...

#include <IBNLearner.h>

Collaboration diagram for gum::learning::IBNLearner::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, const bool induceTypes=false)
	default constructor
	Database (const DatabaseTable &db)
	default constructor
	Database (const std::string &filename, const Database &score_database, const std::vector< std::string > &missing_symbols)
	constructor for the priors
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
	Database (const Database &from)
	copy constructor
	Database (Database &&from)
	move constructor
	~Database ()
	destructor
Operators
Database &	operator= (const Database &from)
	copy operator
Database &	operator= (Database &&from)
	move operator
Accessors / Modifiers
DBRowGeneratorParser &	parser ()
	returns the parser for the database
const std::vector< std::size_t > &	domainSizes () const
	returns the domain sizes of the variables
const std::vector< std::string > &	names () const
	returns the names of the variables in the database
NodeId	idFromName (const std::string &var_name) const
	returns the node id corresponding to a variable name
const std::string &	nameFromId (NodeId id) const
	returns the variable name corresponding to a given node id
const DatabaseTable &	databaseTable () const
	returns the internal database table
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
const Bijection< NodeId, std::size_t > &	nodeId2Columns () const
	returns the mapping between node ids and their columns in the database
const std::vector< std::string > &	missingSymbols () const
	returns the set of missing symbols taken into account
std::size_t	nbRows () const
	returns the number of records in the database
std::size_t	size () const
	returns the number of records in the database
void	setWeight (const std::size_t i, const double weight)
	sets the weight of the ith record
double	weight (const std::size_t i) const
	returns the weight of the ith record
double	weight () const
	returns the weight of the whole database

Protected Attributes
DatabaseTable	_database_
	the database itself
DBRowGeneratorParser *	_parser_ {nullptr}
	the parser used for reading the database
std::vector< std::size_t >	_domain_sizes_
	the domain sizes of the variables (useful to speed-up computations)
Bijection< NodeId, std::size_t >	_nodeId2cols_
	a bijection assigning to each variable name its NodeId
Size	_max_threads_number_ {gum::getNumberOfThreads()}
	the max number of threads authorized
Size	_min_nb_rows_per_thread_ {100}
	the minimal number of rows to parse (on average) by thread

Private Member Functions
template<typename GUM_SCALAR>
BayesNet< GUM_SCALAR >	_BNVars_ () const

Detailed Description

a helper to easily read databases

Definition at line 123 of file IBNLearner.h.

Constructor & Destructor Documentation

◆ Database() [1/7]

gum::learning::IBNLearner::Database::Database	(	const std::string &	file,
		const std::vector< std::string > &	missing_symbols,
		const bool	induceTypes = false )

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
induceTypes	By default, all the values in the dataset are interpreted as "labels", i.e., as categorical values. But if some columns of the dataset have only numerical values, it would certainly be better totag them as corresponding to integer, range or continuous variables. By setting induceTypes to true, this is precisely what the BNLearner will do.

Definition at line 84 of file IBNLearner.cpp.

                                                                                :
      Database(IBNLearner::readFile_(filename, missing_symbols)) {
    // if the usr wants the best translators to be inferred, just do it
    if (induceTypes) {
      for (const auto& [first, second]: _database_.betterTranslators()) {
        // change the translator
        _database_.changeTranslator(*second, first);
        // recompute the domain size
        _domain_sizes_[first] = second->domainSize();
      }
    }
  }

References Database(), gum::learning::IBNLearner::IBNLearner(), _database_, _domain_sizes_, and gum::learning::IBNLearner::readFile_().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Database() [2/7]

gum::learning::IBNLearner::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 70 of file IBNLearner.cpp.

                                                      : _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());
  }

References _database_, _domain_sizes_, _nodeId2cols_, and _parser_.

◆ Database() [3/7]

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

constructor for the priors

We must ensure that the variables of the Database are identical to those of the score database (else the counts 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 99 of file IBNLearner.cpp.

                                                                                {
    // assign to each column name in the CSV file its column
    IBNLearner::isCSVFileName_(CSV_filename);
    DBInitializerFromCSV                  initializer(CSV_filename);
    const auto&                           prior_names   = initializer.variableNames();
    std::size_t                           prior_nb_vars = prior_names.size();
    HashTable< std::string, std::size_t > prior_names2col(prior_nb_vars);
    for (auto i = std::size_t(0); i < prior_nb_vars; ++i)
      prior_names2col.insert(prior_names[i], i);
 
    // check that there are at least as many variables in the a priori
    // database as those in the score_database
    if (prior_nb_vars < score_database._database_.nbVariables()) {
      GUM_ERROR(InvalidArgument,
                "the a prior 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 (auto i = std::size_t(0); i < score_nb_vars; ++i) {
      try {
        mapping.insert(i, prior_names2col[score_names[i]]);
      } catch (Exception const&) {
        GUM_ERROR(MissingVariableInDatabase,
                  "Variable " << score_names[i]
                              << " of the observed database does not belong to the "
                              << "prior database")
      }
    }
 
    // create the translators for CSV database
    for (auto 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());
  }

References Database(), _database_, _domain_sizes_, _nodeId2cols_, _parser_, databaseTable(), gum::learning::IDBInitializer::fillDatabase(), GUM_ERROR, gum::HashTable< Key, Val >::insert(), gum::learning::IBNLearner::isCSVFileName_(), gum::learning::IDatabaseTable< T_DATA >::nbVariables(), nodeId2Columns(), gum::learning::DatabaseTable::variable(), gum::learning::IDatabaseTable< T_DATA >::variableNames(), and gum::learning::IDBInitializer::variableNames().

Here is the call graph for this function:

◆ Database() [4/7]

template<typename GUM_SCALAR>

gum::learning::IBNLearner::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

References Database(), and weight().

Here is the call graph for this function:

◆ Database() [5/7]

gum::learning::IBNLearner::Database::Database ( const Database & from )

copy constructor

Definition at line 155 of file IBNLearner.cpp.

                                                   :
      _database_(from._database_), _domain_sizes_(from._domain_sizes_),
      _nodeId2cols_(from._nodeId2cols_) {
    // create the parser
    _parser_ = new DBRowGeneratorParser(_database_.handler(), DBRowGeneratorSet());
  }

References Database(), _database_, _domain_sizes_, _nodeId2cols_, and _parser_.

Here is the call graph for this function:

◆ Database() [6/7]

gum::learning::IBNLearner::Database::Database ( Database && from )

move constructor

Definition at line 162 of file IBNLearner.cpp.

                                              :
      _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());
  }

References Database(), _database_, _domain_sizes_, _nodeId2cols_, and _parser_.

Here is the call graph for this function:

◆ ~Database()

gum::learning::IBNLearner::Database::~Database ( )

destructor

Definition at line 169 of file IBNLearner.cpp.

169{ delete _parser_; }

References _parser_.

◆ Database() [7/7]

template<typename GUM_SCALAR>

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

Definition at line 50 of file IBNLearner_tpl.h.

                                                                                {
    // assign to each column name in the database its position
    IBNLearner::isCSVFileName_(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());
    std::size_t i = std::size_t(0);
    for (auto node: nodes) {
      const Variable& var = bn.variable(node);
      try {
        _database_.insertTranslator(var, var_names[var.name()], missing_symbols);
      } catch (NotFound const&) {
        GUM_ERROR(MissingVariableInDatabase, "Variable '" << var.name() << "' is missing")
      }
      _nodeId2cols_.insert(NodeId(node), i++);
    }
 
    // 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());
  }

References _database_, _domain_sizes_, _nodeId2cols_, _parser_, gum::learning::IDBInitializer::fillDatabase(), GUM_ERROR, gum::HashTable< Key, Val >::insert(), gum::learning::IBNLearner::isCSVFileName_(), gum::Variable::name(), and gum::learning::IDBInitializer::variableNames().

Here is the call graph for this function:

Member Function Documentation

◆ _BNVars_()

template<typename GUM_SCALAR>

BayesNet< GUM_SCALAR > gum::learning::IBNLearner::Database::_BNVars_ ( ) const

private

Definition at line 91 of file IBNLearner_tpl.h.

                                                            {
    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;
  }

References _database_.

◆ databaseTable()

INLINE const DatabaseTable & gum::learning::IBNLearner::Database::databaseTable ( ) const

returns the internal database table

Definition at line 101 of file IBNLearner_inl.h.

101{ return _database_; }

References _database_.

Referenced by Database().

Here is the caller graph for this function:

◆ domainSizes()

INLINE const std::vector< std::size_t > & gum::learning::IBNLearner::Database::domainSizes ( ) const

returns the domain sizes of the variables

Definition at line 63 of file IBNLearner_inl.h.

                                                                             {
    return _domain_sizes_;
  }

References _domain_sizes_.

◆ idFromName()

INLINE NodeId gum::learning::IBNLearner::Database::idFromName ( const std::string & var_name ) const

returns the node id corresponding to a variable name

Definition at line 80 of file IBNLearner_inl.h.

                                                                              {
    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")
    }
  }

References _database_, _nodeId2cols_, and GUM_ERROR.

◆ missingSymbols()

INLINE const std::vector< std::string > & gum::learning::IBNLearner::Database::missingSymbols ( ) const

returns the set of missing symbols taken into account

Definition at line 104 of file IBNLearner_inl.h.

                                                                                {
    return _database_.missingSymbols();
  }

References _database_.

◆ nameFromId()

INLINE const std::string & gum::learning::IBNLearner::Database::nameFromId ( NodeId id ) const

returns the variable name corresponding to a given node id

Definition at line 91 of file IBNLearner_inl.h.

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

References _database_, _nodeId2cols_, and GUM_ERROR.

◆ names()

INLINE const std::vector< std::string > & gum::learning::IBNLearner::Database::names ( ) const

returns the names of the variables in the database

Definition at line 68 of file IBNLearner_inl.h.

                                                                       {
    return _database_.variableNames();
  }

References _database_.

◆ nbRows()

INLINE std::size_t gum::learning::IBNLearner::Database::nbRows ( ) const

returns the number of records in the database

Definition at line 114 of file IBNLearner_inl.h.

114{ return _database_.nbRows(); }

References _database_.

◆ nodeId2Columns()

INLINE const Bijection< NodeId, std::size_t > & gum::learning::IBNLearner::Database::nodeId2Columns ( ) const

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

Definition at line 109 of file IBNLearner_inl.h.

                                                                                        {
    return _nodeId2cols_;
  }

References _nodeId2cols_.

Referenced by Database().

Here is the caller graph for this function:

◆ operator=() [1/2]

IBNLearner::Database & gum::learning::IBNLearner::Database::operator= ( const Database & from )

copy operator

Definition at line 171 of file IBNLearner.cpp.

                                                                      {
    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;
  }

References Database(), _database_, _domain_sizes_, _nodeId2cols_, and _parser_.

Here is the call graph for this function:

◆ operator=() [2/2]

IBNLearner::Database & gum::learning::IBNLearner::Database::operator= ( Database && from )

move operator

Definition at line 185 of file IBNLearner.cpp.

                                                                 {
    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;
  }

References Database(), _database_, _domain_sizes_, _nodeId2cols_, and _parser_.

Here is the call graph for this function:

◆ parser()

INLINE DBRowGeneratorParser & gum::learning::IBNLearner::Database::parser ( )

returns the parser for the database

Definition at line 60 of file IBNLearner_inl.h.

60{ return *_parser_; }

References _parser_.

◆ setDatabaseWeight()

INLINE void gum::learning::IBNLearner::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 73 of file IBNLearner_inl.h.

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

References _database_, and weight().

Here is the call graph for this function:

◆ setWeight()

INLINE void gum::learning::IBNLearner::Database::setWeight	(	const std::size_t	i,
		const double	weight )

sets the weight of the ith record

Exceptions

OutOfBounds if i is outside the set of indices of the records or if the weight is negative

Definition at line 120 of file IBNLearner_inl.h.

                                                                                  {
    _database_.setWeight(i, weight);
  }

References _database_, and weight().

Here is the call graph for this function:

◆ size()

INLINE std::size_t gum::learning::IBNLearner::Database::size ( ) const

returns the number of records in the database

Definition at line 117 of file IBNLearner_inl.h.

117{ return _database_.size(); }

References _database_.

◆ weight() [1/2]

INLINE double gum::learning::IBNLearner::Database::weight ( ) const

returns the weight of the whole database

Definition at line 130 of file IBNLearner_inl.h.

130{ return _database_.weight(); }

References _database_.

◆ weight() [2/2]

INLINE double gum::learning::IBNLearner::Database::weight ( const std::size_t i ) const

returns the weight of the ith record

Exceptions

OutOfBounds if i is outside the set of indices of the records

Definition at line 125 of file IBNLearner_inl.h.

                                                                  {
    return _database_.weight(i);
  }

References _database_.

Referenced by Database(), setDatabaseWeight(), and setWeight().

Here is the caller graph for this function:

Member Data Documentation

◆ _database_

DatabaseTable gum::learning::IBNLearner::Database::_database_

protected

the database itself

Definition at line 259 of file IBNLearner.h.

Referenced by Database(), Database(), Database(), Database(), Database(), Database(), _BNVars_(), databaseTable(), idFromName(), missingSymbols(), nameFromId(), names(), nbRows(), operator=(), operator=(), setDatabaseWeight(), setWeight(), size(), weight(), and weight().

◆ _domain_sizes_

std::vector< std::size_t > gum::learning::IBNLearner::Database::_domain_sizes_

protected

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

Definition at line 265 of file IBNLearner.h.

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

◆ _max_threads_number_

Size gum::learning::IBNLearner::Database::_max_threads_number_ {gum::getNumberOfThreads()}

protected

the max number of threads authorized

Definition at line 271 of file IBNLearner.h.

271{gum::getNumberOfThreads()};

gum::getNumberOfThreads

unsigned int getNumberOfThreads()

returns the max number of threads used by default when entering the next parallel region

Definition threadsSTL.cpp:68

◆ _min_nb_rows_per_thread_

Size gum::learning::IBNLearner::Database::_min_nb_rows_per_thread_ {100}

protected

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

Definition at line 274 of file IBNLearner.h.

274{100};

◆ _nodeId2cols_

Bijection< NodeId, std::size_t > gum::learning::IBNLearner::Database::_nodeId2cols_

protected

a bijection assigning to each variable name its NodeId

Definition at line 268 of file IBNLearner.h.

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

◆ _parser_

DBRowGeneratorParser* gum::learning::IBNLearner::Database::_parser_ {nullptr}

protected

the parser used for reading the database

Definition at line 262 of file IBNLearner.h.

262{nullptr};

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

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

agrum/BN/learning/BNLearnUtils/IBNLearner.h
agrum/BN/learning/BNLearnUtils/IBNLearner.cpp
agrum/BN/learning/BNLearnUtils/IBNLearner_inl.h
agrum/BN/learning/BNLearnUtils/IBNLearner_tpl.h

Public Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ Database() [1/7]

◆ Database() [2/7]

◆ Database() [3/7]

◆ Database() [4/7]

◆ Database() [5/7]

◆ Database() [6/7]

◆ ~Database()

◆ Database() [7/7]

Member Function Documentation

◆ _BNVars_()

◆ databaseTable()

◆ domainSizes()

◆ idFromName()

◆ missingSymbols()

◆ nameFromId()

◆ names()

◆ nbRows()

◆ nodeId2Columns()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ parser()

◆ setDatabaseWeight()

◆ setWeight()

◆ size()

◆ weight() [1/2]

◆ weight() [2/2]

Member Data Documentation

◆ _database_

◆ _domain_sizes_

◆ _max_threads_number_

◆ _min_nb_rows_per_thread_

◆ _nodeId2cols_

◆ _parser_