```
# 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 = NULL, R = 200, m = nrow(data),
algorithm, algorithm.args = list(), cpdag = TRUE, debug = FALSE)
# strength of all possible arcs, from a list of custom networks.
custom.strength(networks, nodes, weights = NULL, cpdag = TRUE, debug = FALSE)
# average arc strengths.
# S3 method for bn.strength
mean(x, ..., weights = NULL)
```# averaged network structure.
averaged.network(strength, nodes, threshold)

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").data

a data frame containing the data the Bayesian network was
learned from.

cluster

an optional cluster object from package parallel. See

`parallel integration`

for details and a simple example.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. In

`averaged.network`

, it defaults to the set of the
unique node labels in the `strength`

argument.criterion

a character string, the label of a score function or an
independence test. See

`bnlearn-package`

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.algorithm

a character string, the learning algorithm to be applied
to the bootstrap replicates. Possible values are

`gs`

, `iamb`

,
`fast.iamb`

, `inter.iamb`

, `mmpc`

, `hc`

, `tabu`

,
`mmhc`

and `rsmax2`

. See `bnlearn-package`

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.`arc.strength`

, `boot.strength`

, `custom.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.`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 possible additional argument is `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
including the arc and the score of the network in which the arc is not
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
aguments depending on the choice of the score, see `score`

for
details. `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). `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`

or by `custom.strength`

. The
returned network contains the arcs whose strength is greater than the
`threshold`

attribute of the `bn.strength`

object passed to
`averaged.network`

.`strength.plot`

, `choose.direction`

,
`score`

, `ci.test`

.```
data(learning.test)
res = gs(learning.test)
res = set.arc(res, "A", "B")
arc.strength(res, 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))
## ---------------------------------------------
```

Run the code above in your browser using DataLab