def jaccard_coefficient(G, ebunch=None): """ For NetworkX Compatability. See `jaccard` Parameters ---------- graph : cugraph.Graph cuGraph graph descriptor, should contain the connectivity information as an edge list (edge weights are not used for this algorithm). The graph should be undirected where an undirected edge is represented by a directed edge in both direction. The adjacency list will be computed if not already present. ebunch : cudf.DataFrame A GPU dataframe consisting of two columns representing pairs of vertices. If provided, the jaccard coefficient is computed for the given vertex pairs. If the vertex_pair is not provided then the current implementation computes the jaccard coefficient for all adjacent vertices in the graph. Returns ------- df : cudf.DataFrame GPU data frame of size E (the default) or the size of the given pairs (first, second) containing the Jaccard weights. The ordering is relative to the adjacency list, or that given by the specified vertex pairs. df['source'] : cudf.Series The source vertex ID (will be identical to first if specified) df['destination'] : cudf.Series The destination vertex ID (will be identical to second if specified) df['jaccard_coeff'] : cudf.Series The computed Jaccard coefficient between the source and destination vertices Examples -------- >>> gdf = cudf.read_csv('datasets/karate.csv', delimiter=' ', >>> dtype=['int32', 'int32', 'float32'], header=None) >>> G = cugraph.Graph() >>> G.from_cudf_edgelist(gdf, source='0', destination='1') >>> df = cugraph.jaccard_coefficient(G) """ vertex_pair = None G, isNx = check_nx_graph(G) if isNx is True and ebunch is not None: vertex_pair = cudf.from_pandas(pd.DataFrame(ebunch)) df = jaccard(G, vertex_pair) if isNx is True: df = df_edge_score_to_dictionary(df, k="jaccard_coeff", src="source", dst="destination") return df
def maximum_spanning_tree(G, weight=None, algorithm="boruvka", ignore_nan=False): """ Returns a maximum spanning tree (MST) or forest (MSF) on an undirected graph Parameters ---------- G : cuGraph.Graph or networkx.Graph cuGraph graph descriptor with connectivity information. weight : string default to the weights in the graph, if the graph edges do not have a weight attribute a default weight of 1 will be used. algorithm : string Default to 'boruvka'. The parallel algorithm to use when finding a maximum spanning tree. ignore_nan : bool Default to False Returns ------- G_mst : cuGraph.Graph or networkx.Graph A graph descriptor with a maximum spanning tree or forest. The networkx graph will not have all attributes copied over """ G, isNx = check_nx_graph(G) if isNx is True: mst = maximum_spanning_tree_subgraph(G) return cugraph_to_nx(mst) else: return maximum_spanning_tree_subgraph(G)
def k_truss(G, k): """ Returns the K-Truss subgraph of a graph for a specific k. The k-truss of a graph is a subgraph where each edge is part of at least (k−2) triangles. K-trusses are used for finding tighlty knit groups of vertices in a graph. A k-truss is a relaxation of a k-clique in the graph and was define in [1]. Finding cliques is computationally demanding and finding the maximal k-clique is known to be NP-Hard. Parameters ---------- G : cuGraph.Graph or networkx.Graph cuGraph graph descriptor with connectivity information. k-Trusses are defined for only undirected graphs as they are defined for undirected triangle in a graph. k : int The desired k to be used for extracting the k-truss subgraph. Returns ------- G_truss : cuGraph.Graph or networkx.Graph A cugraph graph descriptor with the k-truss subgraph for the given k. The networkx graph will NOT have all attributes copied over """ G, isNx = check_nx_graph(G) if isNx is True: k_sub = ktruss_subgraph(G, k) S = cugraph_to_nx(k_sub) return S else: return ktruss_subgraph(G, k)
def analyzeClustering_edge_cut(G, n_clusters, clustering, vertex_col_name='vertex', cluster_col_name='cluster'): """ Compute the edge cut score for a partitioning/clustering Parameters ---------- G : cugraph.Graph cuGraph graph descriptor n_clusters : integer Specifies the number of clusters in the given clustering clustering : cudf.DataFrame The cluster assignment to analyze. vertex_col_name : str The name of the column in the clustering dataframe identifying the external vertex id cluster_col_name : str The name of the column in the clustering dataframe identifying the cluster id Returns ------- score : float The computed edge cut score Examples -------- >>> M = cudf.read_csv('datasets/karate.csv', delimiter = ' ', dtype=['int32', 'int32', 'float32'], header=None) >>> G = cugraph.Graph() >>> G.from_cudf_edgelist(M, source='0', destination='1', edge_attr=None) >>> df = cugraph.spectralBalancedCutClustering(G, 5) >>> score = cugraph.analyzeClustering_edge_cut(G, 5, df, >>> 'vertex', 'cluster') """ G, isNx = check_nx_graph(G) if G.renumbered: clustering = G.add_internal_vertex_id(clustering, vertex_col_name, vertex_col_name, drop=True) clustering = clustering.sort_values(vertex_col_name).reset_index(drop=True) score = spectral_clustering_wrapper.analyzeClustering_edge_cut( G, n_clusters, clustering[cluster_col_name]) return score
def strongly_connected_components(G): """ Generate the Stronlgly Connected Components and attach a component label to each vertex. Parameters ---------- G : cugraph.Graph or networkx.Graph cuGraph graph descriptor, should contain the connectivity information as an edge list (edge weights are not used for this algorithm). The graph can be either directed or undirected where an undirected edge is represented by a directed edge in both directions. The adjacency list will be computed if not already present. The number of vertices should fit into a 32b int. Returns ------- df : cudf.DataFrame GPU data frame containing two cudf.Series of size V: the vertex identifiers and the corresponding component identifier. df['vertices'] Contains the vertex identifier df['labels'] The component identifier Examples -------- >>> M = cudf.read_csv('datasets/karate.csv', delimiter = ' ', dtype=['int32', 'int32', 'float32'], header=None) >>> G = cugraph.Graph() >>> G.from_cudf_edgelist(M, source='0', destination='1', edge_attr=None) >>> df = cugraph.strongly_connected_components(G) """ G, isNx = check_nx_graph(G) df = connectivity_wrapper.strongly_connected_components(G) if G.renumbered: df = G.unrenumber(df, "vertices") if isNx is True: df = df_score_to_dictionary(df, "labels", "vertices") return df
def core_number(G): """ 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. A node has a core number of k if it belongs a k-core but not to k+1-core. This call does not support a graph with self-loops and parallel edges. Parameters ---------- graph : cuGraph.Graph or networkx.Graph The graph 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 core numbers. Returns ------- df : cudf.DataFrame or python dictionary (in NetworkX input) GPU data frame containing two cudf.Series of size V: the vertex identifiers and the corresponding core number values. df['vertex'] : cudf.Series Contains the vertex identifiers df['core_number'] : cudf.Series Contains the core number of vertices Examples -------- >>> gdf = cudf.read_csv('datasets/karate.csv', delimiter=' ', >>> dtype=['int32', 'int32', 'float32'], header=None) >>> G = cugraph.Graph() >>> G.from_cudf_edgelist(gdf, source='0', destination='1') >>> cn = cugraph.core_number(G) """ G, isNx = check_nx_graph(G) df = core_number_wrapper.core_number(G) if G.renumbered: df = G.unrenumber(df, "vertex") if isNx is True: df = df_score_to_dictionary(df, 'core_number') return df
def shortest_path(G, source): """ Compute the distance and predecessors for shortest paths from the specified source to all the vertices in the graph. The distances column will store the distance from the source to each vertex. The predecessors column will store each vertex's predecessor in the shortest path. Vertices that are unreachable will have a distance of infinity denoted by the maximum value of the data type and the predecessor set as -1. The source vertex's predecessor is also set to -1. Graphs with negative weight cycles are not supported. Parameters ---------- graph : cuGraph.Graph or NetworkX.Graph cuGraph graph descriptor with connectivity information. Edge weights, if present, should be single or double precision floating point values. source : int Index of the source vertex. Returns ------- df : cudf.DataFrame or pandas.DataFrame df['vertex'] vertex id df['distance'] gives the path distance from the starting vertex df['predecessor'] the vertex it was reached from Examples -------- >>> M = cudf.read_csv('datasets/karate.csv', delimiter=' ', >>> dtype=['int32', 'int32', 'float32'], header=None) >>> G = cugraph.Graph() >>> G.from_cudf_edgelist(M, source='0', destination='1') >>> distances = cugraph.shortest_path(G, 0) """ G, isNx = check_nx_graph(G) df = sssp(G, source) if isNx is True: df = df.to_pandas() return df
def overlap_coefficient(G, ebunch=None): """ NetworkX similar API. See 'jaccard' for a description """ vertex_pair = None G, isNx = check_nx_graph(G) if isNx is True and ebunch is not None: vertex_pair = cudf.from_pandas(pd.DataFrame(ebunch)) df = overlap(G, vertex_pair) if isNx is True: df = df_edge_score_to_dictionary(df, k="overlap_coeff", src="source", dst="destination") return df
def triangles(G): """ Compute the number of triangles (cycles of length three) in the input graph. Unlike NetworkX, this algorithm simply returns the total number of triangle and not the number per vertex. Parameters ---------- G : cugraph.graph or networkx.Graph cuGraph graph descriptor, should contain the connectivity information, (edge weights are not used in this algorithm) Returns ------- count : int64 A 64 bit integer whose value gives the number of triangles in the graph. Examples -------- >>> gdf = cudf.read_csv('datasets/karate.csv', delimiter = ' ', dtype=['int32', 'int32', 'float32'], header=None) >>> G = cugraph.Graph() >>> G.from_cudf_edgelist(gdf, source='0', destination='1') >>> count = cugraph.triangles(G) """ G, _ = check_nx_graph(G) if type(G) is not Graph: raise Exception("input graph must be undirected") result = triangle_count_wrapper.triangles(G) return result
def bfs_edges(G, source, reverse=False, depth_limit=None, sort_neighbors=None, return_sp_counter=False): """ Find the distances and predecessors for a breadth first traversal of a graph. Parameters ---------- G : cugraph.graph or NetworkX.Graph graph descriptor that contains connectivity information source : Integer The starting vertex index reverse : boolean If a directed graph, then process edges in a reverse direction Currently not implemented depth_limit : Int or None Limit the depth of the search Currently not implemented sort_neighbors : None or Function Currently not implemented return_sp_counter : bool, optional, default=False Indicates if shortest path counters should be returned Returns ------- df : cudf.DataFrame or Pandas.DataFrame df['vertex'][i] gives the vertex id of the i'th vertex df['distance'][i] gives the path distance for the i'th vertex from the starting vertex df['predecessor'][i] gives for the i'th vertex the vertex it was reached from in the traversal df['sp_counter'][i] gives for the i'th vertex the number of shortest path leading to it during traversal (Only if retrun_sp_counter is True) Examples -------- >>> M = cudf.read_csv('datasets/karate.csv', delimiter=' ', >>> dtype=['int32', 'int32', 'float32'], header=None) >>> G = cugraph.Graph() >>> G.from_cudf_edgelist(M, source='0', destination='1') >>> df = cugraph.bfs_edges(G, 0) """ if reverse is True: raise NotImplementedError("reverse processing of graph is " "currently not supported") if depth_limit is not None: raise NotImplementedError("depth limit implementation of BFS " "is not currently supported") G, isNx = check_nx_graph(G) df = bfs(G, source, return_sp_counter) if isNx is True: df = df.to_pandas() return df
def hits(G, max_iter=100, tol=1.0e-5, nstart=None, normalized=True): """ Compute HITS hubs and authorities values for each vertex The HITS algorithm computes two numbers for a node. Authorities estimates the node value based on the incoming links. Hubs estimates the node value based on outgoing links. The cuGraph implementation of HITS is a wrapper around the gunrock implementation of HITS. Note that the gunrock implementation uses a 2-norm, while networkx uses a 1-norm. The raw scores will be different, but the rank ordering should be comparable with networkx. Parameters ---------- graph : cugraph.Graph cuGraph graph descriptor, should contain the connectivity information as an edge list (edge weights are not used for this algorithm). The adjacency list will be computed if not already present. max_iter : int The maximum number of iterations before an answer is returned. The gunrock implementation does not currently support tolerance, so this will in fact be the number of iterations the HITS algorithm executes. tolerance : float Set the tolerance the approximation, this parameter should be a small magnitude value. This parameter is not currently supported. nstart : cudf.Dataframe Not currently supported normalized : bool Not currently supported, always used as True Returns ------- HubsAndAuthorities : cudf.DataFrame GPU data frame containing three cudf.Series of size V: the vertex identifiers and the corresponding hubs values and the corresponding authorities values. df['vertex'] : cudf.Series Contains the vertex identifiers df['hubs'] : cudf.Series Contains the hubs score df['authorities'] : cudf.Series Contains the authorities score Examples -------- >>> gdf = cudf.read_csv('datasets/karate.csv', delimiter=' ', >>> dtype=['int32', 'int32', 'float32'], header=None) >>> G = cugraph.Graph() >>> G.from_cudf_edgelist(gdf, source='0', destination='1') >>> hits = cugraph.hits(G, max_iter = 50) """ G, isNx = check_nx_graph(G) df = hits_wrapper.hits(G, max_iter, tol) if G.renumbered: df = G.unrenumber(df, "vertex") if isNx is True: d1 = df_score_to_dictionary(df[["vertex", "hubs"]], "hubs") d2 = df_score_to_dictionary(df[["vertex", "authorities"]], "authorities") df = (d1, d2) return df
def spectralBalancedCutClustering( G, num_clusters, num_eigen_vects=2, evs_tolerance=0.00001, evs_max_iter=100, kmean_tolerance=0.00001, kmean_max_iter=100, ): """ Compute a clustering/partitioning of the given graph using the spectral balanced cut method. Parameters ---------- G : cugraph.Graph or networkx.Graph cuGraph graph descriptor num_clusters : integer Specifies the number of clusters to find num_eigen_vects : integer Specifies the number of eigenvectors to use. Must be lower or equal to num_clusters. evs_tolerance: float Specifies the tolerance to use in the eigensolver Default is 0.00001 evs_max_iter: integer Specifies the maximum number of iterations for the eigensolver Default is 100 kmean_tolerance: float Specifies the tolerance to use in the k-means solver Default is 0.00001 kmean_max_iter: integer Specifies the maximum number of iterations for the k-means solver Default is 100 Returns ------- df : cudf.DataFrame GPU data frame containing two cudf.Series of size V: the vertex identifiers and the corresponding cluster assignments. df['vertex'] : cudf.Series contains the vertex identifiers df['cluster'] : cudf.Series contains the cluster assignments Examples -------- >>> M = cudf.read_csv('datasets/karate.csv', delimiter = ' ', dtype=['int32', 'int32', 'float32'], header=None) >>> G = cugraph.Graph() >>> G.from_cudf_edgelist(M, source='0', destination='1') >>> df = cugraph.spectralBalancedCutClustering(G, 5) """ G, isNx = check_nx_graph(G) df = spectral_clustering_wrapper.spectralBalancedCutClustering( G, num_clusters, num_eigen_vects, evs_tolerance, evs_max_iter, kmean_tolerance, kmean_max_iter, ) if G.renumbered: df = G.unrenumber(df, "vertex") if isNx is True: df = df_score_to_dictionary(df, "cluster") return df
def leiden(G, max_iter=100, resolution=1.): """ Compute the modularity optimizing partition of the input graph using the Leiden algorithm It uses the Louvain method described in: Traag, V. A., Waltman, L., & van Eck, N. J. (2019). From Louvain to Leiden: guaranteeing well-connected communities. Scientific reports, 9(1), 5233. doi: 10.1038/s41598-019-41695-z Parameters ---------- G : cugraph.Graph cuGraph graph descriptor of type Graph The adjacency list will be computed if not already present. max_iter : integer This controls the maximum number of levels/iterations of the Leiden algorithm. When specified the algorithm will terminate after no more than the specified number of iterations. No error occurs when the algorithm terminates early in this manner. resolution: float/double, optional Called gamma in the modularity formula, this changes the size of the communities. Higher resolutions lead to more smaller communities, lower resolutions lead to fewer larger communities. Defaults to 1. Returns ------- parts : cudf.DataFrame GPU data frame of size V containing two columns the vertex id and the partition id it is assigned to. df['vertex'] : cudf.Series Contains the vertex identifiers df['partition'] : cudf.Series Contains the partition assigned to the vertices modularity_score : float a floating point number containing the global modularity score of the partitioning. Examples -------- >>> M = cudf.read_csv('datasets/karate.csv', delimiter = ' ', dtype=['int32', 'int32', 'float32'], header=None) >>> G = cugraph.Graph() >>> G.from_cudf_edgelist(M, source='0', destination='1') >>> parts, modularity_score = cugraph.leiden(G) """ G, isNx = check_nx_graph(G) if type(G) is not Graph: raise Exception(f"input graph must be undirected was {type(G)}") parts, modularity_score = leiden_wrapper.leiden( G, max_iter, resolution ) if G.renumbered: parts = G.unrenumber(parts, "vertex") if isNx is True: parts = df_score_to_dictionary(parts, "partition") return parts, modularity_score
def analyzeClustering_modularity(G, n_clusters, clustering, vertex_col_name='vertex', cluster_col_name='cluster'): """ Compute the modularity score for a given partitioning/clustering. The assumption is that “clustering” is the results from a call from a special clustering algorithm and contains columns named “vertex” and “cluster”. Parameters ---------- G : cugraph.Graph or networkx.Graph graph descriptor. This graph should have edge weights. n_clusters : integer Specifies the number of clusters in the given clustering clustering : cudf.DataFrame The cluster assignment to analyze. vertex_col_name : str The name of the column in the clustering dataframe identifying the external vertex id cluster_col_name : str The name of the column in the clustering dataframe identifying the cluster id Returns ------- score : float The computed modularity score Examples -------- >>> M = cudf.read_csv('datasets/karate.csv', delimiter = ' ', dtype=['int32', 'int32', 'float32'], header=None) >>> G = cugraph.Graph() >>> G.from_cudf_edgelist(M, source='0', destination='1', edge_attr='2') >>> df = cugraph.spectralBalancedCutClustering(G, 5) >>> score = cugraph.analyzeClustering_modularity(G, 5, df) """ if type(vertex_col_name) is not str: raise Exception("vertex_col_name must be a string") if type(cluster_col_name) is not str: raise Exception("cluster_col_name must be a string") G, isNx = check_nx_graph(G) if G.renumbered: clustering = G.add_internal_vertex_id(clustering, vertex_col_name, vertex_col_name, drop=True) clustering = clustering.sort_values(vertex_col_name) score = spectral_clustering_wrapper.analyzeClustering_modularity( G, n_clusters, clustering[cluster_col_name]) return score
def k_core(G, k=None, core_number=None): """ 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 more. This call does not support a graph with self-loops and parallel edges. Parameters ---------- G : cuGraph.Graph or networkx.Graph cuGraph graph descriptor with connectivity information. The graph 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. k : int, optional Order of the core. This value must not be negative. If set to None, the main core is returned. core_number : cudf.DataFrame, optional Precomputed core number of the nodes of the graph G containing two cudf.Series of size V: the vertex identifiers and the corresponding core number values. If set to None, the core numbers of the nodes are calculated internally. core_number['vertex'] : cudf.Series Contains the vertex identifiers core_number['values'] : cudf.Series Contains the core number of vertices Returns ------- KCoreGraph : cuGraph.Graph K Core of the input graph Examples -------- >>> gdf = cudf.read_csv('datasets/karate.csv', delimiter=' ', >>> dtype=['int32', 'int32', 'float32'], header=None) >>> G = cugraph.Graph() >>> G.from_cudf_edgelist(gdf, source='0', destination='1') >>> KCoreGraph = cugraph.k_core(G) """ G, isNx = check_nx_graph(G) mytype = type(G) KCoreGraph = mytype() if mytype is not Graph: raise Exception("directed graph not supported") if core_number is not None: if G.renumbered is True: core_number = G.add_internal_vertex_id(core_number, "vertex", "vertex", drop=True) else: core_number = core_number_wrapper.core_number(G) core_number = core_number.rename(columns={"core_number": "values"}, copy=False) print(core_number) if k is None: k = core_number["values"].max() k_core_df = k_core_wrapper.k_core(G, k, core_number) if G.renumbered: k_core_df = G.unrenumber(k_core_df, "src") k_core_df = G.unrenumber(k_core_df, "dst") if G.edgelist.weights: KCoreGraph.from_cudf_edgelist(k_core_df, source="src", destination="dst", edge_attr="weight") else: KCoreGraph.from_cudf_edgelist(k_core_df, source="src", destination="dst") if isNx is True: KCoreGraph = cugraph_to_nx(KCoreGraph) return KCoreGraph
def spectralModularityMaximizationClustering( G, num_clusters, num_eigen_vects=2, evs_tolerance=0.00001, evs_max_iter=100, kmean_tolerance=0.00001, kmean_max_iter=100, ): """ Compute a clustering/partitioning of the given graph using the spectral modularity maximization method. Parameters ---------- G : cugraph.Graph or networkx.Graph cuGraph graph descriptor. This graph should have edge weights. num_clusters : integer Specifies the number of clusters to find num_eigen_vects : integer Specifies the number of eigenvectors to use. Must be lower or equal to num_clusters. Default is 2 evs_tolerance: float Specifies the tolerance to use in the eigensolver. Default is 0.00001 evs_max_iter: integer Specifies the maximum number of iterations for the eigensolver. Default is 100 kmean_tolerance: float Specifies the tolerance to use in the k-means solver. Default is 0.00001 kmean_max_iter: integer Specifies the maximum number of iterations for the k-means solver. Default is 100 Returns ------- df : cudf.DataFrame df['vertex'] : cudf.Series contains the vertex identifiers df['cluster'] : cudf.Series contains the cluster assignments Examples -------- >>> M = cudf.read_csv('datasets/karate.csv', delimiter = ' ', dtype=['int32', 'int32', 'float32'], header=None) >>> G = cugraph.Graph() >>> G.from_cudf_edgelist(M, source='0', destination='1', edge_attr='2') >>> df = cugraph.spectralModularityMaximizationClustering(G, 5) """ # Error checking in C++ code G, isNx = check_nx_graph(G) df = spectral_clustering_wrapper.spectralModularityMaximizationClustering( G, num_clusters, num_eigen_vects, evs_tolerance, evs_max_iter, kmean_tolerance, kmean_max_iter, ) if G.renumbered: df = G.unrenumber(df, "vertex") if isNx is True: df = df_score_to_dictionary(df, "cluster") return df
def subgraph(G, vertices): """ Compute a subgraph of the existing graph including only the specified vertices. This algorithm works for both directed and undirected graphs, it does not actually traverse the edges, simply pulls out any edges that are incident on vertices that are both contained in the vertices list. Parameters ---------- G : cugraph.Graph cuGraph graph descriptor vertices : cudf.Series Specifies the vertices of the induced subgraph Returns ------- Sg : cugraph.Graph A graph object containing the subgraph induced by the given vertex set. Examples -------- >>> gdf = cudf.read_csv('datasets/karate.csv', delimiter = ' ', dtype=['int32', 'int32', 'float32'], header=None) >>> G = cugraph.Graph() >>> G.from_cudf_edgelist(gdf, source='0', destination='1') >>> verts = numpy.zeros(3, dtype=numpy.int32) >>> verts[0] = 0 >>> verts[1] = 1 >>> verts[2] = 2 >>> sverts = cudf.Series(verts) >>> Sg = cugraph.subgraph(G, sverts) """ null_check(vertices) G, isNx = check_nx_graph(G) if G.renumbered: vertices = G.lookup_internal_vertex_id(vertices) result_graph = type(G)() df = subgraph_extraction_wrapper.subgraph(G, vertices) if G.renumbered: df = G.unrenumber(df, "src") df = G.unrenumber(df, "dst") if G.edgelist.weights: result_graph.from_cudf_edgelist(df, source="src", destination="dst", edge_attr="weight") else: result_graph.from_cudf_edgelist(df, source="src", destination="dst") if isNx is True: result_graph = cugraph_to_nx(result_graph) return result_graph
def ecg(input_graph, min_weight=0.05, ensemble_size=16, weight=None): """ Compute the Ensemble Clustering for Graphs (ECG) partition of the input graph. ECG runs truncated Louvain on an ensemble of permutations of the input graph, then uses the ensemble partitions to determine weights for the input graph. The final result is found by running full Louvain on the input graph using the determined weights. See https://arxiv.org/abs/1809.05578 for further information. Parameters ---------- input_graph : cugraph.Graph or NetworkX Graph The graph descriptor should contain the connectivity information and weights. The adjacency list will be computed if not already present. min_weight : floating point The minimum value to assign as an edgeweight in the ECG algorithm. It should be a value in the range [0,1] usually left as the default value of .05 ensemble_size : integer The number of graph permutations to use for the ensemble. The default value is 16, larger values may produce higher quality partitions for some graphs. weight : str This parameter is here for NetworkX compatibility and represents which NetworkX data column represents Edge weights. Default is None Returns ------- parts : cudf.DataFrame or python dictionary GPU data frame of size V containing two columns, the vertex id and the partition id it is assigned to. df[vertex] : cudf.Series Contains the vertex identifiers df[partition] : cudf.Series Contains the partition assigned to the vertices Examples -------- >>> M = cudf.read_csv('datasets/karate.csv', delimiter = ' ', dtype=['int32', 'int32', 'float32'], header=None) >>> G = cugraph.Graph() >>> G.from_cudf_edgelist(M, source='0', destination='1', edge_attr='2') >>> parts = cugraph.ecg(G) """ input_graph, isNx = check_nx_graph(input_graph, weight) parts = ecg_wrapper.ecg(input_graph, min_weight, ensemble_size) if input_graph.renumbered: parts = input_graph.unrenumber(parts, "vertex") if isNx is True: return df_score_to_dictionary(parts, 'partition') else: return parts
def louvain(G, max_iter=100, resolution=1.): """ Compute the modularity optimizing partition of the input graph using the Louvain method It uses the Louvain method described in: VD Blondel, J-L Guillaume, R Lambiotte and E Lefebvre: Fast unfolding of community hierarchies in large networks, J Stat Mech P10008 (2008), http://arxiv.org/abs/0803.0476 Parameters ---------- G : cugraph.Graph or NetworkX Graph The graph descriptor should contain the connectivity information and weights. The adjacency list will be computed if not already present. max_iter : integer This controls the maximum number of levels/iterations of the Louvain algorithm. When specified the algorithm will terminate after no more than the specified number of iterations. No error occurs when the algorithm terminates early in this manner. resolution: float/double, optional Called gamma in the modularity formula, this changes the size of the communities. Higher resolutions lead to more smaller communities, lower resolutions lead to fewer larger communities. Defaults to 1. Returns ------- parts : cudf.DataFrame GPU data frame of size V containing two columns the vertex id and the partition id it is assigned to. df['vertex'] : cudf.Series Contains the vertex identifiers df['partition'] : cudf.Series Contains the partition assigned to the vertices modularity_score : float a floating point number containing the global modularity score of the partitioning. Examples -------- >>> M = cudf.read_csv('datasets/karate.csv', delimiter = ' ', dtype=['int32', 'int32', 'float32'], header=None) >>> G = cugraph.Graph() >>> G.from_cudf_edgelist(M, source='0', destination='1') >>> parts, modularity_score = cugraph.louvain(G) """ G, isNx = check_nx_graph(G) if type(G) is not Graph: raise Exception("input graph must be undirected") parts, modularity_score = louvain_wrapper.louvain(G, max_iter, resolution) if G.renumbered: parts = G.unrenumber(parts, "vertex") if isNx is True: parts = df_score_to_dictionary(parts, "partition") return parts, modularity_score