lcd-package               package:lcd               R Documentation

_S_t_r_u_c_t_u_r_a_l _l_e_a_r_n_i_n_g _o_f _c_h_a_i_n _g_r_a_p_h_s _v_i_a _t_h_e _d_e_c_o_m_p_o_s_i_t_i_o_n
_a_p_p_r_o_a_c_h

_D_e_s_c_r_i_p_t_i_o_n:

     This package implements the algorithms for learning chain graphs
     (and as a special case, Bayesian networks) via the decomposition
     approach as described in Ma, Xie and Geng (2008)and Xie, Geng and
     Zhao (2006). The correctness of the algorithms is given in the
     above cited paper.

     The algorithms are _constraint-based_ method: the actual learning
     procedure depends on testing statistical significances. See the
     learning functions for the particular tests we used in the
     implementation.

     Currently, the package supports learning with continuous and
     discrete data, but not the mix of them.

     The package also provides some utility functions for graph
     manipulation, frequency table construction and compression and
     random distribution and random sample generation from chain
     graphs.

_L_i_s_t _o_f _f_u_n_c_t_i_o_n_s:

     The package has the following categories of functions.

        *  Chain graph/Bayesian network learning: 'learn.mec.norm',
           'learn.mec.multinom', 'learn.skeleton.norm',
           'learn.skeleton.multinom', 'learn.complex.norm',
           'learn.complex.multinom', 'learn.v'.

        *  Graphical model manipulation and graph plotting: 'draw',
           'is.chaingraph', 'is.separated', 'moralize', 'pattern',
           'skeleton', 'tri.ug', 'maxcard.search', 'ug.to.jtree'.

        *  Random distribution and random sample generation from chain
           graph: 'get.normal.dist', 'get.multinom.dist', 'rnorm.cg',
           'rmultinom.cg'.

        *  Conditional independence tests: 'norm.ci.test',
           'multinom.ci.test'.

        *  Construction of undirected independence graphs from data:
           'naive.getug.norm', 'naive.getug.multinom'.

        *  Frequency table manipulation: 'as.freq.tb',
           'compress.freq.tb'.

        *  Graph Comparison: 'comp.pat', 'comp.skel'.

        *  The ALARM network: 'alarm.net';

        *  A toy example: 'toy.graph'.

_A_u_t_h_o_r(_s):

     Zongming Ma
      Department of Statistics
      Stanford University, USA
      zongming.ma@gmail.com

     Xiangrui Meng
      Institute of Computational and Mathematical Engineering
      Stanford University, USA

_R_e_f_e_r_e_n_c_e_s:

     Ma, Z., Xie, X. and Geng, Z. (2008). Structural learning of chain
     graphs via decomposition. _J. Mach. Learn. Res.,_ *9*, 2847-2880.

     Xie, X., Geng, Z. and Zhao, Q. (2006). Decomposition of structural
     learning about directed acyclic graphs. _Artif. Intell.,_ *170*,
     422-439.

_E_x_a_m_p_l_e_s:

     set.seed(100)
     p.value <- .01
     n <- 3000
     is.chaingraph(toy.graph)
     tgdata <- rnorm.cg(n, toy.graph, get.normal.dist(toy.graph))
     tgug <- naive.getug.norm(tgdata, p.value)
     tg.jtree <- ug.to.jtree(tgug)
     tg.pat <- learn.mec.norm(tg.jtree, cov(tgdata), n, p.value, "CG")
     comp.skel(skeleton(toy.graph), skeleton(tg.pat))
     comp.pat(pattern(toy.graph), tg.pat)

