Refactor k-core

python/cugraph/CMakeLists.txt

@@ -93,7 +93,6 @@ rapids_cython_init()
 add_subdirectory(cugraph/centrality)
 add_subdirectory(cugraph/community)
 add_subdirectory(cugraph/components)
-add_subdirectory(cugraph/cores)
 add_subdirectory(cugraph/dask/comms)
 add_subdirectory(cugraph/dask/structure)
 add_subdirectory(cugraph/generators)

python/cugraph/cugraph/community/egonet.py

@@ -95,6 +95,13 @@ def ego_graph(G, n, radius=1, center=True, undirected=None, distance=None):
 
  result_graph = type(G)(directed=G.is_directed())
 
+ if not G.edgelist.weights:
+ warning_msg = (
+ "'Ego_graph' requires the input graph to be weighted: Unweighted "
+ "graphs will not be supported in the next release."
+ )
+ warnings.warn(warning_msg, PendingDeprecationWarning)
+
  if undirected is not None:
  warning_msg = (
  "The parameter 'undirected' is deprecated and "

python/cugraph/cugraph/community/leiden.py

@@ -16,6 +16,7 @@
  ensure_cugraph_obj_for_nx,
  df_score_to_dictionary,
 )
+import warnings
 
 
 def leiden(G, max_iter=100, resolution=1.0):
@@ -75,7 +76,11 @@ def leiden(G, max_iter=100, resolution=1.0):
  G, isNx = ensure_cugraph_obj_for_nx(G)
 
  if not G.edgelist.weights:
- raise RuntimeError("input graph must be weighted")
+ warning_msg = (
+ "'Leiden' requires the input graph to be weighted: Unweighted "
+ "graphs will not be supported in the next release."
+ )
+ warnings.warn(warning_msg, PendingDeprecationWarning)
 
  if G.is_directed():
  raise ValueError("input graph must be undirected")

python/cugraph/cugraph/community/louvain.py

@@ -19,6 +19,7 @@
 
 from pylibcugraph import louvain as pylibcugraph_louvain
 from pylibcugraph import ResourceHandle
+import warnings
 
 
 def louvain(G, max_iter=100, resolution=1.0):
@@ -78,7 +79,11 @@ def louvain(G, max_iter=100, resolution=1.0):
  G, isNx = ensure_cugraph_obj_for_nx(G)
 
  if not G.edgelist.weights:
- raise RuntimeError("input graph must be weighted")
+ warning_msg = (
+ "'Louvain' requires the input graph to be weighted: Unweighted "
+ "graphs will not be supported in the next release."
+ )
+ warnings.warn(warning_msg, PendingDeprecationWarning)
 
  if G.is_directed():
  raise ValueError("input graph must be undirected")

python/cugraph/cugraph/community/subgraph_extraction.py

@@ -58,9 +58,6 @@ def subgraph(G, vertices):
 
  G, isNx = ensure_cugraph_obj_for_nx(G)
 
- if not G.edgelist.weights:
- raise RuntimeError("input graph must be weighted")
-
  if G.renumbered:
  if isinstance(vertices, cudf.DataFrame):
  vertices = G.lookup_internal_vertex_id(vertices, vertices.columns)

python/cugraph/cugraph/cores/core_number.py

@@ -16,12 +16,11 @@
  df_score_to_dictionary,
 )
 import cudf
-import warnings
 
 from pylibcugraph import core_number as pylibcugraph_core_number, ResourceHandle
 
 
-def core_number(G, degree_type=None):
+def core_number(G, degree_type="bidirectional"):
  """
  Compute the core numbers for the nodes of the graph G. A k-core of a graph
  is a maximal subgraph that contains nodes of degree k or more.
@@ -36,13 +35,12 @@ def core_number(G, degree_type=None):
  represented as directed edges in both directions. While this graph
  can contain edge weights, they don't participate in the calculation
  of the core numbers.
+ The current implementation only supports undirected graphs.
 
- degree_type: str
+ degree_type: str, (default="bidirectional")
  This option determines if the core number computation should be based
  on input, output, or both directed edges, with valid values being
  "incoming", "outgoing", and "bidirectional" respectively.
- This option is currently ignored in this release, and setting it will
- result in a warning.
 
  Returns
  -------
@@ -65,19 +63,15 @@ def core_number(G, degree_type=None):
 
  G, isNx = ensure_cugraph_obj_for_nx(G)
 
- if degree_type is not None:
- warning_msg = "The 'degree_type' parameter is ignored in this release."
- warnings.warn(warning_msg, Warning)
-
  if G.is_directed():
  raise ValueError("input graph must be undirected")
 
- # FIXME: enable this check once 'degree_type' is supported
- """
  if degree_type not in ["incoming", "outgoing", "bidirectional"]:
