[gpuCI] Auto-merge branch-0.17 to branch-0.18 [skip ci]

CHANGELOG.md

@@ -9,6 +9,7 @@
 - PR #1274 Add generic from_edgelist() and from_adjlist() APIs
 - PR #1279 Add self loop check variable in graph
 - PR #1277 SciPy sparse matrix input support for WCC, SCC, SSSP, and BFS
+- PR #1278 Add support for shortest_path_length and fix graph vertex checks
 
 ## Improvements
 - PR #1227 Pin cmake policies to cmake 3.17 version

python/cugraph/__init__.py

@@ -77,6 +77,7 @@
  sssp,
  shortest_path,
  filter_unreachable,
+ shortest_path_length
 )
 
 from cugraph.tree import minimum_spanning_tree, maximum_spanning_tree

python/cugraph/structure/graph.py

@@ -1322,7 +1322,7 @@ def has_node(self, n):
  return (ddf == n).any().any().compute()
  if self.renumbered:
  tmp = self.renumber_map.to_internal_vertex_id(cudf.Series([n]))
- return tmp[0] >= 0
+ return tmp[0] is not cudf.NA and tmp[0] >= 0
  else:
  df = self.edgelist.edgelist_df[["src", "dst"]]
  return (df == n).any().any()

python/cugraph/tests/test_graph.py

@@ -606,6 +606,15 @@ def test_has_node(graph_file):
  assert G.has_node(n)
 
 
+def test_invalid_has_node():
+ df = cudf.DataFrame([[1, 2]], columns=["src", "dst"])
+ G = cugraph.Graph()
+ G.from_cudf_edgelist(df, source="src", destination="dst")
+ assert not G.has_node(-1)
+ assert not G.has_node(0)
+ assert not G.has_node(G.number_of_nodes() + 1)
+
+
 @pytest.mark.parametrize('graph_file', utils.DATASETS)
 def test_bipartite_api(graph_file):
  # This test only tests the functionality of adding set of nodes and

python/cugraph/tests/test_paths.py

