Dask cuGraph edge-weight behavior appears algorithm-dependent; request clarification and test coverage

[sauravsingla]

Summary

I would like to clarify edge-weight support in Dask / multi-GPU cuGraph.

From the documentation, Dask graph construction appears to support weighted edge lists through from_dask_cudf_edgelist() using edge_attr or weight.

However, edge-weight behavior seems to be algorithm-dependent. Some distributed algorithms appear to support or rely on edge weights, while others document that edge weights are not used.

Documentation references

The Dask graph-construction API documents arguments such as:

Graph.from_dask_cudf_edgelist(
    input_ddf,
    source="source",
    destination="destination",
    edge_attr=None,
    weight=None,
    edge_id=None,
    edge_type=None,
)

The docs say edge_attr can be a single string representing the weight column, or a list containing [weight, edge_id, edge_type]. They also provide a separate weight parameter.

For Dask PageRank, the documentation says the graph should contain connectivity information as a Dask cuDF edge-list dataframe, but edge weights are not used for this algorithm.

For Dask SSSP, the documentation refers to cutoff as the maximum edge-weight sum considered by the algorithm, and examples build a Dask graph using a weighted edge column such as:

dg.from_dask_cudf_edgelist(
    ddf,
    source="src",
    destination="dst",
    edge_attr="value",
)

and then run:

df = dcg.sssp(dg, 0)

Question / concern

Can the cuGraph team clarify the intended support matrix for edge weights in Dask / multi-GPU cuGraph?

Specifically:

1. Are edge weights fully preserved when constructing a Dask cuGraph graph using from_dask_cudf_edgelist()?
2. Which Dask cuGraph algorithms are expected to use edge weights?
3. Which Dask cuGraph algorithms intentionally ignore edge weights?
4. Is there an official weighted-edge support matrix for single-GPU vs Dask / multi-GPU algorithms?
5. Should documentation explicitly call out weighted vs unweighted behavior per algorithm?

Expected behavior

If a Dask graph is constructed with an edge-weight column, users should be able to clearly know whether a given distributed algorithm:

• uses the provided edge weights,
• ignores the edge weights by design, or
• does not support weighted execution.

Suggested improvement

It would be useful to add either:

1. a weighted-edge support matrix in the docs, or
2. a short note in each Dask algorithm page saying whether edge weights are used.

It would also help to have small test examples comparing:

• single-GPU weighted behavior,
• Dask / multi-GPU weighted behavior,
• algorithms that intentionally ignore edge weights.

Why this matters

For fraud, AML, payments, and graph-risk use cases, edge weights often represent transaction amount, risk score, frequency, or relationship strength. In multi-GPU graph analytics, users need to know whether those weights are used consistently across distributed algorithms.

I am also building a small CUDA/cuGraph regression harness to test weighted-edge behavior across single-GPU and Dask/multi-GPU execution, and I can contribute a minimal reproducible example if useful.

Thanks for any clarification.

[ChuckHastings]

I've tagged this as a documentation issue.

The python functions from_*_edgelist create a graph using the edge properties that are provided (weights, types, ids). The SGGraph, or MGGraph object that is created contains these edge properties (they're actually stored in C++ objects).

The algorithms then decide whether or not to use the attributes that are stored based on what they require. A list of algorithms that use require weights:

• SSSP
• Spectral Clustering
• Minimum Spanning Tree
• Approximate Weighted Matching
• Force Atlas 2
• Biased Random Walks
• Biased Sampling

Algorithms that will use weights if they are specified and assume a weight of 1.0 if not specified:

• PageRank/Personalized PageRank (see note below)
• Katz Centrality
• Eigenvector Centrality
• Louvain
• Leiden
• ECG
• Jaccard
• node2vec

Algorithms that do not use weights even if they are present (these algorithms either inherently don't use weights, or our current implementation doesn't use weights):

• BFS
• HITS
• Triangle Count
• Core Number
• Weakly Connected Components
• Strongly Connected Components
• Betweenness Centrality
• Edge Betweenness Centrality

As a note... there is a bug in the PageRank documentation, the python documentation indicates that edge weights are not used, but they are actually used in the C++ code.