gum::prm::LayerGenerator< GUM_SCALAR > Class Template Reference

<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 >:

Public Member Functions
Constructors and destructor.
	LayerGenerator ()
	Default constructor. More...
	LayerGenerator (const LayerGenerator &source)
	Copy constructor. More...
LayerGenerator &	operator= (const LayerGenerator &source)
	Copy operator. More...
virtual	~LayerGenerator ()
	Destructor. More...
Size	getDomainSize () const
	Returns the domain size of generated types. More...
void	setDomainSize (Size s)
	Set the domain size of generated types. More...
Size	getMaxParents () const
	Returns the max number of parents allowed for any attribute or aggregator. More...
void	setMaxParents (Size s)
	Returns the max number of parents allowed for any attribute or aggregator. More...
void	setLayers (const std::vector< LayerData > &v)
	Defines the structure of each layers. More...
std::vector< LayerData > &	getLayer ()
	Returns the domain size of generated types. More...
const std::vector< LayerData > &	getLayer () const
	Returns the domain size of generated types. More...
virtual PRM< GUM_SCALAR > *	generate ()
	Proceeds with the generation of the PRM<GUM_SCALAR>. More...
void	setNameGenerator (const NameGenerator &name_gen)
	Getters and setters. More...
const NameGenerator &	getNameGenerator () const
	Returns the NameGenerator used by this generator. More...

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

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

Detailed Description

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

<agrum/PRM/generator/layerGenerator.h>

This class generates PRMs with a layer structure.

Definition at line 55 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 271 of file layerGenerator_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                        :
        layers__(), domain_size__(2), max_parents__(INT_MAX) {
      GUM_CONSTRUCTOR(LayerGenerator);
    }

Here is the call 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 277 of file layerGenerator_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                   :
        layers__(source.layers__),
        domain_size__(source.domain_size__), max_parents__(source.max_parents__) {
      GUM_CONS_CPY(LayerGenerator);
    }

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 285 of file layerGenerator_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                         {
      GUM_DESTRUCTOR(LayerGenerator);
    }

Here is the call graph for this function:

Member Function Documentation

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 34 of file layerGenerator_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

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

Here is the call graph for this function:

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 172 of file layerGenerator_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                                    {
      float                 density = layers__[lvl].inner_density * RAND_MAX;
      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 (std::rand() < 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 = std::rand() % v.size();
            Arc    arc(v[idx], node);
            GUM_ASSERT(dag.existsArc(arc));
            dag.eraseArc(arc);
            v[idx] = v.back();
            v.pop_back();
          }
        }
      }
    }

Here is the call 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 97 of file layerGenerator_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                                    {
      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[std::rand() % 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);
      }
    }

Here is the call 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 66 of file layerGenerator_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

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

Here is the call 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 222 of file layerGenerator_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                                    {
      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 * RAND_MAX;

        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[std::rand() % 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 (std::rand() <= density) ref2add.push_back(*iter);

            if (ref2add.empty())
              factory.setReferenceSlot(
                 chain.str(),
                 o[lvl - 1][std::rand() % o[lvl - 1].size()]);

            while (ref2add.size() > getMaxParents()) {
              idx          = std::rand() % 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();
    }

Here is the call 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 50 of file layerGenerator_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

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

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 299 of file layerGenerator_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                                  {
      return domain_size__;
    }

Here is the call 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 326 of file layerGenerator_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                  {
      return layers__;
    }

Here is the call graph for this function:

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 332 of file layerGenerator_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                              {
      return layers__;
    }

Here is the call graph for this function:

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 309 of file layerGenerator_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                                  {
      return max_parents__;
    }

Here is the call 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 57 of file PRMGenerator_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                                    {
      return name_gen_;
    }

Here is the call graph for this function:

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 290 of file layerGenerator_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                   {
      layers__      = source.layers__;
      domain_size__ = source.domain_size__;
      max_parents__ = source.max_parents__;
      return *this;
    }

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 304 of file layerGenerator_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                                  {
      domain_size__ = s;
    }

Here is the call graph for this function:

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 319 of file layerGenerator_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                                             {
      layers__ = v;
    }

Here is the call graph for this function:

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 314 of file layerGenerator_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                                  {
      max_parents__ = s;
    }

Here is the call graph for this function:

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 50 of file PRMGenerator_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                      {
      name_gen_ = name_gen;
    }

Here is the call graph for this function:

Member Data Documentation

domain_size__

template<typename GUM_SCALAR >

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

private

Definition at line 127 of file layerGenerator.h.

layers__

template<typename GUM_SCALAR >

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

private

Definition at line 126 of file layerGenerator.h.

max_parents__

template<typename GUM_SCALAR >

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

private

Definition at line 128 of file layerGenerator.h.

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 80 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