Description Usage Arguments Details Value Author(s) References See Also Examples

This function is used to infer a causal network (or a causal graph) with directed and undirected edges from observational data. It implements the MRPC (PC with the principle of Mendelian randomization) algorithm described in Badsha and Fu, 2019 and Badsha et al., 2018, and the implementation is based on the pc algorithm in the `pcalg`

package. The MRPC algorithm contains four major updates over the pc algorithm: (i) incorporating a sequential testing method to control the False Discovery Rate (FDR), (ii) improved v-structure identification; (iii) allowing for calculation of robust correlation to reduce the impact of outliers, and (iv) a new procedure for edge orientation based on the principle of Mendelian randomization (PMR) (Badsha and Fu, 2019 and Badsha et al., 2018). See details below.

1 2 3 4 5 6 7 8 | ```
MRPC(data, suffStat, GV, FDR = 0.05, alpha = 0.05, indepTest, labels, p,
fixedGaps = NULL, fixedEdges = NULL,
NAdelete = TRUE, m.max = Inf,
u2pd = c("relaxed", "rand", "retry"),
skel.method = c("stable", "original", "stable.fast"),
conservative = FALSE,
maj.rule = FALSE, solve.confl = FALSE, FDRcontrol = TRUE,
verbose = FALSE)
``` |

This function is based on the pc function in the `pcalg`

package. Therefore, many arguments are similar to those in pc.

`data` |
Data matrix, where the rows are observations and the columns are features (i.e., variables, or nodes). If genetic variants (GVs) are included, then the columns start from GVs (e.g., single-nucleotide polymorphisms, or SNPs; insertions and deletions, or indels; copy number variation, or CNVs; and expression quantitative trait loci, or eQTLs to genes), and followed by phenotypes (e.g., gene expression). For example, if the data contains one GV, then the first column of the input matrix is the GV and the remaining columns are the gene expression data. |

`suffStat` |
A list of sufficient statistics. When the data is continuous or can be viewed as continuous, this list contains the correlation matrix of the data and the sample size, which are the necessary elements for the conditional independence tests in gaussCItest. When the data is discrete, this list contains the entire dataset. |

`GV` |
The number of genetic variants (SNPs/indels/CNV/eQTL) in the input data matrix. For example, if the data has one SNPs/indels/CNV/eQTL, first column, then GV = 1, if 2 SNPs/indels/CNV/eQTL, 1st and 2nd Column, then GV = 2, if no GV then GV = 0, and so on. |

`FDR` |
Need to specify the desired level of the overall false discovery rate. |