@@ -0,0 +1,177 @@
+import cudf
+import cugraph
+from cupy.sparse import coo_matrix as cupy_coo_matrix
+import cupy
+import networkx as nx
+import pytest
+import sys
+from tempfile import NamedTemporaryFile
+
+CONNECTED_GRAPH = """1,5,3
+1,4,1
+1,2,1
+1,6,2
+1,7,2
+4,5,1
+2,3,1
+7,6,2
+"""
+
+DISCONNECTED_GRAPH = CONNECTED_GRAPH + "8,9,4"
+
+
+@pytest.fixture
+def graphs(request):
+ with NamedTemporaryFile(mode="w+", suffix=".csv") as graph_tf:
+ graph_tf.writelines(request.param)
+ graph_tf.seek(0)
+
+ nx_G = nx.read_weighted_edgelist(graph_tf.name, delimiter=',')
+ cudf_df = cudf.read_csv(graph_tf.name,
+ names=["src", "dst", "data"],
+ delimiter=",",
+ dtype=["int32", "int32", "float64"])
+ cugraph_G = cugraph.Graph()
+ cugraph_G.from_cudf_edgelist(
+ cudf_df, source="src",
+ destination="dst", edge_attr="data")
+
+ # construct cupy coo_matrix graph
+ i = []
+ j = []
+ weights = []
+ for index in range(cudf_df.shape[0]):
+ vertex1 = cudf_df.iloc[index]["src"]
+ vertex2 = cudf_df.iloc[index]["dst"]
+ weight = cudf_df.iloc[index]["data"]
+ i += [vertex1, vertex2]
+ j += [vertex2, vertex1]
+ weights += [weight, weight]
+ i = cupy.array(i)
+ j = cupy.array(j)
+ weights = cupy.array(weights)
+ largest_vertex = max(cupy.amax(i), cupy.amax(j))
+ cupy_df = cupy_coo_matrix(
+ (weights, (i, j)),
+ shape=(largest_vertex + 1, largest_vertex + 1))
+
+ yield cugraph_G, nx_G, cupy_df
+
+
+@pytest.mark.parametrize("graphs", [CONNECTED_GRAPH], indirect=True)
+def test_connected_graph_shortest_path_length(graphs):
+ cugraph_G, nx_G, cupy_df = graphs
+
+ path_1_to_1_length = cugraph.shortest_path_length(cugraph_G, 1, 1)
+ assert path_1_to_1_length == 0.0
+ assert path_1_to_1_length == nx.shortest_path_length(
+ nx_G, "1", target="1", weight="weight")
+ assert path_1_to_1_length == cugraph.shortest_path_length(nx_G, "1", "1")
+ assert path_1_to_1_length == cugraph.shortest_path_length(cupy_df, 1, 1)
+
+ path_1_to_5_length = cugraph.shortest_path_length(cugraph_G, 1, 5)
+ assert path_1_to_5_length == 2.0
+ assert path_1_to_5_length == nx.shortest_path_length(
+ nx_G, "1", target="5", weight="weight")
+ assert path_1_to_5_length == cugraph.shortest_path_length(nx_G, "1", "5")
+ assert path_1_to_5_length == cugraph.shortest_path_length(cupy_df, 1, 5)
+
+ path_1_to_3_length = cugraph.shortest_path_length(cugraph_G, 1, 3)
+ assert path_1_to_3_length == 2.0
+ assert path_1_to_3_length == nx.shortest_path_length(
+ nx_G, "1", target="3", weight="weight")
+ assert path_1_to_3_length == cugraph.shortest_path_length(nx_G, "1", "3")
+ assert path_1_to_3_length == cugraph.shortest_path_length(cupy_df, 1, 3)
+
+ path_1_to_6_length = cugraph.shortest_path_length(cugraph_G, 1, 6)
+ assert path_1_to_6_length == 2.0
+ assert path_1_to_6_length == nx.shortest_path_length(
+ nx_G, "1", target="6", weight="weight")
+ assert path_1_to_6_length == cugraph.shortest_path_length(nx_G, "1", "6")
+ assert path_1_to_6_length == cugraph.shortest_path_length(cupy_df, 1, 6)
+
+
+@pytest.mark.parametrize("graphs", [CONNECTED_GRAPH], indirect=True)
+def test_shortest_path_length_invalid_source(graphs):
+ cugraph_G, nx_G, cupy_df = graphs
+
+ with pytest.raises(ValueError):
+ cugraph.shortest_path_length(cugraph_G, -1, 1)
+
+ with pytest.raises(ValueError):
+ cugraph.shortest_path_length(nx_G, "-1", "1")
+
+ with pytest.raises(ValueError):
+ cugraph.shortest_path_length(cupy_df, -1, 1)
+
+
+@pytest.mark.parametrize("graphs", [DISCONNECTED_GRAPH], indirect=True)
+def test_shortest_path_length_invalid_target(graphs):
+ cugraph_G, nx_G, cupy_df = graphs
+
+ with pytest.raises(ValueError):
+ cugraph.shortest_path_length(cugraph_G, 1, 10)
+
+ with pytest.raises(ValueError):
+ cugraph.shortest_path_length(nx_G, "1", "10")
+
+ with pytest.raises(ValueError):
+ cugraph.shortest_path_length(cupy_df, 1, 10)
+
+
+@pytest.mark.parametrize("graphs", [CONNECTED_GRAPH], indirect=True)
+def test_shortest_path_length_invalid_vertexes(graphs):
+ cugraph_G, nx_G, cupy_df = graphs
+
+ with pytest.raises(ValueError):
+ cugraph.shortest_path_length(cugraph_G, 0, 42)
+
+ with pytest.raises(ValueError):
+ cugraph.shortest_path_length(nx_G, "0", "42")
+
+ with pytest.raises(ValueError):
+ cugraph.shortest_path_length(cupy_df, 0, 42)
+
+
+@pytest.mark.parametrize("graphs", [DISCONNECTED_GRAPH], indirect=True)
+def test_shortest_path_length_no_path(graphs):
+ cugraph_G, nx_G, cupy_df = graphs
+
+ path_1_to_8 = cugraph.shortest_path_length(cugraph_G, 1, 8)
+ assert path_1_to_8 == sys.float_info.max
+ assert path_1_to_8 == cugraph.shortest_path_length(nx_G, "1", "8")
+ assert path_1_to_8 == cugraph.shortest_path_length(cupy_df, 1, 8)
+
+
+@pytest.mark.parametrize("graphs", [DISCONNECTED_GRAPH], indirect=True)
+def test_shortest_path_length_no_target(graphs):
+ cugraph_G, nx_G, cupy_df = graphs
+
+ cugraph_path_1_to_all = cugraph.shortest_path_length(cugraph_G, 1)
+ nx_path_1_to_all = nx.shortest_path_length(
+ nx_G, source="1", weight="weight")
+ nx_gpu_path_1_to_all = cugraph.shortest_path_length(nx_G, "1")
+ cupy_path_1_to_all = cugraph.shortest_path_length(cupy_df, 1)
+
+ # Cast networkx graph on cugraph vertex column type from str to int.
+ # SSSP preserves vertex type, convert for comparison
+ nx_gpu_path_1_to_all["vertex"] = \
+ nx_gpu_path_1_to_all["vertex"].astype("int32")
+
+ assert cugraph_path_1_to_all == nx_gpu_path_1_to_all
+ assert cugraph_path_1_to_all == cupy_path_1_to_all
+
+ # results for vertex 8 and 9 are not returned
+ assert cugraph_path_1_to_all.shape[0] == len(nx_path_1_to_all) + 2
+
+ for index in range(cugraph_path_1_to_all.shape[0]):
+
+ vertex = str(cugraph_path_1_to_all["vertex"][index].item())
+ distance = cugraph_path_1_to_all["distance"][index].item()
+
+ # verify cugraph against networkx
+ if vertex in {'8', '9'}:
+ # Networkx does not return distances for these vertexes.
+ assert distance == sys.float_info.max
+ else:
+ assert distance == nx_path_1_to_all[vertex]

