Workflow#

This guide explains the canonical workflow for extracting a backbone from a network.

The score-then-filter pattern#

Most backbone methods follow a two-step process:

Apply a backbone method to the original graph. This returns a copy of the graph with a new edge attribute containing a score (p-value, similarity coefficient, salience, etc.).
Apply a filter from the filters module to select the edges that form the backbone.

import networkx as nx
import networkx_backbone as nb

G = nx.les_miserables_graph()

# Step 1: Score
H = nb.disparity_filter(G)

# Step 2: Filter
backbone = nb.threshold_filter(H, "disparity_pvalue", 0.05)

Score attributes by method#

Each method adds a specific edge attribute to the returned graph. Use this attribute name when calling a filter function.

Method	Edge Attribute	Interpretation
`disparity_filter()`	`disparity_pvalue`	p-value (lower = more significant)
`noise_corrected_filter()`	`nc_score`	z-score (higher = more significant)
`marginal_likelihood_filter()`	`ml_pvalue`	p-value (lower = more significant)
`ecm_filter()`	`ecm_pvalue`	p-value (lower = more significant)
`lans_filter()`	`lans_pvalue`	p-value (lower = more significant)
`multiple_linkage_analysis()`	`mla_pvalue` + `mla_keep`	p-value + boolean keep flag
`global_threshold_filter()`	`global_threshold_keep`	Boolean keep flag
`strongest_n_ties()`	`strongest_n_ties_keep`	Boolean keep flag
`global_sparsification()`	`global_sparsification_keep`	Boolean keep flag
`primary_linkage_analysis()`	`primary_linkage_keep`	Boolean keep flag
`edge_betweenness_filter()`	`edge_betweenness` + `edge_betweenness_keep`	centrality score + boolean keep flag
`node_degree_filter()`	`node_degree_keep` (node + edge)	Boolean keep flag
`high_salience_skeleton()`	`salience`	Fraction in [0, 1] (higher = more important)
`metric_backbone()`	`metric_keep`	Boolean keep flag
`ultrametric_backbone()`	`ultrametric_keep`	Boolean keep flag
`doubly_stochastic_filter()`	`ds_weight`	Normalized weight (higher = more important)
`h_backbone()`	`h_backbone_keep`	Boolean keep flag
`glab_filter()`	`glab_pvalue`	p-value (lower = more significant)
`neighborhood_overlap()`	`overlap`	Count (higher = more embedded)
`jaccard_backbone()`	`jaccard`	Coefficient in [0, 1] (higher = more embedded)
`dice_backbone()`	`dice`	Coefficient in [0, 1] (higher = more embedded)
`cosine_backbone()`	`cosine`	Coefficient in [0, 1] (higher = more embedded)
`hub_promoted_index()`	`hpi`	Index (higher = more embedded)
`hub_depressed_index()`	`hdi`	Index (higher = more embedded)
`lhn_local_index()`	`lhn_local`	Index (higher = more embedded)
`preferential_attachment_score()`	`pa`	Score (higher = more expected)
`adamic_adar_index()`	`adamic_adar`	Score (higher = more embedded)
`resource_allocation_index()`	`resource_allocation`	Score (higher = more embedded)
`graph_distance_proximity()`	`dist`	Reciprocal distance (higher = closer)
`local_path_index()`	`lp`	Score (higher = more embedded)
`sparsify()` / `lspar()` / `local_degree()`	`sparsify_score` + `sparsify_keep`	score + boolean keep flag
`sdsm()`	`sdsm_pvalue`	p-value (lower = more significant)
`fdsm()`	`fdsm_pvalue`	p-value (lower = more significant)
`modularity_backbone()`	`vitality` (node) + `modularity_keep` (edge)	node score + boolean keep flag

Filtering functions#

The filters module provides filtering functions and graph-preparation support utilities.

multigraph_to_weighted()

Convert MultiGraph / MultiDiGraph inputs into weighted simple graphs by collapsing parallel edges. Use edge_type_attr to count distinct edge types per node pair:

weighted_simple = nb.multigraph_to_weighted(MG, edge_type_attr="edge_type")

The high-level backbone_from_weighted() wrapper applies this conversion automatically for multigraph inputs by default.

threshold_filter()

Keep edges where the score is below (for p-values) or above (for importance scores) a given threshold. Use mode="below" for p-values and mode="above" for importance scores. By default, all input nodes are kept; set include_all_nodes=False to drop isolates:

# For p-values (keep low values)
backbone = nb.threshold_filter(H, "disparity_pvalue", 0.05)

# For scores (keep high values)
backbone = nb.threshold_filter(H, "salience", 0.5, mode="above")

# Optionally remove isolate nodes after edge filtering
backbone = nb.threshold_filter(H, "disparity_pvalue", 0.05, include_all_nodes=False)

fraction_filter()

Keep a fixed fraction of edges, sorted by score. Use ascending=True to keep the smallest scores (p-values) or ascending=False to keep the largest scores:

# Keep the 20% most significant edges
backbone = nb.fraction_filter(H, "disparity_pvalue", 0.2, ascending=True)

boolean_filter()

Keep edges where a boolean attribute is truthy:

H = nb.global_sparsification(G, s=0.4)
backbone = nb.boolean_filter(H, "global_sparsification_keep")

consensus_backbone()

Take the intersection of multiple backbones – only edges present in all input backbones are kept:

b1 = nb.threshold_filter(nb.disparity_filter(G), "disparity_pvalue", 0.05)
b2 = nb.boolean_filter(nb.metric_backbone(G), "metric_keep")
consensus = nb.consensus_backbone(b1, b2)

Visual comparison#

Use visualization helpers to compare an original graph with a backbone and highlight dropped structure:

backbone = nb.threshold_filter(
    nb.disparity_filter(G), "disparity_pvalue", 0.05, include_all_nodes=False
)
fig, ax, diff = nb.compare_graphs(G, backbone, return_diff=True)
print(f"Removed nodes: {len(diff['removed_nodes'])}")

Methods with boolean keep flags#

Several methods provide built-in boolean edge attributes specifically for the filter step. Apply boolean_filter() to extract the final backbone:

global_threshold_filter() -> global_threshold_keep
strongest_n_ties() -> strongest_n_ties_keep
global_sparsification() -> global_sparsification_keep
primary_linkage_analysis() -> primary_linkage_keep
edge_betweenness_filter() -> edge_betweenness_keep
node_degree_filter() -> node_degree_keep
metric_backbone() -> metric_keep
ultrametric_backbone() -> ultrametric_keep
h_backbone() -> h_backbone_keep
modularity_backbone() -> modularity_keep
planar_maximally_filtered_graph() -> pmfg_keep
maximum_spanning_tree_backbone() -> mst_keep
multiple_linkage_analysis() -> mla_keep
sparsify() / lspar() / local_degree() -> sparsify_keep

For bipartite projections, sdsm() and fdsm() return full projected graphs with p-values (sdsm_pvalue / fdsm_pvalue), which you can then filter with threshold_filter(). Use projection= to attach simple, hyper, probs, or ycn projection weights.

Function Image Reference#

These static snapshots from docs/_static/graph_gallery/ map functions to their score-then-filter visual outcomes.

Workflow#

The score-then-filter pattern#

Score attributes by method#

Filtering functions#

Visual comparison#

Methods with boolean keep flags#

Function Image Reference#

Hybrid (Les Miserables)#

Proximity (Les Miserables)#

Statistical (Les Miserables)#

Structural (Les Miserables)#

Unweighted (Les Miserables)#

Bipartite (Davis Southern Women)#

This Page