15. FASK-Vote β€” Multi-Dataset FASK Voting over IMaGES

Type: Non-Gaussian / skewness-based orientation, multi-dataset ensemble wrapper
Output: Directed graph (with possible undirected edges when votes tie)
Status: Experimental / work-in-progress

FaskVote is a meta-algorithm that combines IMaGES (for multi-dataset adjacency discovery) with FASK (for skewness-based orientation) across multiple datasets.
Given several datasets over overlapping variables, FaskVote:

  1. Learns a consensus adjacency graph with IMaGES, and then

  2. Runs FASK separately on each dataset, constrained to that adjacency graph, and

  3. Votes on edge orientation across datasets to obtain a final directed graph.

Conceptually, it is an alternative to bootstrapping for orientation: instead of repeatedly resampling one dataset, it leverages multiple subject-level datasets directly.

15.1. Key Idea

FaskVote assumes you have multiple datasets on (approximately) the same variables (for example, one dataset per subject or per group).

It proceeds in two phases:

15.1.1. 1. Multi-dataset skeleton via IMaGES

  • Standardize each dataset (z-scoring).

  • Run IMaGES (using the Images wrapper) across the list of datasets with a chosen score (for example, SEM-BIC).

  • IMaGES returns a consensus graph G0 whose adjacencies reflect edges that are supported across datasets.

This step focuses on where edges exist, not on their direction.

15.1.2. 2. Orientation voting via FASK

Given the IMaGES adjacency graph G0:

  • For each dataset:

    • Run FASK on that dataset, but:

      • Supply G0 as an external skeleton (undirected version of G0).

      • Use skewness-based FASK orientation (LeftRight.FASK2 in the code).

    • Replace nodes so all FASK graphs share the same node objects.

  • For each adjacency X–Y in G0:

    • Count how many FASK runs orient X β†’ Y (sum1).

    • Count how many orient Y β†’ X (sum2).

    • Let count be the number of runs that oriented the edge in either direction.

    • Compute mean1 = sum1 / count and mean2 = sum2 / count.

Then:

  • If mean1 and mean2 are both 0.5, keep X–Y undirected (tie).

  • If mean1 > 0.5, add X β†’ Y.

  • If mean2 > 0.5, add Y β†’ X.

The result is a graph G whose adjacencies come from IMaGES and whose orientations come from skewness-based majority votes across FASK runs.

15.2. When to Use

FaskVote is appropriate when:

  • You have multiple datasets over similar or overlapping variable sets (for example, multi-subject fMRI, multi-site studies).

  • Non-Gaussianity and especially skewness are plausible, so FASK’s orientation logic is informative.

  • You want an orientation procedure that uses between-dataset variation rather than bootstrapping a single dataset.

  • You already think IMaGES is a reasonable choice for multi-dataset adjacency discovery and want to add a skew-based orientation layer.

Typical scenarios:

  • Neuroimaging, where each subject provides one dataset, and you want a group-level causal graph.

  • Multi-site clinical or observational studies, with one dataset per site or cohort.

  • Any situation where multiple datasets should vote on direction, not just on adjacency.

15.3. Prior Knowledge Support

FaskVote uses and respects a Knowledge object:

  • Knowledge is passed into IMaGES to constrain the adjacency search.

  • The same knowledge is passed into each FASK run when orienting edges.

Supported constraints include:

  • Required edges

  • Forbidden edges

  • Temporal or tiered constraints

These constraints are enforced consistently across IMaGES and all FASK runs.

15.4. Strengths

  • Multi-dataset aware: integrates information from several datasets, not just one.

  • Robust orientation via voting: unstable directions in individual datasets are averaged out.

  • Separation of concerns:

    • IMaGES handles multi-dataset structure discovery (adjacencies).

    • FASK handles non-Gaussian orientation on a fixed skeleton.

  • Can be seen as a multi-dataset alternative to bootstrap ensembles for edge direction.

