arc.strength {bnlearn} R Documentation

## Measure arc strength

### Description

Measure the strength of the probabilistic relationships expressed by the arcs of a Bayesian network, and use model averaging to build a network containing only the significant arcs.

### Usage

``````# strength of the arcs present in x.
arc.strength(x, data, criterion = NULL, ..., debug = FALSE)
# strength of all possible arcs, as learned from bootstrapped data.
boot.strength(data, cluster, R = 200, m = nrow(data),
algorithm, algorithm.args = list(), cpdag = TRUE, shuffle = TRUE,
debug = FALSE)
# strength of all possible arcs, from a list of custom networks.
custom.strength(networks, nodes, weights = NULL, cpdag = TRUE, debug = FALSE)
# strength of all possible arcs, computed using Bayes factors.
bf.strength(x, data, score, ..., debug = FALSE)

# average arc strengths.
## S3 method for class 'bn.strength'
mean(x, ..., weights = NULL)

# averaged network structure.
averaged.network(strength, threshold)
# strength threshold for inclusion in the averaged network structure.
inclusion.threshold(strength)
``````

### Arguments

 `x` an object of class `bn.strength` (for `mean()`) or of class `bn` (for all other functions). `networks` a list, containing either object of class `bn` or arc sets (matrices or data frames with two columns, optionally labeled "from" and "to"); or an object of class `bn.kcv` or `bn.kcv.list` from `bn.cv()`. `data` a data frame containing the data the Bayesian network was learned from (for `arc.strength()`) or that will be used to compute the arc strengths (for `boot.strength()` and `bf.strength()`). `cluster` an optional cluster object from package parallel. `strength` an object of class `bn.strength`, see below. `threshold` a numeric value, the minimum strength required for an arc to be included in the averaged network. The default value is the `threshold` attribute of the `strength` argument. `nodes` a vector of character strings, the labels of the nodes in the network. `criterion,score` a character string. For `arc.strength()`, the label of a score function or an independence test; see `network scores` for details.

For `bf.strength()`, the label of the score used to compute the Bayes factors; see `BF` for details.

 `R` a positive integer, the number of bootstrap replicates. `m` a positive integer, the size of each bootstrap replicate. `weights` a vector of non-negative numbers, to be used as weights when averaging arc strengths (in `mean()`) or network structures (in `custom.strength()`) to compute strength coefficients. If `NULL`, weights are assumed to be uniform. `cpdag` a boolean value. If `TRUE` the (PDAG of) the equivalence class is used instead of the network structure itself. It should make it easier to identify score-equivalent arcs. `shuffle` a boolean value. If `TRUE` the columns in the data are permuted in each bootstrap sample to enforce the fact that the ordering of the variables in the data should be an invariant. `algorithm` a character string, the structure learning algorithm to be applied to the bootstrap replicates. See `structure learning` and the documentation of each algorithm for details. `algorithm.args` a list of extra arguments to be passed to the learning algorithm. `...` in `arc.strength()`, the additional tuning parameters for the network score (if `criterion` is the label of a score function, see `score` for details), the conditional independence test (currently the only one is `B`, the number of permutations). In `mean()`, additional objects of class `bn.strength` to average. `debug` a boolean value. If `TRUE` a lot of debugging output is printed; otherwise the function is completely silent.

### Details

`arc.strength()` computes a measure of confidence or strength for each arc, while keeping fixed the rest of the network structure.

If `criterion` is a conditional independence test, the strength is a p-value (so the lower the value, the stronger the relationship). The conditional independence test would be that to drop the arc from the network. The only two possible additional arguments are `alpha`, which sets the significance threshold that is used in `strength.plot()`; and `B`, the number of permutations to be generated for each permutation test.

If `criterion` is the label of a score function, the strength is measured by the score gain/loss which would be caused by the arc's removal. In other words, it is the difference between the score of the network in which the arc is not present and the score of the network in which the arc is present. Negative values correspond to decreases in the network score and positive values correspond to increases in the network score (the stronger the relationship, the more negative the difference). There may be additional arguments depending on the choice of the score, see `score` for details. The significance threshold is set to `0`.

`boot.strength()` estimates the strength of each arc as its empirical frequency over a set of networks learned from bootstrap samples. It computes the probability of each arc (modulo its direction) and the probabilities of each arc's directions conditional on the arc being present in the graph (in either direction). The significance threshold is computed automatically from the strength estimates.

`bf.strength()` estimates the strength of each arc using Bayes factors to overcome the fact that Bayesian posterior scores are not normalised, and uses the latter to estimate the probabilities of all possible states of an arc given the rest of the network. The significance threshold is set to `1`.

`custom.strength()` takes a list of networks and estimates arc strength in the same way as
`boot.strength()`.

Model averaging is supported for objects of class `bn.strength` returned by `boot.strength`, `custom.strength` and `bf.strength`. The returned network contains the arcs whose strength is greater than the `threshold` attribute of the `bn.strength` object passed to `averaged.network()`.

### Value

`arc.strength()`, `boot.strength()`, `custom.strength()`, `bf.strength()` and `mean()` return an object of class `bn.strength`; `boot.strength()` and `custom.strength()` also include information about the relative probabilities of arc directions.

`averaged.network()` returns an object of class `bn`.

See `bn.strength class` and `bn-class` for details.

### Note

`averaged.network()` typically returns a completely directed graph; an arc can be undirected if and only if the probability of each of its directions is exactly 0.5. This may happen, for example, if the arc is undirected in all the networks being averaged.

Marco Scutari

### References

for model averaging and boostrap strength (confidence):

Friedman N, Goldszmidt M, Wyner A (1999). "Data Analysis with Bayesian Networks: A Bootstrap Approach". Proceedings of the 15th Annual Conference on Uncertainty in Artificial Intelligence, 196–201.

for the computation of the bootstrap strength (confidence) significance threshold:

Scutari M, Nagarajan R (2013). "On Identifying Significant Edges in Graphical Models of Molecular Networks". Artificial Intelligence in Medicine, 57(3):207–217.

`strength.plot`, `score`, `ci.test`.

### Examples

``````data(learning.test)
dag = hc(learning.test)
arc.strength(dag, learning.test)

## Not run:
arcs = boot.strength(learning.test, algorithm = "hc")
arcs[(arcs\$strength > 0.85) & (arcs\$direction >= 0.5), ]
averaged.network(arcs)

start = random.graph(nodes = names(learning.test), num = 50)
netlist = lapply(start, function(net) {
hc(learning.test, score = "bde", iss = 10, start = net) })
arcs = custom.strength(netlist, nodes = names(learning.test),
cpdag = FALSE)
arcs[(arcs\$strength > 0.85) & (arcs\$direction >= 0.5), ]
modelstring(averaged.network(arcs))

## End(Not run)

bf.strength(dag, learning.test, score = "bds", prior = "marginal")
``````