Fast Flow Matching based Conditional Independence Tests for Causal Discovery

Constraint-based causal discovery methods require a large number of conditional independence (CI) tests, which severely limits their practical applicability due to high computational complexity. Therefore, it is crucial to design an algorithm that accelerates each individual test. To this end, we propose the Flow Matching-based Conditional Independence Test (FMCIT). The proposed test leverages the high computational efficiency of flow matching and requires the model to be trained only once throughout the entire causal discovery procedure, substantially accelerating causal discovery. According to numerical experiments, FMCIT effectively controls type-I error and maintains high testing power under the alternative hypothesis, even in the presence of high-dimensional conditioning sets. In addition, we further integrate FMCIT into a two-stage guided PC skeleton learning framework, termed GPC-FMCIT, which combines fast screening with guided, budgeted refinement using FMCIT. This design yields explicit bounds on the number of CI queries while maintaining high statistical power. Experiments on synthetic and real-world causal discovery tasks demonstrate favorable accuracy-efficiency trade-offs over existing CI testing methods and PC variants.

💡 Research Summary

The paper addresses a critical bottleneck in constraint‑based causal discovery: the large number of conditional independence (CI) tests required by algorithms such as PC, each of which can be computationally expensive. To accelerate both individual CI tests and the overall discovery pipeline, the authors introduce the Flow‑Matching based Conditional Independence Test (FMCIT) and embed it into a guided two‑stage PC skeleton learning framework (GPC‑FMCIT).

Core technical contribution – FMCIT
FMCIT builds on the Conditional Randomization Test (CRT) but replaces the costly estimation of the conditional distribution (P_{X_i|X_S}) with a single flow‑matching (FM) model trained on the full joint distribution of all variables. FM learns an ODE vector field (v_\theta) that transports standard Gaussian noise to the data distribution; the loss (Eq. 4) aligns the vector field with the true data flow. Crucially, the model is trained once for the whole dataset, eliminating the need to retrain a generative model for each ((i,S)) pair.

Conditional sampling is reframed as an imputation problem: given a conditioning set (S), the FM model generates a sample of the entire vector (X) conditioned on the observed components (X_S). This is achieved by a Picard‑based fixed‑point iteration combined with the RePaint stochastic correction. At each ODE time step (t_k) the algorithm computes a Picard update (b_X(t_k) = X(t_k) + (1-t_k)v_\theta(X(t_k),t_k)), then overwrites the coordinates belonging to (S) with their true values, and finally adds Gaussian noise before moving to the next step. Because the underlying ODE is linear, the integral can be approximated accurately with only a few (5–50) steps, far fewer than the hundreds of steps required by diffusion‑based samplers.

With the imputed samples, FMCIT performs the CRT by generating (B) parallel resamples of the target variable (X_i) and computing a test statistic (e.g., a kernel or distance measure) on each. The resulting p‑value is obtained via the usual CRT permutation logic. The number of repetitions (B) can be made level‑dependent: fewer repetitions for unconditional tests, more for higher‑order conditionals, providing a practical speed‑power trade‑off.

Guided PC skeleton learning – GPC‑FMCIT
The authors recognize that even with fast CI tests, the combinatorial explosion of conditioning sets can dominate runtime. They therefore propose a two‑stage PC‑style procedure:

1. Screening stage – Run PC‑stable with a cheap Fisher‑Z test, limited to a small maximum conditioning size (d_{\text{scr}}^{\max}). This yields a sparse “screening graph” (G_{\text{scr}}) whose neighborhoods provide candidate separators.

2. Refinement stage – Initialize the working graph with (G_{\text{scr}}) and iteratively test edges using FMCIT. For each edge ((i,j)), a candidate pool (P_{ij}) of size (k) is built from the union of the two nodes’ neighborhoods in (G_{\text{scr}}) (set (Q_{ij})). If (Q_{ij}) is smaller than (k), global ranking scores (e.g., degree frequency) fill the remainder. This pool is deterministic given the screening output, ensuring reproducibility.

   At conditioning level (\ell), only up to (M) subsets of size (\ell) drawn from (P_{ij}) are examined (early stopping once an independent set is found). When (|P_{ij}^\ell| \le M) the algorithm enumerates all subsets; otherwise it samples uniformly with a fixed seed. The per‑edge budget ((k,M)) and the level‑dependent repeat count (B(\ell)) give explicit control over total CI queries, while still allowing the powerful FMCIT oracle to be used.

Because the FM model is shared across all queries, the refinement stage incurs only the cost of fast Picard‑RePaint sampling and CRT evaluation, not repeated model training.

Theoretical and empirical validation
The paper provides extensive experiments:

• Type‑I error control – Across synthetic settings with varying dimensions (up to several hundred) and sample sizes, FMCIT maintains empirical false‑positive rates close to the nominal (\alpha).

• Power – Under a range of nonlinear dependencies, FMCIT’s power exceeds that of kernel‑HSIC, CD‑CIT (conditional diffusion), and other recent generative‑based CI tests, especially when the conditioning set is high‑dimensional.

• Runtime – Training the FM model once takes comparable time to fitting a single Gaussian mixture, while each CI test runs in milliseconds. Overall GPC‑FMCIT achieves 10–30× speed‑ups over standard PC‑stable with Fisher‑Z and orders of magnitude over PC‑stable with diffusion‑based CI tests.

• Real‑world applications – Gene‑expression network reconstruction (≈1,000 genes) and macro‑economic indicator analysis demonstrate that GPC‑FMCIT recovers more plausible causal edges than baseline PC variants while completing in a fraction of the time.

Key insights and contributions

1. Single‑model reuse – By learning the full joint distribution once via flow matching, the method sidesteps the prohibitive retraining cost that plagues existing generative‑based CI tests.

2. Efficient conditional sampling – Picard‑RePaint provides a globally stable fixed‑point iteration that respects observed conditioning values, requiring only a handful of ODE steps.

3. Budgeted conditioning search – The guided pool and per‑level budget (M) give explicit, theoretically tractable bounds on the number of CI queries, a rare feature in constraint‑based discovery literature.

4. Practical flexibility – Level‑dependent repeat counts (B(\ell)) and the ability to plug in alternative test statistics make FMCIT adaptable to various domains and data regimes.

In summary, the paper delivers a novel, computationally efficient CI testing framework that integrates modern flow‑based generative modeling with classic CRT ideas, and demonstrates that this integration can dramatically accelerate constraint‑based causal discovery without sacrificing statistical rigor. The proposed GPC‑FMCIT pipeline offers a practical solution for high‑dimensional, real‑world causal inference tasks.