bnlearn (version 0.8)

bnlearn-package: Bayesian network constraint-based structure learning.

Description

Bayesian network learning via constraint-based and score-based algorithms.

Available constraint-based learning algorithms

• Grow-Shrink(gs): based on theGrow-Shrink Markov Blanketalgorithm, a forward-selection technique for Markov blanket detection (Margaritis, 2003).
• Incremental Association(iamb): based on the Markov blanket detection algorithm of the same name, which uses stepwise selection (Tsamardinos et al., 2003).
• Fast Incremental Association(fast.iamb): a variant of IAMB which uses speculative forward-selection to reduce the number of conditional independence tests (Yaramakala and Margaritis, 2005).
• Interleaved Incremental Association(inter.iamb): another variant of IAMB which interleaves the backward selection with the forward one to avid false positives (i.e. nodes erroneously included in the Markov blanket) (Yaramakala and Margaritis, 2005).

This package includes three implementations of each algorithm:

• an optimized implementation (used when theoptimizedparameter is set toTRUE), which uses backtracking to roughly halve the number of independence tests.
• an unoptimized implementation (used when theoptimizedparameter is set toFALSE) which is better at uncovering possible erratic behaviour of the statistical tests.
• a cluster-aware implementation, which requires a running cluster set up with themakeClusterfunction from thesnowpackage. Seesnow integrationfor a sample usage.

The computational complexity of these algorithms is polynomial in the number of tests, usually $O(N^2)$ ($O(N^4)$ in the worst case scenario). The execution time also scales linearly with the size of the data set.

Other learning algorithms

• Hill-Climbing(hc): anhill climbinggreedy search on the space of the directed graphs. The optimized implementation uses score caching, score decomposability and score equivalence to reduce the number of duplicated tests. Random restart with a configurable number of perturbing operations is implemented.

Available (conditional) independence tests

The conditional independence tests used in constraint-based algorithms in practice are statistical tests on the data set. Available tests (and the respective labels) are:

• categorical data(multinomial distribution)
  • mutual information(mi): an information-theoretic distance measure. It's proportional to the log-likelihood ratio (they differ by a$2n$factor) and is related to the deviance of the tested models.
  • fast mutual information(fmi): a variant of the mutual information which is set to zero when there aren't at least five data per parameter.
  • Akaike Information Criterion(aict): an experimental AIC-based independence test, computed comparing the mutual information and the expected information gain.
  • Cochran-Mantel-Haenszel(mh): a stratified independence test, included for testing purposes only. Seemantelhaen.testin packagestats.
• numerical data(multivariate normal distribution)
  • linear correlation(cor): linear correlation.
  • Fisher's Z(zf): a transformation of the linear correlation with asymptotic normal distribution. Used by commercial software (such as TETRAD II) for the PC algorithm (an R implementation is present in thepcalgpackage on CRAN).

Available network scores

Available scores (and the respective labels) are:

• categorical data(multinomial distribution)
  • the multinomiallikelihood(lik) score.
  • the multinomialloglikelihood(loglik) score.
  • theAkaike Information Criterionscore (aic).
  • theBayesian Information Criterionscore (bic).
  • the logarithm of theBayesian Dirichlet equivalentscore (bdeodir), a score equivalent Dirichlet posterior density.
  • the logarithm of theK2score (k2), a Dirichlet posterior density (not score equivalent).
• numerical data(multivariate normal distribution)
  • a score equivalent {Gaussian posterior density} (bge).

Whitelist and blacklist support

All learning algorithms support arc whitelisting and blacklisting:

• blacklisted arcs are never present in the graph.
• arcs whitelisted in one direction only (i.e.$A \rightarrow B$is whitelisted but$B \rightarrow A$is not) have the respective reverse arcs blacklisted, and are always present in the graph.
• arcs whitelisted in both directions (i.e. both$A \rightarrow B$and$B \rightarrow A$are whitelisted) are present in the graph, but their direction is set by the learning algorithm.

Any arc whitelisted and blacklisted at the same time is assumed to be whitelisted, and is thus removed from the blacklist.

Error detection and correction: the strict mode

Optimized implementations of the constraint-based algorithms rely heavily on backtracking to reduce the number of tests needed by the learning procedure. This approach may hide errors either in the Markov blanket or the neighbourhood detection phase in some particular cases, such as when hidden variables are present or there are external (logical) constraints on the interactions between the variables.