`alpha` |
significance level (number in (0,1) for the individual tests. |

`indepTest` |
A function for testing conditional independence. It is used to test the conditional independence of x and y given S, called as indepTest(x, y, S, suffStat). Where, x and y are variables, and S is a vector, possibly empty, of variables. suffStat is a list, see the argument above. The return value of indepTest is the p-value of the test for conditional independence. The different indepTest is used for different data types, for example, Gaussian data = gaussCItest, Discrete data = disCItest and Binary data = binCItest. See help(gaussCItest) The ci.test (Marco Scutari, 2010) is also used for testing conditional independence and return value of indepTest is the p-value. If none is specified, the default test statistic is the mutual information for categorical variables, the Jonckheere-Terpstra test for ordered factors and the linear correlation for continuous variables.See help(ci.test) Remember that need to specify the which indepTest would like for independence testing. For example, if you would like to use gaussCItest you would type indepTest = 'gaussCItest' into the function otherwise indepTest = 'citest'. Note that, we used gaussCItest to compare our MRPC with the existing pc, because of ci.test is not robust. See details in example. |

`labels` |
A character vector of variable, or node, names. All variables are denoted in column in the input matrix. |

`p` |
(optional) The number of variables, or nodes. May be specified if the labels are not provided, in which case the labels are set to 1:p. |

`fixedGaps` |
(optional) A logical matrix of dimension p*p. If entry [x, y], [y, x], or both are TRUE, the edge x—y is removed before starting the algorithm. Therefore, this edge is guaranteed to be absent in the resulting graph. |

`fixedEdges` |
(optional) A logical matrix of dimension p*p. If entry [x, y], [y, x], or both are TRUE, the edge x—y is never considered for removal. Therefore, this edge is guaranteed to be present in the resulting graph. |

`NAdelete` |
(optional) If indepTest returns NA and this option is TRUE, the corresponding edge is deleted. If this option is FALSE, the edge is not deleted. |

`m.max` |
(optional) Maximum size of the conditioning sets that are considered in the conditional independence tests. |

`u2pd` |
(optional) Character string specifying the method for dealing with conflicting information. |

`skel.method` |
(optional) Character string specifying method; the default, "stable" provides an order-independent skeleton. |

`conservative` |
(optional) Logical. Indicates if the conservative PC algorithm is used. In this case, only option u2pd = "relaxed" is supported. Note that the resulting object might not be extendable to a DAG. See details for more information. |

`maj.rule` |
(optional) Logical. Indicates that the triplets will be checked for ambiguity using a majority rule idea, which is less strict than the conservative PC algorithm. For more information, see details. |

`solve.confl` |
(optional) If TRUE, the orientation of the v-structures and the orientation rules work with lists for candidate sets and allow bi-directed edges to resolve conflicting edge orientations. In this case, only option u2pd = "relaxed" is supported. Note that the resulting object might not be a CPDAG because bi-directed edges might be present. See details for more information. |

`FDRcontrol` |
(optional) The default is TRUE which is used sequential FDR control method, otherwise used fixed significance level for the individual tests. |

`verbose` |
(optional) If TRUE, detailed output is provided. The default is FALSE which does not print output details. |

The PC algorithm is computationally efficient for learning a directed acyclic graph (Spirtes et al., 2000). Several variants of the original PC algorithms are available (Kalisch and Buhlmann, 2007; Kalisch et al., 2012). Similar to these PC-like algorithms, our MRPC algorithm also contains two main steps:

**Step-1**: Inference of the graph skeleton. A graph skeleton is an undirected graph with edges that are supported by the data. Similar to existing PC-like algorithms, we perform statistical tests for marginal and conditional independence tests. If the null hypothesis of independence is not rejected, then the corresponding edge is removed and never tested again.

However, unlike existing algorithms, which control only the type I error rate for each individual test, MRPC implements the LOND (Level On the Number of Discoveries) method (Javanmard and Montanari, 2015), which is a sequential hypothesis testing procedure and sets the significance level for each test based on the number of discoveries (i.e., rejections), to control the overall false discovery rate (FDR). See ModiSkeleton.

Genome data may have outliers that drastically alter the topology of the inferred graph. MRPC allows for the estimate of robust correlation, which may be the substitute of the Pearson correlation as the input to graph inference (Badsha et al., 2013).

**Step-2**: Edge orientation. With the graph skeleton inferred from Step 1, we orient each edge that is present in the graph. MRPC is fundamentally different from algorithms in the `pcalg`

(Kalisch and Buhlmann, 2007; Kalisch et al., 2012) and `bnlearn`

(Scutari, 2010) packages in the following ways (see EdgeOrientation):

(i) When analyzing genomic data, genetic variants provide additional information that helps distinguish the casual direction between two genes. Our MRPC algorithm incorporates the principle of Mendelian randomization in graph inference, which greatly reduces the space of possible graphs and increases the inference efficiency.

(ii) Next or if the input is not genomic data, we search for possible triplets that may form a v-structure (e.g.,X–>Y<–Z). We check conditional test results from step I to see whether X and Z are independent given Y. If they are, then this is not a v-structure; alternative models for the triplet may be any of the following three Markov equivalent graphs: X–>Y–>Z, X<–Y<–Z, and X<–Y–>Z. If this test is not performed in the first step, we conduct it in this step. This step improves the accuracy of the v-structure identification over existing methods.

(iii) If there are undirected edges after steps (i) and (ii), we examine iteratively triplets of nodes with at least one directed edge and no more than one undirected edge. We check the marginal and conditional test results from Step I to determine which of the basic models is consistent with the test results. It is plausible that some undirected edges cannot be oriented, and we leave them as undirected.

An object of class that contains an estimate of the equivalence class of the underlying DAG.

`call`

:a call object: the original function call.

`n`

:The sample size used to estimate the graph.

`max.ord`

:The maximum size of the conditioning set used in the conditional independence tests in the first part of the algorithm.

`n.edgetests`

:The number of conditional independence tests performed by the first part of the algorithm.

`sepset`

:Separation sets.

`pMax`

:A numeric square matrix , where the (i, j)th entry contains the maximal p-value of all conditional independence tests for edge i–j.

`graph`

:Object of class

`"graph"`

: the undirected or partially directed graph that was estimated.`zMin`

:Deprecated.

`test`

:The number of tests that have been performed.

`alpha`

:The level of significance for the current test.

`R`

:All of the decisions made so far from tests that have been performed.

Md. Bahadur Badsha (mbbadshar@gmail.com)

1. Badsha MB and Fu AQ (2019). Learning causal biological networks with the principle of Mendelian randomization. Frontiers in Genetics, 10(460).

2. Badsha MB, Martin EA and Fu AQ (2018). MRPC: An R package for accurate inference of causal graphs. arXiv:1806.01899.

3. Badsha MB, Mollah MN, Jahan N and Kurata H (2013). Robust complementary hierarchical clustering for gene expression data analysis by beta-divergence. J Biosci Bioeng, 116(3): 397-407.

4. Javanmard A and Montanari A (2015). On Online Control of False Discovery Rate. arXiv:150206197 [statME].

5. Kalisch M and Buhlmann P (2007). Estimating High-Dimensional Directed Acyclic Graphs with the PC-Algorithm, Journal of Machine Learning Research, 8, 613-636.

6. Kalisch M, Machler M, Colombo D, Maathuis MH and Buhlmann P (2012). Causal Inference Using Graphical Models with the R Package pcalg. Journal of Statistical Software, 47, 26.

7. Scutari M (2010). Learning Bayesian Networks with the bnlearn R Package. Journal of Statistical Software, 35(3), 1-22.

8. Spirtes P, Glymour C and Scheines R (2000). Causation, Prediction, and Search, 2nd edition. The MIT Press.

ModiSkeleton for inferring a graph skeleton (i.e., an undirected graph); EdgeOrientation for edge orientation in the inferred graph skeleton; SimulateData for generating data under a topology.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 | ```
# Load packages
# We compare different simulated data across six methods: MRPC,
# PC in pcalg (Kalisch et al., 2012), and pc.stable, mmpc mmhc and hc in
# bnlearn (Marco Scutari, 2010)
library(MRPC) # MRPC
library(pcalg) # pc
library(bnlearn) # pc.stable, mmpc, mmhc and hc
# Data pre-processing
# The 1st column of the input matrix will be the genotype of the
# expression quantitative trait loci (eQTL)/Copy number variation (CNV)
# and the remaining columns are the gene expression data.
# We used pre-assigned level alpha = 0.05 that ensures FDR and mFDR
# will remain below 0.05.
# Load predefined simulated data
# Model 1
Truth <- MRPCtruth$M1 # Truth for model 1
data <- simu_data_M1 # load data for model 1
n <- nrow (data) # Number of rows
V <- colnames(data) # Column names
# Calculate Pearson correlation
suffStat_C <- list(C = cor(data),
n = n)
# Infer the graph by MRPC
MRPC.fit <- MRPC(data,
suffStat = suffStat_C,
GV = 1,
FDR = 0.05,
indepTest = 'gaussCItest',
labels = V,
FDRcontrol = TRUE,
verbose = FALSE)
# Infer the graph by PC
pc.fit <- pc(suffStat = suffStat_C,
indepTest = gaussCItest,
alpha = 0.05,
labels = V,
verbose = FALSE)
# arcs not to be included from gene expression to genotype used in pc.stable, mmpc
bl <- data.frame (from = colnames (data)[-1],
to = 'V1')
# Infer the graph by pc.stable
pc.stable.fit <- pc.stable(data.frame(data),
blacklist = bl,
undirected = FALSE)
# Infer the graph by mmpc
mmpc.fit <- mmpc(data.frame(data),
blacklist = bl,
undirected = FALSE,
debug = FALSE)
# Infer the graph by mmhc
mmhc.fit <- mmhc(data.frame(data),
blacklist = bl,
debug = FALSE)
# Infer the graph by hc
hc.fit <- hc (data.frame (data),
blacklist = bl,
debug = FALSE)
# Plot the inferred graphs
par(mfrow = c(1, 7))
plot(Truth,
main = "(A) Truth")
plot(MRPC.fit,
main = "(B) MRPC")
plot(pc.fit,
main ="(C) pc")
graphviz.plot(pc.stable.fit,
main = "(D) pc.stable")
graphviz.plot(mmpc.fit,
main = "(E) mmpc")
graphviz.plot(mmhc.fit,
main = "(F) mmhc")
graphviz.plot(hc.fit,
main = "(G) hc")
# Another option for plot of the results. First fig is the nodes
# dendrogram with colored modules. Second fig is the plot of the graph
# with color based on modules.
# To idendify modules and complex graph (Suitable if you have many nodes)
# Adjacency matrix from directed graph
Adj_directed <- as(MRPC.fit@graph,
"matrix")
# Plot of dendrogram with modules colors of nodes
PlotDendrogramObj <- PlotDendrogram(Adj_directed,
minModuleSize = 2)
# Visualization of inferred graph with modules colors
PlotGraphWithModulesObj <- PlotGraphWithModules(Adj_directed,
PlotDendrogramObj,
GV = 1,
node.size = 8,
arrow.size = 5,
label.size = 3,
alpha = 1)
# Plot
plot(PlotGraphWithModulesObj)
# Other models are available and may be called as follows:
# Model 0
# Truth <- MRPCtruth$M0
# data <- simu_data_M0
# Model 2
# Truth <- MRPCtruth$M2
# data <- simu_data_M2
# Model 3
# Truth <- MRPCtruth$M3
# data <- simu_data_M3
# Model 4
# Truth <- MRPCtruth$M4
# data <- simu_data_M4
# Model Multiparent
# Truth <- MRPCtruth$Multiparent
# data <- simu_data_multiparent
# Model Star
# Truth <- MRPCtruth$Star
# data <- simu_data_starshaped
# Model Layered
# Truth <- MRPCtruth$Layered
# data <- simu_data_layered
# Examples for analyzing discrete data
# Discrete data with genetic variants
data <- data_examples$simple$disc$withGV$data
n <- nrow (data) # Sample size
V <- colnames (data) # Node labels
# need different suffStat for discrete data
suffStat <- list (dm = data,
adaptDF = FALSE,
n.min = 1000)
# Infer the graph by MRPC
data.mrpc.disc.withGV <- MRPC (data,
suffStat = suffStat,
GV = 1,
FDR = 0.05,
indepTest = 'disCItest',
labels = V,
FDRcontrol = TRUE,
verbose = FALSE)
# Discrete data without genetic variants
data <- data_examples$simple$disc$withoutGV$data
n <- nrow (data) # Sample size
V <- colnames (data) # Node labels
# need different suffStat for discrete data
suffStat <- list (dm = data,
adaptDF = FALSE,
n.min = 1000)
# Infer the graph by MRPC
data.mrpc.disc.withoutGV <- MRPC (data,
suffStat = suffStat,
GV = 0,
FDR = 0.05,
indepTest = 'disCItest',
labels = V,
FDRcontrol = TRUE,
verbose = FALSE)
# Plots of true and inferred graphs on discrete data
par (mfrow = c (2,2))
plot (data_examples$simple$disc$withGV$graph, main = "truth")
plot (data.mrpc.disc.withGV, main = "inferred")
plot (data_examples$simple$disc$withoutGV$graph, main = "truth")
plot (data.mrpc.disc.withoutGV, main = "inferred")
``` |

Embedding an R snippet on your website

Add the following code to your website.

For more information on customizing the embed code, read Embedding Snippets.