python/cugraph/traversal/__init__.py

@@ -13,6 +13,9 @@
 
 from cugraph.traversal.bfs import bfs
 from cugraph.traversal.bfs import bfs_edges
-from cugraph.traversal.sssp import sssp
-from cugraph.traversal.sssp import shortest_path
-from cugraph.traversal.sssp import filter_unreachable
+from cugraph.traversal.sssp import (
+ sssp,
+ shortest_path,
+ filter_unreachable,
+ shortest_path_length
+)

python/cugraph/traversal/sssp.py

@@ -156,12 +156,26 @@ def sssp(G,
 
  Parameters
  ----------
+<<<<<<< HEAD
  graph : cugraph.Graph, networkx.Graph, CuPy or SciPy sparse matrix Graph or
  matrix object, which should contain the connectivity information. Edge
  weights, if present, should be single or double precision floating
  point values.
  source : int
  Index of the source vertex.
+=======
+ graph : cuGraph.Graph, NetworkX.Graph, or CuPy sparse COO matrix
+ cuGraph graph descriptor with connectivity information. Edge weights,
+ if present, should be single or double precision floating point values.
+
+ source : Dependant on graph type. Index of the source vertex.
+
+ If graph is an instance of cuGraph.Graph or CuPy sparse COO matrix:
+ int
+
+ If graph is an instance of a NetworkX.Graph:
+ str
+>>>>>>> Document shortest_path_length and sssp behavior
 
  Returns
  -------
@@ -214,6 +228,10 @@ def sssp(G,
  if G.renumbered:
  source = G.lookup_internal_vertex_id(cudf.Series([source]))[0]
 
+ if source is cudf.NA:
+ raise ValueError(
+ "Starting vertex should be between 0 to number of vertices")
+
  df = sssp_wrapper.sssp(G, source)
 
  if G.renumbered:
@@ -268,3 +286,83 @@ def shortest_path(G,
  """
  return sssp(G, source, method, directed, return_predecessors,
  unweighted, overwrite, indices)
+
+
+def shortest_path_length(G, source, target=None):
+ """
+ Compute the distance from a source vertex to one or all vertexes in graph.
+ Uses Single Source Shortest Path (SSSP).
+
+ Parameters
+ ----------
+ graph : cuGraph.Graph, NetworkX.Graph, or CuPy sparse COO matrix
+ cuGraph graph descriptor with connectivity information. Edge weights,
+ if present, should be single or double precision floating point values.
+
+ source : Dependant on graph type. Index of the source vertex.
+
+ If graph is an instance of cuGraph.Graph or CuPy sparse COO matrix:
+ int
+
+ If graph is an instance of a NetworkX.Graph:
+ str
+
+ target: Dependant on graph type. Vertex to find distance to.
+
+ If graph is an instance of cuGraph.Graph or CuPy sparse COO matrix:
+ int
+
+ If graph is an instance of a NetworkX.Graph:
+ str
+
+ Returns
+ -------
+ Return value type is based on the input type.
+
+ If target is None, returns:
+
+ cudf.DataFrame
+ df['vertex']
+ vertex id
+
+ df['distance']
+ gives the path distance from the starting vertex
+
+ If target is not None, returns:
+
+ Distance from source to target vertex.
+ """
+
+ # verify target is in graph before traversing
+ if target is not None:
+ if not hasattr(G, "has_node"):
+ # G is a cupy coo_matrix. Extract maximum possible vertex value
+ as_matrix = G.toarray()
+ if target < 0 or target >= max(as_matrix.shape[0],
+ as_matrix.shape[1]):
+ raise ValueError("Graph does not contain target vertex")
+ elif not G.has_node(target):
+ # G is an instance of cugraph or networkx graph
+ raise ValueError("Graph does not contain target vertex")
+
+ df = sssp(G, source)
+
+ if isinstance(df, tuple):
+ # cupy path, df is tuple of (distance, predecessor)
+ if target:
+ return df[0][target-1]
+ results = cudf.DataFrame()
+ results["vertex"] = range(df[0].shape[0])
+ results["distance"] = df[0]
+ return results
+
+ else:
+ # cugraph and networkx path
+ if target:
+ target_distance = df.loc[df["vertex"] == target]
+ return target_distance.iloc[0]["distance"]
+
+ results = cudf.DataFrame()
+ results["vertex"] = df["vertex"]
+ results["distance"] = df["distance"]
+ return results