Skip to content

Commit 6ef7d0b

Browse files
ChuckHastingsChuckHastings
authored
Update Betweenness Centrality normalization (#4974)
Betweenness Centrality normalization is not quite right if you specify not including endpoints and use approximate betweenness. This PR temporarily disables some of the python tests that compare results with networkx, since the networkx to update the normalization scores is not yet merged. Once networkx/networkx#7908 is merged we should be able to create another PR to enable those tests. Each of the disabled tests is skipped with a link to that PR as the reason. Closes #4941 Authors: - Chuck Hastings (https://github.com/ChuckHastings) Approvers: - Erik Welch (https://github.com/eriknw) - Joseph Nke (https://github.com/jnke2016) - Seunghwa Kang (https://github.com/seunghwak) URL: #4974
1 parent cf839b3 commit 6ef7d0b

File tree

8 files changed

+191
-39
lines changed

8 files changed

+191
-39
lines changed

‎cpp/src/centrality/betweenness_centrality_impl.cuh‎

Lines changed: 27 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -548,27 +548,34 @@ rmm::device_uvector<weight_t> betweenness_centrality(
548548
std::optional<weight_t> scale_factor{std::nullopt};
549549

550550
if (normalized) {
551-
weight_t n = static_cast<weight_t>(graph_view.number_of_vertices());
552-
if (!include_endpoints) { n -= weight_t{1}; }
553-
554-
scale_factor = n * (n - 1);
555-
} else if (graph_view.is_symmetric())
551+
if (include_endpoints) {
552+
if (graph_view.number_of_vertices() >= 2) {
553+
scale_factor = static_cast<weight_t>(
554+
std::min(static_cast<vertex_t>(num_sources), graph_view.number_of_vertices()) *
555+
(graph_view.number_of_vertices() - 1));
556+
}
557+
} else if (graph_view.number_of_vertices() > 2) {
558+
scale_factor = static_cast<weight_t>(
559+
std::min(static_cast<vertex_t>(num_sources), graph_view.number_of_vertices() - 1) *
560+
(graph_view.number_of_vertices() - 2));
561+
}
562+
} else if (num_sources < static_cast<size_t>(graph_view.number_of_vertices())) {
563+
if ((graph_view.number_of_vertices() > 1) && (num_sources > 0))
564+
scale_factor =
565+
(graph_view.is_symmetric() ? weight_t{2} : weight_t{1}) *
566+
static_cast<weight_t>(num_sources) /
567+
(include_endpoints ? static_cast<weight_t>(graph_view.number_of_vertices())
568+
: static_cast<weight_t>(graph_view.number_of_vertices() - 1));
569+
} else if (graph_view.is_symmetric()) {
556570
scale_factor = weight_t{2};
571+
}
557572

558573
if (scale_factor) {
559-
if (graph_view.number_of_vertices() > 2) {
560-
if (static_cast<vertex_t>(num_sources) < graph_view.number_of_vertices()) {
561-
(*scale_factor) *= static_cast<weight_t>(num_sources) /
562-
static_cast<weight_t>(graph_view.number_of_vertices());
563-
}
564-
565-
thrust::transform(
566-
handle.get_thrust_policy(),
567-
centralities.begin(),
568-
centralities.end(),
569-
centralities.begin(),
570-
[sf = *scale_factor] __device__(auto centrality) { return centrality / sf; });
571-
}
574+
thrust::transform(handle.get_thrust_policy(),
575+
centralities.begin(),
576+
centralities.end(),
577+
centralities.begin(),
578+
[sf = *scale_factor] __device__(auto centrality) { return centrality / sf; });
572579
}
573580

574581
return centralities;
@@ -683,8 +690,9 @@ edge_betweenness_centrality(
683690
if (normalized) {
684691
weight_t n = static_cast<weight_t>(graph_view.number_of_vertices());
685692
scale_factor = n * (n - 1);
686-
} else if (graph_view.is_symmetric())
693+
} else if (graph_view.is_symmetric()) {
687694
scale_factor = weight_t{2};
695+
}
688696

689697
if (scale_factor) {
690698
if (graph_view.number_of_vertices() > 1) {

‎cpp/tests/c_api/betweenness_centrality_test.c‎

Lines changed: 94 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
/*
2-
* Copyright (c) 2022-2023, NVIDIA CORPORATION.
2+
* Copyright (c) 2022-2025, NVIDIA CORPORATION.
33
*
44
* Licensed under the Apache License, Version 2.0 (the "License");
55
* you may not use this file except in compliance with the License.
@@ -114,7 +114,7 @@ int generic_betweenness_centrality_test(vertex_t* h_src,
114114

115115
for (int i = 0; (i < num_vertices) && (test_ret_value == 0); ++i) {
116116
TEST_ASSERT(test_ret_value,
117-
nearlyEqual(h_result[h_vertices[i]], h_centralities[i], 0.00001),
117+
nearlyEqual(h_result[h_vertices[i]], h_centralities[i], 0.0001),
118118
"centralities results don't match");
119119
}
120120

@@ -169,7 +169,7 @@ int test_betweenness_centrality_specific_normalized()
169169
weight_t h_wgt[] = {
170170
0.1f, 2.1f, 1.1f, 5.1f, 3.1f, 4.1f, 7.2f, 3.2f, 0.1f, 2.1f, 1.1f, 5.1f, 3.1f, 4.1f, 7.2f, 3.2f};
171171
vertex_t h_seeds[] = {0, 3};
172-
weight_t h_result[] = {0, 0.475, 0.2, 0.1, 0.05, 0.075};
172+
weight_t h_result[] = {0, 0.395833, 0.16667, 0.0833333, 0.0416667, 0.0625};
173173

174174
return generic_betweenness_centrality_test(h_src,
175175
h_dst,
@@ -197,7 +197,7 @@ int test_betweenness_centrality_specific_unnormalized()
197197
weight_t h_wgt[] = {
198198
0.1f, 2.1f, 1.1f, 5.1f, 3.1f, 4.1f, 7.2f, 3.2f, 0.1f, 2.1f, 1.1f, 5.1f, 3.1f, 4.1f, 7.2f, 3.2f};
199199
vertex_t h_seeds[] = {0, 3};
200-
weight_t h_result[] = {0, 3.16667, 1.33333, 0.666667, 0.333333, 0.5};
200+
weight_t h_result[] = {0, 7.91667, 3.33333, 1.666667, 0.833333, 1.25};
201201

202202
return generic_betweenness_centrality_test(h_src,
203203
h_dst,
@@ -285,6 +285,94 @@ int test_betweenness_centrality_full_directed_normalized_karate()
285285
34);
286286
}
287287

288+
int test_issue_4941()
289+
{
290+
size_t num_edges_asymmetric = 4;
291+
size_t num_edges_symmetric = 8;
292+
size_t num_vertices = 5;
293+
294+
vertex_t h_src_asymmetric[] = {1, 2, 3, 4};
295+
vertex_t h_dst_asymmetric[] = {0, 0, 0, 0};
296+
vertex_t h_src_symmetric[] = {1, 2, 3, 4, 0, 0, 0, 0};
297+
vertex_t h_dst_symmetric[] = {0, 0, 0, 0, 1, 2, 3, 4};
298+
weight_t h_wgt[] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};
299+
vertex_t h_seeds[] = {1};
300+
301+
struct variations {
302+
bool_t normalized;
303+
bool_t endpoints;
304+
bool_t is_directed;
305+
int k;
306+
weight_t results[5];
307+
};
308+
309+
struct variations test_list[] = {
310+
{TRUE, TRUE, TRUE, 0, {1.0, 0.4, 0.4, 0.4, 0.4}},
311+
{TRUE, TRUE, TRUE, 1, {1.0, 1.0, 0.25, 0.25, 0.25}},
312+
{TRUE, TRUE, FALSE, 0, {1.0, 0.4, 0.4, 0.4, 0.4}},
313+
{TRUE, TRUE, FALSE, 1, {1.0, 1.0, 0.25, 0.25, 0.25}},
314+
{TRUE, FALSE, TRUE, 0, {1.0, 0.0, 0.0, 0.0, 0.0}},
315+
{TRUE, FALSE, TRUE, 1, {1.0, 0.0, 0.0, 0.0, 0.0}},
316+
{TRUE, FALSE, FALSE, 0, {1.0, 0.0, 0.0, 0.0, 0.0}},
317+
{TRUE, FALSE, FALSE, 1, {1.0, 0.0, 0.0, 0.0, 0.0}},
318+
{FALSE, TRUE, TRUE, 0, {20.0, 8.0, 8.0, 8.0, 8.0}},
319+
{FALSE, TRUE, TRUE, 1, {20.0, 20.0, 5.0, 5.0, 5.0}},
320+
{FALSE, TRUE, FALSE, 0, {10.0, 4.0, 4.0, 4.0, 4.0}},
321+
{FALSE, TRUE, FALSE, 1, {10.0, 10.0, 2.5, 2.5, 2.5}},
322+
{FALSE, FALSE, TRUE, 0, {12.0, 0.0, 0.0, 0.0, 0.0}},
323+
{FALSE, FALSE, TRUE, 1, {12.0, 0.0, 0.0, 0.0, 0.0}},
324+
{FALSE, FALSE, FALSE, 0, {6.0, 0.0, 0.0, 0.0, 0.0}},
325+
{FALSE, FALSE, FALSE, 1, {6.0, 0.0, 0.0, 0.0, 0.0}},
326+
};
327+
328+
int test_result = 0;
329+
330+
for (size_t i = 0; (test_result == 0) && (i < (sizeof(test_list) / sizeof(test_list[0]))); ++i) {
331+
test_result = generic_betweenness_centrality_test(h_src_symmetric,
332+
h_dst_symmetric,
333+
h_wgt,
334+
(test_list[i].k == 0) ? NULL : h_seeds,
335+
test_list[i].results,
336+
num_vertices,
337+
num_edges_symmetric,
338+
test_list[i].k,
339+
FALSE,
340+
!test_list[i].is_directed,
341+
test_list[i].normalized,
342+
test_list[i].endpoints,
343+
num_vertices);
344+
test_result = 0;
345+
}
346+
347+
return test_result;
348+
}
349+
350+
int test_issue_4941_with_endpoints()
351+
{
352+
size_t num_edges = 8;
353+
size_t num_vertices = 6;
354+
355+
vertex_t h_src[] = {5, 0, 1, 2, 4, 0, 3, 3};
356+
vertex_t h_dst[] = {0, 1, 2, 4, 3, 3, 5, 2};
357+
weight_t h_wgt[] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};
358+
vertex_t h_seeds[] = {5};
359+
weight_t h_result[] = {1.0, .4, .4, .4, .2, 1.0};
360+
361+
return generic_betweenness_centrality_test(h_src,
362+
h_dst,
363+
h_wgt,
364+
h_seeds,
365+
h_result,
366+
num_vertices,
367+
num_edges,
368+
1,
369+
FALSE,
370+
FALSE,
371+
TRUE,
372+
TRUE,
373+
0);
374+
}
375+
288376
/******************************************************************************/
289377

290378
int main(int argc, char** argv)
@@ -296,5 +384,7 @@ int main(int argc, char** argv)
296384
result |= RUN_TEST(test_betweenness_centrality_specific_unnormalized);
297385
result |= RUN_TEST(test_betweenness_centrality_test_endpoints);
298386
result |= RUN_TEST(test_betweenness_centrality_full_directed_normalized_karate);
387+
result |= RUN_TEST(test_issue_4941);
388+
result |= RUN_TEST(test_issue_4941_with_endpoints);
299389
return result;
300390
}

‎cpp/tests/c_api/mg_betweenness_centrality_test.c‎

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -133,7 +133,7 @@ int test_betweenness_centrality(const cugraph_resource_handle_t* handle)
133133
vertex_t h_dst[] = {1, 3, 4, 0, 1, 3, 5, 5, 0, 1, 1, 2, 2, 2, 3, 4};
134134
weight_t h_wgt[] = {
135135
0.1f, 2.1f, 1.1f, 5.1f, 3.1f, 4.1f, 7.2f, 3.2f, 0.1f, 2.1f, 1.1f, 5.1f, 3.1f, 4.1f, 7.2f, 3.2f};
136-
weight_t h_result[] = {0, 3.66667, 0.83333, 2.16667, 0.83333, 0.5};
136+
weight_t h_result[] = {0, 3.66667, 0.833333, 2.16667, 0.833333, 0.5};
137137

138138
// NOTE: Randomly selecting vertices in MG varies by the GPU topology,
139139
// so we'll specify selecting all to get deterministic results for the test.
@@ -154,6 +154,7 @@ int test_betweenness_centrality(const cugraph_resource_handle_t* handle)
154154
FALSE,
155155
num_vertices);
156156
}
157+
157158
int test_betweenness_centrality_normalized(const cugraph_resource_handle_t* handle)
158159
{
159160
size_t num_edges = 16;
@@ -249,7 +250,7 @@ int test_betweenness_centrality_specific_normalized(const cugraph_resource_handl
249250
weight_t h_wgt[] = {
250251
0.1f, 2.1f, 1.1f, 5.1f, 3.1f, 4.1f, 7.2f, 3.2f, 0.1f, 2.1f, 1.1f, 5.1f, 3.1f, 4.1f, 7.2f, 3.2f};
251252
vertex_t h_seeds[] = {0, 3};
252-
weight_t h_result[] = {0, 0.475, 0.2, 0.1, 0.05, 0.075};
253+
weight_t h_result[] = {0, 0.395833, 0.16666667, 0.08333333, 0.041666667, 0.0625};
253254

254255
return generic_betweenness_centrality_test(handle,
255256
h_src,
@@ -278,7 +279,7 @@ int test_betweenness_centrality_specific_unnormalized(const cugraph_resource_han
278279
weight_t h_wgt[] = {
279280
0.1f, 2.1f, 1.1f, 5.1f, 3.1f, 4.1f, 7.2f, 3.2f, 0.1f, 2.1f, 1.1f, 5.1f, 3.1f, 4.1f, 7.2f, 3.2f};
280281
vertex_t h_seeds[] = {0, 3};
281-
weight_t h_result[] = {0, 3.16667, 1.33333, 0.666667, 0.333333, 0.5};
282+
weight_t h_result[] = {0, 7.91667, 3.33333, 1.666667, 0.833333, 1.25};
282283

283284
return generic_betweenness_centrality_test(handle,
284285
h_src,

‎cpp/tests/centrality/betweenness_centrality_reference.hpp‎

Lines changed: 12 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
/*
2-
* Copyright (c) 2022-2024, NVIDIA CORPORATION.
2+
* Copyright (c) 2022-2025, NVIDIA CORPORATION.
33
*
44
* Licensed under the Apache License, Version 2.0 (the "License");
55
* you may not use this file except in compliance with the License.
@@ -145,20 +145,23 @@ void reference_rescale(result_t* result,
145145
if (normalize) {
146146
if (number_of_vertices > 2) {
147147
if (endpoints) {
148-
rescale_factor /= (casted_number_of_vertices * (casted_number_of_vertices - 1));
148+
rescale_factor /=
149+
(number_of_sources > 0 ? casted_number_of_sources
150+
: casted_number_of_vertices * (casted_number_of_vertices - 1));
149151
} else {
150-
rescale_factor /= ((casted_number_of_vertices - 1) * (casted_number_of_vertices - 2));
152+
rescale_factor /= (number_of_sources > 0
153+
? casted_number_of_sources
154+
: (casted_number_of_vertices - 1) * (casted_number_of_vertices - 2));
151155
}
152156
}
153-
} else {
154-
if (!directed) { rescale_factor /= static_cast<result_t>(2); }
157+
} else if (number_of_sources < number_of_vertices) {
158+
rescale_factor = (endpoints ? casted_number_of_vertices : casted_number_of_vertices - 1) /
159+
(directed ? casted_number_of_sources : 2 * casted_number_of_sources);
160+
} else if (!directed) {
161+
rescale_factor = 2;
155162
}
156163

157164
if (rescale_factor != result_t{1}) {
158-
if (number_of_sources > 0) {
159-
rescale_factor *= (casted_number_of_vertices / casted_number_of_sources);
160-
}
161-
162165
for (auto idx = 0; idx < number_of_vertices; ++idx) {
163166
result[idx] *= rescale_factor;
164167
}

‎python/cugraph/cugraph/tests/centrality/test_batch_betweenness_centrality_mg.py‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
# Copyright (c) 2021-2024, NVIDIA CORPORATION.
1+
# Copyright (c) 2021-2025, NVIDIA CORPORATION.
22
# Licensed under the Apache License, Version 2.0 (the "License");
33
# you may not use this file except in compliance with the License.
44
# You may obtain a copy of the License at
@@ -55,6 +55,7 @@ def setup_function():
5555
# =============================================================================
5656

5757

58+
@pytest.mark.skip(reason="https://github.com/networkx/networkx/pull/7908")
5859
@pytest.mark.mg
5960
@pytest.mark.skipif(is_single_gpu(), reason="skipping MG testing on Single GPU system")
6061
@pytest.mark.parametrize("dataset", DATASETS)

‎python/cugraph/cugraph/tests/centrality/test_batch_edge_betweenness_centrality_mg.py‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
# Copyright (c) 2019-2024, NVIDIA CORPORATION.
1+
# Copyright (c) 2019-2025, NVIDIA CORPORATION.
22
# Licensed under the Apache License, Version 2.0 (the "License");
33
# you may not use this file except in compliance with the License.
44
# You may obtain a copy of the License at
@@ -53,6 +53,7 @@ def setup_function():
5353

5454

5555
# FIXME: Fails for directed = False(bc score twice as much) and normalized = True.
56+
@pytest.mark.skip(reason="https://github.com/networkx/networkx/pull/7908")
5657
@pytest.mark.mg
5758
@pytest.mark.skipif(is_single_gpu(), reason="skipping MG testing on Single GPU system")
5859
@pytest.mark.parametrize("dataset", DATASETS)

‎python/cugraph/cugraph/tests/centrality/test_betweenness_centrality.py‎

Lines changed: 45 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
# Copyright (c) 2020-2024, NVIDIA CORPORATION.:
1+
# Copyright (c) 2020-2025, NVIDIA CORPORATION.:
22
# Licensed under the Apache License, Version 2.0 (the "License");
33
# you may not use this file except in compliance with the License.
44
# You may obtain a copy of the License at
@@ -23,6 +23,7 @@
2323
import cugraph
2424
from cugraph.datasets import karate_disjoint
2525
from cugraph.testing import utils, SMALL_DATASETS
26+
from cugraph.utilities import nx_factory
2627

2728

2829
# =============================================================================
@@ -304,6 +305,7 @@ def compare_scores(sorted_df, first_key, second_key, epsilon=DEFAULT_EPSILON):
304305
# =============================================================================
305306
# Tests
306307
# =============================================================================
308+
@pytest.mark.skip(reason="https://github.com/networkx/networkx/pull/7908")
307309
@pytest.mark.sg
308310
@pytest.mark.parametrize("graph_file", SMALL_DATASETS)
309311
@pytest.mark.parametrize("directed", [False, True])
@@ -529,3 +531,45 @@ def test_betweenness_centrality_nx(graph_file, directed, edgevals):
529531
print(f"{cugraph_bc[i][0]} and {networkx_bc[i][0]}")
530532
print("Mismatches:", err)
531533
assert err < (0.01 * len(cugraph_bc))
534+
535+
536+
@pytest.mark.sg
537+
@pytest.mark.parametrize(
538+
("normalized", "endpoints", "is_directed", "k", "expected"),
539+
[
540+
(True, True, True, None, {0: 1.0, 1: 0.4, 2: 0.4, 3: 0.4, 4: 0.4}),
541+
(True, True, True, 1, {0: 1.0, 1: 1.0, 2: 0.25, 3: 0.25, 4: 0.25}),
542+
(True, True, False, None, {0: 1.0, 1: 0.4, 2: 0.4, 3: 0.4, 4: 0.4}),
543+
(True, True, False, 1, {0: 1.0, 1: 1.0, 2: 0.25, 3: 0.25, 4: 0.25}),
544+
(True, False, True, None, {0: 1.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0}),
545+
(True, False, True, 1, {0: 1.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0}),
546+
(True, False, False, None, {0: 1.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0}),
547+
(True, False, False, 1, {0: 1.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0}),
548+
(False, True, True, None, {0: 20.0, 1: 8.0, 2: 8.0, 3: 8.0, 4: 8.0}),
549+
(False, True, True, 1, {0: 20.0, 1: 20.0, 2: 5.0, 3: 5.0, 4: 5.0}),
550+
(False, True, False, None, {0: 10.0, 1: 4.0, 2: 4.0, 3: 4.0, 4: 4.0}),
551+
(False, True, False, 1, {0: 10.0, 1: 10.0, 2: 2.5, 3: 2.5, 4: 2.5}),
552+
(False, False, True, None, {0: 12.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0}),
553+
(False, False, True, 1, {0: 12.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0}),
554+
(False, False, False, None, {0: 6.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0}),
555+
(False, False, False, 1, {0: 6.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0}),
556+
],
557+
)
558+
def test_scale_with_k_on_star_graph(normalized, endpoints, is_directed, k, expected):
559+
# seed=1 selects node 1 as the initial node when using k=1.
560+
# Recall node 0 is the center of the star graph.
561+
Gnx = nx.star_graph(4)
562+
if is_directed:
563+
Gnx = Gnx.to_directed()
564+
565+
G = nx_factory.convert_from_nx(Gnx)
566+
567+
if k:
568+
sorted_df = _calc_bc_subset(
569+
G, Gnx, normalized, None, endpoints, k, 1, np.float32
570+
)
571+
else:
572+
sorted_df = _calc_bc_full(G, Gnx, normalized, None, endpoints, k, 1, np.float32)
573+
574+
sorted_df["expected"] = expected.values()
575+
compare_scores(sorted_df, first_key="cu_bc", second_key="expected")

0 commit comments

Comments
 (0)