<agrum/PRM/generator/layerGenerator.h> More...

#include <layerGenerator.h>

Inheritance diagram for gum::prm::LayerGenerator< GUM_SCALAR >:

Collaboration diagram for gum::prm::LayerGenerator< GUM_SCALAR >:

Classes
struct	LayerData
	Getters and setters. More...
struct	MyData

Public Member Functions
Constructors and destructor.
	LayerGenerator ()
	Default constructor.
	LayerGenerator (const LayerGenerator &source)
	Copy constructor.
LayerGenerator &	operator= (const LayerGenerator &source)
	Copy operator.
virtual	~LayerGenerator ()
	Destructor.

Size	getDomainSize () const
	Returns the domain size of generated types.
void	setDomainSize (Size s)
	Set the domain size of generated types.
Size	getMaxParents () const
	Returns the max number of parents allowed for any attribute or aggregator.
void	setMaxParents (Size s)
	Returns the max number of parents allowed for any attribute or aggregator.
void	setLayers (const std::vector< LayerData > &v)
	Defines the structure of each layers.
std::vector< LayerData > &	getLayer ()
	Returns the domain size of generated types.
const std::vector< LayerData > &	getLayer () const
	Returns the domain size of generated types.
virtual PRM< GUM_SCALAR > *	generate ()
	Proceeds with the generation of the PRM<GUM_SCALAR>.

void	setNameGenerator (const NameGenerator &name_gen)
	Getters and setters.
const NameGenerator &	getNameGenerator () const
	Returns the NameGenerator used by this generator.

Protected Attributes
NameGenerator	name_gen_
	The name generator used by this class.

Private Member Functions
std::string	_generateType_ (PRMFactory< GUM_SCALAR > &f)
void	_generateInterfaces_ (PRMFactory< GUM_SCALAR > &f, const std::string &type, std::vector< MyData > &l)
void	_generateClasses_ (PRMFactory< GUM_SCALAR > &f, const std::string &type, std::vector< typename LayerGenerator::MyData > &l)
void	_generateClassDag_ (Size lvl, DAG &dag, Bijection< std::string, NodeId > &names, std::vector< typename LayerGenerator::MyData > &l)
void	_generateSystem_ (PRMFactory< GUM_SCALAR > &factory, std::vector< typename LayerGenerator::MyData > &l)

Private Attributes
std::vector< LayerData >	_layers_
Size	_domain_size_
Size	_max_parents_

Detailed Description

template<typename GUM_SCALAR>
class gum::prm::LayerGenerator< GUM_SCALAR >

This class generates PRMs with a layer structure.

Definition at line 73 of file layerGenerator.h.

Constructor & Destructor Documentation

◆ LayerGenerator() [1/2]

template<typename GUM_SCALAR>

INLINE gum::prm::LayerGenerator< GUM_SCALAR >::LayerGenerator ( )

Default constructor.

Definition at line 279 of file layerGenerator_tpl.h.

                                                        :
        _layers_(), _domain_size_(2), _max_parents_(INT_MAX) {
      GUM_CONSTRUCTOR(LayerGenerator);
    }

References LayerGenerator(), _domain_size_, _layers_, and _max_parents_.