15.5. Limitations

  • Requires at least two datasets; otherwise voting is pointless.

  • Inherits assumptions and limitations from both:

    • IMaGES (score-based, acyclic, multi-dataset assumptions), and

    • FASK (skewness, non-Gaussianity, linear or mildly nonlinear).

  • If skewness is weak or sample sizes are small, orientations may be unreliable and often remain undirected due to ties.

15.6. ImagES Parameters

ImagES uses parameters from three sources:

  1. SemBicScore (scoring)

  2. FGES (the search component)

  3. ImagES-specific parameters

These are shown in grouped tables below.

15.6.1. SemBicScore Parameters (Inherited)

Parameter (camelCase)

Description

penaltyDiscount

Scalar β‰₯ 0. Penalizes model complexity; smaller values reduce the penalty (denser models).

semBicStructurePrior

Strength of the structure prior (0 = none).

semBicRule

Choice of penalty-rule variant for SEM-BIC.

precomputeCovariances

Boolean. Precompute covariance matrix for speed.

singularityLambda

Ridge regularization added to covariance matrix diagonal.

effectiveSampleSize

Override for sample size (useful for weighted or subsampled data).

15.6.2. FGES Parameters (Inherited)

Parameter (camelCase)

Description

faithfulnessAssumed

Boolean. If true, pruning uses stricter heuristics.

numRestarts

Number of restart attempts for escaping local optima.

useDataOrder

Boolean. If true, variable order influences heuristics.

maxDegree

Maximum degree limit for the output graph.

verbose

Boolean. Print progress messages.

(Your FGES implementation may include additional parametersβ€”these can be added here the same way.)

15.6.3. ImagES-Specific Parameters

Parameter (camelCase)

Description

randomSelectionSize

Number of subsets drawn in each resampling/aggregation round.

timeLag

Integer. Time-lag used for temporal modeling; 0 for untimed data.

imagesMetaAlg

Meta-algorithm choice (e.g., majority vote, weighted vote, etc.).

verbose

Boolean. Controls ImagES-level verbosity.

15.7. FASK Parameters

The FASK algorithm includes parameters inherited from its base algorithm (typically FGES or GES), plus FASK-specific parameters used for skew-based orientation.

15.7.1. Base Algorithm Parameters (Inherited)

If a base algorithm is supplied, its parameters are included here. For example, if FASK wraps FGES, all FGES parameters apply.

(You can insert the FGES table here if desired.)

15.7.2. FASK-Specific Parameters

Parameter (camelCase)

Description

depth

Depth of adjacency search (as in PC/FCI-style pruning).

skewEdgeThreshold

Minimum absolute skewness needed for considering a skew-based orientation.

alpha

Significance level for independence tests used during pruning/refinement.

faskDelta

Threshold for detecting left-right orientation via conditional expectations.

faskLeftRightRule

Boolean. Enables the left-right orientation rule based on skew differences.

15.8. Reference

FaskVote builds directly on:

  • IMaGES (multi-dataset FGES)
    Ramsey, J., Hanson, S. J., Hanson, C., Halchenko, Y., Poldrack, R., & Glymour, C. (2010).
    Six problems for causal inference from fMRI. NeuroImage, 49(2), 1545–1558.
    (IMaGES is introduced and discussed in this and related work.)

  • FASK (Fast Adjacency Skewness)
    Sanchez-Romero, R., Ramsey, J., Zhang, K., Glymour, C., Huang, B., & Spirtes, P. (2019).
    Causal discovery of feedback networks with functional interventions.
    Proceedings of the Conference on Causal Learning and Reasoning (CLeaR).
    (FASK is described in detail in the supplementary materials.)

There is no separate paper devoted solely to FaskVote; it is an extension that combines these two ideas.

15.9. Summary

FaskVote is an multi-dataset voting wrapper: it uses IMaGES to learn a consensus adjacency graph and then applies FASK to each dataset to determine edge direction, combining these via a simple majority vote. It is useful when you have many related datasets and want a non-Gaussian, skewness-based group-level orientation mechanism without resorting to bootstrapping a single dataset.