On the other hand in the unoptimized implementations the Markov blanket and neighbour detection of each node is completely independent from the rest of the learning process. Thus it may happen that the Markov blanket or the neighbourhoods are not symmetric (i.e. A is in the Markov blanket of B but not vice versa), or that some arc directions conflict with each other.

The strict parameter enables some measure of error correction, which may help to retrieve a good model even when the learning process would fail:

• ifstrictis set toTRUE, every error stops the learning process and results in an error message.
• ifstrictis set toFALSE:
  1. v-structures are applied to the network structure in lowest-p.value order; if any arc is already oriented in the opposite direction, the v-structure is discarded.
  2. nodes which causes asymmetries in any Markov blanket are removed from that Markov blanket.
  3. nodes which causes asymmetries in any neighbourhood are removed from that neighbourhood.

Details

ll{

Package: bnlearn Type: Package Version: 0.8 Date: 2008-06-20 License: GPLv2 or later

}

This package implements some constraint-based algorithms for learning the structure of Bayesian networks. Also known as conditional independence learners, they are all optimized derivatives of the Inductive Causation algorithm (Verma and Pearl, 1991).

These algorithms differ in the way they detect the Markov blankets of the variables, which in turn are used to compute the structure of the Bayesian network. Proofs of correctness are present in the respective papers.

A score-based learning algorithm (greedy search via hill-climbing) is implemented as well for comparison purposes.

References

A. Agresti. Categorical Data Analysis. John Wiley & Sons, Inc., 2002.

K. Korb and A. Nicholson. Bayesian artificial intelligence. Chapman and Hall, 2004.

D. Margaritis. Learning Bayesian Network Model Structure from Data. PhD thesis, School of Computer Science, Carnegie-Mellon University, Pittsburgh, PA, May 2003. Available as Technical Report CMU-CS-03-153.

J. Pearl. Probabilistic Reasoning in Intelligent Systems: Networks of Plausible Inference. Morgan Kaufmann Publishers Inc., 1988.

I. Tsamardinos, C. F. Aliferis, and A. Statnikov. Algorithms for large scale Markov blanket discovery. In Proceedings of the Sixteenth International Florida Artificial Intelligence Research Society Conference, pages 376-381. AAAI Press, 2003.

S. Yaramakala, D. Margaritis. Speculative Markov Blanket Discovery for Optimal Feature Selection. In Proceedings of the Fifth IEEE International Conference on Data Mining, pages 809-812. IEEE Computer Society, 2005.

Examples

library(bnlearn)
data(learning.test)

## Simple learning
# first try the Grow-Shrink algorithm
res = gs(learning.test)
# plot the network structure.
plot(res)
# now try the Incremental Association algorithm.
res2 = iamb(learning.test)
# plot the new network structure.
plot(res2)
# the network structures seem to be identical, don't they?
compare(res, res2)
# [1] TRUE
# how many tests each of the two algorithms used?
res$learning$ntests
# [1] 43
res2$learning$ntests
# [1] 50
# and the unoptimized implementation of these algorithms?
gs(learning.test, optimized = FALSE)$ntests
# [1] 90
iamb(learning.test, optimized = FALSE)$ntests
# [1] 116

## Greedy search
res = hc(learning.test)
plot(res)

## Another simple example (gaussian data)
data(gaussian.test)
# first try the Grow-Shrink algorithm
res = gs(gaussian.test)
plot(res)

## Blacklist and whitelist use
# the arc B - F should not be there?
blacklist = data.frame(from = c("B", "F"), to = c("F", "B"))
blacklist
#   from to
# 1    B  F
# 2    F  B
res3 = gs(learning.test, blacklist = blacklist)
plot(res3)
# force E - F direction (E -> F).
whitelist = data.frame(from = c("E"), to = c("F"))
whitelist
#   from to
# 1    E  F
res4 = gs(learning.test, whitelist = whitelist)
plot(res4)
# use both blacklist and whitelist.
res5 = gs(learning.test, whitelist = whitelist, blacklist = blacklist)
plot(res5)

## Debugging
# use the debugging mode to see the learning algorithms
# in action.
res = gs(learning.test, debug = TRUE)
res = hc(learning.test, debug = TRUE)
# log the learning process for future reference.
sink(file = "learning-log.txt")
res = gs(learning.test, debug = TRUE)
sink()
# if something seems wrong, try the unoptimized version
# in strict mode (inconsistencies trigger errors):
res = gs(learning.test, optimized = FALSE, strict = TRUE, debug = TRUE)
# or disable strict mode to try to fix errors on the fly:
res = gs(learning.test, optimized = FALSE, strict = FALSE, debug = TRUE)