Referenced by LayerGenerator(), LayerGenerator(), ~LayerGenerator(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LayerGenerator() [2/2]

template<typename GUM_SCALAR>

INLINE gum::prm::LayerGenerator< GUM_SCALAR >::LayerGenerator ( const LayerGenerator< GUM_SCALAR > & source )

Copy constructor.

Definition at line 286 of file layerGenerator_tpl.h.

                                                                                               :
        _layers_(source._layers_), _domain_size_(source._domain_size_),
        _max_parents_(source._max_parents_) {
      GUM_CONS_CPY(LayerGenerator);
    }

References LayerGenerator(), _domain_size_, _layers_, and _max_parents_.

Here is the call graph for this function:

◆ ~LayerGenerator()

template<typename GUM_SCALAR>

INLINE gum::prm::LayerGenerator< GUM_SCALAR >::~LayerGenerator ( )

virtual

Destructor.

Definition at line 293 of file layerGenerator_tpl.h.

                                                         {
      GUM_DESTRUCTOR(LayerGenerator);
    }

References LayerGenerator().

Here is the call graph for this function:

Member Function Documentation

◆ _generateClassDag_()

template<typename GUM_SCALAR>

void gum::prm::LayerGenerator< GUM_SCALAR >::_generateClassDag_	(	Size	lvl,
		DAG &	dag,
		Bijection< std::string, NodeId > &	names,
		std::vector< typename LayerGenerator< GUM_SCALAR >::MyData > &	l )

private

Definition at line 183 of file layerGenerator_tpl.h.

                                                                     {
      float                 density = _layers_[lvl].inner_density;
      std::vector< NodeId > nodes;
      NodeId                id = 0;
 
      if (lvl) {
        for (const auto& agg: l[lvl].g) {
          id = dag.addNode();
          names.insert(agg, id);
          nodes.push_back(id);
        }
      }
 
      for (const auto& attr: l[lvl].a) {
        id = dag.addNode();
        names.insert(attr, id);
 
        for (const auto node: nodes)
          if (randomProba() < density) dag.addArc(node, names.second(attr));
 
        nodes.push_back(id);
      }
 
      // For each nodes with #parents >  _max_parents_ we randomly remove parents
      // until
      // #parents <=  _max_parents_
      for (const auto node: dag.nodes()) {
        if (dag.parents(node).size() > getMaxParents()) {
          std::vector< NodeId > v;
 
          for (const auto par: dag.parents(node))
            v.push_back(par);
 
          while (dag.parents(node).size() > getMaxParents()) {
            size_t idx = randomValue(v.size());
            Arc    arc(v[idx], node);
            GUM_ASSERT(dag.existsArc(arc));
            dag.eraseArc(arc);
            v[idx] = v.back();
            v.pop_back();
          }
        }
      }
    }

References _layers_, gum::DAG::addArc(), gum::NodeGraphPart::addNode(), gum::ArcGraphPart::eraseArc(), gum::ArcGraphPart::existsArc(), getMaxParents(), gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::insert(), gum::NodeGraphPart::nodes(), gum::ArcGraphPart::parents(), gum::randomProba(), gum::randomValue(), gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::second(), and gum::Set< Key >::size().

Referenced by _generateClasses_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _generateClasses_()

template<typename GUM_SCALAR>

void gum::prm::LayerGenerator< GUM_SCALAR >::_generateClasses_	(	PRMFactory< GUM_SCALAR > &	f,
		const std::string &	type,
		std::vector< typename LayerGenerator< GUM_SCALAR >::MyData > &	l )

private

Definition at line 114 of file layerGenerator_tpl.h.

                                                                     {
      Size               size = 0;
      GUM_SCALAR         sum  = 0.0;
      Set< std::string > i;
 
      for (Size lvl = 0; lvl < _layers_.size(); ++lvl) {
        i.insert(l[lvl].i);
 
        for (Size c = 0; c < _layers_[lvl].c; ++c) {
          l[lvl].c.push_back(this->name_gen_.nextName(PRMObject::prm_type::CLASS));
          f.startClass(l[lvl].c.back(), "", &i);
 
          if (lvl) f.addReferenceSlot(l[lvl - 1].i, l[lvl].r, true);
 
          DAG                              dag;
          Bijection< std::string, NodeId > names;
          _generateClassDag_(lvl, dag, names, l);
 
          // Adding aggregates
          if (lvl) {
            for (std::vector< std::string >::iterator g = l[lvl].g.begin(); g != l[lvl].g.end();
                 ++g) {
              std::stringstream s;
              s << l[lvl].r << "." << l[lvl - 1].a[randomValue(l[lvl - 1].a.size())];
              std::vector< std::string > chain(1, s.str()), param(1, "1");
              f.addAggregator(*g, "exists", chain, param);
            }
          }
 
          // Adding attributes
          for (std::vector< std::string >::iterator a = l[lvl].a.begin(); a != l[lvl].a.end();
               ++a) {
            f.startAttribute(type, *a, true);
            size = getDomainSize();
 
            for (const auto par: dag.parents(names.second(*a))) {
              f.addParent(names.first(par));
              size *= f.retrieveClass(l[lvl].c.back()).get(names.first(par)).type()->domainSize();
            }
 
            std::vector< GUM_SCALAR > cpf(size), val(getDomainSize());
 
            for (size_t norms = 0; norms < size; norms += getDomainSize()) {
              sum = 0.0;
 
              for (size_t idx = 0; idx < getDomainSize(); ++idx) {
                val[idx] = 1 + std::rand();
                sum += val[idx];
              }
 
              for (size_t idx = 0; idx < getDomainSize(); ++idx)
                cpf[norms + idx] = val[idx] / sum;
            }
 
            f.setRawCPFByLines(cpf);
            f.endAttribute();
          }
 
          f.endClass();
        }
 
        i.erase(l[lvl].i);
      }
    }

Referenced by generate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _generateInterfaces_()

template<typename GUM_SCALAR>

void gum::prm::LayerGenerator< GUM_SCALAR >::_generateInterfaces_	(	PRMFactory< GUM_SCALAR > &	f,
		const std::string &	type,
		std::vector< MyData > &	l )

private

Definition at line 85 of file layerGenerator_tpl.h.

                                                                     {
      for (Size lvl = 0; lvl < _layers_.size(); ++lvl) {
        l.push_back(LayerGenerator< GUM_SCALAR >::MyData());
        l[lvl].i = this->name_gen_.nextName(PRMObject::prm_type::PRM_INTERFACE);
        f.startInterface(l[lvl].i);
 
        for (Size a = 0; a < _layers_[lvl].a; ++a) {
          l[lvl].a.push_back(this->name_gen_.nextName(PRMObject::prm_type::CLASS_ELT));
          f.addAttribute(type, l[lvl].a.back());
        }
 
        if (lvl) {
          for (Size g = 0; g < _layers_[lvl].g; ++g) {
            l[lvl].g.push_back(this->name_gen_.nextName(PRMObject::prm_type::CLASS_ELT));
            f.addAttribute("boolean", l[lvl].g.back());
          }
 
          l[lvl].r = this->name_gen_.nextName(PRMObject::prm_type::CLASS_ELT);
          f.addReferenceSlot(l[lvl - 1].i, l[lvl].r, true);
        }
 
        f.endInterface();
      }
    }

References _layers_, gum::prm::PRMFactory< GUM_SCALAR >::addAttribute(), gum::prm::PRMFactory< GUM_SCALAR >::addReferenceSlot(), gum::prm::PRMObject::CLASS_ELT, gum::prm::PRMFactory< GUM_SCALAR >::endInterface(), gum::prm::PRMGenerator< GUM_SCALAR >::name_gen_, gum::prm::PRMObject::PRM_INTERFACE, and gum::prm::PRMFactory< GUM_SCALAR >::startInterface().

Referenced by generate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _generateSystem_()

template<typename GUM_SCALAR>

void gum::prm::LayerGenerator< GUM_SCALAR >::_generateSystem_	(	PRMFactory< GUM_SCALAR > &	factory,
		std::vector< typename LayerGenerator< GUM_SCALAR >::MyData > &	l )

private

Definition at line 233 of file layerGenerator_tpl.h.

                                                                     {
      factory.startSystem(this->name_gen_.nextName(PRMObject::prm_type::SYSTEM));
      std::vector< std::vector< std::string > > o(_layers_.size());
      std::string                               name;
      size_t                                    idx = 0;
 
      for (size_t lvl = 0; lvl < _layers_.size(); ++lvl) {
        float density = _layers_[lvl].outter_density;
 
        for (size_t count = 0; count < _layers_[lvl].o; ++count) {
          name = this->name_gen_.nextName(PRMObject::prm_type::PRM_INTERFACE);
          factory.addInstance(l[lvl].c[randomValue(l[lvl].c.size())], name);
          o[lvl].push_back(name);
 
          if (lvl) {
            std::stringstream chain;
            chain << name << "." << l[lvl].r;
            std::vector< std::string > ref2add;
 
            for (std::vector< std::string >::iterator iter = o[lvl - 1].begin();
                 iter != o[lvl - 1].end();
                 ++iter)
              if (randomProba() <= density) ref2add.push_back(*iter);
 
            if (ref2add.empty())
              factory.setReferenceSlot(chain.str(), o[lvl - 1][randomValue(o[lvl - 1].size())]);
 
            while (ref2add.size() > getMaxParents()) {
              idx          = randomValue(ref2add.size());
              ref2add[idx] = ref2add.back();
              ref2add.pop_back();
            }
 
            for (std::vector< std::string >::iterator iter = ref2add.begin(); iter != ref2add.end();
                 ++iter)
              factory.setReferenceSlot(chain.str(), *iter);
          }
        }
      }
 
      factory.endSystem();
    }

References _layers_, gum::prm::PRMFactory< GUM_SCALAR >::addInstance(), gum::prm::PRMFactory< GUM_SCALAR >::endSystem(), getMaxParents(), gum::prm::PRMGenerator< GUM_SCALAR >::name_gen_, gum::prm::PRMObject::PRM_INTERFACE, gum::randomProba(), gum::randomValue(), gum::prm::PRMFactory< GUM_SCALAR >::setReferenceSlot(), gum::prm::PRMFactory< GUM_SCALAR >::startSystem(), and gum::prm::PRMObject::SYSTEM.

Referenced by generate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _generateType_()

template<typename GUM_SCALAR>

std::string gum::prm::LayerGenerator< GUM_SCALAR >::_generateType_ ( PRMFactory< GUM_SCALAR > & f )

private

Definition at line 70 of file layerGenerator_tpl.h.

                                                                                            {
      std::string name = this->name_gen_.nextName(PRMObject::prm_type::TYPE);
      factory.startDiscreteType(name);
 
      for (Size i = 0; i < _domain_size_; ++i) {
        std::stringstream sBuff;
        sBuff << i;
        factory.addLabel(sBuff.str());
      }
 
      factory.endDiscreteType();
      return name;
    }

References _domain_size_, gum::prm::PRMFactory< GUM_SCALAR >::addLabel(), gum::prm::PRMFactory< GUM_SCALAR >::endDiscreteType(), gum::prm::PRMGenerator< GUM_SCALAR >::name_gen_, gum::prm::PRMFactory< GUM_SCALAR >::startDiscreteType(), and gum::prm::PRMObject::TYPE.

Referenced by generate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate()

template<typename GUM_SCALAR>

PRM< GUM_SCALAR > * gum::prm::LayerGenerator< GUM_SCALAR >::generate ( )

virtual

Proceeds with the generation of the PRM<GUM_SCALAR>.

Implements gum::prm::PRMGenerator< GUM_SCALAR >.

Definition at line 55 of file layerGenerator_tpl.h.

                                                              {
      if (_layers_.size() == 0) {
        GUM_ERROR(OperationNotAllowed, "cannot generate a layered PRM<GUM_SCALAR> without layers")
      }
 
      std::vector< MyData >    l;
      PRMFactory< GUM_SCALAR > factory;
      std::string              type = _generateType_(factory);
      _generateInterfaces_(factory, type, l);
      _generateClasses_(factory, type, l);
      _generateSystem_(factory, l);
      return factory.prm();
    }

References _generateClasses_(), _generateInterfaces_(), _generateSystem_(), _generateType_(), _layers_, GUM_ERROR, and gum::prm::PRMFactory< GUM_SCALAR >::prm().

Here is the call graph for this function:

◆ getDomainSize()

template<typename GUM_SCALAR>

INLINE Size gum::prm::LayerGenerator< GUM_SCALAR >::getDomainSize ( ) const

Returns the domain size of generated types.

Definition at line 307 of file layerGenerator_tpl.h.

                                                                  {
      return _domain_size_;
    }

References _domain_size_.

Referenced by _generateClasses_().

Here is the caller graph for this function:

◆ getLayer() [1/2]

template<typename GUM_SCALAR>

INLINE std::vector< typename LayerGenerator< GUM_SCALAR >::LayerData > & gum::prm::LayerGenerator< GUM_SCALAR >::getLayer ( )

Returns the domain size of generated types.

Definition at line 334 of file layerGenerator_tpl.h.

                                                  {
      return _layers_;
    }

References _layers_.

◆ getLayer() [2/2]

template<typename GUM_SCALAR>

INLINE const std::vector< typename LayerGenerator< GUM_SCALAR >::LayerData > & gum::prm::LayerGenerator< GUM_SCALAR >::getLayer ( ) const

Returns the domain size of generated types.

Definition at line 340 of file layerGenerator_tpl.h.

                                                              {
      return _layers_;
    }

References _layers_.

◆ getMaxParents()

template<typename GUM_SCALAR>

INLINE Size gum::prm::LayerGenerator< GUM_SCALAR >::getMaxParents ( ) const

Returns the max number of parents allowed for any attribute or aggregator.

Definition at line 317 of file layerGenerator_tpl.h.

                                                                  {
      return _max_parents_;
    }

References _max_parents_.

Referenced by _generateClassDag_(), and _generateSystem_().

Here is the caller graph for this function:

◆ getNameGenerator()

template<typename GUM_SCALAR>

INLINE const NameGenerator & gum::prm::PRMGenerator< GUM_SCALAR >::getNameGenerator ( ) const

inherited

Returns the NameGenerator used by this generator.

Definition at line 76 of file PRMGenerator_tpl.h.

                                                                                   {
      return name_gen_;
    }

References name_gen_.

◆ operator=()

template<typename GUM_SCALAR>

INLINE LayerGenerator< GUM_SCALAR > & gum::prm::LayerGenerator< GUM_SCALAR >::operator= ( const LayerGenerator< GUM_SCALAR > & source )

Copy operator.

Definition at line 299 of file layerGenerator_tpl.h.

                                                                                           {
      _layers_      = source._layers_;
      _domain_size_ = source._domain_size_;
      _max_parents_ = source._max_parents_;
      return *this;
    }

References LayerGenerator(), _domain_size_, _layers_, and _max_parents_.

Here is the call graph for this function:

◆ setDomainSize()

template<typename GUM_SCALAR>

INLINE void gum::prm::LayerGenerator< GUM_SCALAR >::setDomainSize ( Size s )

Set the domain size of generated types.

Definition at line 312 of file layerGenerator_tpl.h.

                                                                  {
      _domain_size_ = s;
    }

References _domain_size_.

◆ setLayers()

template<typename GUM_SCALAR>

INLINE void gum::prm::LayerGenerator< GUM_SCALAR >::setLayers ( const std::vector< LayerData > & v )

Defines the structure of each layers.

Each value in v defines a layer, were v[i].first is the number of different classes in the i-th layer and v[i].second is the number of instances in the i-th layer.

Parameters

v	A vector describing each layer.

Definition at line 327 of file layerGenerator_tpl.h.

                                                                              {
      _layers_ = v;
    }

References _layers_.

◆ setMaxParents()

template<typename GUM_SCALAR>

INLINE void gum::prm::LayerGenerator< GUM_SCALAR >::setMaxParents ( Size s )

Returns the max number of parents allowed for any attribute or aggregator.

Definition at line 322 of file layerGenerator_tpl.h.

                                                                  {
      _max_parents_ = s;
    }

References _max_parents_.

◆ setNameGenerator()

template<typename GUM_SCALAR>

INLINE void gum::prm::PRMGenerator< GUM_SCALAR >::setNameGenerator ( const NameGenerator & name_gen )

inherited

Getters and setters.

Defines the NameGenerator used by this generator.

Definition at line 71 of file PRMGenerator_tpl.h.

                                                                                          {
      name_gen_ = name_gen;
    }

References name_gen_.

Member Data Documentation

◆ _domain_size_

template<typename GUM_SCALAR>

Size gum::prm::LayerGenerator< GUM_SCALAR >::_domain_size_

private

Definition at line 146 of file layerGenerator.h.

Referenced by LayerGenerator(), LayerGenerator(), _generateType_(), getDomainSize(), operator=(), and setDomainSize().

◆ _layers_

template<typename GUM_SCALAR>

std::vector< LayerData > gum::prm::LayerGenerator< GUM_SCALAR >::_layers_

private

Definition at line 145 of file layerGenerator.h.

Referenced by LayerGenerator(), LayerGenerator(), _generateClassDag_(), _generateClasses_(), _generateInterfaces_(), _generateSystem_(), generate(), getLayer(), getLayer(), operator=(), and setLayers().

◆ _max_parents_

template<typename GUM_SCALAR>

Size gum::prm::LayerGenerator< GUM_SCALAR >::_max_parents_

private

Definition at line 147 of file layerGenerator.h.

Referenced by LayerGenerator(), LayerGenerator(), getMaxParents(), operator=(), and setMaxParents().

◆ name_gen_

template<typename GUM_SCALAR>

NameGenerator gum::prm::PRMGenerator< GUM_SCALAR >::name_gen_

protectedinherited

The name generator used by this class.

Definition at line 101 of file PRMGenerator.h.

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

agrum/PRM/generator/layerGenerator.h
agrum/PRM/generator/layerGenerator_tpl.h

Classes

Public Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ LayerGenerator() [1/2]

◆ LayerGenerator() [2/2]

◆ ~LayerGenerator()

Member Function Documentation

◆ _generateClassDag_()

◆ _generateClasses_()

◆ _generateInterfaces_()

◆ _generateSystem_()

◆ _generateType_()

◆ generate()

◆ getDomainSize()

◆ getLayer() [1/2]

◆ getLayer() [2/2]

◆ getMaxParents()

◆ getNameGenerator()

◆ operator=()

◆ setDomainSize()

◆ setLayers()

◆ setMaxParents()

◆ setNameGenerator()

Member Data Documentation

◆ _domain_size_

◆ _layers_

◆ _max_parents_

◆ name_gen_