- raise ValueError(f"'degree_type' must be either incoming, "
- f"outgoing or bidirectional, got: {degree_type}")
- """
+ raise ValueError(
+ f"'degree_type' must be either incoming, "
+ f"outgoing or bidirectional, got: {degree_type}"
+ )
+
  vertex, core_number = pylibcugraph_core_number(
  resource_handle=ResourceHandle(),
  graph=G._plc_graph,

python/cugraph/cugraph/cores/k_core.py

@@ -11,20 +11,25 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from cugraph.cores import k_core_wrapper
 import cudf
-from pylibcugraph import core_number as pylibcugraph_core_number, ResourceHandle
+
+from pylibcugraph import (
+ core_number as pylibcugraph_core_number,
+ k_core as pylibcugraph_k_core,
+ ResourceHandle,
+)
+
 from cugraph.utilities import (
  ensure_cugraph_obj_for_nx,
  cugraph_to_nx,
 )
 
 
-def _call_plc_core_number(G):
+def _call_plc_core_number(G, degree_type):
  vertex, core_number = pylibcugraph_core_number(
  resource_handle=ResourceHandle(),
  graph=G._plc_graph,
- degree_type=None,
+ degree_type=degree_type,
  do_expensive_check=False,
  )
 
@@ -34,7 +39,7 @@ def _call_plc_core_number(G):
  return df
 
 
-def k_core(G, k=None, core_number=None):
+def k_core(G, k=None, core_number=None, degree_type="bidirectional"):
  """
  Compute the k-core of the graph G based on the out degree of its nodes. A
  k-core of a graph is a maximal subgraph that contains nodes of degree k or
@@ -48,11 +53,17 @@ def k_core(G, k=None, core_number=None):
  should contain undirected edges where undirected edges are represented
  as directed edges in both directions. While this graph can contain edge
  weights, they don't participate in the calculation of the k-core.
+ The current implementation only supports undirected graphs.
 
  k : int, optional (default=None)
  Order of the core. This value must not be negative. If set to None, the
  main core is returned.
 
+ degree_type: str, (default="bidirectional")
+ This option determines if the core number computation should be based
+ on input, output, or both directed edges, with valid values being
+ "incoming", "outgoing", and "bidirectional" respectively.
+
  core_number : cudf.DataFrame, optional (default=None)
  Precomputed core number of the nodes of the graph G containing two
  cudf.Series of size V: the vertex identifiers and the corresponding
@@ -79,34 +90,58 @@ def k_core(G, k=None, core_number=None):
 
  G, isNx = ensure_cugraph_obj_for_nx(G)
 
+ if degree_type not in ["incoming", "outgoing", "bidirectional"]:
+ raise ValueError(
+ f"'degree_type' must be either incoming, "
+ f"outgoing or bidirectional, got: {degree_type}"
+ )
+
  mytype = type(G)
+
  KCoreGraph = mytype()
 
  if G.is_directed():
  raise ValueError("G must be an undirected Graph instance")
 
- if core_number is not None:
- if G.renumbered is True:
+ if core_number is None:
+ core_number = _call_plc_core_number(G, degree_type=degree_type)
+ else:
+ if G.renumbered:
  if len(G.renumber_map.implementation.col_names) > 1:
  cols = core_number.columns[:-1].to_list()
  else:
  cols = "vertex"
- core_number = G.add_internal_vertex_id(core_number, "vertex", cols)
 
- else:
- core_number = _call_plc_core_number(G)
- core_number = core_number.rename(columns={"core_number": "values"}, copy=False)
+ core_number = G.add_internal_vertex_id(core_number, "vertex", cols)
 
+ core_number = core_number.rename(columns={"core_number": "values"})
  if k is None:
  k = core_number["values"].max()
 
- k_core_df = k_core_wrapper.k_core(G, k, core_number)
+ src_vertices, dst_vertices, weights = pylibcugraph_k_core(
+ resource_handle=ResourceHandle(),
+ graph=G._plc_graph,
+ degree_type=degree_type,
+ k=k,
+ core_result=core_number,
+ do_expensive_check=False,
+ )
+
+ k_core_df = cudf.DataFrame()
+ k_core_df["src"] = src_vertices
+ k_core_df["dst"] = dst_vertices
+ k_core_df["weight"] = weights
 
  if G.renumbered:
  k_core_df, src_names = G.unrenumber(k_core_df, "src", get_column_names=True)
  k_core_df, dst_names = G.unrenumber(k_core_df, "dst", get_column_names=True)
 
+ else:
+ src_names = k_core_df.columns[0]
+ dst_names = k_core_df.columns[1]
+
  if G.edgelist.weights:
+
  KCoreGraph.from_cudf_edgelist(
  k_core_df, source=src_names, destination=dst_names, edge_attr="weight"
  )

python/cugraph/cugraph/dask/__init__.py

@@ -26,6 +26,7 @@
 from .sampling.random_walks import random_walks
 from .centrality.eigenvector_centrality import eigenvector_centrality
 from .cores.core_number import core_number
+from .cores.k_core import k_core
 from .link_prediction.jaccard import jaccard
 from .link_prediction.sorensen import sorensen
 from .link_prediction.overlap import overlap

python/cugraph/cugraph/dask/community/egonet.py

@@ -19,6 +19,7 @@
 import dask_cudf
 import cudf
 from cugraph.dask.common.input_utils import get_distributed_data
+import warnings
 
 from pylibcugraph import ResourceHandle, ego_graph as pylibcugraph_ego_graph
 
@@ -110,6 +111,15 @@ def ego_graph(input_graph, n, radius=1, center=True):
  # Initialize dask client
  client = input_graph._client
 
+ # FIXME: Implement a better way to check if the graph is weighted similar
+ # to 'simpleGraph'
+ if len(input_graph.edgelist.edgelist_df.columns) != 3:
+ warning_msg = (
+ "'Ego_graph' requires the input graph to be weighted: Unweighted "
+ "graphs will not be supported in the next release."
+ )
+ warnings.warn(warning_msg, PendingDeprecationWarning)
+
  if isinstance(n, (int, list)):
  n = cudf.Series(n)
  elif not isinstance(