From fe7d31d65a6797c226769941aa89ed5e96012d81 Mon Sep 17 00:00:00 2001 From: Nicola Vitucci Date: Mon, 13 May 2024 16:32:45 +0100 Subject: [PATCH 01/21] Add example of updated algorithm RST file --- doc/sphinx/source/algorithms.rst | 152 +++++++++++++++++++++++++++++++ 1 file changed, 152 insertions(+) diff --git a/doc/sphinx/source/algorithms.rst b/doc/sphinx/source/algorithms.rst index 4819ab183..f3a81859d 100644 --- a/doc/sphinx/source/algorithms.rst +++ b/doc/sphinx/source/algorithms.rst @@ -376,6 +376,22 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Article Rank is a variant of the Page Rank algorithm, which measures the transitive influence or connectivity of nodes. + | + Configuration parameters: + + * **dampingFactor** - The damping factor of the Page Rank calculation. Must be in [0, 1). *Default*: 0.85. + + * **maxIterations** - The maximum number of iterations of Article Rank to run. *Default*: 20. + + * **tolerance** - Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable, and the algorithm returns. *Default*: 0.0000001. + + * **relationshipWeightProperty** - Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + + * **sourceNodes** - The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. + + * **scaler** - The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. + + .. py:function:: gds.articleRank.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -772,6 +788,16 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Betweenness centrality measures the relative information flow that passes through a node. + | + Configuration parameters: + + * **samplingSize** - The number of source nodes to consider for computing centrality scores. *Default*: node count. + + * **samplingSeed** - The seed value for the random number generator that selects start nodes. *Default*: null. + + * **relationshipWeightProperty** - Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + + .. py:function:: gds.betweenness.stream.estimate(G: Graph, **config: Any) -> Series[Any] Betweenness centrality measures the relative information flow that passes through a node. @@ -807,6 +833,16 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level. + | + Configuration parameters: + + * **sourceNode** - The node id of the node where to start the traversal. *Default*: n/a. + + * **targetNodes** - Ids for target nodes. Traversal terminates when any target node is visited. *Default*: empty list. + + * **maxDepth** - The maximum distance from the source node at which nodes are visited. *Default*: -1. + + .. py:function:: gds.bfs.stream.estimate(G: Graph, **config: Any) -> Series[Any] BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth @@ -858,6 +894,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Evaluates a division of nodes into communities based on the proportion of relationships that cross community boundaries. + | + Configuration parameters: + + * **relationshipWeightProperty** - Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + + * **communityProperty** - The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their conductance computed. *Default*: n/a. + + .. py:function:: gds.dag.topologicalSort.stream(G: Graph, **config: Any) -> DataFrame Returns a topological ordering of the nodes in a directed acyclic graph (DAG). @@ -886,6 +930,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Degree centrality measures the number of incoming and outgoing relationships from a node. + | + Configuration parameters: + + * **orientation** - The orientation used to compute node degrees. Supported orientations are `NATURAL`, `REVERSE` and `UNDIRECTED`. *Default*: NATURAL. + + * **relationshipWeightProperty** - Name of the relationship property to use for weighted degree computation. If unspecified, the algorithm runs unweighted. *Default*: null. + + .. py:function:: gds.degree.stream.estimate(G: Graph, **config: Any) -> Series[Any] Degree centrality measures the number of incoming and outgoing relationships from a node. @@ -914,6 +966,16 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g The algorithm starts at the root node (selecting some arbitrary node as the root node in the case of a graph) and explores as far as possible along each branch before backtracking. + | + Configuration parameters: + + * **sourceNode** - The node id of the node where to start the traversal. *Default*: n/a. + + * **targetNodes** - Ids for target nodes. Traversal terminates when any target node is visited. *Default*: empty list. + + * **maxDepth** - The maximum distance from the source node at which nodes are visited. *Default*: -1. + + .. py:function:: gds.dfs.stream.estimate(G: Graph, **config: Any) -> Series[Any] Depth-first search (DFS) is an algorithm for traversing or searching tree or graph data structures. @@ -940,6 +1002,20 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Eigenvector Centrality is an algorithm that measures the transitive influence or connectivity of nodes. + | + Configuration parameters: + + * **maxIterations** - The maximum number of iterations of Eigenvector Centrality to run. *Default*: 20. + + * **tolerance** - Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable and the algorithm returns. *Default*: 0.0000001. + + * **relationshipWeightProperty** - Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + + * **sourceNodes** - The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. + + * **scaler** - The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. + + .. py:function:: gds.eigenvector.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1300,6 +1376,12 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g The local clustering coefficient is a metric quantifying how connected the neighborhood of a node is. + | + Configuration parameters: + + * **triangleCountProperty** - Node property that contains pre-computed triangle count. *Default*: n/a. + + .. py:function:: gds.localClusteringCoefficient.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1370,6 +1452,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.modularity.stream(G: Graph, **config: Any) -> DataFrame + | + Configuration parameters: + + * **relationshipWeightProperty** - Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + + * **communityProperty** - The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their modularity score computed. *Default*: n/a. + + .. py:function:: gds.modularity.stream.estimate(G: Graph, **config: Any) -> Series[Any] .. py:function:: gds.modularityOptimization.mutate(G: Graph, **config: Any) -> Series[Any] @@ -1430,6 +1520,46 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Two nodes are considered similar if they share many of the same neighbors. Node Similarity computes pair-wise similarities based on the Jaccard metric. + | + Configuration parameters: + + * **similarityCutoff** - Lower limit for the similarity score to be present in the result. +Values must be between 0 and 1. *Default*: 1e-42. + + * **degreeCutoff** - Inclusive lower bound on the node degree for a node to be considered in the comparisons. +This value can not be lower than 1. *Default*: 1. + + * **upperDegreeCutoff** - Inclusive upper bound on the node degree for a node to be considered in the comparisons. +This value can not be lower than 1. *Default*: 2147483647. + + * **topK** - Limit on the number of scores per node. +The K largest results are returned. +This value cannot be lower than 1. *Default*: 10. + + * **bottomK** - Limit on the number of scores per node. +The K smallest results are returned. +This value cannot be lower than 1. *Default*: 10. + + * **topN** - Global limit on the number of scores computed. +The N largest total results are returned. +This value cannot be negative, a value of 0 means no global limit. *Default*: 0. + + * **bottomN** - Global limit on the number of scores computed. +The N smallest total results are returned. +This value cannot be negative, a value of 0 means no global limit. *Default*: 0. + + * **relationshipWeightProperty** - Name of the relationship property to use as weights. +If unspecified, the algorithm runs unweighted. *Default*: null. + + * **similarityMetric** - The metric used to compute similarity. +Can be either `JACCARD`, `OVERLAP` or `COSINE`. *Default*: JACCARD. + + * ** useComponents** - If enabled, Node Similarity will use components to improve the performance of the computation, skipping comparisons of nodes in different components. +Set to `false` (Default): the algorithm does not use components, but computes similarity across the entire graph. +Set to `true`: the algorithm uses components, and will compute these components before computing similarity. +Set to *String*: use pre-computed components stored in graph, *String* is the key for a node property representing components. *Default*: false. + + .. py:function:: gds.nodeSimilarity.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1508,6 +1638,22 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Page Rank is an algorithm that measures the transitive influence or connectivity of nodes. + | + Configuration parameters: + + * **dampingFactor** - The damping factor of the Page Rank calculation. Must be in [0, 1). *Default*: 0.85. + + * **maxIterations** - The maximum number of iterations of Page Rank to run. *Default*: 20. + + * **tolerance** - Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable and the algorithm returns. *Default*: 0.0000001. + + * **relationshipWeightProperty** - Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + + * **sourceNodes** - The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. + + * **scaler** - The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. + + .. py:function:: gds.pageRank.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1748,6 +1894,12 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Triangle counting is a community detection graph algorithm that is used to determine the number of triangles passing through each node in the graph. + | + Configuration parameters: + + * **maxDegree** - If a node has a degree higher than this it will not be considered by the algorithm. The triangle count for these nodes will be `-1`. *Default*: 2^63^ - 1. + + .. py:function:: gds.triangleCount.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. From 0c484d4721bb414d8b2628022421ce1063e95260 Mon Sep 17 00:00:00 2001 From: Nicola Vitucci Date: Tue, 14 May 2024 09:20:07 +0100 Subject: [PATCH 02/21] Update RST file --- doc/sphinx/source/algorithms.rst | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/doc/sphinx/source/algorithms.rst b/doc/sphinx/source/algorithms.rst index f3a81859d..2b624e34f 100644 --- a/doc/sphinx/source/algorithms.rst +++ b/doc/sphinx/source/algorithms.rst @@ -531,7 +531,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.beta.kmeans.mutate(G: Graph, **config: Any) -> Series[Any] - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.mutate` instead. @@ -545,7 +545,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.beta.kmeans.stats(G: Graph, **config: Any) -> Series[Any] - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.stats` instead. @@ -559,7 +559,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.beta.kmeans.stream(G: Graph, **config: Any) -> DataFrame - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.stream` instead. @@ -573,7 +573,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.beta.kmeans.write(G: Graph, **config: Any) -> Series[Any] - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.write` instead. @@ -1110,7 +1110,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.kmeans.mutate(G: Graph, **config: Any) -> Series[Any] - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. py:function:: gds.kmeans.mutate.estimate(G: Graph, **config: Any) -> Series[Any] @@ -1118,7 +1118,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.kmeans.stats(G: Graph, **config: Any) -> Series[Any] - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. py:function:: gds.kmeans.stats.estimate(G: Graph, **config: Any) -> Series[Any] @@ -1126,7 +1126,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.kmeans.stream(G: Graph, **config: Any) -> DataFrame - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. py:function:: gds.kmeans.stream.estimate(G: Graph, **config: Any) -> Series[Any] @@ -1134,7 +1134,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.kmeans.write(G: Graph, **config: Any) -> Series[Any] - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. py:function:: gds.kmeans.write.estimate(G: Graph, **config: Any) -> Series[Any] From 3fe2371b5571c949d9cb79eae477a79397fbf0ca Mon Sep 17 00:00:00 2001 From: Nicola Vitucci Date: Tue, 14 May 2024 09:48:09 +0100 Subject: [PATCH 03/21] Update RST file --- doc/sphinx/source/algorithms.rst | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/doc/sphinx/source/algorithms.rst b/doc/sphinx/source/algorithms.rst index 2b624e34f..f3a81859d 100644 --- a/doc/sphinx/source/algorithms.rst +++ b/doc/sphinx/source/algorithms.rst @@ -531,7 +531,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.beta.kmeans.mutate(G: Graph, **config: Any) -> Series[Any] - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.mutate` instead. @@ -545,7 +545,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.beta.kmeans.stats(G: Graph, **config: Any) -> Series[Any] - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.stats` instead. @@ -559,7 +559,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.beta.kmeans.stream(G: Graph, **config: Any) -> DataFrame - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.stream` instead. @@ -573,7 +573,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.beta.kmeans.write(G: Graph, **config: Any) -> Series[Any] - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.write` instead. @@ -1110,7 +1110,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.kmeans.mutate(G: Graph, **config: Any) -> Series[Any] - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. py:function:: gds.kmeans.mutate.estimate(G: Graph, **config: Any) -> Series[Any] @@ -1118,7 +1118,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.kmeans.stats(G: Graph, **config: Any) -> Series[Any] - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. py:function:: gds.kmeans.stats.estimate(G: Graph, **config: Any) -> Series[Any] @@ -1126,7 +1126,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.kmeans.stream(G: Graph, **config: Any) -> DataFrame - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. py:function:: gds.kmeans.stream.estimate(G: Graph, **config: Any) -> Series[Any] @@ -1134,7 +1134,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.kmeans.write(G: Graph, **config: Any) -> Series[Any] - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. py:function:: gds.kmeans.write.estimate(G: Graph, **config: Any) -> Series[Any] From 0431fe6b3c81214059da933d5356db94048c2e0a Mon Sep 17 00:00:00 2001 From: Nicola Vitucci Date: Tue, 14 May 2024 10:12:07 +0100 Subject: [PATCH 04/21] Update RST file --- doc/sphinx/source/algorithms.rst | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/doc/sphinx/source/algorithms.rst b/doc/sphinx/source/algorithms.rst index f3a81859d..2b624e34f 100644 --- a/doc/sphinx/source/algorithms.rst +++ b/doc/sphinx/source/algorithms.rst @@ -531,7 +531,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.beta.kmeans.mutate(G: Graph, **config: Any) -> Series[Any] - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.mutate` instead. @@ -545,7 +545,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.beta.kmeans.stats(G: Graph, **config: Any) -> Series[Any] - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.stats` instead. @@ -559,7 +559,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.beta.kmeans.stream(G: Graph, **config: Any) -> DataFrame - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.stream` instead. @@ -573,7 +573,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.beta.kmeans.write(G: Graph, **config: Any) -> Series[Any] - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.write` instead. @@ -1110,7 +1110,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.kmeans.mutate(G: Graph, **config: Any) -> Series[Any] - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. py:function:: gds.kmeans.mutate.estimate(G: Graph, **config: Any) -> Series[Any] @@ -1118,7 +1118,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.kmeans.stats(G: Graph, **config: Any) -> Series[Any] - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. py:function:: gds.kmeans.stats.estimate(G: Graph, **config: Any) -> Series[Any] @@ -1126,7 +1126,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.kmeans.stream(G: Graph, **config: Any) -> DataFrame - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. py:function:: gds.kmeans.stream.estimate(G: Graph, **config: Any) -> Series[Any] @@ -1134,7 +1134,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.kmeans.write(G: Graph, **config: Any) -> Series[Any] - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. py:function:: gds.kmeans.write.estimate(G: Graph, **config: Any) -> Series[Any] From 3d37128621de1eb48429db2126745bd8eb8bd121 Mon Sep 17 00:00:00 2001 From: Nicola Vitucci Date: Tue, 14 May 2024 12:20:12 +0100 Subject: [PATCH 05/21] Update RST file --- doc/sphinx/source/algorithms.rst | 224 ++++++++++++++++++------------- 1 file changed, 132 insertions(+), 92 deletions(-) diff --git a/doc/sphinx/source/algorithms.rst b/doc/sphinx/source/algorithms.rst index 2b624e34f..873b945c3 100644 --- a/doc/sphinx/source/algorithms.rst +++ b/doc/sphinx/source/algorithms.rst @@ -376,20 +376,22 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Article Rank is a variant of the Page Rank algorithm, which measures the transitive influence or connectivity of nodes. - | - Configuration parameters: + | - * **dampingFactor** - The damping factor of the Page Rank calculation. Must be in [0, 1). *Default*: 0.85. + Configuration parameters: - * **maxIterations** - The maximum number of iterations of Article Rank to run. *Default*: 20. + * **dampingFactor** - The damping factor of the Page Rank calculation. Must be in [0, 1). *Default*: 0.85. - * **tolerance** - Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable, and the algorithm returns. *Default*: 0.0000001. + * **maxIterations** - The maximum number of iterations of Article Rank to run. *Default*: 20. - * **relationshipWeightProperty** - Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + * **tolerance** - Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable, and the algorithm returns. *Default*: 0.0000001. - * **sourceNodes** - The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. + * **relationshipWeightProperty** - Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + + * **sourceNodes** - The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. + + * **scaler** - The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. - * **scaler** - The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. .. py:function:: gds.articleRank.stream.estimate(G: Graph, **config: Any) -> Series[Any] @@ -531,7 +533,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.beta.kmeans.mutate(G: Graph, **config: Any) -> Series[Any] - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.mutate` instead. @@ -545,7 +547,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.beta.kmeans.stats(G: Graph, **config: Any) -> Series[Any] - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.stats` instead. @@ -559,7 +561,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.beta.kmeans.stream(G: Graph, **config: Any) -> DataFrame - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.stream` instead. @@ -573,7 +575,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.beta.kmeans.write(G: Graph, **config: Any) -> Series[Any] - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.write` instead. @@ -788,14 +790,16 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Betweenness centrality measures the relative information flow that passes through a node. - | - Configuration parameters: + | + + Configuration parameters: + + * **samplingSize** - The number of source nodes to consider for computing centrality scores. *Default*: node count. - * **samplingSize** - The number of source nodes to consider for computing centrality scores. *Default*: node count. + * **samplingSeed** - The seed value for the random number generator that selects start nodes. *Default*: null. - * **samplingSeed** - The seed value for the random number generator that selects start nodes. *Default*: null. + * **relationshipWeightProperty** - Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. - * **relationshipWeightProperty** - Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. .. py:function:: gds.betweenness.stream.estimate(G: Graph, **config: Any) -> Series[Any] @@ -833,14 +837,20 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level. - | - Configuration parameters: + | + + Required configuration parameters: **sourceNode** + + | + + Configuration parameters: + + * **sourceNode** - The node id of the node where to start the traversal. *Default*: n/a. - * **sourceNode** - The node id of the node where to start the traversal. *Default*: n/a. + * **targetNodes** - Ids for target nodes. Traversal terminates when any target node is visited. *Default*: empty list. - * **targetNodes** - Ids for target nodes. Traversal terminates when any target node is visited. *Default*: empty list. + * **maxDepth** - The maximum distance from the source node at which nodes are visited. *Default*: -1. - * **maxDepth** - The maximum distance from the source node at which nodes are visited. *Default*: -1. .. py:function:: gds.bfs.stream.estimate(G: Graph, **config: Any) -> Series[Any] @@ -894,12 +904,18 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Evaluates a division of nodes into communities based on the proportion of relationships that cross community boundaries. - | - Configuration parameters: + | - * **relationshipWeightProperty** - Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + Required configuration parameters: **communityProperty** + + | + + Configuration parameters: + + * **relationshipWeightProperty** - Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + + * **communityProperty** - The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their conductance computed. *Default*: n/a. - * **communityProperty** - The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their conductance computed. *Default*: n/a. .. py:function:: gds.dag.topologicalSort.stream(G: Graph, **config: Any) -> DataFrame @@ -930,12 +946,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Degree centrality measures the number of incoming and outgoing relationships from a node. - | - Configuration parameters: + | - * **orientation** - The orientation used to compute node degrees. Supported orientations are `NATURAL`, `REVERSE` and `UNDIRECTED`. *Default*: NATURAL. + Configuration parameters: + + * **orientation** - The orientation used to compute node degrees. Supported orientations are `NATURAL`, `REVERSE` and `UNDIRECTED`. *Default*: NATURAL. + + * **relationshipWeightProperty** - Name of the relationship property to use for weighted degree computation. If unspecified, the algorithm runs unweighted. *Default*: null. - * **relationshipWeightProperty** - Name of the relationship property to use for weighted degree computation. If unspecified, the algorithm runs unweighted. *Default*: null. .. py:function:: gds.degree.stream.estimate(G: Graph, **config: Any) -> Series[Any] @@ -966,14 +984,20 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g The algorithm starts at the root node (selecting some arbitrary node as the root node in the case of a graph) and explores as far as possible along each branch before backtracking. - | - Configuration parameters: + | + + Required configuration parameters: **sourceNode** + + | - * **sourceNode** - The node id of the node where to start the traversal. *Default*: n/a. + Configuration parameters: - * **targetNodes** - Ids for target nodes. Traversal terminates when any target node is visited. *Default*: empty list. + * **sourceNode** - The node id of the node where to start the traversal. *Default*: n/a. + + * **targetNodes** - Ids for target nodes. Traversal terminates when any target node is visited. *Default*: empty list. + + * **maxDepth** - The maximum distance from the source node at which nodes are visited. *Default*: -1. - * **maxDepth** - The maximum distance from the source node at which nodes are visited. *Default*: -1. .. py:function:: gds.dfs.stream.estimate(G: Graph, **config: Any) -> Series[Any] @@ -1002,18 +1026,20 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Eigenvector Centrality is an algorithm that measures the transitive influence or connectivity of nodes. - | - Configuration parameters: + | + + Configuration parameters: + + * **maxIterations** - The maximum number of iterations of Eigenvector Centrality to run. *Default*: 20. - * **maxIterations** - The maximum number of iterations of Eigenvector Centrality to run. *Default*: 20. + * **tolerance** - Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable and the algorithm returns. *Default*: 0.0000001. - * **tolerance** - Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable and the algorithm returns. *Default*: 0.0000001. + * **relationshipWeightProperty** - Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. - * **relationshipWeightProperty** - Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + * **sourceNodes** - The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. - * **sourceNodes** - The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. + * **scaler** - The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. - * **scaler** - The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. .. py:function:: gds.eigenvector.stream.estimate(G: Graph, **config: Any) -> Series[Any] @@ -1110,7 +1136,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.kmeans.mutate(G: Graph, **config: Any) -> Series[Any] - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. py:function:: gds.kmeans.mutate.estimate(G: Graph, **config: Any) -> Series[Any] @@ -1118,7 +1144,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.kmeans.stats(G: Graph, **config: Any) -> Series[Any] - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. py:function:: gds.kmeans.stats.estimate(G: Graph, **config: Any) -> Series[Any] @@ -1126,7 +1152,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.kmeans.stream(G: Graph, **config: Any) -> DataFrame - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. py:function:: gds.kmeans.stream.estimate(G: Graph, **config: Any) -> Series[Any] @@ -1134,7 +1160,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.kmeans.write(G: Graph, **config: Any) -> Series[Any] - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. py:function:: gds.kmeans.write.estimate(G: Graph, **config: Any) -> Series[Any] @@ -1376,10 +1402,12 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g The local clustering coefficient is a metric quantifying how connected the neighborhood of a node is. - | - Configuration parameters: + | + + Configuration parameters: + + * **triangleCountProperty** - Node property that contains pre-computed triangle count. *Default*: n/a. - * **triangleCountProperty** - Node property that contains pre-computed triangle count. *Default*: n/a. .. py:function:: gds.localClusteringCoefficient.stream.estimate(G: Graph, **config: Any) -> Series[Any] @@ -1452,12 +1480,18 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.modularity.stream(G: Graph, **config: Any) -> DataFrame - | - Configuration parameters: + | + + Required configuration parameters: **communityProperty** + + | - * **relationshipWeightProperty** - Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + Configuration parameters: + + * **relationshipWeightProperty** - Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + + * **communityProperty** - The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their modularity score computed. *Default*: n/a. - * **communityProperty** - The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their modularity score computed. *Default*: n/a. .. py:function:: gds.modularity.stream.estimate(G: Graph, **config: Any) -> Series[Any] @@ -1520,44 +1554,46 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Two nodes are considered similar if they share many of the same neighbors. Node Similarity computes pair-wise similarities based on the Jaccard metric. - | - Configuration parameters: + | + + Configuration parameters: + + * **similarityCutoff** - Lower limit for the similarity score to be present in the result. + Values must be between 0 and 1. *Default*: 1e-42. - * **similarityCutoff** - Lower limit for the similarity score to be present in the result. -Values must be between 0 and 1. *Default*: 1e-42. + * **degreeCutoff** - Inclusive lower bound on the node degree for a node to be considered in the comparisons. + This value can not be lower than 1. *Default*: 1. - * **degreeCutoff** - Inclusive lower bound on the node degree for a node to be considered in the comparisons. -This value can not be lower than 1. *Default*: 1. + * **upperDegreeCutoff** - Inclusive upper bound on the node degree for a node to be considered in the comparisons. + This value can not be lower than 1. *Default*: 2147483647. - * **upperDegreeCutoff** - Inclusive upper bound on the node degree for a node to be considered in the comparisons. -This value can not be lower than 1. *Default*: 2147483647. + * **topK** - Limit on the number of scores per node. + The K largest results are returned. + This value cannot be lower than 1. *Default*: 10. - * **topK** - Limit on the number of scores per node. -The K largest results are returned. -This value cannot be lower than 1. *Default*: 10. + * **bottomK** - Limit on the number of scores per node. + The K smallest results are returned. + This value cannot be lower than 1. *Default*: 10. - * **bottomK** - Limit on the number of scores per node. -The K smallest results are returned. -This value cannot be lower than 1. *Default*: 10. + * **topN** - Global limit on the number of scores computed. + The N largest total results are returned. + This value cannot be negative, a value of 0 means no global limit. *Default*: 0. - * **topN** - Global limit on the number of scores computed. -The N largest total results are returned. -This value cannot be negative, a value of 0 means no global limit. *Default*: 0. + * **bottomN** - Global limit on the number of scores computed. + The N smallest total results are returned. + This value cannot be negative, a value of 0 means no global limit. *Default*: 0. - * **bottomN** - Global limit on the number of scores computed. -The N smallest total results are returned. -This value cannot be negative, a value of 0 means no global limit. *Default*: 0. + * **relationshipWeightProperty** - Name of the relationship property to use as weights. + If unspecified, the algorithm runs unweighted. *Default*: null. - * **relationshipWeightProperty** - Name of the relationship property to use as weights. -If unspecified, the algorithm runs unweighted. *Default*: null. + * **similarityMetric** - The metric used to compute similarity. + Can be either `JACCARD`, `OVERLAP` or `COSINE`. *Default*: JACCARD. - * **similarityMetric** - The metric used to compute similarity. -Can be either `JACCARD`, `OVERLAP` or `COSINE`. *Default*: JACCARD. + * ** useComponents** - If enabled, Node Similarity will use components to improve the performance of the computation, skipping comparisons of nodes in different components. + Set to `false` (Default): the algorithm does not use components, but computes similarity across the entire graph. + Set to `true`: the algorithm uses components, and will compute these components before computing similarity. + Set to *String*: use pre-computed components stored in graph, *String* is the key for a node property representing components. *Default*: false. - * ** useComponents** - If enabled, Node Similarity will use components to improve the performance of the computation, skipping comparisons of nodes in different components. -Set to `false` (Default): the algorithm does not use components, but computes similarity across the entire graph. -Set to `true`: the algorithm uses components, and will compute these components before computing similarity. -Set to *String*: use pre-computed components stored in graph, *String* is the key for a node property representing components. *Default*: false. .. py:function:: gds.nodeSimilarity.stream.estimate(G: Graph, **config: Any) -> Series[Any] @@ -1638,20 +1674,22 @@ Set to *String*: use pre-computed components stored in graph, *String* is the ke Page Rank is an algorithm that measures the transitive influence or connectivity of nodes. - | - Configuration parameters: + | - * **dampingFactor** - The damping factor of the Page Rank calculation. Must be in [0, 1). *Default*: 0.85. + Configuration parameters: - * **maxIterations** - The maximum number of iterations of Page Rank to run. *Default*: 20. + * **dampingFactor** - The damping factor of the Page Rank calculation. Must be in [0, 1). *Default*: 0.85. - * **tolerance** - Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable and the algorithm returns. *Default*: 0.0000001. + * **maxIterations** - The maximum number of iterations of Page Rank to run. *Default*: 20. - * **relationshipWeightProperty** - Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + * **tolerance** - Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable and the algorithm returns. *Default*: 0.0000001. - * **sourceNodes** - The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. + * **relationshipWeightProperty** - Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + + * **sourceNodes** - The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. + + * **scaler** - The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. - * **scaler** - The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. .. py:function:: gds.pageRank.stream.estimate(G: Graph, **config: Any) -> Series[Any] @@ -1894,10 +1932,12 @@ Set to *String*: use pre-computed components stored in graph, *String* is the ke Triangle counting is a community detection graph algorithm that is used to determine the number of triangles passing through each node in the graph. - | - Configuration parameters: + | + + Configuration parameters: + + * **maxDegree** - If a node has a degree higher than this it will not be considered by the algorithm. The triangle count for these nodes will be `-1`. *Default*: 2^63^ - 1. - * **maxDegree** - If a node has a degree higher than this it will not be considered by the algorithm. The triangle count for these nodes will be `-1`. *Default*: 2^63^ - 1. .. py:function:: gds.triangleCount.stream.estimate(G: Graph, **config: Any) -> Series[Any] From 6eea2ae66e1d7a70f96b03691fa44b577c298fd0 Mon Sep 17 00:00:00 2001 From: Nicola Vitucci Date: Tue, 14 May 2024 13:44:46 +0100 Subject: [PATCH 06/21] Update RST file --- doc/sphinx/source/algorithms.rst | 104 +++++++++++++------------------ 1 file changed, 44 insertions(+), 60 deletions(-) diff --git a/doc/sphinx/source/algorithms.rst b/doc/sphinx/source/algorithms.rst index 873b945c3..890b300b9 100644 --- a/doc/sphinx/source/algorithms.rst +++ b/doc/sphinx/source/algorithms.rst @@ -380,17 +380,17 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Configuration parameters: - * **dampingFactor** - The damping factor of the Page Rank calculation. Must be in [0, 1). *Default*: 0.85. + * **dampingFactor** - *(Optional)* The damping factor of the Page Rank calculation. Must be in [0, 1). *Default*: 0.85. - * **maxIterations** - The maximum number of iterations of Article Rank to run. *Default*: 20. + * **maxIterations** - *(Optional)* The maximum number of iterations of Article Rank to run. *Default*: 20. - * **tolerance** - Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable, and the algorithm returns. *Default*: 0.0000001. + * **tolerance** - *(Optional)* Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable, and the algorithm returns. *Default*: 0.0000001. - * **relationshipWeightProperty** - Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. - * **sourceNodes** - The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. + * **sourceNodes** - *(Optional)* The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. - * **scaler** - The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. + * **scaler** - *(Optional)* The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. @@ -794,11 +794,11 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Configuration parameters: - * **samplingSize** - The number of source nodes to consider for computing centrality scores. *Default*: node count. + * **samplingSize** - *(Optional)* The number of source nodes to consider for computing centrality scores. *Default*: node count. - * **samplingSeed** - The seed value for the random number generator that selects start nodes. *Default*: null. + * **samplingSeed** - *(Optional)* The seed value for the random number generator that selects start nodes. *Default*: null. - * **relationshipWeightProperty** - Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. @@ -839,17 +839,13 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g | - Required configuration parameters: **sourceNode** - - | - Configuration parameters: - * **sourceNode** - The node id of the node where to start the traversal. *Default*: n/a. + * **sourceNode** - *(Required)* The node id of the node where to start the traversal. *Default*: n/a. - * **targetNodes** - Ids for target nodes. Traversal terminates when any target node is visited. *Default*: empty list. + * **targetNodes** - *(Optional)* Ids for target nodes. Traversal terminates when any target node is visited. *Default*: empty list. - * **maxDepth** - The maximum distance from the source node at which nodes are visited. *Default*: -1. + * **maxDepth** - *(Optional)* The maximum distance from the source node at which nodes are visited. *Default*: -1. @@ -906,15 +902,11 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g | - Required configuration parameters: **communityProperty** - - | - Configuration parameters: - * **relationshipWeightProperty** - Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + * **communityProperty** - *(Required)* The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their conductance computed. *Default*: n/a. - * **communityProperty** - The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their conductance computed. *Default*: n/a. + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. @@ -950,9 +942,9 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Configuration parameters: - * **orientation** - The orientation used to compute node degrees. Supported orientations are `NATURAL`, `REVERSE` and `UNDIRECTED`. *Default*: NATURAL. + * **orientation** - *(Optional)* The orientation used to compute node degrees. Supported orientations are `NATURAL`, `REVERSE` and `UNDIRECTED`. *Default*: NATURAL. - * **relationshipWeightProperty** - Name of the relationship property to use for weighted degree computation. If unspecified, the algorithm runs unweighted. *Default*: null. + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use for weighted degree computation. If unspecified, the algorithm runs unweighted. *Default*: null. @@ -986,17 +978,13 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g | - Required configuration parameters: **sourceNode** - - | - Configuration parameters: - * **sourceNode** - The node id of the node where to start the traversal. *Default*: n/a. + * **sourceNode** - *(Required)* The node id of the node where to start the traversal. *Default*: n/a. - * **targetNodes** - Ids for target nodes. Traversal terminates when any target node is visited. *Default*: empty list. + * **targetNodes** - *(Optional)* Ids for target nodes. Traversal terminates when any target node is visited. *Default*: empty list. - * **maxDepth** - The maximum distance from the source node at which nodes are visited. *Default*: -1. + * **maxDepth** - *(Optional)* The maximum distance from the source node at which nodes are visited. *Default*: -1. @@ -1030,15 +1018,15 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Configuration parameters: - * **maxIterations** - The maximum number of iterations of Eigenvector Centrality to run. *Default*: 20. + * **maxIterations** - *(Optional)* The maximum number of iterations of Eigenvector Centrality to run. *Default*: 20. - * **tolerance** - Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable and the algorithm returns. *Default*: 0.0000001. + * **tolerance** - *(Optional)* Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable and the algorithm returns. *Default*: 0.0000001. - * **relationshipWeightProperty** - Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. - * **sourceNodes** - The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. + * **sourceNodes** - *(Optional)* The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. - * **scaler** - The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. + * **scaler** - *(Optional)* The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. @@ -1406,7 +1394,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Configuration parameters: - * **triangleCountProperty** - Node property that contains pre-computed triangle count. *Default*: n/a. + * **triangleCountProperty** - *(Optional)* Node property that contains pre-computed triangle count. *Default*: n/a. @@ -1482,15 +1470,11 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g | - Required configuration parameters: **communityProperty** - - | - Configuration parameters: - * **relationshipWeightProperty** - Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + * **communityProperty** - *(Required)* The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their modularity score computed. *Default*: n/a. - * **communityProperty** - The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their modularity score computed. *Default*: n/a. + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. @@ -1558,38 +1542,38 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Configuration parameters: - * **similarityCutoff** - Lower limit for the similarity score to be present in the result. + * **similarityCutoff** - *(Optional)* Lower limit for the similarity score to be present in the result. Values must be between 0 and 1. *Default*: 1e-42. - * **degreeCutoff** - Inclusive lower bound on the node degree for a node to be considered in the comparisons. + * **degreeCutoff** - *(Optional)* Inclusive lower bound on the node degree for a node to be considered in the comparisons. This value can not be lower than 1. *Default*: 1. - * **upperDegreeCutoff** - Inclusive upper bound on the node degree for a node to be considered in the comparisons. + * **upperDegreeCutoff** - *(Optional)* Inclusive upper bound on the node degree for a node to be considered in the comparisons. This value can not be lower than 1. *Default*: 2147483647. - * **topK** - Limit on the number of scores per node. + * **topK** - *(Optional)* Limit on the number of scores per node. The K largest results are returned. This value cannot be lower than 1. *Default*: 10. - * **bottomK** - Limit on the number of scores per node. + * **bottomK** - *(Optional)* Limit on the number of scores per node. The K smallest results are returned. This value cannot be lower than 1. *Default*: 10. - * **topN** - Global limit on the number of scores computed. + * **topN** - *(Optional)* Global limit on the number of scores computed. The N largest total results are returned. This value cannot be negative, a value of 0 means no global limit. *Default*: 0. - * **bottomN** - Global limit on the number of scores computed. + * **bottomN** - *(Optional)* Global limit on the number of scores computed. The N smallest total results are returned. This value cannot be negative, a value of 0 means no global limit. *Default*: 0. - * **relationshipWeightProperty** - Name of the relationship property to use as weights. + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. - * **similarityMetric** - The metric used to compute similarity. + * **similarityMetric** - *(Optional)* The metric used to compute similarity. Can be either `JACCARD`, `OVERLAP` or `COSINE`. *Default*: JACCARD. - * ** useComponents** - If enabled, Node Similarity will use components to improve the performance of the computation, skipping comparisons of nodes in different components. + * ** useComponents** - *(Optional)* If enabled, Node Similarity will use components to improve the performance of the computation, skipping comparisons of nodes in different components. Set to `false` (Default): the algorithm does not use components, but computes similarity across the entire graph. Set to `true`: the algorithm uses components, and will compute these components before computing similarity. Set to *String*: use pre-computed components stored in graph, *String* is the key for a node property representing components. *Default*: false. @@ -1678,17 +1662,17 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Configuration parameters: - * **dampingFactor** - The damping factor of the Page Rank calculation. Must be in [0, 1). *Default*: 0.85. + * **dampingFactor** - *(Optional)* The damping factor of the Page Rank calculation. Must be in [0, 1). *Default*: 0.85. - * **maxIterations** - The maximum number of iterations of Page Rank to run. *Default*: 20. + * **maxIterations** - *(Optional)* The maximum number of iterations of Page Rank to run. *Default*: 20. - * **tolerance** - Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable and the algorithm returns. *Default*: 0.0000001. + * **tolerance** - *(Optional)* Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable and the algorithm returns. *Default*: 0.0000001. - * **relationshipWeightProperty** - Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. - * **sourceNodes** - The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. + * **sourceNodes** - *(Optional)* The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. - * **scaler** - The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. + * **scaler** - *(Optional)* The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. @@ -1936,7 +1920,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Configuration parameters: - * **maxDegree** - If a node has a degree higher than this it will not be considered by the algorithm. The triangle count for these nodes will be `-1`. *Default*: 2^63^ - 1. + * **maxDegree** - *(Optional)* If a node has a degree higher than this it will not be considered by the algorithm. The triangle count for these nodes will be `-1`. *Default*: 2^63^ - 1. From 83d6294dae00e8ebbeb135addbb9f15b3ae3f161 Mon Sep 17 00:00:00 2001 From: Nicola Vitucci Date: Tue, 14 May 2024 14:07:34 +0100 Subject: [PATCH 07/21] Update RST file --- doc/sphinx/source/algorithms.rst | 3318 +++++++++++++++++++++++++++++- 1 file changed, 3216 insertions(+), 102 deletions(-) diff --git a/doc/sphinx/source/algorithms.rst b/doc/sphinx/source/algorithms.rst index 890b300b9..7f65c47e3 100644 --- a/doc/sphinx/source/algorithms.rst +++ b/doc/sphinx/source/algorithms.rst @@ -11,69 +11,189 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g The Delta Stepping shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph. The computation is run multi-threaded. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.allShortestPaths.delta.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for allShortestPaths.dealta.mutate. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.allShortestPaths.delta.stats(G: Graph, **config: Any) -> Series[Any] The Delta Stepping shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph. The computation is run multi-threaded + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.allShortestPaths.delta.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for allShortestPaths.delta.stats. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.allShortestPaths.delta.stream(G: Graph, **config: Any) -> DataFrame The Delta Stepping shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph. The computation is run multi-threaded. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.allShortestPaths.delta.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for allShortestPaths.delta.strema. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.allShortestPaths.delta.write(G: Graph, **config: Any) -> Series[Any] The Delta Stepping shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph. The computation is run multi-threaded. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.allShortestPaths.delta.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.allShortestPaths.dijkstra.mutate(G: Graph, **config: Any) -> Series[Any] The Dijkstra shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.allShortestPaths.dijkstra.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.allShortestPaths.dijkstra.stream(G: Graph, **config: Any) -> DataFrame The Dijkstra shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.allShortestPaths.dijkstra.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.allShortestPaths.dijkstra.write(G: Graph, **config: Any) -> Series[Any] The Dijkstra shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.allShortestPaths.dijkstra.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.allShortestPaths.stream(G: Graph, **config: Any) -> DataFrame The All Pairs Shortest Path (APSP) calculates the shortest (weighted) path between all pairs of nodes. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.allShortestPaths.stream(G: Graph, **config: Any) -> DataFrame The All Pairs Shortest Path (APSP) calculates the shortest (weighted) path @@ -82,6 +202,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.allShortestPaths.stream` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.closeness.harmonic.stream(G: Graph, **config: Any) -> DataFrame Harmonic centrality is a way of detecting nodes that are able to spread information @@ -90,6 +218,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.closeness.harmonic.stream` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.closeness.harmonic.write(G: Graph, **config: Any) -> Series[Any] Harmonic centrality is a way of detecting nodes that are able to spread information @@ -98,11 +234,27 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.closeness.harmonic.write` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.conductance.stream(G: Graph, **config: Any) -> DataFrame Evaluates a division of nodes into communities based on the proportion of relationships that cross community boundaries. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.graph.sample.rwr(graph_name: str, from_G: Graph, **config: Any) -> GraphCreateResult Constructs a random subgraph based on random walks with restarts. @@ -110,6 +262,16 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.4.0 Since GDS server version 2.4.0 you should use the endpoint :func:`gds.graph.sample.rwr` instead. + | + + **Parameters:** + + * **graph_name** - str + + * **from_G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.hits.mutate(G: Graph, **config: Any) -> Series[Any] Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes. @@ -117,6 +279,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.hits.mutate` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.hits.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -124,6 +294,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.hits.mutate.estimate` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.hits.stats(G: Graph, **config: Any) -> Series[Any] Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes. @@ -131,6 +309,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.hits.stats` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.hits.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -138,6 +324,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.hits.stats.estimate` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.hits.stream(G: Graph, **config: Any) -> DataFrame Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes. @@ -145,6 +339,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.hits.stream` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.hits.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -152,6 +354,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.hits.stream.estimate` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.hits.write(G: Graph, **config: Any) -> Series[Any] Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes. @@ -159,6 +369,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.hits.write` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.hits.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -166,6 +384,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.hits.write.estimate` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.kSpanningTree.write(G: Graph, **config: Any) -> Series[Any] The K-spanning tree algorithm starts from a root node and returns a spanning tree with exactly k nodes @@ -173,6 +399,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kSpanningTree.write` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.knn.filtered.mutate(G: Graph, **config: Any) -> Series[Any] The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance @@ -180,6 +414,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g KNN computes distances based on the similarity of node properties. Filtered KNN extends this functionality, allowing filtering on source nodes and target nodes, respectively. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.knn.filtered.stats(G: Graph, **config: Any) -> Series[Any] The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance @@ -187,6 +429,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g KNN computes distances based on the similarity of node properties. Filtered KNN extends this functionality, allowing filtering on source nodes and target nodes, respectively. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.knn.filtered.stream(G: Graph, **config: Any) -> DataFrame The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance @@ -194,6 +444,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g KNN computes distances based on the similarity of node properties. Filtered KNN extends this functionality, allowing filtering on source nodes and target nodes, respectively. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.knn.filtered.write(G: Graph, **config: Any) -> Series[Any] The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance @@ -201,30 +459,86 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g KNN computes distances based on the similarity of node properties. Filtered KNN extends this functionality, allowing filtering on source nodes and target nodes, respectively. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.maxkcut.mutate(G: Graph, **config: Any) -> Series[Any] Approximate Maximum k-cut maps each node into one of k disjoint communities trying to maximize the sum of weights of relationships between these communities. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.maxkcut.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Approximate Maximum k-cut maps each node into one of k disjoint communities trying to maximize the sum of weights of relationships between these communities. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.maxkcut.stream(G: Graph, **config: Any) -> DataFrame Approximate Maximum k-cut maps each node into one of k disjoint communities trying to maximize the sum of weights of relationships between these communities. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.maxkcut.stream.estimate(G: Graph, **config: Any) -> Series[Any] Approximate Maximum k-cut maps each node into one of k disjoint communities trying to maximize the sum of weights of relationships between these communities. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.modularity.stats(G: Graph, **config: Any) -> Series[Any] + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.modularity.stream(G: Graph, **config: Any) -> DataFrame + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.nodeSimilarity.filtered.mutate(G: Graph, **config: Any) -> Series[Any] The Filtered Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. @@ -232,10 +546,26 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g The algorithm computes pair-wise similarities based on Jaccard or Overlap metrics. The filtered variant supports limiting which nodes to compare via source and target node filters. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.nodeSimilarity.filtered.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.nodeSimilarity.filtered.stats(G: Graph, **config: Any) -> Series[Any] The Filtered Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. @@ -243,10 +573,26 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g The algorithm computes pair-wise similarities based on Jaccard or Overlap metrics. The filtered variant supports limiting which nodes to compare via source and target node filters. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.nodeSimilarity.filtered.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.nodeSimilarity.filtered.stream(G: Graph, **config: Any) -> DataFrame The Filtered Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. @@ -254,10 +600,26 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g The algorithm computes pair-wise similarities based on Jaccard or Overlap metrics. The filtered variant supports limiting which nodes to compare via source and target node filters. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.nodeSimilarity.filtered.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.nodeSimilarity.filtered.write(G: Graph, **config: Any) -> Series[Any] The Filtered Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. @@ -265,10 +627,26 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g The algorithm computes pair-wise similarities based on Jaccard or Overlap metrics. The filtered variant supports limiting which nodes to compare via source and target node filters. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.nodeSimilarity.filtered.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.scaleProperties.mutate(G: Graph, **config: Any) -> Series[Any] Scale node properties @@ -276,6 +654,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.4.0 Since GDS server version 2.4.0 you should use the endpoint :func:`gds.scaleProperties.mutate` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.scaleProperties.stream(G: Graph, **config: Any) -> DataFrame Scale node properties @@ -283,16 +669,40 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.4.0 Since GDS server version 2.4.0 you should use the endpoint :func:`gds.scaleProperties.stream` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.scc.stream(G: Graph, **config: Any) -> DataFrame The SCC algorithm finds sets of connected nodes in an directed graph, where all nodes in the same set form a connected component. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.scc.write(G: Graph, **config: Any) -> Series[Any] The SCC algorithm finds sets of connected nodes in an directed graph, where all nodes in the same set form a connected component. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.sllpa.mutate(G: Graph, **config: Any) -> Series[Any] The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph. @@ -300,6 +710,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.sllpa.mutate` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.sllpa.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -307,6 +725,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.sllpa.mutate.estimate` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.sllpa.stats(G: Graph, **config: Any) -> Series[Any] The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph. @@ -314,6 +740,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.sllpa.stats` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.sllpa.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -321,6 +755,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.sllpa.stats.estimate` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.sllpa.stream(G: Graph, **config: Any) -> DataFrame The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph. @@ -328,6 +770,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.sllpa.stream` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.sllpa.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -335,6 +785,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.sllpa.stream.estimate` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.sllpa.write(G: Graph, **config: Any) -> Series[Any] The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph. @@ -342,6 +800,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.sllpa.write` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.sllpa.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -349,6 +815,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.sllpa.write.estimate` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.triangles(G: Graph, **config: Any) -> DataFrame Triangles streams the nodeIds of each triangle in the graph. @@ -356,41 +830,85 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.triangles` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.articleRank.mutate(G: Graph, **config: Any) -> Series[Any] Article Rank is a variant of the Page Rank algorithm, which measures the transitive influence or connectivity of nodes. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.articleRank.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.articleRank.stats(G: Graph, **config: Any) -> Series[Any] Executes the algorithm and returns result statistics without writing the result to Neo4j. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.articleRank.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.articleRank.stream(G: Graph, **config: Any) -> DataFrame Article Rank is a variant of the Page Rank algorithm, which measures the transitive influence or connectivity of nodes. | - Configuration parameters: + **Parameters:** + + * **G** - Graph - * **dampingFactor** - *(Optional)* The damping factor of the Page Rank calculation. Must be in [0, 1). *Default*: 0.85. + * ****config** - Any - * **maxIterations** - *(Optional)* The maximum number of iterations of Article Rank to run. *Default*: 20. + * **dampingFactor** - *(Optional)* The damping factor of the Page Rank calculation. Must be in [0, 1). *Default*: 0.85. - * **tolerance** - *(Optional)* Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable, and the algorithm returns. *Default*: 0.0000001. + * **maxIterations** - *(Optional)* The maximum number of iterations of Article Rank to run. *Default*: 20. - * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + * **tolerance** - *(Optional)* Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable, and the algorithm returns. *Default*: 0.0000001. - * **sourceNodes** - *(Optional)* The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. - * **scaler** - *(Optional)* The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. + * **sourceNodes** - *(Optional)* The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. + + * **scaler** - *(Optional)* The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. @@ -398,139 +916,395 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.articleRank.write(G: Graph, **config: Any) -> Series[Any] Article Rank is a variant of the Page Rank algorithm, which measures the transitive influence or connectivity of nodes. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.articleRank.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.bellmanFord.mutate(G: Graph, **config: Any) -> Series[Any] The Bellman-Ford shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph without negative cycles. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.bellmanFord.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.bellmanFord.stats(G: Graph, **config: Any) -> Series[Any] The Bellman-Ford shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph without negative cycles. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.bellmanFord.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.bellmanFord.stream(G: Graph, **config: Any) -> DataFrame The Bellman-Ford shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph without negative cycles. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.bellmanFord.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.bellmanFord.write(G: Graph, **config: Any) -> Series[Any] The Bellman-Ford shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph without negative cycles. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.bellmanFord.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.closeness.mutate(G: Graph, **config: Any) -> Series[Any] Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.closeness.stats(G: Graph, **config: Any) -> Series[Any] Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.closeness.stream(G: Graph, **config: Any) -> DataFrame Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.closeness.write(G: Graph, **config: Any) -> Series[Any] Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.collapsePath.mutate(G: Graph, **config: Any) -> Series[Any] Collapse Path algorithm is a traversal algorithm capable of creating relationships between the start and end nodes of a traversal + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.influenceMaximization.celf.mutate(G: Graph, **config: Any) -> Series[Any] The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes that maximize the expected spread of influence in the network. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.influenceMaximization.celf.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.influenceMaximization.celf.stats(G: Graph, **config: Any) -> Series[Any] Executes the algorithm and returns result statistics without writing the result to Neo4j. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.influenceMaximization.celf.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.influenceMaximization.celf.stream(G: Graph, **config: Any) -> DataFrame The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes that maximize the expected spread of influence in the network. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.influenceMaximization.celf.stream.estimate(G: Graph, **config: Any) -> Series[Any] The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes that maximize the expected spread of influence in the network. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.influenceMaximization.celf.write(G: Graph, **config: Any) -> Series[Any] The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes that maximize the expected spread of influence in the network. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.influenceMaximization.celf.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.k1coloring.mutate(G: Graph, **config: Any) -> Series[Any] The K-1 Coloring algorithm assigns a color to every node in the graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.k1coloring.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.k1coloring.stats(G: Graph, **config: Any) -> Series[Any] The K-1 Coloring algorithm assigns a color to every node in the graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.k1coloring.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.k1coloring.stream(G: Graph, **config: Any) -> DataFrame The K-1 Coloring algorithm assigns a color to every node in the graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.k1coloring.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.k1coloring.write(G: Graph, **config: Any) -> Series[Any] The K-1 Coloring algorithm assigns a color to every node in the graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.k1coloring.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.kmeans.mutate(G: Graph, **config: Any) -> Series[Any] The Kmeans algorithm clusters nodes into different communities based on Euclidean distance @@ -538,6 +1312,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.mutate` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.kmeans.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -545,6 +1327,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.mutate.estimate` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.kmeans.stats(G: Graph, **config: Any) -> Series[Any] The Kmeans algorithm clusters nodes into different communities based on Euclidean distance @@ -552,6 +1342,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.stats` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.kmeans.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -559,6 +1357,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.stats.estimate` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.kmeans.stream(G: Graph, **config: Any) -> DataFrame The Kmeans algorithm clusters nodes into different communities based on Euclidean distance @@ -566,6 +1372,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.stream` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.kmeans.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -573,13 +1387,29 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.stream.estimate` instead. -.. py:function:: gds.beta.kmeans.write(G: Graph, **config: Any) -> Series[Any] + | - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + **Parameters:** -.. deprecated:: 2.5.0 + * **G** - Graph + + * ****config** - Any + +.. py:function:: gds.beta.kmeans.write(G: Graph, **config: Any) -> Series[Any] + + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + +.. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.write` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.kmeans.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -587,218 +1417,598 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.write.estimate` instead. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.leiden.mutate(G: Graph, **config: Any) -> Series[Any] Leiden is a community detection algorithm, which guarantees that communities are well connected + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.leiden.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.leiden.stats(G: Graph, **config: Any) -> Series[Any] Executes the algorithm and returns result statistics without writing the result to Neo4j. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.leiden.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.leiden.stream(G: Graph, **config: Any) -> DataFrame Leiden is a community detection algorithm, which guarantees that communities are well connected + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.leiden.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.leiden.write(G: Graph, **config: Any) -> Series[Any] Leiden is a community detection algorithm, which guarantees that communities are well connected + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.leiden.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.modularityOptimization.mutate(G: Graph, **config: Any) -> Series[Any] The Modularity Optimization algorithm groups the nodes in the graph by optimizing the graphs modularity. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.modularityOptimization.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.modularityOptimization.stream(G: Graph, **config: Any) -> DataFrame The Modularity Optimization algorithm groups the nodes in the graph by optimizing the graphs modularity. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.modularityOptimization.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.modularityOptimization.write(G: Graph, **config: Any) -> Series[Any] The Modularity Optimization algorithm groups the nodes in the graph by optimizing the graphs modularity. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.modularityOptimization.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.scaleProperties.mutate(G: Graph, **config: Any) -> Series[Any] Scale node properties + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.scaleProperties.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.scaleProperties.stats(G: Graph, **config: Any) -> Series[Any] Scale node properties + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.scaleProperties.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.scaleProperties.stream(G: Graph, **config: Any) -> DataFrame Scale node properties + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.scaleProperties.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.scaleProperties.write(G: Graph, **config: Any) -> Series[Any] Scale node properties + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.scaleProperties.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.scc.mutate(G: Graph, **config: Any) -> Series[Any] The SCC algorithm finds sets of connected nodes in an directed graph, where all nodes in the same set form a connected component. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.scc.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for SCC. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.scc.stats(G: Graph, **config: Any) -> Series[Any] The SCC algorithm finds sets of connected nodes in an directed graph, where all nodes in the same set form a connected component. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.scc.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for SCC. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.scc.stream(G: Graph, **config: Any) -> DataFrame The SCC algorithm finds sets of connected nodes in an directed graph, where all nodes in the same set form a connected component. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.scc.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for SCC. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.scc.write(G: Graph, **config: Any) -> Series[Any] The SCC algorithm finds sets of connected nodes in an directed graph, where all nodes in the same set form a connected component. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.scc.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for SCC. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.spanningTree.mutate(G: Graph, **config: Any) -> Series[Any] The spanning tree algorithm visits all nodes that are in the same connected component as the starting node, and returns a spanning tree of all nodes in the component where the total weight of the relationships is either minimized or maximized. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.spanningTree.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.spanningTree.stats(G: Graph, **config: Any) -> Series[Any] The spanning tree algorithm visits all nodes that are in the same connected component as the starting node, and returns a spanning tree of all nodes in the component where the total weight of the relationships is either minimized or maximized. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.spanningTree.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.spanningTree.stream(G: Graph, **config: Any) -> DataFrame The spanning tree algorithm visits all nodes that are in the same connected component as the starting node, and returns a spanning tree of all nodes in the component where the total weight of the relationships is either minimized or maximized. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.spanningTree.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.spanningTree.write(G: Graph, **config: Any) -> Series[Any] The spanning tree algorithm visits all nodes that are in the same connected component as the starting node, and returns a spanning tree of all nodes in the component where the total weight of the relationships is either minimized or maximized. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.spanningTree.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.steinerTree.mutate(G: Graph, **config: Any) -> Series[Any] The steiner tree algorithm accepts a source node, as well as a list of target nodes. It then attempts to find a spanning tree where there is a path from the source node to each target node, such that the total weight of the relationships is as low as possible. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.steinerTree.stats(G: Graph, **config: Any) -> Series[Any] The steiner tree algorithm accepts a source node, as well as a list of target nodes. It then attempts to find a spanning tree where there is a path from the source node to each target node, such that the total weight of the relationships is as low as possible. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.steinerTree.stream(G: Graph, **config: Any) -> DataFrame The steiner tree algorithm accepts a source node, as well as a list of target nodes. It then attempts to find a spanning tree where there is a path from the source node to each target node, such that the total weight of the relationships is as low as possible. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.beta.steinerTree.write(G: Graph, **config: Any) -> Series[Any] The steiner tree algorithm accepts a source node, as well as a list of target nodes. It then attempts to find a spanning tree where there is a path from the source node to each target node, such that the total weight of the relationships is as low as possible. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.betweenness.mutate(G: Graph, **config: Any) -> Series[Any] Betweenness centrality measures the relative information flow that passes through a node. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.betweenness.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Betweenness centrality measures the relative information flow that passes through a node. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.betweenness.stats(G: Graph, **config: Any) -> Series[Any] Betweenness centrality measures the relative information flow that passes through a node. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.betweenness.stats.estimate(G: Graph, **config: Any) -> Series[Any] Betweenness centrality measures the relative information flow that passes through a node. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.betweenness.stream(G: Graph, **config: Any) -> DataFrame Betweenness centrality measures the relative information flow that passes through a node. | - Configuration parameters: + **Parameters:** + + * **G** - Graph - * **samplingSize** - *(Optional)* The number of source nodes to consider for computing centrality scores. *Default*: node count. + * ****config** - Any - * **samplingSeed** - *(Optional)* The seed value for the random number generator that selects start nodes. *Default*: null. + * **samplingSize** - *(Optional)* The number of source nodes to consider for computing centrality scores. *Default*: node count. - * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + * **samplingSeed** - *(Optional)* The seed value for the random number generator that selects start nodes. *Default*: null. + + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. @@ -806,32 +2016,88 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Betweenness centrality measures the relative information flow that passes through a node. -.. py:function:: gds.betweenness.write(G: Graph, **config: Any) -> Series[Any] + | - Betweenness centrality measures the relative information flow that passes through a node. + **Parameters:** -.. py:function:: gds.betweenness.write.estimate(G: Graph, **config: Any) -> Series[Any] + * **G** - Graph - Betweenness centrality measures the relative information flow that passes through a node. + * ****config** - Any -.. py:function:: gds.bfs.mutate(G: Graph, **config: Any) -> Series[Any] +.. py:function:: gds.betweenness.write(G: Graph, **config: Any) -> Series[Any] + + Betweenness centrality measures the relative information flow that passes through a node. + + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + +.. py:function:: gds.betweenness.write.estimate(G: Graph, **config: Any) -> Series[Any] + + Betweenness centrality measures the relative information flow that passes through a node. + + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + +.. py:function:: gds.bfs.mutate(G: Graph, **config: Any) -> Series[Any] BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.bfs.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.bfs.stats(G: Graph, **config: Any) -> Series[Any] BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.bfs.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.bfs.stream(G: Graph, **config: Any) -> DataFrame BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth @@ -839,13 +2105,17 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g | - Configuration parameters: + **Parameters:** + + * **G** - Graph + + * ****config** - Any - * **sourceNode** - *(Required)* The node id of the node where to start the traversal. *Default*: n/a. + * **sourceNode** - *(Required)* The node id of the node where to start the traversal. *Default*: n/a. - * **targetNodes** - *(Optional)* Ids for target nodes. Traversal terminates when any target node is visited. *Default*: empty list. + * **targetNodes** - *(Optional)* Ids for target nodes. Traversal terminates when any target node is visited. *Default*: empty list. - * **maxDepth** - *(Optional)* The maximum distance from the source node at which nodes are visited. *Default*: -1. + * **maxDepth** - *(Optional)* The maximum distance from the source node at which nodes are visited. *Default*: -1. @@ -854,47 +2124,127 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.closeness.mutate(G: Graph, **config: Any) -> Series[Any] Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.closeness.stats(G: Graph, **config: Any) -> Series[Any] Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.closeness.stream(G: Graph, **config: Any) -> DataFrame Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.closeness.write(G: Graph, **config: Any) -> Series[Any] Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.closeness.harmonic.mutate(G: Graph, **config: Any) -> DataFrame Harmonic centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.closeness.harmonic.stats(G: Graph, **config: Any) -> DataFrame Harmonic centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.closeness.harmonic.stream(G: Graph, **config: Any) -> DataFrame Harmonic centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.closeness.harmonic.write(G: Graph, **config: Any) -> Series[Any] Harmonic centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.collapsePath.mutate(G: Graph, **config: Any) -> Series[Any] Collapse Path algorithm is a traversal algorithm capable of creating relationships between the start and end nodes of a traversal + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.conductance.stream(G: Graph, **config: Any) -> DataFrame Evaluates a division of nodes into communities based on the proportion of relationships @@ -902,11 +2252,15 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g | - Configuration parameters: + **Parameters:** + + * **G** - Graph + + * ****config** - Any - * **communityProperty** - *(Required)* The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their conductance computed. *Default*: n/a. + * **communityProperty** - *(Required)* The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their conductance computed. *Default*: n/a. - * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. @@ -914,37 +2268,89 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Returns a topological ordering of the nodes in a directed acyclic graph (DAG). + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.dag.longestPath.stream(G: Graph, **config: Any) -> DataFrame Finds the longest path that leads to a node in a directed acyclic graph (DAG). + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.degree.mutate(G: Graph, **config: Any) -> Series[Any] Degree centrality measures the number of incoming and outgoing relationships from a node. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.degree.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Degree centrality measures the number of incoming and outgoing relationships from a node. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.degree.stats(G: Graph, **config: Any) -> Series[Any] Degree centrality measures the number of incoming and outgoing relationships from a node. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.degree.stats.estimate(G: Graph, **config: Any) -> Series[Any] Degree centrality measures the number of incoming and outgoing relationships from a node. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.degree.stream(G: Graph, **config: Any) -> DataFrame Degree centrality measures the number of incoming and outgoing relationships from a node. | - Configuration parameters: + **Parameters:** + + * **G** - Graph + + * ****config** - Any - * **orientation** - *(Optional)* The orientation used to compute node degrees. Supported orientations are `NATURAL`, `REVERSE` and `UNDIRECTED`. *Default*: NATURAL. + * **orientation** - *(Optional)* The orientation used to compute node degrees. Supported orientations are `NATURAL`, `REVERSE` and `UNDIRECTED`. *Default*: NATURAL. - * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use for weighted degree computation. If unspecified, the algorithm runs unweighted. *Default*: null. + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use for weighted degree computation. If unspecified, the algorithm runs unweighted. *Default*: null. @@ -952,24 +2358,64 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Degree centrality measures the number of incoming and outgoing relationships from a node. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.degree.write(G: Graph, **config: Any) -> Series[Any] Degree centrality measures the number of incoming and outgoing relationships from a node. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.degree.write.estimate(G: Graph, **config: Any) -> Series[Any] Degree centrality measures the number of incoming and outgoing relationships from a node. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.dfs.mutate(G: Graph, **config: Any) -> Series[Any] Depth-first search (DFS) is an algorithm for traversing or searching tree or graph data structures. The algorithm starts at the root node (selecting some arbitrary node as the root node in the case of a graph) and explores as far as possible along each branch before backtracking. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.dfs.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.dfs.stream(G: Graph, **config: Any) -> DataFrame Depth-first search (DFS) is an algorithm for traversing or searching tree or graph data structures. @@ -978,13 +2424,17 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g | - Configuration parameters: + **Parameters:** + + * **G** - Graph - * **sourceNode** - *(Required)* The node id of the node where to start the traversal. *Default*: n/a. + * ****config** - Any - * **targetNodes** - *(Optional)* Ids for target nodes. Traversal terminates when any target node is visited. *Default*: empty list. + * **sourceNode** - *(Required)* The node id of the node where to start the traversal. *Default*: n/a. - * **maxDepth** - *(Optional)* The maximum distance from the source node at which nodes are visited. *Default*: -1. + * **targetNodes** - *(Optional)* Ids for target nodes. Traversal terminates when any target node is visited. *Default*: empty list. + + * **maxDepth** - *(Optional)* The maximum distance from the source node at which nodes are visited. *Default*: -1. @@ -994,39 +2444,83 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g The algorithm starts at the root node (selecting some arbitrary node as the root node in the case of a graph) and explores as far as possible along each branch before backtracking. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.eigenvector.mutate(G: Graph, **config: Any) -> Series[Any] Eigenvector Centrality is an algorithm that measures the transitive influence or connectivity of nodes. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.eigenvector.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.eigenvector.stats(G: Graph, **config: Any) -> Series[Any] Eigenvector Centrality is an algorithm that measures the transitive influence or connectivity of nodes. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.eigenvector.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.eigenvector.stream(G: Graph, **config: Any) -> DataFrame Eigenvector Centrality is an algorithm that measures the transitive influence or connectivity of nodes. | - Configuration parameters: + **Parameters:** - * **maxIterations** - *(Optional)* The maximum number of iterations of Eigenvector Centrality to run. *Default*: 20. + * **G** - Graph - * **tolerance** - *(Optional)* Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable and the algorithm returns. *Default*: 0.0000001. + * ****config** - Any - * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + * **maxIterations** - *(Optional)* The maximum number of iterations of Eigenvector Centrality to run. *Default*: 20. - * **sourceNodes** - *(Optional)* The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. + * **tolerance** - *(Optional)* Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable and the algorithm returns. *Default*: 0.0000001. - * **scaler** - *(Optional)* The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + + * **sourceNodes** - *(Optional)* The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. + + * **scaler** - *(Optional)* The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. @@ -1034,230 +2528,666 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.eigenvector.write(G: Graph, **config: Any) -> Series[Any] Eigenvector Centrality is an algorithm that measures the transitive influence or connectivity of nodes. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.eigenvector.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.graph.sample.cnarw(graph_name: str, from_G: Graph, **config: Any) -> GraphCreateResult Constructs a random subgraph based on common-neighbour-aware random walks. + | + + **Parameters:** + + * **graph_name** - str + + * **from_G** - Graph + + * ****config** - Any + .. py:function:: gds.graph.sample.cnarw.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.graph.sample.rwr(graph_name: str, from_G: Graph, **config: Any) -> GraphCreateResult Constructs a random subgraph based on random walks with restarts. + | + + **Parameters:** + + * **graph_name** - str + + * **from_G** - Graph + + * ****config** - Any + .. py:function:: gds.hits.mutate(G: Graph, **config: Any) -> Series[Any] Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.hits.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.hits.stats(G: Graph, **config: Any) -> Series[Any] Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.hits.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.hits.stream(G: Graph, **config: Any) -> DataFrame Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.hits.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.hits.write(G: Graph, **config: Any) -> Series[Any] Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes. -.. py:function:: gds.hits.write.estimate(G: Graph, **config: Any) -> Series[Any] + | - Returns an estimation of the memory consumption for that procedure. + **Parameters:** -.. py:function:: gds.influenceMaximization.celf.mutate(G: Graph, **config: Any) -> Series[Any] + * **G** - Graph - The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes - that maximize the expected spread of influence in the network. + * ****config** - Any -.. py:function:: gds.influenceMaximization.celf.mutate.estimate(G: Graph, **config: Any) -> Series[Any] +.. py:function:: gds.hits.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. -.. py:function:: gds.influenceMaximization.celf.stats(G: Graph, **config: Any) -> Series[Any] + | - Executes the algorithm and returns result statistics without writing the result to Neo4j. + **Parameters:** -.. py:function:: gds.influenceMaximization.celf.stats.estimate(G: Graph, **config: Any) -> Series[Any] + * **G** - Graph - Returns an estimation of the memory consumption for that procedure. + * ****config** - Any -.. py:function:: gds.influenceMaximization.celf.stream(G: Graph, **config: Any) -> DataFrame +.. py:function:: gds.influenceMaximization.celf.mutate(G: Graph, **config: Any) -> Series[Any] The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes that maximize the expected spread of influence in the network. -.. py:function:: gds.influenceMaximization.celf.stream.estimate(G: Graph, **config: Any) -> Series[Any] + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + +.. py:function:: gds.influenceMaximization.celf.mutate.estimate(G: Graph, **config: Any) -> Series[Any] + + Returns an estimation of the memory consumption for that procedure. + + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + +.. py:function:: gds.influenceMaximization.celf.stats(G: Graph, **config: Any) -> Series[Any] + + Executes the algorithm and returns result statistics without writing the result to Neo4j. + + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + +.. py:function:: gds.influenceMaximization.celf.stats.estimate(G: Graph, **config: Any) -> Series[Any] + + Returns an estimation of the memory consumption for that procedure. + + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + +.. py:function:: gds.influenceMaximization.celf.stream(G: Graph, **config: Any) -> DataFrame + + The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes + that maximize the expected spread of influence in the network. + + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + +.. py:function:: gds.influenceMaximization.celf.stream.estimate(G: Graph, **config: Any) -> Series[Any] The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes that maximize the expected spread of influence in the network. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.influenceMaximization.celf.write(G: Graph, **config: Any) -> Series[Any] The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes that maximize the expected spread of influence in the network. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.influenceMaximization.celf.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.kmeans.mutate(G: Graph, **config: Any) -> Series[Any] The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.kmeans.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.kmeans.stats(G: Graph, **config: Any) -> Series[Any] The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.kmeans.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.kmeans.stream(G: Graph, **config: Any) -> DataFrame The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.kmeans.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.kmeans.write(G: Graph, **config: Any) -> Series[Any] The Kmeans algorithm clusters nodes into different communities based on Euclidean distance + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.kmeans.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.k1coloring.mutate(G: Graph, **config: Any) -> Series[Any] The K-1 Coloring algorithm assigns a color to every node in the graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.k1coloring.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.k1coloring.stats(G: Graph, **config: Any) -> Series[Any] The K-1 Coloring algorithm assigns a color to every node in the graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.k1coloring.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.k1coloring.stream(G: Graph, **config: Any) -> DataFrame The K-1 Coloring algorithm assigns a color to every node in the graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.k1coloring.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.k1coloring.write(G: Graph, **config: Any) -> Series[Any] The K-1 Coloring algorithm assigns a color to every node in the graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.k1coloring.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.kcore.mutate(G: Graph, **config: Any) -> Series[Any] Computes the k-core values in a network + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.kcore.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.kcore.stats(G: Graph, **config: Any) -> Series[Any] Computes the k-core values in a network + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.kcore.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.kcore.stream(G: Graph, **config: Any) -> Series[Any] Computes the k-core values in a network + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.kcore.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.kcore.write(G: Graph, **config: Any) -> Series[Any] Computes the k-core values in a network + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.kcore.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.knn.mutate(G: Graph, **config: Any) -> Series[Any] The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance between two nodes is among the k nearest distances compared to other nodes. KNN computes distances based on the similarity of node properties + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.knn.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.knn.stats(G: Graph, **config: Any) -> Series[Any] The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance between two nodes is among the k nearest distances compared to other nodes. KNN computes distances based on the similarity of node properties + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.knn.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.knn.stream(G: Graph, **config: Any) -> DataFrame The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance between two nodes is among the k nearest distances compared to other nodes. KNN computes distances based on the similarity of node properties + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.knn.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.knn.write(G: Graph, **config: Any) -> Series[Any] The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance between two nodes is among the k nearest distances compared to other nodes. KNN computes distances based on the similarity of node properties + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.knn.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.knn.filtered.mutate(G: Graph, **config: Any) -> Series[Any] The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance @@ -1269,6 +3199,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.knn.filtered.stats(G: Graph, **config: Any) -> Series[Any] The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance @@ -1276,10 +3214,26 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g KNN computes distances based on the similarity of node properties. Filtered KNN extends this functionality, allowing filtering on source nodes and target nodes, respectively. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.knn.filtered.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.knn.filtered.stream(G: Graph, **config: Any) -> DataFrame The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance @@ -1287,10 +3241,26 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g KNN computes distances based on the similarity of node properties. Filtered KNN extends this functionality, allowing filtering on source nodes and target nodes, respectively. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.knn.filtered.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.knn.filtered.write(G: Graph, **config: Any) -> Series[Any] The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance @@ -1298,103 +3268,291 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g KNN computes distances based on the similarity of node properties. Filtered KNN extends this functionality, allowing filtering on source nodes and target nodes, respectively. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.knn.filtered.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.kSpanningTree.write(G: Graph, **config: Any) -> Series[Any] The K-spanning tree algorithm starts from a root node and returns a spanning tree with exactly k nodes + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.labelPropagation.mutate(G: Graph, **config: Any) -> Series[Any] The Label Propagation algorithm is a fast algorithm for finding communities in a graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.labelPropagation.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.labelPropagation.stats(G: Graph, **config: Any) -> Series[Any] The Label Propagation algorithm is a fast algorithm for finding communities in a graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.labelPropagation.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.labelPropagation.stream(G: Graph, **config: Any) -> DataFrame The Label Propagation algorithm is a fast algorithm for finding communities in a graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.labelPropagation.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.labelPropagation.write(G: Graph, **config: Any) -> Series[Any] The Label Propagation algorithm is a fast algorithm for finding communities in a graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.labelPropagation.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.leiden.mutate(G: Graph, **config: Any) -> Series[Any] Leiden is a community detection algorithm, which guarantees that communities are well connected + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.leiden.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.leiden.stats(G: Graph, **config: Any) -> Series[Any] Executes the algorithm and returns result statistics without writing the result to Neo4j. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.leiden.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.leiden.stream(G: Graph, **config: Any) -> DataFrame Leiden is a community detection algorithm, which guarantees that communities are well connected + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.leiden.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.leiden.write(G: Graph, **config: Any) -> Series[Any] Leiden is a community detection algorithm, which guarantees that communities are well connected + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.leiden.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.localClusteringCoefficient.mutate(G: Graph, **config: Any) -> Series[Any] The local clustering coefficient is a metric quantifying how connected the neighborhood of a node is. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.localClusteringCoefficient.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.localClusteringCoefficient.stats(G: Graph, **config: Any) -> Series[Any] Executes the algorithm and returns result statistics without writing the result to Neo4j. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.localClusteringCoefficient.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.localClusteringCoefficient.stream(G: Graph, **config: Any) -> DataFrame The local clustering coefficient is a metric quantifying how connected the neighborhood of a node is. | - Configuration parameters: + **Parameters:** + + * **G** - Graph + + * ****config** - Any - * **triangleCountProperty** - *(Optional)* Node property that contains pre-computed triangle count. *Default*: n/a. + * **triangleCountProperty** - *(Optional)* Node property that contains pre-computed triangle count. *Default*: n/a. @@ -1402,115 +3560,327 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.localClusteringCoefficient.write(G: Graph, **config: Any) -> Series[Any] The local clustering coefficient is a metric quantifying how connected the neighborhood of a node is. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.localClusteringCoefficient.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.louvain.mutate(G: Graph, **config: Any) -> Series[Any] The Louvain method for community detection is an algorithm for detecting communities in networks. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.louvain.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.louvain.stats(G: Graph, **config: Any) -> Series[Any] Executes the algorithm and returns result statistics without writing the result to Neo4j. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.louvain.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.louvain.stream(G: Graph, **config: Any) -> DataFrame The Louvain method for community detection is an algorithm for detecting communities in networks. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.louvain.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.louvain.write(G: Graph, **config: Any) -> Series[Any] The Louvain method for community detection is an algorithm for detecting communities in networks. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.louvain.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.maxkcut.mutate(G: Graph, **config: Any) -> Series[Any] Approximate Maximum k-cut maps each node into one of k disjoint communities trying to maximize the sum of weights of relationships between these communities. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.maxkcut.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Approximate Maximum k-cut maps each node into one of k disjoint communities trying to maximize the sum of weights of relationships between these communities. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.maxkcut.stream(G: Graph, **config: Any) -> DataFrame Approximate Maximum k-cut maps each node into one of k disjoint communities trying to maximize the sum of weights of relationships between these communities. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.maxkcut.stream.estimate(G: Graph, **config: Any) -> Series[Any] Approximate Maximum k-cut maps each node into one of k disjoint communities trying to maximize the sum of weights of relationships between these communities. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.modularity.stats(G: Graph, **config: Any) -> Series[Any] + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.modularity.stats.estimate(G: Graph, **config: Any) -> Series[Any] + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.modularity.stream(G: Graph, **config: Any) -> DataFrame | - Configuration parameters: + **Parameters:** - * **communityProperty** - *(Required)* The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their modularity score computed. *Default*: n/a. + * **G** - Graph - * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + * ****config** - Any + + * **communityProperty** - *(Required)* The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their modularity score computed. *Default*: n/a. + + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. .. py:function:: gds.modularity.stream.estimate(G: Graph, **config: Any) -> Series[Any] + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.modularityOptimization.mutate(G: Graph, **config: Any) -> Series[Any] The Modularity Optimization algorithm groups the nodes in the graph by optimizing the graphs modularity. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.modularityOptimization.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.modularityOptimization.stats(G: Graph, **config: Any) -> Series[Any] The Modularity Optimization algorithm groups the nodes in the graph by optimizing the graphs modularity. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.modularityOptimization.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.modularityOptimization.stream(G: Graph, **config: Any) -> DataFrame The Modularity Optimization algorithm groups the nodes in the graph by optimizing the graphs modularity. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.modularityOptimization.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.modularityOptimization.write(G: Graph, **config: Any) -> Series[Any] The Modularity Optimization algorithm groups the nodes in the graph by optimizing the graphs modularity. -.. py:function:: gds.modularityOptimization.write.estimate(G: Graph, **config: Any) -> Series[Any] + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + +.. py:function:: gds.modularityOptimization.write.estimate(G: Graph, **config: Any) -> Series[Any] + + Returns an estimation of the memory consumption for that procedure. + + | + + **Parameters:** + + * **G** - Graph - Returns an estimation of the memory consumption for that procedure. + * ****config** - Any .. py:function:: gds.nodeSimilarity.mutate(G: Graph, **config: Any) -> Series[Any] @@ -1518,20 +3888,52 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Two nodes are considered similar if they share many of the same neighbors. Node Similarity computes pair-wise similarities based on the Jaccard metric. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.nodeSimilarity.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.nodeSimilarity.stats(G: Graph, **config: Any) -> Series[Any] The Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. Two nodes are considered similar if they share many of the same neighbors. Node Similarity computes pair-wise similarities based on the Jaccard metric. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.nodeSimilarity.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.nodeSimilarity.stream(G: Graph, **config: Any) -> DataFrame The Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. @@ -1540,40 +3942,44 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g | - Configuration parameters: + **Parameters:** + + * **G** - Graph + + * ****config** - Any - * **similarityCutoff** - *(Optional)* Lower limit for the similarity score to be present in the result. + * **similarityCutoff** - *(Optional)* Lower limit for the similarity score to be present in the result. Values must be between 0 and 1. *Default*: 1e-42. - * **degreeCutoff** - *(Optional)* Inclusive lower bound on the node degree for a node to be considered in the comparisons. + * **degreeCutoff** - *(Optional)* Inclusive lower bound on the node degree for a node to be considered in the comparisons. This value can not be lower than 1. *Default*: 1. - * **upperDegreeCutoff** - *(Optional)* Inclusive upper bound on the node degree for a node to be considered in the comparisons. + * **upperDegreeCutoff** - *(Optional)* Inclusive upper bound on the node degree for a node to be considered in the comparisons. This value can not be lower than 1. *Default*: 2147483647. - * **topK** - *(Optional)* Limit on the number of scores per node. + * **topK** - *(Optional)* Limit on the number of scores per node. The K largest results are returned. This value cannot be lower than 1. *Default*: 10. - * **bottomK** - *(Optional)* Limit on the number of scores per node. + * **bottomK** - *(Optional)* Limit on the number of scores per node. The K smallest results are returned. This value cannot be lower than 1. *Default*: 10. - * **topN** - *(Optional)* Global limit on the number of scores computed. + * **topN** - *(Optional)* Global limit on the number of scores computed. The N largest total results are returned. This value cannot be negative, a value of 0 means no global limit. *Default*: 0. - * **bottomN** - *(Optional)* Global limit on the number of scores computed. + * **bottomN** - *(Optional)* Global limit on the number of scores computed. The N smallest total results are returned. This value cannot be negative, a value of 0 means no global limit. *Default*: 0. - * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. - * **similarityMetric** - *(Optional)* The metric used to compute similarity. + * **similarityMetric** - *(Optional)* The metric used to compute similarity. Can be either `JACCARD`, `OVERLAP` or `COSINE`. *Default*: JACCARD. - * ** useComponents** - *(Optional)* If enabled, Node Similarity will use components to improve the performance of the computation, skipping comparisons of nodes in different components. + * ** useComponents** - *(Optional)* If enabled, Node Similarity will use components to improve the performance of the computation, skipping comparisons of nodes in different components. Set to `false` (Default): the algorithm does not use components, but computes similarity across the entire graph. Set to `true`: the algorithm uses components, and will compute these components before computing similarity. Set to *String*: use pre-computed components stored in graph, *String* is the key for a node property representing components. *Default*: false. @@ -1584,16 +3990,40 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.nodeSimilarity.write(G: Graph, **config: Any) -> Series[Any] The Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. Two nodes are considered similar if they share many of the same neighbors. Node Similarity computes pair-wise similarities based on the Jaccard metric. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.nodeSimilarity.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.nodeSimilarity.filtered.mutate(G: Graph, **config: Any) -> Series[Any] The Filtered Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. @@ -1601,10 +4031,26 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g The algorithm computes pair-wise similarities based on Jaccard or Overlap metrics. The filtered variant supports limiting which nodes to compare via source and target node filters. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.nodeSimilarity.filtered.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.nodeSimilarity.filtered.stats(G: Graph, **config: Any) -> Series[Any] The Filtered Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. @@ -1612,10 +4058,26 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g The algorithm computes pair-wise similarities based on Jaccard or Overlap metrics. The filtered variant supports limiting which nodes to compare via source and target node filters. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.nodeSimilarity.filtered.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.nodeSimilarity.filtered.stream(G: Graph, **config: Any) -> DataFrame The Filtered Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. @@ -1623,10 +4085,26 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g The algorithm computes pair-wise similarities based on Jaccard or Overlap metrics. The filtered variant supports limiting which nodes to compare via source and target node filters. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.nodeSimilarity.filtered.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.nodeSimilarity.filtered.write(G: Graph, **config: Any) -> Series[Any] The Filtered Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. @@ -1634,45 +4112,97 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g The algorithm computes pair-wise similarities based on Jaccard or Overlap metrics. The filtered variant supports limiting which nodes to compare via source and target node filters. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.nodeSimilarity.filtered.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.pageRank.mutate(G: Graph, **config: Any) -> Series[Any] Page Rank is an algorithm that measures the transitive influence or connectivity of nodes. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.pageRank.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.pageRank.stats(G: Graph, **config: Any) -> Series[Any] Executes the algorithm and returns result statistics without writing the result to Neo4j. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.pageRank.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.pageRank.stream(G: Graph, **config: Any) -> DataFrame Page Rank is an algorithm that measures the transitive influence or connectivity of nodes. | - Configuration parameters: + **Parameters:** + + * **G** - Graph - * **dampingFactor** - *(Optional)* The damping factor of the Page Rank calculation. Must be in [0, 1). *Default*: 0.85. + * ****config** - Any - * **maxIterations** - *(Optional)* The maximum number of iterations of Page Rank to run. *Default*: 20. + * **dampingFactor** - *(Optional)* The damping factor of the Page Rank calculation. Must be in [0, 1). *Default*: 0.85. - * **tolerance** - *(Optional)* Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable and the algorithm returns. *Default*: 0.0000001. + * **maxIterations** - *(Optional)* The maximum number of iterations of Page Rank to run. *Default*: 20. - * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + * **tolerance** - *(Optional)* Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable and the algorithm returns. *Default*: 0.0000001. - * **sourceNodes** - *(Optional)* The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. - * **scaler** - *(Optional)* The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. + * **sourceNodes** - *(Optional)* The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. + + * **scaler** - *(Optional)* The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. @@ -1680,237 +4210,661 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.pageRank.write(G: Graph, **config: Any) -> Series[Any] Page Rank is an algorithm that measures the transitive influence or connectivity of nodes. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.pageRank.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.randomWalk.stats(G: Graph, **config: Any) -> Series[Any] Random Walk is an algorithm that provides random paths in a graph. It’s similar to how a drunk person traverses a city. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.randomWalk.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.randomWalk.stream(G: Graph, **config: Any) -> DataFrame Random Walk is an algorithm that provides random paths in a graph. It’s similar to how a drunk person traverses a city. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.randomWalk.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.shortestPath.astar.mutate(G: Graph, **config: Any) -> Series[Any] The A* shortest path algorithm computes the shortest path between a pair of nodes. It uses the relationship weight property to compare path lengths. In addition, this implementation uses the haversine distance as a heuristic to converge faster. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.shortestPath.astar.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.shortestPath.astar.stream(G: Graph, **config: Any) -> DataFrame The A* shortest path algorithm computes the shortest path between a pair of nodes. It uses the relationship weight property to compare path lengths. In addition, this implementation uses the haversine distance as a heuristic to converge faster. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.shortestPath.astar.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.shortestPath.astar.write(G: Graph, **config: Any) -> Series[Any] The A* shortest path algorithm computes the shortest path between a pair of nodes. It uses the relationship weight property to compare path lengths. In addition, this implementation uses the haversine distance as a heuristic to converge faster. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.shortestPath.astar.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.shortestPath.dijkstra.mutate(G: Graph, **config: Any) -> Series[Any] The Dijkstra shortest path algorithm computes the shortest (weighted) path between a pair of nodes. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.shortestPath.dijkstra.mutate.estimate(G: Graph, **config: Any) -> Series[Any] - Returns an estimation of the memory consumption for that procedure. + Returns an estimation of the memory consumption for that procedure. + + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + +.. py:function:: gds.shortestPath.dijkstra.stream(G: Graph, **config: Any) -> DataFrame + + The Dijkstra shortest path algorithm computes the shortest (weighted) path between a pair of nodes. + + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + +.. py:function:: gds.shortestPath.dijkstra.stream.estimate(G: Graph, **config: Any) -> Series[Any] + + Returns an estimation of the memory consumption for that procedure. + + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + +.. py:function:: gds.shortestPath.dijkstra.write(G: Graph, **config: Any) -> Series[Any] + + The Dijkstra shortest path algorithm computes the shortest (weighted) path between a pair of nodes. + + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + +.. py:function:: gds.shortestPath.dijkstra.write.estimate(G: Graph, **config: Any) -> Series[Any] + + Returns an estimation of the memory consumption for that procedure. + + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + +.. py:function:: gds.shortestPath.yens.mutate(G: Graph, **config: Any) -> Series[Any] + + The Yen's shortest path algorithm computes the k shortest (weighted) paths between a pair of nodes. + + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + +.. py:function:: gds.shortestPath.yens.mutate.estimate(G: Graph, **config: Any) -> Series[Any] + + Returns an estimation of the memory consumption for that procedure. + + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + +.. py:function:: gds.shortestPath.yens.stream(G: Graph, **config: Any) -> DataFrame + + The Yen's shortest path algorithm computes the k shortest (weighted) paths between a pair of nodes. + + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + +.. py:function:: gds.shortestPath.yens.stream.estimate(G: Graph, **config: Any) -> Series[Any] + + Returns an estimation of the memory consumption for that procedure. + + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + +.. py:function:: gds.shortestPath.yens.write(G: Graph, **config: Any) -> Series[Any] + + The Yen's shortest path algorithm computes the k shortest (weighted) paths between a pair of nodes. + + | + + **Parameters:** -.. py:function:: gds.shortestPath.dijkstra.stream(G: Graph, **config: Any) -> DataFrame + * **G** - Graph - The Dijkstra shortest path algorithm computes the shortest (weighted) path between a pair of nodes. + * ****config** - Any -.. py:function:: gds.shortestPath.dijkstra.stream.estimate(G: Graph, **config: Any) -> Series[Any] +.. py:function:: gds.shortestPath.yens.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. -.. py:function:: gds.shortestPath.dijkstra.write(G: Graph, **config: Any) -> Series[Any] + | - The Dijkstra shortest path algorithm computes the shortest (weighted) path between a pair of nodes. + **Parameters:** -.. py:function:: gds.shortestPath.dijkstra.write.estimate(G: Graph, **config: Any) -> Series[Any] + * **G** - Graph - Returns an estimation of the memory consumption for that procedure. + * ****config** - Any -.. py:function:: gds.shortestPath.yens.mutate(G: Graph, **config: Any) -> Series[Any] +.. py:function:: gds.sllpa.mutate(G: Graph, **config: Any) -> Series[Any] - The Yen's shortest path algorithm computes the k shortest (weighted) paths between a pair of nodes. + The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph. -.. py:function:: gds.shortestPath.yens.mutate.estimate(G: Graph, **config: Any) -> Series[Any] + | - Returns an estimation of the memory consumption for that procedure. + **Parameters:** -.. py:function:: gds.shortestPath.yens.stream(G: Graph, **config: Any) -> DataFrame + * **G** - Graph - The Yen's shortest path algorithm computes the k shortest (weighted) paths between a pair of nodes. + * ****config** - Any -.. py:function:: gds.shortestPath.yens.stream.estimate(G: Graph, **config: Any) -> Series[Any] +.. py:function:: gds.sllpa.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. -.. py:function:: gds.shortestPath.yens.write(G: Graph, **config: Any) -> Series[Any] + | - The Yen's shortest path algorithm computes the k shortest (weighted) paths between a pair of nodes. + **Parameters:** -.. py:function:: gds.shortestPath.yens.write.estimate(G: Graph, **config: Any) -> Series[Any] + * **G** - Graph - Returns an estimation of the memory consumption for that procedure. + * ****config** - Any -.. py:function:: gds.sllpa.mutate(G: Graph, **config: Any) -> Series[Any] +.. py:function:: gds.sllpa.stats(G: Graph, **config: Any) -> Series[Any] The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph. -.. py:function:: gds.sllpa.mutate.estimate(G: Graph, **config: Any) -> Series[Any] + | - Returns an estimation of the memory consumption for that procedure. + **Parameters:** -.. py:function:: gds.sllpa.stats(G: Graph, **config: Any) -> Series[Any] + * **G** - Graph - The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph. + * ****config** - Any .. py:function:: gds.sllpa.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.sllpa.stream(G: Graph, **config: Any) -> DataFrame The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.sllpa.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.sllpa.write(G: Graph, **config: Any) -> Series[Any] The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.sllpa.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.spanningTree.mutate(G: Graph, **config: Any) -> Series[Any] The spanning tree algorithm visits all nodes that are in the same connected component as the starting node, and returns a spanning tree of all nodes in the component where the total weight of the relationships is either minimized or maximized. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.spanningTree.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.spanningTree.stats(G: Graph, **config: Any) -> Series[Any] The spanning tree algorithm visits all nodes that are in the same connected component as the starting node, and returns a spanning tree of all nodes in the component where the total weight of the relationships is either minimized or maximized. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.spanningTree.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.spanningTree.stream(G: Graph, **config: Any) -> DataFrame The spanning tree algorithm visits all nodes that are in the same connected component as the starting node, and returns a spanning tree of all nodes in the component where the total weight of the relationships is either minimized or maximized. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.spanningTree.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.spanningTree.write(G: Graph, **config: Any) -> Series[Any] The spanning tree algorithm visits all nodes that are in the same connected component as the starting node, and returns a spanning tree of all nodes in the component where the total weight of the relationships is either minimized or maximized. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.spanningTree.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.steinerTree.mutate(G: Graph, **config: Any) -> Series[Any] The steiner tree algorithm accepts a source node, as well as a list of target nodes. It then attempts to find a spanning tree where there is a path from the source node to each target node, such that the total weight of the relationships is as low as possible. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.steinerTree.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.steinerTree.stats(G: Graph, **config: Any) -> Series[Any] The steiner tree algorithm accepts a source node, as well as a list of target nodes. It then attempts to find a spanning tree where there is a path from the source node to each target node, such that the total weight of the relationships is as low as possible. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.steinerTree.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.steinerTree.stream(G: Graph, **config: Any) -> DataFrame The steiner tree algorithm accepts a source node, as well as a list of target nodes. It then attempts to find a spanning tree where there is a path from the source node to each target node, such that the total weight of the relationships is as low as possible. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.steinerTree.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.steinerTree.write(G: Graph, **config: Any) -> Series[Any] The steiner tree algorithm accepts a source node, as well as a list of target nodes. It then attempts to find a spanning tree where there is a path from the source node to each target node, such that the total weight of the relationships is as low as possible. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.steinerTree.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.triangleCount.mutate(G: Graph, **config: Any) -> Series[Any] Triangle counting is a community detection graph algorithm that is used to determine the number of triangles passing through each node in the graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.triangleCount.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.triangleCount.stats(G: Graph, **config: Any) -> Series[Any] Triangle counting is a community detection graph algorithm that is used to determine the number of triangles passing through each node in the graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.triangleCount.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.triangleCount.stream(G: Graph, **config: Any) -> DataFrame Triangle counting is a community detection graph algorithm that is used to @@ -1918,9 +4872,13 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g | - Configuration parameters: + **Parameters:** + + * **G** - Graph + + * ****config** - Any - * **maxDegree** - *(Optional)* If a node has a degree higher than this it will not be considered by the algorithm. The triangle count for these nodes will be `-1`. *Default*: 2^63^ - 1. + * **maxDegree** - *(Optional)* If a node has a degree higher than this it will not be considered by the algorithm. The triangle count for these nodes will be `-1`. *Default*: 2^63^ - 1. @@ -1928,76 +4886,232 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.triangleCount.write(G: Graph, **config: Any) -> Series[Any] Triangle counting is a community detection graph algorithm that is used to determine the number of triangles passing through each node in the graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.triangleCount.write.estimate(G: Graph, **config: Any) -> Series[Any] Triangle counting is a community detection graph algorithm that is used to determine the number of triangles passing through each node in the graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.triangles(G: Graph, **config: Any) -> DataFrame Triangles streams the nodeIds of each triangle in the graph. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.wcc.mutate(G: Graph, **config: Any) -> Series[Any] The WCC algorithm finds sets of connected nodes in an undirected graph, where all nodes in the same set form a connected component. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.wcc.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.wcc.stats(G: Graph, **config: Any) -> Series[Any] Executes the algorithm and returns result statistics without writing the result to Neo4j. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.wcc.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.wcc.stream(G: Graph, **config: Any) -> DataFrame The WCC algorithm finds sets of connected nodes in an undirected graph, where all nodes in the same set form a connected component. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.wcc.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.wcc.write(G: Graph, **config: Any) -> Series[Any] The WCC algorithm finds sets of connected nodes in an undirected graph, where all nodes in the same set form a connected component. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.wcc.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. + | + + **Parameters:** + + * **G** - Graph + + * ****config** - Any + .. py:function:: gds.alpha.linkprediction.adamicAdar(node1: int, node2: int, **config: Any) -> float Given two nodes, calculate Adamic Adar similarity + | + + **Parameters:** + + * **node1** - int + + * **node2** - int + + * ****config** - Any + .. py:function:: gds.alpha.linkprediction.commonNeighbors(node1: int, node2: int, **config: Any) -> float Given two nodes, returns the number of common neighbors + | + + **Parameters:** + + * **node1** - int + + * **node2** - int + + * ****config** - Any + .. py:function:: gds.alpha.linkprediction.preferentialAttachment(node1: int, node2: int, **config: Any) -> float Given two nodes, calculate Preferential Attachment + | + + **Parameters:** + + * **node1** - int + + * **node2** - int + + * ****config** - Any + .. py:function:: gds.alpha.linkprediction.resourceAllocation(node1: int, node2: int, **config: Any) -> float Given two nodes, calculate Resource Allocation similarity + | + + **Parameters:** + + * **node1** - int + + * **node2** - int + + * ****config** - Any + .. py:function:: gds.alpha.linkprediction.sameCommunity(node1: int, node2: int, communityProperty: Optional[str] = None) -> float Given two nodes, indicates if they have the same community + | + + **Parameters:** + + * **node1** - int + + * **node2** - int + + * **communityProperty** - Optional[str] = None + .. py:function:: gds.alpha.linkprediction.totalNeighbors(node1: int, node2: int, **config: Any) -> float Given two nodes, calculate Total Neighbors + | + + **Parameters:** + + * **node1** - int + + * **node2** - int + + * ****config** - Any + From 6e7796e810e39fa94f260c4ccdcee3831f443cab Mon Sep 17 00:00:00 2001 From: Nicola Vitucci Date: Wed, 29 May 2024 16:12:04 +0100 Subject: [PATCH 08/21] Update RST file --- doc/sphinx/source/algorithms.rst | 928 +++---------------------------- 1 file changed, 72 insertions(+), 856 deletions(-) diff --git a/doc/sphinx/source/algorithms.rst b/doc/sphinx/source/algorithms.rst index 7f65c47e3..a5f670b52 100644 --- a/doc/sphinx/source/algorithms.rst +++ b/doc/sphinx/source/algorithms.rst @@ -17,8 +17,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.allShortestPaths.delta.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for allShortestPaths.dealta.mutate. @@ -29,8 +27,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.allShortestPaths.delta.stats(G: Graph, **config: Any) -> Series[Any] The Delta Stepping shortest path algorithm computes the shortest (weighted) path @@ -42,8 +38,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.allShortestPaths.delta.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for allShortestPaths.delta.stats. @@ -54,8 +48,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.allShortestPaths.delta.stream(G: Graph, **config: Any) -> DataFrame The Delta Stepping shortest path algorithm computes the shortest (weighted) path @@ -67,8 +59,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.allShortestPaths.delta.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for allShortestPaths.delta.strema. @@ -79,8 +69,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.allShortestPaths.delta.write(G: Graph, **config: Any) -> Series[Any] The Delta Stepping shortest path algorithm computes the shortest (weighted) path @@ -92,8 +80,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.allShortestPaths.delta.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -104,8 +90,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.allShortestPaths.dijkstra.mutate(G: Graph, **config: Any) -> Series[Any] The Dijkstra shortest path algorithm computes the shortest (weighted) path @@ -117,8 +101,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.allShortestPaths.dijkstra.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -129,8 +111,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.allShortestPaths.dijkstra.stream(G: Graph, **config: Any) -> DataFrame The Dijkstra shortest path algorithm computes the shortest (weighted) path @@ -142,8 +122,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.allShortestPaths.dijkstra.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -154,8 +132,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.allShortestPaths.dijkstra.write(G: Graph, **config: Any) -> Series[Any] The Dijkstra shortest path algorithm computes the shortest (weighted) path @@ -167,8 +143,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.allShortestPaths.dijkstra.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -179,8 +153,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.allShortestPaths.stream(G: Graph, **config: Any) -> DataFrame The All Pairs Shortest Path (APSP) calculates the shortest (weighted) path @@ -192,8 +164,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.allShortestPaths.stream(G: Graph, **config: Any) -> DataFrame The All Pairs Shortest Path (APSP) calculates the shortest (weighted) path @@ -208,8 +178,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.closeness.harmonic.stream(G: Graph, **config: Any) -> DataFrame Harmonic centrality is a way of detecting nodes that are able to spread information @@ -224,8 +192,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.closeness.harmonic.write(G: Graph, **config: Any) -> Series[Any] Harmonic centrality is a way of detecting nodes that are able to spread information @@ -240,8 +206,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.conductance.stream(G: Graph, **config: Any) -> DataFrame Evaluates a division of nodes into communities based on the proportion of relationships @@ -253,8 +217,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.graph.sample.rwr(graph_name: str, from_G: Graph, **config: Any) -> GraphCreateResult Constructs a random subgraph based on random walks with restarts. @@ -270,8 +232,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **from_G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.hits.mutate(G: Graph, **config: Any) -> Series[Any] Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes. @@ -285,8 +245,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.hits.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -300,8 +258,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.hits.stats(G: Graph, **config: Any) -> Series[Any] Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes. @@ -315,8 +271,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.hits.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -330,8 +284,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.hits.stream(G: Graph, **config: Any) -> DataFrame Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes. @@ -345,8 +297,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.hits.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -360,8 +310,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.hits.write(G: Graph, **config: Any) -> Series[Any] Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes. @@ -375,8 +323,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.hits.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -390,8 +336,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.kSpanningTree.write(G: Graph, **config: Any) -> Series[Any] The K-spanning tree algorithm starts from a root node and returns a spanning tree with exactly k nodes @@ -405,8 +349,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.knn.filtered.mutate(G: Graph, **config: Any) -> Series[Any] The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance @@ -420,8 +362,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.knn.filtered.stats(G: Graph, **config: Any) -> Series[Any] The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance @@ -435,8 +375,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.knn.filtered.stream(G: Graph, **config: Any) -> DataFrame The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance @@ -450,8 +388,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.knn.filtered.write(G: Graph, **config: Any) -> Series[Any] The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance @@ -465,8 +401,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.maxkcut.mutate(G: Graph, **config: Any) -> Series[Any] Approximate Maximum k-cut maps each node into one of k disjoint communities @@ -478,8 +412,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.maxkcut.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Approximate Maximum k-cut maps each node into one of k disjoint communities @@ -491,8 +423,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.maxkcut.stream(G: Graph, **config: Any) -> DataFrame Approximate Maximum k-cut maps each node into one of k disjoint communities @@ -504,8 +434,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.maxkcut.stream.estimate(G: Graph, **config: Any) -> Series[Any] Approximate Maximum k-cut maps each node into one of k disjoint communities @@ -517,8 +445,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.modularity.stats(G: Graph, **config: Any) -> Series[Any] | @@ -527,8 +453,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.modularity.stream(G: Graph, **config: Any) -> DataFrame | @@ -537,8 +461,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.nodeSimilarity.filtered.mutate(G: Graph, **config: Any) -> Series[Any] The Filtered Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. @@ -552,8 +474,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.nodeSimilarity.filtered.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -564,8 +484,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.nodeSimilarity.filtered.stats(G: Graph, **config: Any) -> Series[Any] The Filtered Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. @@ -579,8 +497,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.nodeSimilarity.filtered.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -591,8 +507,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.nodeSimilarity.filtered.stream(G: Graph, **config: Any) -> DataFrame The Filtered Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. @@ -606,8 +520,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.nodeSimilarity.filtered.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -618,8 +530,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.nodeSimilarity.filtered.write(G: Graph, **config: Any) -> Series[Any] The Filtered Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. @@ -633,8 +543,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.nodeSimilarity.filtered.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -645,8 +553,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.scaleProperties.mutate(G: Graph, **config: Any) -> Series[Any] Scale node properties @@ -660,8 +566,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.scaleProperties.stream(G: Graph, **config: Any) -> DataFrame Scale node properties @@ -675,8 +579,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.scc.stream(G: Graph, **config: Any) -> DataFrame The SCC algorithm finds sets of connected nodes in an directed graph, @@ -688,8 +590,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.scc.write(G: Graph, **config: Any) -> Series[Any] The SCC algorithm finds sets of connected nodes in an directed graph, @@ -701,8 +601,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.sllpa.mutate(G: Graph, **config: Any) -> Series[Any] The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph. @@ -716,8 +614,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.sllpa.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -731,8 +627,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.sllpa.stats(G: Graph, **config: Any) -> Series[Any] The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph. @@ -746,8 +640,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.sllpa.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -761,8 +653,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.sllpa.stream(G: Graph, **config: Any) -> DataFrame The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph. @@ -776,8 +666,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.sllpa.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -791,8 +679,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.sllpa.write(G: Graph, **config: Any) -> Series[Any] The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph. @@ -806,8 +692,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.sllpa.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -821,8 +705,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.triangles(G: Graph, **config: Any) -> DataFrame Triangles streams the nodeIds of each triangle in the graph. @@ -836,8 +718,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.articleRank.mutate(G: Graph, **config: Any) -> Series[Any] Article Rank is a variant of the Page Rank algorithm, which measures the transitive influence or connectivity of nodes. @@ -848,8 +728,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.articleRank.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -860,8 +738,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.articleRank.stats(G: Graph, **config: Any) -> Series[Any] Executes the algorithm and returns result statistics without writing the result to Neo4j. @@ -872,8 +748,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.articleRank.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -884,9 +758,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - -.. py:function:: gds.articleRank.stream(G: Graph, **config: Any) -> DataFrame +.. py:function:: gds.articleRank.stream(G: Graph, *, , dampingFactor="0.85", maxIterations="20", tolerance="0.0000001", relationshipWeightProperty="null", sourceNodes="[]", scaler="None": Any) -> DataFrame Article Rank is a variant of the Page Rank algorithm, which measures the transitive influence or connectivity of nodes. @@ -896,19 +768,17 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - - * **dampingFactor** - *(Optional)* The damping factor of the Page Rank calculation. Must be in [0, 1). *Default*: 0.85. + * **dampingFactor** - *(Optional)* The damping factor of the Page Rank calculation. Must be in [0, 1). *Default*: 0.85. - * **maxIterations** - *(Optional)* The maximum number of iterations of Article Rank to run. *Default*: 20. + * **maxIterations** - *(Optional)* The maximum number of iterations of Article Rank to run. *Default*: 20. - * **tolerance** - *(Optional)* Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable, and the algorithm returns. *Default*: 0.0000001. + * **tolerance** - *(Optional)* Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable, and the algorithm returns. *Default*: 0.0000001. - * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. - * **sourceNodes** - *(Optional)* The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. + * **sourceNodes** - *(Optional)* The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. - * **scaler** - *(Optional)* The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. + * **scaler** - *(Optional)* The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. @@ -922,8 +792,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.articleRank.write(G: Graph, **config: Any) -> Series[Any] Article Rank is a variant of the Page Rank algorithm, which measures the transitive influence or connectivity of nodes. @@ -934,8 +802,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.articleRank.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -946,8 +812,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.bellmanFord.mutate(G: Graph, **config: Any) -> Series[Any] The Bellman-Ford shortest path algorithm computes the shortest (weighted) path between one node @@ -959,8 +823,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.bellmanFord.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -971,8 +833,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.bellmanFord.stats(G: Graph, **config: Any) -> Series[Any] The Bellman-Ford shortest path algorithm computes the shortest (weighted) path between one node @@ -984,8 +844,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.bellmanFord.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -996,8 +854,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.bellmanFord.stream(G: Graph, **config: Any) -> DataFrame The Bellman-Ford shortest path algorithm computes the shortest (weighted) path between one node @@ -1009,8 +865,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.bellmanFord.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1021,8 +875,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.bellmanFord.write(G: Graph, **config: Any) -> Series[Any] The Bellman-Ford shortest path algorithm computes the shortest (weighted) path between one node @@ -1034,8 +886,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.bellmanFord.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1046,8 +896,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.closeness.mutate(G: Graph, **config: Any) -> Series[Any] Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. @@ -1058,8 +906,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.closeness.stats(G: Graph, **config: Any) -> Series[Any] Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. @@ -1070,8 +916,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.closeness.stream(G: Graph, **config: Any) -> DataFrame Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. @@ -1082,8 +926,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.closeness.write(G: Graph, **config: Any) -> Series[Any] Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. @@ -1094,8 +936,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.collapsePath.mutate(G: Graph, **config: Any) -> Series[Any] Collapse Path algorithm is a traversal algorithm capable of creating relationships between the start @@ -1107,8 +947,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.influenceMaximization.celf.mutate(G: Graph, **config: Any) -> Series[Any] The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes @@ -1120,8 +958,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.influenceMaximization.celf.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1132,8 +968,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.influenceMaximization.celf.stats(G: Graph, **config: Any) -> Series[Any] Executes the algorithm and returns result statistics without writing the result to Neo4j. @@ -1144,8 +978,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.influenceMaximization.celf.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1156,8 +988,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.influenceMaximization.celf.stream(G: Graph, **config: Any) -> DataFrame The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes @@ -1169,8 +999,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.influenceMaximization.celf.stream.estimate(G: Graph, **config: Any) -> Series[Any] The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes @@ -1182,8 +1010,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.influenceMaximization.celf.write(G: Graph, **config: Any) -> Series[Any] The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes @@ -1195,8 +1021,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.influenceMaximization.celf.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1207,8 +1031,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.k1coloring.mutate(G: Graph, **config: Any) -> Series[Any] The K-1 Coloring algorithm assigns a color to every node in the graph. @@ -1219,8 +1041,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.k1coloring.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1231,8 +1051,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.k1coloring.stats(G: Graph, **config: Any) -> Series[Any] The K-1 Coloring algorithm assigns a color to every node in the graph. @@ -1243,8 +1061,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.k1coloring.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1255,8 +1071,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.k1coloring.stream(G: Graph, **config: Any) -> DataFrame The K-1 Coloring algorithm assigns a color to every node in the graph. @@ -1267,8 +1081,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.k1coloring.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1279,8 +1091,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.k1coloring.write(G: Graph, **config: Any) -> Series[Any] The K-1 Coloring algorithm assigns a color to every node in the graph. @@ -1291,8 +1101,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.k1coloring.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1303,8 +1111,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.kmeans.mutate(G: Graph, **config: Any) -> Series[Any] The Kmeans algorithm clusters nodes into different communities based on Euclidean distance @@ -1318,8 +1124,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.kmeans.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1333,8 +1137,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.kmeans.stats(G: Graph, **config: Any) -> Series[Any] The Kmeans algorithm clusters nodes into different communities based on Euclidean distance @@ -1348,8 +1150,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.kmeans.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1363,8 +1163,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.kmeans.stream(G: Graph, **config: Any) -> DataFrame The Kmeans algorithm clusters nodes into different communities based on Euclidean distance @@ -1378,8 +1176,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.kmeans.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1393,8 +1189,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.kmeans.write(G: Graph, **config: Any) -> Series[Any] The Kmeans algorithm clusters nodes into different communities based on Euclidean distance @@ -1408,8 +1202,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.kmeans.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1423,8 +1215,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.leiden.mutate(G: Graph, **config: Any) -> Series[Any] Leiden is a community detection algorithm, which guarantees that communities are well connected @@ -1435,8 +1225,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.leiden.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1447,8 +1235,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.leiden.stats(G: Graph, **config: Any) -> Series[Any] Executes the algorithm and returns result statistics without writing the result to Neo4j. @@ -1459,8 +1245,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.leiden.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1471,8 +1255,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.leiden.stream(G: Graph, **config: Any) -> DataFrame Leiden is a community detection algorithm, which guarantees that communities are well connected @@ -1483,8 +1265,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.leiden.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1495,8 +1275,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.leiden.write(G: Graph, **config: Any) -> Series[Any] Leiden is a community detection algorithm, which guarantees that communities are well connected @@ -1507,8 +1285,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.leiden.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1519,8 +1295,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.modularityOptimization.mutate(G: Graph, **config: Any) -> Series[Any] The Modularity Optimization algorithm groups the nodes in the graph by optimizing the graphs modularity. @@ -1531,8 +1305,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.modularityOptimization.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1543,8 +1315,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.modularityOptimization.stream(G: Graph, **config: Any) -> DataFrame The Modularity Optimization algorithm groups the nodes in the graph by optimizing the graphs modularity. @@ -1555,8 +1325,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.modularityOptimization.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1567,8 +1335,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.modularityOptimization.write(G: Graph, **config: Any) -> Series[Any] The Modularity Optimization algorithm groups the nodes in the graph by optimizing the graphs modularity. @@ -1579,8 +1345,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.modularityOptimization.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1591,8 +1355,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.scaleProperties.mutate(G: Graph, **config: Any) -> Series[Any] Scale node properties @@ -1603,8 +1365,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.scaleProperties.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1615,8 +1375,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.scaleProperties.stats(G: Graph, **config: Any) -> Series[Any] Scale node properties @@ -1627,8 +1385,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.scaleProperties.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1639,8 +1395,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.scaleProperties.stream(G: Graph, **config: Any) -> DataFrame Scale node properties @@ -1651,8 +1405,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.scaleProperties.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1663,8 +1415,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.scaleProperties.write(G: Graph, **config: Any) -> Series[Any] Scale node properties @@ -1675,8 +1425,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.scaleProperties.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1687,8 +1435,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.scc.mutate(G: Graph, **config: Any) -> Series[Any] The SCC algorithm finds sets of connected nodes in an directed graph, where all nodes in the same set form a connected component. @@ -1699,8 +1445,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.scc.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for SCC. @@ -1711,8 +1455,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.scc.stats(G: Graph, **config: Any) -> Series[Any] The SCC algorithm finds sets of connected nodes in an directed graph, where all nodes in the same set form a connected component. @@ -1723,8 +1465,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.scc.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for SCC. @@ -1735,8 +1475,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.scc.stream(G: Graph, **config: Any) -> DataFrame The SCC algorithm finds sets of connected nodes in an directed graph, where all nodes in the same set form a connected component. @@ -1747,8 +1485,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.scc.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for SCC. @@ -1759,8 +1495,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.scc.write(G: Graph, **config: Any) -> Series[Any] The SCC algorithm finds sets of connected nodes in an directed graph, where all nodes in the same set form a connected component. @@ -1771,8 +1505,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.scc.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for SCC. @@ -1783,8 +1515,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.spanningTree.mutate(G: Graph, **config: Any) -> Series[Any] The spanning tree algorithm visits all nodes that are in the same connected component as the starting node, @@ -1796,8 +1526,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.spanningTree.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1808,8 +1536,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.spanningTree.stats(G: Graph, **config: Any) -> Series[Any] The spanning tree algorithm visits all nodes that are in the same connected component as the starting node, @@ -1822,8 +1548,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.spanningTree.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1834,8 +1558,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.spanningTree.stream(G: Graph, **config: Any) -> DataFrame The spanning tree algorithm visits all nodes that are in the same connected component as the starting node, @@ -1848,8 +1570,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.spanningTree.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1860,8 +1580,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.spanningTree.write(G: Graph, **config: Any) -> Series[Any] The spanning tree algorithm visits all nodes that are in the same connected component as the starting node, @@ -1874,8 +1592,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.spanningTree.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1886,8 +1602,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.steinerTree.mutate(G: Graph, **config: Any) -> Series[Any] The steiner tree algorithm accepts a source node, as well as a list of target nodes. @@ -1900,8 +1614,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.steinerTree.stats(G: Graph, **config: Any) -> Series[Any] The steiner tree algorithm accepts a source node, as well as a list of target nodes. @@ -1914,8 +1626,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.steinerTree.stream(G: Graph, **config: Any) -> DataFrame The steiner tree algorithm accepts a source node, as well as a list of target nodes. @@ -1928,8 +1638,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.beta.steinerTree.write(G: Graph, **config: Any) -> Series[Any] The steiner tree algorithm accepts a source node, as well as a list of target nodes. @@ -1942,8 +1650,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.betweenness.mutate(G: Graph, **config: Any) -> Series[Any] Betweenness centrality measures the relative information flow that passes through a node. @@ -1954,8 +1660,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.betweenness.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Betweenness centrality measures the relative information flow that passes through a node. @@ -1966,8 +1670,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.betweenness.stats(G: Graph, **config: Any) -> Series[Any] Betweenness centrality measures the relative information flow that passes through a node. @@ -1978,8 +1680,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.betweenness.stats.estimate(G: Graph, **config: Any) -> Series[Any] Betweenness centrality measures the relative information flow that passes through a node. @@ -1990,9 +1690,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - -.. py:function:: gds.betweenness.stream(G: Graph, **config: Any) -> DataFrame +.. py:function:: gds.betweenness.stream(G: Graph, *, , samplingSize="node count", samplingSeed="null", relationshipWeightProperty="null": Any) -> DataFrame Betweenness centrality measures the relative information flow that passes through a node. @@ -2002,13 +1700,11 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any + * **samplingSize** - *(Optional)* The number of source nodes to consider for computing centrality scores. *Default*: node count. - * **samplingSize** - *(Optional)* The number of source nodes to consider for computing centrality scores. *Default*: node count. + * **samplingSeed** - *(Optional)* The seed value for the random number generator that selects start nodes. *Default*: null. - * **samplingSeed** - *(Optional)* The seed value for the random number generator that selects start nodes. *Default*: null. - - * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. @@ -2022,8 +1718,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.betweenness.write(G: Graph, **config: Any) -> Series[Any] Betweenness centrality measures the relative information flow that passes through a node. @@ -2034,8 +1728,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.betweenness.write.estimate(G: Graph, **config: Any) -> Series[Any] Betweenness centrality measures the relative information flow that passes through a node. @@ -2046,8 +1738,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.bfs.mutate(G: Graph, **config: Any) -> Series[Any] BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth @@ -2059,8 +1749,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.bfs.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -2071,8 +1759,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.bfs.stats(G: Graph, **config: Any) -> Series[Any] BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth @@ -2084,8 +1770,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.bfs.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -2096,9 +1780,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - -.. py:function:: gds.bfs.stream(G: Graph, **config: Any) -> DataFrame +.. py:function:: gds.bfs.stream(G: Graph, *, , sourceNode, targetNodes="empty list", maxDepth="-1": Any) -> DataFrame BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level. @@ -2109,13 +1791,11 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - - * **sourceNode** - *(Required)* The node id of the node where to start the traversal. *Default*: n/a. + * **sourceNode** - *(Required)* The node id of the node where to start the traversal. *Default*: n/a. - * **targetNodes** - *(Optional)* Ids for target nodes. Traversal terminates when any target node is visited. *Default*: empty list. + * **targetNodes** - *(Optional)* Ids for target nodes. Traversal terminates when any target node is visited. *Default*: empty list. - * **maxDepth** - *(Optional)* The maximum distance from the source node at which nodes are visited. *Default*: -1. + * **maxDepth** - *(Optional)* The maximum distance from the source node at which nodes are visited. *Default*: -1. @@ -2130,8 +1810,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.closeness.mutate(G: Graph, **config: Any) -> Series[Any] Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. @@ -2142,8 +1820,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.closeness.stats(G: Graph, **config: Any) -> Series[Any] Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. @@ -2154,8 +1830,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.closeness.stream(G: Graph, **config: Any) -> DataFrame Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. @@ -2166,8 +1840,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.closeness.write(G: Graph, **config: Any) -> Series[Any] Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. @@ -2178,8 +1850,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.closeness.harmonic.mutate(G: Graph, **config: Any) -> DataFrame Harmonic centrality is a way of detecting nodes that are able to spread information @@ -2191,8 +1861,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.closeness.harmonic.stats(G: Graph, **config: Any) -> DataFrame Harmonic centrality is a way of detecting nodes that are able to spread information @@ -2204,8 +1872,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.closeness.harmonic.stream(G: Graph, **config: Any) -> DataFrame Harmonic centrality is a way of detecting nodes that are able to spread information @@ -2217,8 +1883,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.closeness.harmonic.write(G: Graph, **config: Any) -> Series[Any] Harmonic centrality is a way of detecting nodes that are able to spread information @@ -2230,8 +1894,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.collapsePath.mutate(G: Graph, **config: Any) -> Series[Any] Collapse Path algorithm is a traversal algorithm capable of creating relationships between the start @@ -2243,9 +1905,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - -.. py:function:: gds.conductance.stream(G: Graph, **config: Any) -> DataFrame +.. py:function:: gds.conductance.stream(G: Graph, *, , communityProperty, relationshipWeightProperty="null": Any) -> DataFrame Evaluates a division of nodes into communities based on the proportion of relationships that cross community boundaries. @@ -2256,11 +1916,9 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - - * **communityProperty** - *(Required)* The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their conductance computed. *Default*: n/a. + * **communityProperty** - *(Required)* The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their conductance computed. *Default*: n/a. - * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. @@ -2274,8 +1932,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.dag.longestPath.stream(G: Graph, **config: Any) -> DataFrame Finds the longest path that leads to a node in a directed acyclic graph (DAG). @@ -2286,8 +1942,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.degree.mutate(G: Graph, **config: Any) -> Series[Any] Degree centrality measures the number of incoming and outgoing relationships from a node. @@ -2298,8 +1952,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.degree.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Degree centrality measures the number of incoming and outgoing relationships from a node. @@ -2310,8 +1962,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.degree.stats(G: Graph, **config: Any) -> Series[Any] Degree centrality measures the number of incoming and outgoing relationships from a node. @@ -2322,8 +1972,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.degree.stats.estimate(G: Graph, **config: Any) -> Series[Any] Degree centrality measures the number of incoming and outgoing relationships from a node. @@ -2334,9 +1982,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - -.. py:function:: gds.degree.stream(G: Graph, **config: Any) -> DataFrame +.. py:function:: gds.degree.stream(G: Graph, *, , orientation="NATURAL", relationshipWeightProperty="null": Any) -> DataFrame Degree centrality measures the number of incoming and outgoing relationships from a node. @@ -2346,11 +1992,9 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - - * **orientation** - *(Optional)* The orientation used to compute node degrees. Supported orientations are `NATURAL`, `REVERSE` and `UNDIRECTED`. *Default*: NATURAL. + * **orientation** - *(Optional)* The orientation used to compute node degrees. Supported orientations are `NATURAL`, `REVERSE` and `UNDIRECTED`. *Default*: NATURAL. - * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use for weighted degree computation. If unspecified, the algorithm runs unweighted. *Default*: null. + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use for weighted degree computation. If unspecified, the algorithm runs unweighted. *Default*: null. @@ -2364,8 +2008,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.degree.write(G: Graph, **config: Any) -> Series[Any] Degree centrality measures the number of incoming and outgoing relationships from a node. @@ -2376,8 +2018,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.degree.write.estimate(G: Graph, **config: Any) -> Series[Any] Degree centrality measures the number of incoming and outgoing relationships from a node. @@ -2388,8 +2028,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.dfs.mutate(G: Graph, **config: Any) -> Series[Any] Depth-first search (DFS) is an algorithm for traversing or searching tree or graph data structures. @@ -2402,8 +2040,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.dfs.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -2414,9 +2050,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - -.. py:function:: gds.dfs.stream(G: Graph, **config: Any) -> DataFrame +.. py:function:: gds.dfs.stream(G: Graph, *, , sourceNode, targetNodes="empty list", maxDepth="-1": Any) -> DataFrame Depth-first search (DFS) is an algorithm for traversing or searching tree or graph data structures. The algorithm starts at the root node (selecting some arbitrary node as the root node in the case of a graph) @@ -2428,13 +2062,11 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - - * **sourceNode** - *(Required)* The node id of the node where to start the traversal. *Default*: n/a. + * **sourceNode** - *(Required)* The node id of the node where to start the traversal. *Default*: n/a. - * **targetNodes** - *(Optional)* Ids for target nodes. Traversal terminates when any target node is visited. *Default*: empty list. + * **targetNodes** - *(Optional)* Ids for target nodes. Traversal terminates when any target node is visited. *Default*: empty list. - * **maxDepth** - *(Optional)* The maximum distance from the source node at which nodes are visited. *Default*: -1. + * **maxDepth** - *(Optional)* The maximum distance from the source node at which nodes are visited. *Default*: -1. @@ -2450,8 +2082,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.eigenvector.mutate(G: Graph, **config: Any) -> Series[Any] Eigenvector Centrality is an algorithm that measures the transitive influence or connectivity of nodes. @@ -2462,8 +2092,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.eigenvector.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -2474,8 +2102,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.eigenvector.stats(G: Graph, **config: Any) -> Series[Any] Eigenvector Centrality is an algorithm that measures the transitive influence or connectivity of nodes. @@ -2486,8 +2112,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.eigenvector.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -2498,9 +2122,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - -.. py:function:: gds.eigenvector.stream(G: Graph, **config: Any) -> DataFrame +.. py:function:: gds.eigenvector.stream(G: Graph, *, , maxIterations="20", tolerance="0.0000001", relationshipWeightProperty="null", sourceNodes="[]", scaler="None": Any) -> DataFrame Eigenvector Centrality is an algorithm that measures the transitive influence or connectivity of nodes. @@ -2510,17 +2132,15 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - - * **maxIterations** - *(Optional)* The maximum number of iterations of Eigenvector Centrality to run. *Default*: 20. + * **maxIterations** - *(Optional)* The maximum number of iterations of Eigenvector Centrality to run. *Default*: 20. - * **tolerance** - *(Optional)* Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable and the algorithm returns. *Default*: 0.0000001. + * **tolerance** - *(Optional)* Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable and the algorithm returns. *Default*: 0.0000001. - * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. - * **sourceNodes** - *(Optional)* The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. + * **sourceNodes** - *(Optional)* The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. - * **scaler** - *(Optional)* The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. + * **scaler** - *(Optional)* The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. @@ -2534,8 +2154,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.eigenvector.write(G: Graph, **config: Any) -> Series[Any] Eigenvector Centrality is an algorithm that measures the transitive influence or connectivity of nodes. @@ -2546,8 +2164,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.eigenvector.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -2558,8 +2174,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.graph.sample.cnarw(graph_name: str, from_G: Graph, **config: Any) -> GraphCreateResult Constructs a random subgraph based on common-neighbour-aware random walks. @@ -2572,8 +2186,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **from_G** - Graph - * ****config** - Any - .. py:function:: gds.graph.sample.cnarw.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -2584,8 +2196,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.graph.sample.rwr(graph_name: str, from_G: Graph, **config: Any) -> GraphCreateResult Constructs a random subgraph based on random walks with restarts. @@ -2598,8 +2208,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **from_G** - Graph - * ****config** - Any - .. py:function:: gds.hits.mutate(G: Graph, **config: Any) -> Series[Any] Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes. @@ -2610,8 +2218,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.hits.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -2622,8 +2228,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.hits.stats(G: Graph, **config: Any) -> Series[Any] Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes. @@ -2634,8 +2238,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.hits.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -2646,8 +2248,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.hits.stream(G: Graph, **config: Any) -> DataFrame Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes. @@ -2658,8 +2258,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.hits.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -2670,8 +2268,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.hits.write(G: Graph, **config: Any) -> Series[Any] Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes. @@ -2682,8 +2278,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.hits.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -2694,8 +2288,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.influenceMaximization.celf.mutate(G: Graph, **config: Any) -> Series[Any] The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes @@ -2707,8 +2299,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.influenceMaximization.celf.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -2719,8 +2309,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.influenceMaximization.celf.stats(G: Graph, **config: Any) -> Series[Any] Executes the algorithm and returns result statistics without writing the result to Neo4j. @@ -2731,8 +2319,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.influenceMaximization.celf.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -2743,8 +2329,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.influenceMaximization.celf.stream(G: Graph, **config: Any) -> DataFrame The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes @@ -2756,8 +2340,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.influenceMaximization.celf.stream.estimate(G: Graph, **config: Any) -> Series[Any] The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes @@ -2769,8 +2351,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.influenceMaximization.celf.write(G: Graph, **config: Any) -> Series[Any] The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes @@ -2782,8 +2362,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.influenceMaximization.celf.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -2794,8 +2372,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.kmeans.mutate(G: Graph, **config: Any) -> Series[Any] The Kmeans algorithm clusters nodes into different communities based on Euclidean distance @@ -2806,8 +2382,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.kmeans.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -2818,8 +2392,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.kmeans.stats(G: Graph, **config: Any) -> Series[Any] The Kmeans algorithm clusters nodes into different communities based on Euclidean distance @@ -2830,8 +2402,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.kmeans.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -2842,8 +2412,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.kmeans.stream(G: Graph, **config: Any) -> DataFrame The Kmeans algorithm clusters nodes into different communities based on Euclidean distance @@ -2854,8 +2422,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.kmeans.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -2866,8 +2432,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.kmeans.write(G: Graph, **config: Any) -> Series[Any] The Kmeans algorithm clusters nodes into different communities based on Euclidean distance @@ -2878,8 +2442,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.kmeans.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -2890,8 +2452,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.k1coloring.mutate(G: Graph, **config: Any) -> Series[Any] The K-1 Coloring algorithm assigns a color to every node in the graph. @@ -2902,8 +2462,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.k1coloring.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -2914,8 +2472,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.k1coloring.stats(G: Graph, **config: Any) -> Series[Any] The K-1 Coloring algorithm assigns a color to every node in the graph. @@ -2926,8 +2482,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.k1coloring.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -2938,8 +2492,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.k1coloring.stream(G: Graph, **config: Any) -> DataFrame The K-1 Coloring algorithm assigns a color to every node in the graph. @@ -2950,8 +2502,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.k1coloring.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -2962,8 +2512,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.k1coloring.write(G: Graph, **config: Any) -> Series[Any] The K-1 Coloring algorithm assigns a color to every node in the graph. @@ -2974,8 +2522,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.k1coloring.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -2986,8 +2532,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.kcore.mutate(G: Graph, **config: Any) -> Series[Any] Computes the k-core values in a network @@ -2998,8 +2542,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.kcore.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3010,8 +2552,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.kcore.stats(G: Graph, **config: Any) -> Series[Any] Computes the k-core values in a network @@ -3022,8 +2562,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.kcore.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3034,8 +2572,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.kcore.stream(G: Graph, **config: Any) -> Series[Any] Computes the k-core values in a network @@ -3046,8 +2582,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.kcore.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3058,8 +2592,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.kcore.write(G: Graph, **config: Any) -> Series[Any] Computes the k-core values in a network @@ -3070,8 +2602,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.kcore.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3082,8 +2612,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.knn.mutate(G: Graph, **config: Any) -> Series[Any] The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance @@ -3096,8 +2624,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.knn.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3108,8 +2634,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.knn.stats(G: Graph, **config: Any) -> Series[Any] The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance @@ -3122,8 +2646,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.knn.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3134,8 +2656,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.knn.stream(G: Graph, **config: Any) -> DataFrame The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance @@ -3148,8 +2668,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.knn.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3160,8 +2678,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.knn.write(G: Graph, **config: Any) -> Series[Any] The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance @@ -3174,8 +2690,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.knn.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3186,8 +2700,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.knn.filtered.mutate(G: Graph, **config: Any) -> Series[Any] The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance @@ -3205,8 +2717,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.knn.filtered.stats(G: Graph, **config: Any) -> Series[Any] The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance @@ -3220,8 +2730,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.knn.filtered.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3232,8 +2740,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.knn.filtered.stream(G: Graph, **config: Any) -> DataFrame The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance @@ -3247,8 +2753,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.knn.filtered.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3259,8 +2763,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.knn.filtered.write(G: Graph, **config: Any) -> Series[Any] The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance @@ -3274,8 +2776,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.knn.filtered.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3286,8 +2786,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.kSpanningTree.write(G: Graph, **config: Any) -> Series[Any] The K-spanning tree algorithm starts from a root node and returns a spanning tree with exactly k nodes @@ -3298,8 +2796,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.labelPropagation.mutate(G: Graph, **config: Any) -> Series[Any] The Label Propagation algorithm is a fast algorithm for finding communities in a graph. @@ -3310,8 +2806,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.labelPropagation.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3322,8 +2816,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.labelPropagation.stats(G: Graph, **config: Any) -> Series[Any] The Label Propagation algorithm is a fast algorithm for finding communities in a graph. @@ -3334,8 +2826,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.labelPropagation.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3346,8 +2836,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.labelPropagation.stream(G: Graph, **config: Any) -> DataFrame The Label Propagation algorithm is a fast algorithm for finding communities in a graph. @@ -3358,8 +2846,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.labelPropagation.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3370,8 +2856,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.labelPropagation.write(G: Graph, **config: Any) -> Series[Any] The Label Propagation algorithm is a fast algorithm for finding communities in a graph. @@ -3382,8 +2866,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.labelPropagation.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3394,8 +2876,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.leiden.mutate(G: Graph, **config: Any) -> Series[Any] Leiden is a community detection algorithm, which guarantees that communities are well connected @@ -3406,8 +2886,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.leiden.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3418,8 +2896,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.leiden.stats(G: Graph, **config: Any) -> Series[Any] Executes the algorithm and returns result statistics without writing the result to Neo4j. @@ -3430,8 +2906,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.leiden.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3442,8 +2916,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.leiden.stream(G: Graph, **config: Any) -> DataFrame Leiden is a community detection algorithm, which guarantees that communities are well connected @@ -3454,8 +2926,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.leiden.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3466,8 +2936,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.leiden.write(G: Graph, **config: Any) -> Series[Any] Leiden is a community detection algorithm, which guarantees that communities are well connected @@ -3478,8 +2946,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.leiden.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3490,8 +2956,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.localClusteringCoefficient.mutate(G: Graph, **config: Any) -> Series[Any] The local clustering coefficient is a metric quantifying how connected the neighborhood of a node is. @@ -3502,8 +2966,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.localClusteringCoefficient.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3514,8 +2976,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.localClusteringCoefficient.stats(G: Graph, **config: Any) -> Series[Any] Executes the algorithm and returns result statistics without writing the result to Neo4j. @@ -3526,8 +2986,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.localClusteringCoefficient.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3538,9 +2996,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - -.. py:function:: gds.localClusteringCoefficient.stream(G: Graph, **config: Any) -> DataFrame +.. py:function:: gds.localClusteringCoefficient.stream(G: Graph, *, , triangleCountProperty="n/a": Any) -> DataFrame The local clustering coefficient is a metric quantifying how connected the neighborhood of a node is. @@ -3550,9 +3006,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - - * **triangleCountProperty** - *(Optional)* Node property that contains pre-computed triangle count. *Default*: n/a. + * **triangleCountProperty** - *(Optional)* Node property that contains pre-computed triangle count. *Default*: n/a. @@ -3566,8 +3020,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.localClusteringCoefficient.write(G: Graph, **config: Any) -> Series[Any] The local clustering coefficient is a metric quantifying how connected the neighborhood of a node is. @@ -3578,8 +3030,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.localClusteringCoefficient.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3590,8 +3040,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.louvain.mutate(G: Graph, **config: Any) -> Series[Any] The Louvain method for community detection is an algorithm for detecting communities in networks. @@ -3602,8 +3050,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.louvain.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3614,8 +3060,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.louvain.stats(G: Graph, **config: Any) -> Series[Any] Executes the algorithm and returns result statistics without writing the result to Neo4j. @@ -3626,8 +3070,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.louvain.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3638,8 +3080,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.louvain.stream(G: Graph, **config: Any) -> DataFrame The Louvain method for community detection is an algorithm for detecting communities in networks. @@ -3650,8 +3090,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.louvain.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3662,8 +3100,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.louvain.write(G: Graph, **config: Any) -> Series[Any] The Louvain method for community detection is an algorithm for detecting communities in networks. @@ -3674,8 +3110,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.louvain.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3686,8 +3120,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.maxkcut.mutate(G: Graph, **config: Any) -> Series[Any] Approximate Maximum k-cut maps each node into one of k disjoint communities @@ -3699,8 +3131,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.maxkcut.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Approximate Maximum k-cut maps each node into one of k disjoint communities @@ -3712,8 +3142,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.maxkcut.stream(G: Graph, **config: Any) -> DataFrame Approximate Maximum k-cut maps each node into one of k disjoint communities @@ -3725,8 +3153,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.maxkcut.stream.estimate(G: Graph, **config: Any) -> Series[Any] Approximate Maximum k-cut maps each node into one of k disjoint communities @@ -3738,8 +3164,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.modularity.stats(G: Graph, **config: Any) -> Series[Any] | @@ -3748,8 +3172,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.modularity.stats.estimate(G: Graph, **config: Any) -> Series[Any] | @@ -3758,9 +3180,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - -.. py:function:: gds.modularity.stream(G: Graph, **config: Any) -> DataFrame +.. py:function:: gds.modularity.stream(G: Graph, *, , communityProperty, relationshipWeightProperty="null": Any) -> DataFrame | @@ -3768,11 +3188,9 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - - * **communityProperty** - *(Required)* The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their modularity score computed. *Default*: n/a. + * **communityProperty** - *(Required)* The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their modularity score computed. *Default*: n/a. - * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. @@ -3784,8 +3202,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.modularityOptimization.mutate(G: Graph, **config: Any) -> Series[Any] The Modularity Optimization algorithm groups the nodes in the graph by optimizing the graphs modularity. @@ -3796,8 +3212,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.modularityOptimization.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3808,8 +3222,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.modularityOptimization.stats(G: Graph, **config: Any) -> Series[Any] The Modularity Optimization algorithm groups the nodes in the graph by optimizing the graphs modularity. @@ -3820,8 +3232,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.modularityOptimization.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3832,8 +3242,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.modularityOptimization.stream(G: Graph, **config: Any) -> DataFrame The Modularity Optimization algorithm groups the nodes in the graph by optimizing the graphs modularity. @@ -3844,8 +3252,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.modularityOptimization.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3856,8 +3262,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.modularityOptimization.write(G: Graph, **config: Any) -> Series[Any] The Modularity Optimization algorithm groups the nodes in the graph by optimizing the graphs modularity. @@ -3868,8 +3272,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.modularityOptimization.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3880,8 +3282,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.nodeSimilarity.mutate(G: Graph, **config: Any) -> Series[Any] The Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. @@ -3894,8 +3294,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.nodeSimilarity.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3906,8 +3304,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.nodeSimilarity.stats(G: Graph, **config: Any) -> Series[Any] The Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. @@ -3920,8 +3316,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.nodeSimilarity.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3932,9 +3326,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - -.. py:function:: gds.nodeSimilarity.stream(G: Graph, **config: Any) -> DataFrame +.. py:function:: gds.nodeSimilarity.stream(G: Graph, *, , similarityCutoff="1e-42", degreeCutoff="1", upperDegreeCutoff="2147483647", topK="10", bottomK="10", topN="0", bottomN="0", relationshipWeightProperty="null", similarityMetric="JACCARD", useComponents="false": Any) -> DataFrame The Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. Two nodes are considered similar if they share many of the same neighbors. @@ -3946,43 +3338,41 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any + * **similarityCutoff** - *(Optional)* Lower limit for the similarity score to be present in the result. + Values must be between 0 and 1. *Default*: 1e-42. - * **similarityCutoff** - *(Optional)* Lower limit for the similarity score to be present in the result. - Values must be between 0 and 1. *Default*: 1e-42. + * **degreeCutoff** - *(Optional)* Inclusive lower bound on the node degree for a node to be considered in the comparisons. + This value can not be lower than 1. *Default*: 1. - * **degreeCutoff** - *(Optional)* Inclusive lower bound on the node degree for a node to be considered in the comparisons. - This value can not be lower than 1. *Default*: 1. + * **upperDegreeCutoff** - *(Optional)* Inclusive upper bound on the node degree for a node to be considered in the comparisons. + This value can not be lower than 1. *Default*: 2147483647. - * **upperDegreeCutoff** - *(Optional)* Inclusive upper bound on the node degree for a node to be considered in the comparisons. - This value can not be lower than 1. *Default*: 2147483647. + * **topK** - *(Optional)* Limit on the number of scores per node. + The K largest results are returned. + This value cannot be lower than 1. *Default*: 10. - * **topK** - *(Optional)* Limit on the number of scores per node. - The K largest results are returned. - This value cannot be lower than 1. *Default*: 10. + * **bottomK** - *(Optional)* Limit on the number of scores per node. + The K smallest results are returned. + This value cannot be lower than 1. *Default*: 10. - * **bottomK** - *(Optional)* Limit on the number of scores per node. - The K smallest results are returned. - This value cannot be lower than 1. *Default*: 10. + * **topN** - *(Optional)* Global limit on the number of scores computed. + The N largest total results are returned. + This value cannot be negative, a value of 0 means no global limit. *Default*: 0. - * **topN** - *(Optional)* Global limit on the number of scores computed. - The N largest total results are returned. - This value cannot be negative, a value of 0 means no global limit. *Default*: 0. + * **bottomN** - *(Optional)* Global limit on the number of scores computed. + The N smallest total results are returned. + This value cannot be negative, a value of 0 means no global limit. *Default*: 0. - * **bottomN** - *(Optional)* Global limit on the number of scores computed. - The N smallest total results are returned. - This value cannot be negative, a value of 0 means no global limit. *Default*: 0. + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. + If unspecified, the algorithm runs unweighted. *Default*: null. - * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. - If unspecified, the algorithm runs unweighted. *Default*: null. + * **similarityMetric** - *(Optional)* The metric used to compute similarity. + Can be either `JACCARD`, `OVERLAP` or `COSINE`. *Default*: JACCARD. - * **similarityMetric** - *(Optional)* The metric used to compute similarity. - Can be either `JACCARD`, `OVERLAP` or `COSINE`. *Default*: JACCARD. - - * ** useComponents** - *(Optional)* If enabled, Node Similarity will use components to improve the performance of the computation, skipping comparisons of nodes in different components. - Set to `false` (Default): the algorithm does not use components, but computes similarity across the entire graph. - Set to `true`: the algorithm uses components, and will compute these components before computing similarity. - Set to *String*: use pre-computed components stored in graph, *String* is the key for a node property representing components. *Default*: false. + * ** useComponents** - *(Optional)* If enabled, Node Similarity will use components to improve the performance of the computation, skipping comparisons of nodes in different components. + Set to `false` (Default): the algorithm does not use components, but computes similarity across the entire graph. + Set to `true`: the algorithm uses components, and will compute these components before computing similarity. + Set to *String*: use pre-computed components stored in graph, *String* is the key for a node property representing components. *Default*: false. @@ -3996,8 +3386,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.nodeSimilarity.write(G: Graph, **config: Any) -> Series[Any] The Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. @@ -4010,8 +3398,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.nodeSimilarity.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4022,8 +3408,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.nodeSimilarity.filtered.mutate(G: Graph, **config: Any) -> Series[Any] The Filtered Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. @@ -4037,8 +3421,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.nodeSimilarity.filtered.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4049,8 +3431,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.nodeSimilarity.filtered.stats(G: Graph, **config: Any) -> Series[Any] The Filtered Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. @@ -4064,8 +3444,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.nodeSimilarity.filtered.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4076,8 +3454,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.nodeSimilarity.filtered.stream(G: Graph, **config: Any) -> DataFrame The Filtered Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. @@ -4091,8 +3467,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.nodeSimilarity.filtered.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4103,8 +3477,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.nodeSimilarity.filtered.write(G: Graph, **config: Any) -> Series[Any] The Filtered Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. @@ -4118,8 +3490,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.nodeSimilarity.filtered.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4130,8 +3500,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.pageRank.mutate(G: Graph, **config: Any) -> Series[Any] Page Rank is an algorithm that measures the transitive influence or connectivity of nodes. @@ -4142,8 +3510,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.pageRank.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4154,8 +3520,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.pageRank.stats(G: Graph, **config: Any) -> Series[Any] Executes the algorithm and returns result statistics without writing the result to Neo4j. @@ -4166,8 +3530,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.pageRank.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4178,9 +3540,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - -.. py:function:: gds.pageRank.stream(G: Graph, **config: Any) -> DataFrame +.. py:function:: gds.pageRank.stream(G: Graph, *, , dampingFactor="0.85", maxIterations="20", tolerance="0.0000001", relationshipWeightProperty="null", sourceNodes="[]", scaler="None": Any) -> DataFrame Page Rank is an algorithm that measures the transitive influence or connectivity of nodes. @@ -4190,19 +3550,17 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - - * **dampingFactor** - *(Optional)* The damping factor of the Page Rank calculation. Must be in [0, 1). *Default*: 0.85. + * **dampingFactor** - *(Optional)* The damping factor of the Page Rank calculation. Must be in [0, 1). *Default*: 0.85. - * **maxIterations** - *(Optional)* The maximum number of iterations of Page Rank to run. *Default*: 20. + * **maxIterations** - *(Optional)* The maximum number of iterations of Page Rank to run. *Default*: 20. - * **tolerance** - *(Optional)* Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable and the algorithm returns. *Default*: 0.0000001. + * **tolerance** - *(Optional)* Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable and the algorithm returns. *Default*: 0.0000001. - * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. - * **sourceNodes** - *(Optional)* The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. + * **sourceNodes** - *(Optional)* The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. - * **scaler** - *(Optional)* The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. + * **scaler** - *(Optional)* The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. @@ -4216,8 +3574,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.pageRank.write(G: Graph, **config: Any) -> Series[Any] Page Rank is an algorithm that measures the transitive influence or connectivity of nodes. @@ -4228,8 +3584,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.pageRank.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4240,8 +3594,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.randomWalk.stats(G: Graph, **config: Any) -> Series[Any] Random Walk is an algorithm that provides random paths in a graph. It’s similar to how a drunk person traverses a city. @@ -4252,8 +3604,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.randomWalk.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4264,8 +3614,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.randomWalk.stream(G: Graph, **config: Any) -> DataFrame Random Walk is an algorithm that provides random paths in a graph. It’s similar to how a drunk person traverses a city. @@ -4276,8 +3624,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.randomWalk.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4288,8 +3634,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.shortestPath.astar.mutate(G: Graph, **config: Any) -> Series[Any] The A* shortest path algorithm computes the shortest path between a pair of nodes. It uses the relationship weight @@ -4302,8 +3646,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.shortestPath.astar.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4314,8 +3656,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.shortestPath.astar.stream(G: Graph, **config: Any) -> DataFrame The A* shortest path algorithm computes the shortest path between a pair of nodes. It uses the relationship weight @@ -4328,8 +3668,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.shortestPath.astar.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4340,8 +3678,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.shortestPath.astar.write(G: Graph, **config: Any) -> Series[Any] The A* shortest path algorithm computes the shortest path between a pair of nodes. It uses the relationship weight @@ -4354,8 +3690,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.shortestPath.astar.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4366,8 +3700,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.shortestPath.dijkstra.mutate(G: Graph, **config: Any) -> Series[Any] The Dijkstra shortest path algorithm computes the shortest (weighted) path between a pair of nodes. @@ -4378,8 +3710,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.shortestPath.dijkstra.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4390,8 +3720,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.shortestPath.dijkstra.stream(G: Graph, **config: Any) -> DataFrame The Dijkstra shortest path algorithm computes the shortest (weighted) path between a pair of nodes. @@ -4402,8 +3730,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.shortestPath.dijkstra.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4414,8 +3740,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.shortestPath.dijkstra.write(G: Graph, **config: Any) -> Series[Any] The Dijkstra shortest path algorithm computes the shortest (weighted) path between a pair of nodes. @@ -4426,8 +3750,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.shortestPath.dijkstra.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4438,8 +3760,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.shortestPath.yens.mutate(G: Graph, **config: Any) -> Series[Any] The Yen's shortest path algorithm computes the k shortest (weighted) paths between a pair of nodes. @@ -4450,8 +3770,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.shortestPath.yens.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4462,8 +3780,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.shortestPath.yens.stream(G: Graph, **config: Any) -> DataFrame The Yen's shortest path algorithm computes the k shortest (weighted) paths between a pair of nodes. @@ -4474,8 +3790,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.shortestPath.yens.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4486,8 +3800,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.shortestPath.yens.write(G: Graph, **config: Any) -> Series[Any] The Yen's shortest path algorithm computes the k shortest (weighted) paths between a pair of nodes. @@ -4498,8 +3810,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.shortestPath.yens.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4510,8 +3820,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.sllpa.mutate(G: Graph, **config: Any) -> Series[Any] The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph. @@ -4522,8 +3830,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.sllpa.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4534,8 +3840,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.sllpa.stats(G: Graph, **config: Any) -> Series[Any] The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph. @@ -4546,8 +3850,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.sllpa.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4558,8 +3860,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.sllpa.stream(G: Graph, **config: Any) -> DataFrame The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph. @@ -4570,8 +3870,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.sllpa.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4582,8 +3880,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.sllpa.write(G: Graph, **config: Any) -> Series[Any] The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph. @@ -4594,8 +3890,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.sllpa.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4606,8 +3900,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.spanningTree.mutate(G: Graph, **config: Any) -> Series[Any] The spanning tree algorithm visits all nodes that are in the same connected component as the starting node, @@ -4619,8 +3911,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.spanningTree.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4631,8 +3921,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.spanningTree.stats(G: Graph, **config: Any) -> Series[Any] The spanning tree algorithm visits all nodes that are in the same connected component as the starting node, @@ -4645,8 +3933,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.spanningTree.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4657,8 +3943,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.spanningTree.stream(G: Graph, **config: Any) -> DataFrame The spanning tree algorithm visits all nodes that are in the same connected component as the starting node, @@ -4671,8 +3955,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.spanningTree.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4683,8 +3965,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.spanningTree.write(G: Graph, **config: Any) -> Series[Any] The spanning tree algorithm visits all nodes that are in the same connected component as the starting node, @@ -4697,8 +3977,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.spanningTree.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4709,8 +3987,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.steinerTree.mutate(G: Graph, **config: Any) -> Series[Any] The steiner tree algorithm accepts a source node, as well as a list of target nodes. @@ -4723,8 +3999,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.steinerTree.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4735,8 +4009,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.steinerTree.stats(G: Graph, **config: Any) -> Series[Any] The steiner tree algorithm accepts a source node, as well as a list of target nodes. @@ -4749,8 +4021,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.steinerTree.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4761,8 +4031,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.steinerTree.stream(G: Graph, **config: Any) -> DataFrame The steiner tree algorithm accepts a source node, as well as a list of target nodes. @@ -4775,8 +4043,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.steinerTree.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4787,8 +4053,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.steinerTree.write(G: Graph, **config: Any) -> Series[Any] The steiner tree algorithm accepts a source node, as well as a list of target nodes. @@ -4801,8 +4065,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.steinerTree.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4813,8 +4075,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.triangleCount.mutate(G: Graph, **config: Any) -> Series[Any] Triangle counting is a community detection graph algorithm that is used to @@ -4826,8 +4086,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.triangleCount.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4838,8 +4096,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.triangleCount.stats(G: Graph, **config: Any) -> Series[Any] Triangle counting is a community detection graph algorithm that is used to @@ -4851,8 +4107,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.triangleCount.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4863,9 +4117,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - -.. py:function:: gds.triangleCount.stream(G: Graph, **config: Any) -> DataFrame +.. py:function:: gds.triangleCount.stream(G: Graph, *, , maxDegree="2^63^ - 1": Any) -> DataFrame Triangle counting is a community detection graph algorithm that is used to determine the number of triangles passing through each node in the graph. @@ -4876,9 +4128,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - - * **maxDegree** - *(Optional)* If a node has a degree higher than this it will not be considered by the algorithm. The triangle count for these nodes will be `-1`. *Default*: 2^63^ - 1. + * **maxDegree** - *(Optional)* If a node has a degree higher than this it will not be considered by the algorithm. The triangle count for these nodes will be `-1`. *Default*: 2^63^ - 1. @@ -4892,8 +4142,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.triangleCount.write(G: Graph, **config: Any) -> Series[Any] Triangle counting is a community detection graph algorithm that is used to @@ -4905,8 +4153,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.triangleCount.write.estimate(G: Graph, **config: Any) -> Series[Any] Triangle counting is a community detection graph algorithm that is used to @@ -4918,8 +4164,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.triangles(G: Graph, **config: Any) -> DataFrame Triangles streams the nodeIds of each triangle in the graph. @@ -4930,8 +4174,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.wcc.mutate(G: Graph, **config: Any) -> Series[Any] The WCC algorithm finds sets of connected nodes in an undirected graph, @@ -4943,8 +4185,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.wcc.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4955,8 +4195,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.wcc.stats(G: Graph, **config: Any) -> Series[Any] Executes the algorithm and returns result statistics without writing the result to Neo4j. @@ -4967,8 +4205,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.wcc.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4979,8 +4215,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.wcc.stream(G: Graph, **config: Any) -> DataFrame The WCC algorithm finds sets of connected nodes in an undirected graph, @@ -4992,8 +4226,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.wcc.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -5004,8 +4236,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.wcc.write(G: Graph, **config: Any) -> Series[Any] The WCC algorithm finds sets of connected nodes in an undirected graph, @@ -5017,8 +4247,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.wcc.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -5029,8 +4257,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * ****config** - Any - .. py:function:: gds.alpha.linkprediction.adamicAdar(node1: int, node2: int, **config: Any) -> float Given two nodes, calculate Adamic Adar similarity @@ -5043,8 +4269,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **node2** - int - * ****config** - Any - .. py:function:: gds.alpha.linkprediction.commonNeighbors(node1: int, node2: int, **config: Any) -> float Given two nodes, returns the number of common neighbors @@ -5057,8 +4281,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **node2** - int - * ****config** - Any - .. py:function:: gds.alpha.linkprediction.preferentialAttachment(node1: int, node2: int, **config: Any) -> float Given two nodes, calculate Preferential Attachment @@ -5071,8 +4293,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **node2** - int - * ****config** - Any - .. py:function:: gds.alpha.linkprediction.resourceAllocation(node1: int, node2: int, **config: Any) -> float Given two nodes, calculate Resource Allocation similarity @@ -5085,8 +4305,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **node2** - int - * ****config** - Any - .. py:function:: gds.alpha.linkprediction.sameCommunity(node1: int, node2: int, communityProperty: Optional[str] = None) -> float Given two nodes, indicates if they have the same community @@ -5113,5 +4331,3 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **node2** - int - * ****config** - Any - From 7897bf416b0fa60522a235bcb24cb72d1a5dd25b Mon Sep 17 00:00:00 2001 From: Nicola Vitucci Date: Wed, 29 May 2024 16:22:05 +0100 Subject: [PATCH 09/21] Update RST file --- doc/sphinx/source/algorithms.rst | 152 +++---------------------------- 1 file changed, 12 insertions(+), 140 deletions(-) diff --git a/doc/sphinx/source/algorithms.rst b/doc/sphinx/source/algorithms.rst index a5f670b52..df03d29c9 100644 --- a/doc/sphinx/source/algorithms.rst +++ b/doc/sphinx/source/algorithms.rst @@ -758,7 +758,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: gds.articleRank.stream(G: Graph, *, , dampingFactor="0.85", maxIterations="20", tolerance="0.0000001", relationshipWeightProperty="null", sourceNodes="[]", scaler="None": Any) -> DataFrame +.. py:function:: scaler(G: Graph, *, , dampingFactor='0.85', maxIterations='20', tolerance='0.0000001', relationshipWeightProperty='None', sourceNodes='[]', scaler='None': Any) -> DataFrame Article Rank is a variant of the Page Rank algorithm, which measures the transitive influence or connectivity of nodes. @@ -768,20 +768,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * **dampingFactor** - *(Optional)* The damping factor of the Page Rank calculation. Must be in [0, 1). *Default*: 0.85. - - * **maxIterations** - *(Optional)* The maximum number of iterations of Article Rank to run. *Default*: 20. - - * **tolerance** - *(Optional)* Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable, and the algorithm returns. *Default*: 0.0000001. - - * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. - - * **sourceNodes** - *(Optional)* The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. - - * **scaler** - *(Optional)* The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. - - - .. py:function:: gds.articleRank.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1690,7 +1676,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: gds.betweenness.stream(G: Graph, *, , samplingSize="node count", samplingSeed="null", relationshipWeightProperty="null": Any) -> DataFrame +.. py:function:: relationshipWeightProperty(G: Graph, *, , samplingSize='node count', samplingSeed='None', relationshipWeightProperty='None': Any) -> DataFrame Betweenness centrality measures the relative information flow that passes through a node. @@ -1700,14 +1686,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * **samplingSize** - *(Optional)* The number of source nodes to consider for computing centrality scores. *Default*: node count. - - * **samplingSeed** - *(Optional)* The seed value for the random number generator that selects start nodes. *Default*: null. - - * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. - - - .. py:function:: gds.betweenness.stream.estimate(G: Graph, **config: Any) -> Series[Any] Betweenness centrality measures the relative information flow that passes through a node. @@ -1780,7 +1758,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: gds.bfs.stream(G: Graph, *, , sourceNode, targetNodes="empty list", maxDepth="-1": Any) -> DataFrame +.. py:function:: maxDepth(G: Graph, *, , sourceNode, targetNodes='empty list', maxDepth='-1': Any) -> DataFrame BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level. @@ -1791,14 +1769,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * **sourceNode** - *(Required)* The node id of the node where to start the traversal. *Default*: n/a. - - * **targetNodes** - *(Optional)* Ids for target nodes. Traversal terminates when any target node is visited. *Default*: empty list. - - * **maxDepth** - *(Optional)* The maximum distance from the source node at which nodes are visited. *Default*: -1. - - - .. py:function:: gds.bfs.stream.estimate(G: Graph, **config: Any) -> Series[Any] BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth @@ -1905,7 +1875,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: gds.conductance.stream(G: Graph, *, , communityProperty, relationshipWeightProperty="null": Any) -> DataFrame +.. py:function:: relationshipWeightProperty(G: Graph, *, , communityProperty, relationshipWeightProperty='None': Any) -> DataFrame Evaluates a division of nodes into communities based on the proportion of relationships that cross community boundaries. @@ -1916,12 +1886,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * **communityProperty** - *(Required)* The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their conductance computed. *Default*: n/a. - - * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. - - - .. py:function:: gds.dag.topologicalSort.stream(G: Graph, **config: Any) -> DataFrame Returns a topological ordering of the nodes in a directed acyclic graph (DAG). @@ -1982,7 +1946,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: gds.degree.stream(G: Graph, *, , orientation="NATURAL", relationshipWeightProperty="null": Any) -> DataFrame +.. py:function:: relationshipWeightProperty(G: Graph, *, , orientation='NATURAL', relationshipWeightProperty='None': Any) -> DataFrame Degree centrality measures the number of incoming and outgoing relationships from a node. @@ -1992,12 +1956,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * **orientation** - *(Optional)* The orientation used to compute node degrees. Supported orientations are `NATURAL`, `REVERSE` and `UNDIRECTED`. *Default*: NATURAL. - - * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use for weighted degree computation. If unspecified, the algorithm runs unweighted. *Default*: null. - - - .. py:function:: gds.degree.stream.estimate(G: Graph, **config: Any) -> Series[Any] Degree centrality measures the number of incoming and outgoing relationships from a node. @@ -2050,7 +2008,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: gds.dfs.stream(G: Graph, *, , sourceNode, targetNodes="empty list", maxDepth="-1": Any) -> DataFrame +.. py:function:: maxDepth(G: Graph, *, , sourceNode, targetNodes='empty list', maxDepth='-1': Any) -> DataFrame Depth-first search (DFS) is an algorithm for traversing or searching tree or graph data structures. The algorithm starts at the root node (selecting some arbitrary node as the root node in the case of a graph) @@ -2062,14 +2020,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * **sourceNode** - *(Required)* The node id of the node where to start the traversal. *Default*: n/a. - - * **targetNodes** - *(Optional)* Ids for target nodes. Traversal terminates when any target node is visited. *Default*: empty list. - - * **maxDepth** - *(Optional)* The maximum distance from the source node at which nodes are visited. *Default*: -1. - - - .. py:function:: gds.dfs.stream.estimate(G: Graph, **config: Any) -> Series[Any] Depth-first search (DFS) is an algorithm for traversing or searching tree or graph data structures. @@ -2122,7 +2072,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: gds.eigenvector.stream(G: Graph, *, , maxIterations="20", tolerance="0.0000001", relationshipWeightProperty="null", sourceNodes="[]", scaler="None": Any) -> DataFrame +.. py:function:: scaler(G: Graph, *, , maxIterations='20', tolerance='0.0000001', relationshipWeightProperty='None', sourceNodes='[]', scaler='None': Any) -> DataFrame Eigenvector Centrality is an algorithm that measures the transitive influence or connectivity of nodes. @@ -2132,18 +2082,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * **maxIterations** - *(Optional)* The maximum number of iterations of Eigenvector Centrality to run. *Default*: 20. - - * **tolerance** - *(Optional)* Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable and the algorithm returns. *Default*: 0.0000001. - - * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. - - * **sourceNodes** - *(Optional)* The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. - - * **scaler** - *(Optional)* The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. - - - .. py:function:: gds.eigenvector.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -2996,7 +2934,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: gds.localClusteringCoefficient.stream(G: Graph, *, , triangleCountProperty="n/a": Any) -> DataFrame +.. py:function:: triangleCountProperty(G: Graph, *, , triangleCountProperty='n/a': Any) -> DataFrame The local clustering coefficient is a metric quantifying how connected the neighborhood of a node is. @@ -3006,10 +2944,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * **triangleCountProperty** - *(Optional)* Node property that contains pre-computed triangle count. *Default*: n/a. - - - .. py:function:: gds.localClusteringCoefficient.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3180,7 +3114,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: gds.modularity.stream(G: Graph, *, , communityProperty, relationshipWeightProperty="null": Any) -> DataFrame +.. py:function:: relationshipWeightProperty(G: Graph, *, , communityProperty, relationshipWeightProperty='None': Any) -> DataFrame | @@ -3188,12 +3122,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * **communityProperty** - *(Required)* The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their modularity score computed. *Default*: n/a. - - * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. - - - .. py:function:: gds.modularity.stream.estimate(G: Graph, **config: Any) -> Series[Any] | @@ -3326,7 +3254,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: gds.nodeSimilarity.stream(G: Graph, *, , similarityCutoff="1e-42", degreeCutoff="1", upperDegreeCutoff="2147483647", topK="10", bottomK="10", topN="0", bottomN="0", relationshipWeightProperty="null", similarityMetric="JACCARD", useComponents="false": Any) -> DataFrame +.. py:function:: useComponents(G: Graph, *, , similarityCutoff='1e-42', degreeCutoff='1', upperDegreeCutoff='2147483647', topK='10', bottomK='10', topN='0', bottomN='0', relationshipWeightProperty='None', similarityMetric='JACCARD', useComponents='false': Any) -> DataFrame The Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. Two nodes are considered similar if they share many of the same neighbors. @@ -3338,44 +3266,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * **similarityCutoff** - *(Optional)* Lower limit for the similarity score to be present in the result. - Values must be between 0 and 1. *Default*: 1e-42. - - * **degreeCutoff** - *(Optional)* Inclusive lower bound on the node degree for a node to be considered in the comparisons. - This value can not be lower than 1. *Default*: 1. - - * **upperDegreeCutoff** - *(Optional)* Inclusive upper bound on the node degree for a node to be considered in the comparisons. - This value can not be lower than 1. *Default*: 2147483647. - - * **topK** - *(Optional)* Limit on the number of scores per node. - The K largest results are returned. - This value cannot be lower than 1. *Default*: 10. - - * **bottomK** - *(Optional)* Limit on the number of scores per node. - The K smallest results are returned. - This value cannot be lower than 1. *Default*: 10. - - * **topN** - *(Optional)* Global limit on the number of scores computed. - The N largest total results are returned. - This value cannot be negative, a value of 0 means no global limit. *Default*: 0. - - * **bottomN** - *(Optional)* Global limit on the number of scores computed. - The N smallest total results are returned. - This value cannot be negative, a value of 0 means no global limit. *Default*: 0. - - * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. - If unspecified, the algorithm runs unweighted. *Default*: null. - - * **similarityMetric** - *(Optional)* The metric used to compute similarity. - Can be either `JACCARD`, `OVERLAP` or `COSINE`. *Default*: JACCARD. - - * ** useComponents** - *(Optional)* If enabled, Node Similarity will use components to improve the performance of the computation, skipping comparisons of nodes in different components. - Set to `false` (Default): the algorithm does not use components, but computes similarity across the entire graph. - Set to `true`: the algorithm uses components, and will compute these components before computing similarity. - Set to *String*: use pre-computed components stored in graph, *String* is the key for a node property representing components. *Default*: false. - - - .. py:function:: gds.nodeSimilarity.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3540,7 +3430,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: gds.pageRank.stream(G: Graph, *, , dampingFactor="0.85", maxIterations="20", tolerance="0.0000001", relationshipWeightProperty="null", sourceNodes="[]", scaler="None": Any) -> DataFrame +.. py:function:: scaler(G: Graph, *, , dampingFactor='0.85', maxIterations='20', tolerance='0.0000001', relationshipWeightProperty='None', sourceNodes='[]', scaler='None': Any) -> DataFrame Page Rank is an algorithm that measures the transitive influence or connectivity of nodes. @@ -3550,20 +3440,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * **dampingFactor** - *(Optional)* The damping factor of the Page Rank calculation. Must be in [0, 1). *Default*: 0.85. - - * **maxIterations** - *(Optional)* The maximum number of iterations of Page Rank to run. *Default*: 20. - - * **tolerance** - *(Optional)* Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable and the algorithm returns. *Default*: 0.0000001. - - * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. - - * **sourceNodes** - *(Optional)* The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. - - * **scaler** - *(Optional)* The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. - - - .. py:function:: gds.pageRank.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -4117,7 +3993,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: gds.triangleCount.stream(G: Graph, *, , maxDegree="2^63^ - 1": Any) -> DataFrame +.. py:function:: maxDegree(G: Graph, *, , maxDegree='2^63^ - 1': Any) -> DataFrame Triangle counting is a community detection graph algorithm that is used to determine the number of triangles passing through each node in the graph. @@ -4128,10 +4004,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * **maxDegree** - *(Optional)* If a node has a degree higher than this it will not be considered by the algorithm. The triangle count for these nodes will be `-1`. *Default*: 2^63^ - 1. - - - .. py:function:: gds.triangleCount.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. From f7e770f2af746be5bd2627316438f141f7fc8608 Mon Sep 17 00:00:00 2001 From: Nicola Vitucci Date: Thu, 30 May 2024 16:11:46 +0100 Subject: [PATCH 10/21] Update RST file --- doc/sphinx/source/algorithms.rst | 152 ++++++++++++++++++++++++++++--- 1 file changed, 140 insertions(+), 12 deletions(-) diff --git a/doc/sphinx/source/algorithms.rst b/doc/sphinx/source/algorithms.rst index df03d29c9..ce002f69e 100644 --- a/doc/sphinx/source/algorithms.rst +++ b/doc/sphinx/source/algorithms.rst @@ -758,7 +758,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: scaler(G: Graph, *, , dampingFactor='0.85', maxIterations='20', tolerance='0.0000001', relationshipWeightProperty='None', sourceNodes='[]', scaler='None': Any) -> DataFrame +.. py:function:: gds.articleRank.stream(G: Graph, *, , dampingFactor=0.85, maxIterations=20, tolerance=0.0000001, relationshipWeightProperty=None, sourceNodes=[], scaler=None) -> DataFrame Article Rank is a variant of the Page Rank algorithm, which measures the transitive influence or connectivity of nodes. @@ -768,6 +768,20 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph + * **dampingFactor** - *(Optional)* The damping factor of the Page Rank calculation. Must be in [0, 1). *Default*: 0.85. + + * **maxIterations** - *(Optional)* The maximum number of iterations of Article Rank to run. *Default*: 20. + + * **tolerance** - *(Optional)* Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable, and the algorithm returns. *Default*: 0.0000001. + + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + + * **sourceNodes** - *(Optional)* The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. + + * **scaler** - *(Optional)* The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. + + + .. py:function:: gds.articleRank.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1676,7 +1690,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: relationshipWeightProperty(G: Graph, *, , samplingSize='node count', samplingSeed='None', relationshipWeightProperty='None': Any) -> DataFrame +.. py:function:: gds.betweenness.stream(G: Graph, *, , samplingSize=node count, samplingSeed=None, relationshipWeightProperty=None) -> DataFrame Betweenness centrality measures the relative information flow that passes through a node. @@ -1686,6 +1700,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph + * **samplingSize** - *(Optional)* The number of source nodes to consider for computing centrality scores. *Default*: node count. + + * **samplingSeed** - *(Optional)* The seed value for the random number generator that selects start nodes. *Default*: null. + + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + + + .. py:function:: gds.betweenness.stream.estimate(G: Graph, **config: Any) -> Series[Any] Betweenness centrality measures the relative information flow that passes through a node. @@ -1758,7 +1780,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: maxDepth(G: Graph, *, , sourceNode, targetNodes='empty list', maxDepth='-1': Any) -> DataFrame +.. py:function:: gds.bfs.stream(G: Graph, *, , sourceNode, targetNodes=empty list, maxDepth=-1) -> DataFrame BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level. @@ -1769,6 +1791,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph + * **sourceNode** - *(Required)* The node id of the node where to start the traversal. *Default*: n/a. + + * **targetNodes** - *(Optional)* Ids for target nodes. Traversal terminates when any target node is visited. *Default*: empty list. + + * **maxDepth** - *(Optional)* The maximum distance from the source node at which nodes are visited. *Default*: -1. + + + .. py:function:: gds.bfs.stream.estimate(G: Graph, **config: Any) -> Series[Any] BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth @@ -1875,7 +1905,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: relationshipWeightProperty(G: Graph, *, , communityProperty, relationshipWeightProperty='None': Any) -> DataFrame +.. py:function:: gds.conductance.stream(G: Graph, *, , communityProperty, relationshipWeightProperty=None) -> DataFrame Evaluates a division of nodes into communities based on the proportion of relationships that cross community boundaries. @@ -1886,6 +1916,12 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph + * **communityProperty** - *(Required)* The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their conductance computed. *Default*: n/a. + + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + + + .. py:function:: gds.dag.topologicalSort.stream(G: Graph, **config: Any) -> DataFrame Returns a topological ordering of the nodes in a directed acyclic graph (DAG). @@ -1946,7 +1982,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: relationshipWeightProperty(G: Graph, *, , orientation='NATURAL', relationshipWeightProperty='None': Any) -> DataFrame +.. py:function:: gds.degree.stream(G: Graph, *, , orientation=NATURAL, relationshipWeightProperty=None) -> DataFrame Degree centrality measures the number of incoming and outgoing relationships from a node. @@ -1956,6 +1992,12 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph + * **orientation** - *(Optional)* The orientation used to compute node degrees. Supported orientations are `NATURAL`, `REVERSE` and `UNDIRECTED`. *Default*: NATURAL. + + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use for weighted degree computation. If unspecified, the algorithm runs unweighted. *Default*: null. + + + .. py:function:: gds.degree.stream.estimate(G: Graph, **config: Any) -> Series[Any] Degree centrality measures the number of incoming and outgoing relationships from a node. @@ -2008,7 +2050,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: maxDepth(G: Graph, *, , sourceNode, targetNodes='empty list', maxDepth='-1': Any) -> DataFrame +.. py:function:: gds.dfs.stream(G: Graph, *, , sourceNode, targetNodes=empty list, maxDepth=-1) -> DataFrame Depth-first search (DFS) is an algorithm for traversing or searching tree or graph data structures. The algorithm starts at the root node (selecting some arbitrary node as the root node in the case of a graph) @@ -2020,6 +2062,14 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph + * **sourceNode** - *(Required)* The node id of the node where to start the traversal. *Default*: n/a. + + * **targetNodes** - *(Optional)* Ids for target nodes. Traversal terminates when any target node is visited. *Default*: empty list. + + * **maxDepth** - *(Optional)* The maximum distance from the source node at which nodes are visited. *Default*: -1. + + + .. py:function:: gds.dfs.stream.estimate(G: Graph, **config: Any) -> Series[Any] Depth-first search (DFS) is an algorithm for traversing or searching tree or graph data structures. @@ -2072,7 +2122,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: scaler(G: Graph, *, , maxIterations='20', tolerance='0.0000001', relationshipWeightProperty='None', sourceNodes='[]', scaler='None': Any) -> DataFrame +.. py:function:: gds.eigenvector.stream(G: Graph, *, , maxIterations=20, tolerance=0.0000001, relationshipWeightProperty=None, sourceNodes=[], scaler=None) -> DataFrame Eigenvector Centrality is an algorithm that measures the transitive influence or connectivity of nodes. @@ -2082,6 +2132,18 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph + * **maxIterations** - *(Optional)* The maximum number of iterations of Eigenvector Centrality to run. *Default*: 20. + + * **tolerance** - *(Optional)* Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable and the algorithm returns. *Default*: 0.0000001. + + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + + * **sourceNodes** - *(Optional)* The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. + + * **scaler** - *(Optional)* The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. + + + .. py:function:: gds.eigenvector.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -2934,7 +2996,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: triangleCountProperty(G: Graph, *, , triangleCountProperty='n/a': Any) -> DataFrame +.. py:function:: gds.localClusteringCoefficient.stream(G: Graph, *, , triangleCountProperty=n/a) -> DataFrame The local clustering coefficient is a metric quantifying how connected the neighborhood of a node is. @@ -2944,6 +3006,10 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph + * **triangleCountProperty** - *(Optional)* Node property that contains pre-computed triangle count. *Default*: n/a. + + + .. py:function:: gds.localClusteringCoefficient.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3114,7 +3180,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: relationshipWeightProperty(G: Graph, *, , communityProperty, relationshipWeightProperty='None': Any) -> DataFrame +.. py:function:: gds.modularity.stream(G: Graph, *, , communityProperty, relationshipWeightProperty=None) -> DataFrame | @@ -3122,6 +3188,12 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph + * **communityProperty** - *(Required)* The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their modularity score computed. *Default*: n/a. + + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + + + .. py:function:: gds.modularity.stream.estimate(G: Graph, **config: Any) -> Series[Any] | @@ -3254,7 +3326,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: useComponents(G: Graph, *, , similarityCutoff='1e-42', degreeCutoff='1', upperDegreeCutoff='2147483647', topK='10', bottomK='10', topN='0', bottomN='0', relationshipWeightProperty='None', similarityMetric='JACCARD', useComponents='false': Any) -> DataFrame +.. py:function:: gds.nodeSimilarity.stream(G: Graph, *, , similarityCutoff=1e-42, degreeCutoff=1, upperDegreeCutoff=2147483647, topK=10, bottomK=10, topN=0, bottomN=0, relationshipWeightProperty=None, similarityMetric=JACCARD, useComponents=false) -> DataFrame The Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. Two nodes are considered similar if they share many of the same neighbors. @@ -3266,6 +3338,44 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph + * **similarityCutoff** - *(Optional)* Lower limit for the similarity score to be present in the result. + Values must be between 0 and 1. *Default*: 1e-42. + + * **degreeCutoff** - *(Optional)* Inclusive lower bound on the node degree for a node to be considered in the comparisons. + This value can not be lower than 1. *Default*: 1. + + * **upperDegreeCutoff** - *(Optional)* Inclusive upper bound on the node degree for a node to be considered in the comparisons. + This value can not be lower than 1. *Default*: 2147483647. + + * **topK** - *(Optional)* Limit on the number of scores per node. + The K largest results are returned. + This value cannot be lower than 1. *Default*: 10. + + * **bottomK** - *(Optional)* Limit on the number of scores per node. + The K smallest results are returned. + This value cannot be lower than 1. *Default*: 10. + + * **topN** - *(Optional)* Global limit on the number of scores computed. + The N largest total results are returned. + This value cannot be negative, a value of 0 means no global limit. *Default*: 0. + + * **bottomN** - *(Optional)* Global limit on the number of scores computed. + The N smallest total results are returned. + This value cannot be negative, a value of 0 means no global limit. *Default*: 0. + + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. + If unspecified, the algorithm runs unweighted. *Default*: null. + + * **similarityMetric** - *(Optional)* The metric used to compute similarity. + Can be either `JACCARD`, `OVERLAP` or `COSINE`. *Default*: JACCARD. + + * ** useComponents** - *(Optional)* If enabled, Node Similarity will use components to improve the performance of the computation, skipping comparisons of nodes in different components. + Set to `false` (Default): the algorithm does not use components, but computes similarity across the entire graph. + Set to `true`: the algorithm uses components, and will compute these components before computing similarity. + Set to *String*: use pre-computed components stored in graph, *String* is the key for a node property representing components. *Default*: false. + + + .. py:function:: gds.nodeSimilarity.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3430,7 +3540,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: scaler(G: Graph, *, , dampingFactor='0.85', maxIterations='20', tolerance='0.0000001', relationshipWeightProperty='None', sourceNodes='[]', scaler='None': Any) -> DataFrame +.. py:function:: gds.pageRank.stream(G: Graph, *, , dampingFactor=0.85, maxIterations=20, tolerance=0.0000001, relationshipWeightProperty=None, sourceNodes=[], scaler=None) -> DataFrame Page Rank is an algorithm that measures the transitive influence or connectivity of nodes. @@ -3440,6 +3550,20 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph + * **dampingFactor** - *(Optional)* The damping factor of the Page Rank calculation. Must be in [0, 1). *Default*: 0.85. + + * **maxIterations** - *(Optional)* The maximum number of iterations of Page Rank to run. *Default*: 20. + + * **tolerance** - *(Optional)* Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable and the algorithm returns. *Default*: 0.0000001. + + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + + * **sourceNodes** - *(Optional)* The nodes or node ids to use for computing Personalized Page Rank. *Default*: []. + + * **scaler** - *(Optional)* The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`. *Default*: None. + + + .. py:function:: gds.pageRank.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -3993,7 +4117,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: maxDegree(G: Graph, *, , maxDegree='2^63^ - 1': Any) -> DataFrame +.. py:function:: gds.triangleCount.stream(G: Graph, *, , maxDegree=2^63^ - 1) -> DataFrame Triangle counting is a community detection graph algorithm that is used to determine the number of triangles passing through each node in the graph. @@ -4004,6 +4128,10 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph + * **maxDegree** - *(Optional)* If a node has a degree higher than this it will not be considered by the algorithm. The triangle count for these nodes will be `-1`. *Default*: 2^63^ - 1. + + + .. py:function:: gds.triangleCount.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. From 5b93d46b9679edf6cb538994140d67c8e7ea54a8 Mon Sep 17 00:00:00 2001 From: Nicola Vitucci Date: Thu, 30 May 2024 16:32:33 +0100 Subject: [PATCH 11/21] Update RST file --- doc/sphinx/source/algorithms.rst | 144 ++++++++++++++++++++++++++++--- 1 file changed, 132 insertions(+), 12 deletions(-) diff --git a/doc/sphinx/source/algorithms.rst b/doc/sphinx/source/algorithms.rst index ce002f69e..a01fbd77c 100644 --- a/doc/sphinx/source/algorithms.rst +++ b/doc/sphinx/source/algorithms.rst @@ -758,7 +758,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: gds.articleRank.stream(G: Graph, *, , dampingFactor=0.85, maxIterations=20, tolerance=0.0000001, relationshipWeightProperty=None, sourceNodes=[], scaler=None) -> DataFrame +.. py:function:: gds.articleRank.stream(G: Graph, *, nodeLabels=['*'], relationshipTypes=['*'], concurrency=4, jobId=None, logProgress=True, dampingFactor=0.85, maxIterations=20, tolerance=0.0000001, relationshipWeightProperty=None, sourceNodes=[], scaler=None) -> DataFrame Article Rank is a variant of the Page Rank algorithm, which measures the transitive influence or connectivity of nodes. @@ -768,6 +768,16 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph + * **nodeLabels** - *(Optional)* Filter the named graph using the given node labels. Nodes with any of the given labels will be included. *Default*: ['*']. + + * **relationshipTypes** - *(Optional)* Filter the named graph using the given relationship types. Relationships with any of the given types will be included. *Default*: ['*']. + + * **concurrency** - *(Optional)* The number of concurrent threads used for running the algorithm. *Default*: 4. + + * **jobId** - *(Optional)* An ID that can be provided to more easily track the algorithm’s progress. *Default*: None (Generated internally). + + * **logProgress** - *(Optional)* If disabled the progress percentage will not be logged. *Default*: True. + * **dampingFactor** - *(Optional)* The damping factor of the Page Rank calculation. Must be in [0, 1). *Default*: 0.85. * **maxIterations** - *(Optional)* The maximum number of iterations of Article Rank to run. *Default*: 20. @@ -1690,7 +1700,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: gds.betweenness.stream(G: Graph, *, , samplingSize=node count, samplingSeed=None, relationshipWeightProperty=None) -> DataFrame +.. py:function:: gds.betweenness.stream(G: Graph, *, nodeLabels=['*'], relationshipTypes=['*'], concurrency=4, jobId=None, logProgress=True, samplingSize=node count, samplingSeed=None, relationshipWeightProperty=None) -> DataFrame Betweenness centrality measures the relative information flow that passes through a node. @@ -1700,6 +1710,16 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph + * **nodeLabels** - *(Optional)* Filter the named graph using the given node labels. Nodes with any of the given labels will be included. *Default*: ['*']. + + * **relationshipTypes** - *(Optional)* Filter the named graph using the given relationship types. Relationships with any of the given types will be included. *Default*: ['*']. + + * **concurrency** - *(Optional)* The number of concurrent threads used for running the algorithm. *Default*: 4. + + * **jobId** - *(Optional)* An ID that can be provided to more easily track the algorithm’s progress. *Default*: None (Generated internally). + + * **logProgress** - *(Optional)* If disabled the progress percentage will not be logged. *Default*: True. + * **samplingSize** - *(Optional)* The number of source nodes to consider for computing centrality scores. *Default*: node count. * **samplingSeed** - *(Optional)* The seed value for the random number generator that selects start nodes. *Default*: null. @@ -1780,7 +1800,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: gds.bfs.stream(G: Graph, *, , sourceNode, targetNodes=empty list, maxDepth=-1) -> DataFrame +.. py:function:: gds.bfs.stream(G: Graph, *, sourceNode, nodeLabels=['*'], relationshipTypes=['*'], concurrency=4, jobId=None, logProgress=True, targetNodes=empty list, maxDepth=-1) -> DataFrame BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level. @@ -1793,6 +1813,16 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **sourceNode** - *(Required)* The node id of the node where to start the traversal. *Default*: n/a. + * **nodeLabels** - *(Optional)* Filter the named graph using the given node labels. Nodes with any of the given labels will be included. *Default*: ['*']. + + * **relationshipTypes** - *(Optional)* Filter the named graph using the given relationship types. Relationships with any of the given types will be included. *Default*: ['*']. + + * **concurrency** - *(Optional)* The number of concurrent threads used for running the algorithm. *Default*: 4. + + * **jobId** - *(Optional)* An ID that can be provided to more easily track the algorithm’s progress. *Default*: None (Generated internally). + + * **logProgress** - *(Optional)* If disabled the progress percentage will not be logged. *Default*: True. + * **targetNodes** - *(Optional)* Ids for target nodes. Traversal terminates when any target node is visited. *Default*: empty list. * **maxDepth** - *(Optional)* The maximum distance from the source node at which nodes are visited. *Default*: -1. @@ -1905,7 +1935,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: gds.conductance.stream(G: Graph, *, , communityProperty, relationshipWeightProperty=None) -> DataFrame +.. py:function:: gds.conductance.stream(G: Graph, *, communityProperty, nodeLabels=['*'], relationshipTypes=['*'], concurrency=4, jobId=None, logProgress=True, relationshipWeightProperty=None) -> DataFrame Evaluates a division of nodes into communities based on the proportion of relationships that cross community boundaries. @@ -1918,6 +1948,16 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **communityProperty** - *(Required)* The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their conductance computed. *Default*: n/a. + * **nodeLabels** - *(Optional)* Filter the named graph using the given node labels. Nodes with any of the given labels will be included. *Default*: ['*']. + + * **relationshipTypes** - *(Optional)* Filter the named graph using the given relationship types. Relationships with any of the given types will be included. *Default*: ['*']. + + * **concurrency** - *(Optional)* The number of concurrent threads used for running the algorithm. *Default*: 4. + + * **jobId** - *(Optional)* An ID that can be provided to more easily track the algorithm’s progress. *Default*: None (Generated internally). + + * **logProgress** - *(Optional)* If disabled the progress percentage will not be logged. *Default*: True. + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. @@ -1982,7 +2022,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: gds.degree.stream(G: Graph, *, , orientation=NATURAL, relationshipWeightProperty=None) -> DataFrame +.. py:function:: gds.degree.stream(G: Graph, *, nodeLabels=['*'], relationshipTypes=['*'], concurrency=4, jobId=None, logProgress=True, orientation=NATURAL, relationshipWeightProperty=None) -> DataFrame Degree centrality measures the number of incoming and outgoing relationships from a node. @@ -1992,6 +2032,16 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph + * **nodeLabels** - *(Optional)* Filter the named graph using the given node labels. Nodes with any of the given labels will be included. *Default*: ['*']. + + * **relationshipTypes** - *(Optional)* Filter the named graph using the given relationship types. Relationships with any of the given types will be included. *Default*: ['*']. + + * **concurrency** - *(Optional)* The number of concurrent threads used for running the algorithm. *Default*: 4. + + * **jobId** - *(Optional)* An ID that can be provided to more easily track the algorithm’s progress. *Default*: None (Generated internally). + + * **logProgress** - *(Optional)* If disabled the progress percentage will not be logged. *Default*: True. + * **orientation** - *(Optional)* The orientation used to compute node degrees. Supported orientations are `NATURAL`, `REVERSE` and `UNDIRECTED`. *Default*: NATURAL. * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use for weighted degree computation. If unspecified, the algorithm runs unweighted. *Default*: null. @@ -2050,7 +2100,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: gds.dfs.stream(G: Graph, *, , sourceNode, targetNodes=empty list, maxDepth=-1) -> DataFrame +.. py:function:: gds.dfs.stream(G: Graph, *, sourceNode, nodeLabels=['*'], relationshipTypes=['*'], concurrency=4, jobId=None, logProgress=True, targetNodes=empty list, maxDepth=-1) -> DataFrame Depth-first search (DFS) is an algorithm for traversing or searching tree or graph data structures. The algorithm starts at the root node (selecting some arbitrary node as the root node in the case of a graph) @@ -2064,6 +2114,16 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **sourceNode** - *(Required)* The node id of the node where to start the traversal. *Default*: n/a. + * **nodeLabels** - *(Optional)* Filter the named graph using the given node labels. Nodes with any of the given labels will be included. *Default*: ['*']. + + * **relationshipTypes** - *(Optional)* Filter the named graph using the given relationship types. Relationships with any of the given types will be included. *Default*: ['*']. + + * **concurrency** - *(Optional)* The number of concurrent threads used for running the algorithm. *Default*: 4. + + * **jobId** - *(Optional)* An ID that can be provided to more easily track the algorithm’s progress. *Default*: None (Generated internally). + + * **logProgress** - *(Optional)* If disabled the progress percentage will not be logged. *Default*: True. + * **targetNodes** - *(Optional)* Ids for target nodes. Traversal terminates when any target node is visited. *Default*: empty list. * **maxDepth** - *(Optional)* The maximum distance from the source node at which nodes are visited. *Default*: -1. @@ -2122,7 +2182,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: gds.eigenvector.stream(G: Graph, *, , maxIterations=20, tolerance=0.0000001, relationshipWeightProperty=None, sourceNodes=[], scaler=None) -> DataFrame +.. py:function:: gds.eigenvector.stream(G: Graph, *, nodeLabels=['*'], relationshipTypes=['*'], concurrency=4, jobId=None, logProgress=True, maxIterations=20, tolerance=0.0000001, relationshipWeightProperty=None, sourceNodes=[], scaler=None) -> DataFrame Eigenvector Centrality is an algorithm that measures the transitive influence or connectivity of nodes. @@ -2132,6 +2192,16 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph + * **nodeLabels** - *(Optional)* Filter the named graph using the given node labels. Nodes with any of the given labels will be included. *Default*: ['*']. + + * **relationshipTypes** - *(Optional)* Filter the named graph using the given relationship types. Relationships with any of the given types will be included. *Default*: ['*']. + + * **concurrency** - *(Optional)* The number of concurrent threads used for running the algorithm. *Default*: 4. + + * **jobId** - *(Optional)* An ID that can be provided to more easily track the algorithm’s progress. *Default*: None (Generated internally). + + * **logProgress** - *(Optional)* If disabled the progress percentage will not be logged. *Default*: True. + * **maxIterations** - *(Optional)* The maximum number of iterations of Eigenvector Centrality to run. *Default*: 20. * **tolerance** - *(Optional)* Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable and the algorithm returns. *Default*: 0.0000001. @@ -2996,7 +3066,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: gds.localClusteringCoefficient.stream(G: Graph, *, , triangleCountProperty=n/a) -> DataFrame +.. py:function:: gds.localClusteringCoefficient.stream(G: Graph, *, nodeLabels=['*'], relationshipTypes=['*'], concurrency=4, jobId=None, logProgress=True, triangleCountProperty=n/a) -> DataFrame The local clustering coefficient is a metric quantifying how connected the neighborhood of a node is. @@ -3006,6 +3076,16 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph + * **nodeLabels** - *(Optional)* Filter the named graph using the given node labels. Nodes with any of the given labels will be included. *Default*: ['*']. + + * **relationshipTypes** - *(Optional)* Filter the named graph using the given relationship types. Relationships with any of the given types will be included. *Default*: ['*']. + + * **concurrency** - *(Optional)* The number of concurrent threads used for running the algorithm. *Default*: 4. + + * **jobId** - *(Optional)* An ID that can be provided to more easily track the algorithm’s progress. *Default*: None (Generated internally). + + * **logProgress** - *(Optional)* If disabled the progress percentage will not be logged. *Default*: True. + * **triangleCountProperty** - *(Optional)* Node property that contains pre-computed triangle count. *Default*: n/a. @@ -3180,7 +3260,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: gds.modularity.stream(G: Graph, *, , communityProperty, relationshipWeightProperty=None) -> DataFrame +.. py:function:: gds.modularity.stream(G: Graph, *, communityProperty, nodeLabels=['*'], relationshipTypes=['*'], concurrency=4, jobId=None, logProgress=True, relationshipWeightProperty=None) -> DataFrame | @@ -3190,6 +3270,16 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **communityProperty** - *(Required)* The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their modularity score computed. *Default*: n/a. + * **nodeLabels** - *(Optional)* Filter the named graph using the given node labels. Nodes with any of the given labels will be included. *Default*: ['*']. + + * **relationshipTypes** - *(Optional)* Filter the named graph using the given relationship types. Relationships with any of the given types will be included. *Default*: ['*']. + + * **concurrency** - *(Optional)* The number of concurrent threads used for running the algorithm. *Default*: 4. + + * **jobId** - *(Optional)* An ID that can be provided to more easily track the algorithm’s progress. *Default*: None (Generated internally). + + * **logProgress** - *(Optional)* If disabled the progress percentage will not be logged. *Default*: True. + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. @@ -3326,7 +3416,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: gds.nodeSimilarity.stream(G: Graph, *, , similarityCutoff=1e-42, degreeCutoff=1, upperDegreeCutoff=2147483647, topK=10, bottomK=10, topN=0, bottomN=0, relationshipWeightProperty=None, similarityMetric=JACCARD, useComponents=false) -> DataFrame +.. py:function:: gds.nodeSimilarity.stream(G: Graph, *, nodeLabels=['*'], relationshipTypes=['*'], concurrency=4, jobId=None, logProgress=True, similarityCutoff=1e-42, degreeCutoff=1, upperDegreeCutoff=2147483647, topK=10, bottomK=10, topN=0, bottomN=0, relationshipWeightProperty=None, similarityMetric=JACCARD, useComponents=false) -> DataFrame The Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. Two nodes are considered similar if they share many of the same neighbors. @@ -3338,6 +3428,16 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph + * **nodeLabels** - *(Optional)* Filter the named graph using the given node labels. Nodes with any of the given labels will be included. *Default*: ['*']. + + * **relationshipTypes** - *(Optional)* Filter the named graph using the given relationship types. Relationships with any of the given types will be included. *Default*: ['*']. + + * **concurrency** - *(Optional)* The number of concurrent threads used for running the algorithm. *Default*: 4. + + * **jobId** - *(Optional)* An ID that can be provided to more easily track the algorithm’s progress. *Default*: None (Generated internally). + + * **logProgress** - *(Optional)* If disabled the progress percentage will not be logged. *Default*: True. + * **similarityCutoff** - *(Optional)* Lower limit for the similarity score to be present in the result. Values must be between 0 and 1. *Default*: 1e-42. @@ -3540,7 +3640,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: gds.pageRank.stream(G: Graph, *, , dampingFactor=0.85, maxIterations=20, tolerance=0.0000001, relationshipWeightProperty=None, sourceNodes=[], scaler=None) -> DataFrame +.. py:function:: gds.pageRank.stream(G: Graph, *, nodeLabels=['*'], relationshipTypes=['*'], concurrency=4, jobId=None, logProgress=True, dampingFactor=0.85, maxIterations=20, tolerance=0.0000001, relationshipWeightProperty=None, sourceNodes=[], scaler=None) -> DataFrame Page Rank is an algorithm that measures the transitive influence or connectivity of nodes. @@ -3550,6 +3650,16 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph + * **nodeLabels** - *(Optional)* Filter the named graph using the given node labels. Nodes with any of the given labels will be included. *Default*: ['*']. + + * **relationshipTypes** - *(Optional)* Filter the named graph using the given relationship types. Relationships with any of the given types will be included. *Default*: ['*']. + + * **concurrency** - *(Optional)* The number of concurrent threads used for running the algorithm. *Default*: 4. + + * **jobId** - *(Optional)* An ID that can be provided to more easily track the algorithm’s progress. *Default*: None (Generated internally). + + * **logProgress** - *(Optional)* If disabled the progress percentage will not be logged. *Default*: True. + * **dampingFactor** - *(Optional)* The damping factor of the Page Rank calculation. Must be in [0, 1). *Default*: 0.85. * **maxIterations** - *(Optional)* The maximum number of iterations of Page Rank to run. *Default*: 20. @@ -4117,7 +4227,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: gds.triangleCount.stream(G: Graph, *, , maxDegree=2^63^ - 1) -> DataFrame +.. py:function:: gds.triangleCount.stream(G: Graph, *, nodeLabels=['*'], relationshipTypes=['*'], concurrency=4, jobId=None, logProgress=True, maxDegree=2^63^ - 1) -> DataFrame Triangle counting is a community detection graph algorithm that is used to determine the number of triangles passing through each node in the graph. @@ -4128,6 +4238,16 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph + * **nodeLabels** - *(Optional)* Filter the named graph using the given node labels. Nodes with any of the given labels will be included. *Default*: ['*']. + + * **relationshipTypes** - *(Optional)* Filter the named graph using the given relationship types. Relationships with any of the given types will be included. *Default*: ['*']. + + * **concurrency** - *(Optional)* The number of concurrent threads used for running the algorithm. *Default*: 4. + + * **jobId** - *(Optional)* An ID that can be provided to more easily track the algorithm’s progress. *Default*: None (Generated internally). + + * **logProgress** - *(Optional)* If disabled the progress percentage will not be logged. *Default*: True. + * **maxDegree** - *(Optional)* If a node has a degree higher than this it will not be considered by the algorithm. The triangle count for these nodes will be `-1`. *Default*: 2^63^ - 1. From 3ab0aef5afe691cd9f3e7898e989ab43e2d71f55 Mon Sep 17 00:00:00 2001 From: Nicola Vitucci Date: Fri, 31 May 2024 09:32:52 +0100 Subject: [PATCH 12/21] Update RST file --- doc/sphinx/source/algorithms.rst | 28 +++++++++++++++++++++++----- 1 file changed, 23 insertions(+), 5 deletions(-) diff --git a/doc/sphinx/source/algorithms.rst b/doc/sphinx/source/algorithms.rst index a01fbd77c..7630fbda5 100644 --- a/doc/sphinx/source/algorithms.rst +++ b/doc/sphinx/source/algorithms.rst @@ -48,7 +48,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: gds.allShortestPaths.delta.stream(G: Graph, **config: Any) -> DataFrame +.. py:function:: gds.allShortestPaths.delta.stream(G: Graph, *, sourceNode, nodeLabels=['*'], relationshipTypes=['*'], concurrency=4, jobId=None, logProgress=True, delta=2.0, relationshipWeightProperty=None) -> DataFrame The Delta Stepping shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph. The computation is run multi-threaded. @@ -59,6 +59,24 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph + * **sourceNode** - The Neo4j source node or node id. + + * **nodeLabels** - *(Optional)* Filter the named graph using the given node labels. Nodes with any of the given labels will be included. *Default*: ['*']. + + * **relationshipTypes** - *(Optional)* Filter the named graph using the given relationship types. Relationships with any of the given types will be included. *Default*: ['*']. + + * **concurrency** - *(Optional)* The number of concurrent threads used for running the algorithm. *Default*: 4. + + * **jobId** - *(Optional)* An ID that can be provided to more easily track the algorithm’s progress. *Default*: None (Generated internally). + + * **logProgress** - *(Optional)* If disabled the progress percentage will not be logged. *Default*: True. + + * **delta** - *(Optional)* The bucket width for grouping nodes with the same tentative distance to the source node. *Default*: 2.0. + + * **relationshipWeightProperty** - *(Optional)* Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted. *Default*: null. + + + .. py:function:: gds.allShortestPaths.delta.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for allShortestPaths.delta.strema. @@ -1811,7 +1829,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * **sourceNode** - *(Required)* The node id of the node where to start the traversal. *Default*: n/a. + * **sourceNode** - The node id of the node where to start the traversal. * **nodeLabels** - *(Optional)* Filter the named graph using the given node labels. Nodes with any of the given labels will be included. *Default*: ['*']. @@ -1946,7 +1964,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * **communityProperty** - *(Required)* The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their conductance computed. *Default*: n/a. + * **communityProperty** - The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their conductance computed. * **nodeLabels** - *(Optional)* Filter the named graph using the given node labels. Nodes with any of the given labels will be included. *Default*: ['*']. @@ -2112,7 +2130,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * **sourceNode** - *(Required)* The node id of the node where to start the traversal. *Default*: n/a. + * **sourceNode** - The node id of the node where to start the traversal. * **nodeLabels** - *(Optional)* Filter the named graph using the given node labels. Nodes with any of the given labels will be included. *Default*: ['*']. @@ -3268,7 +3286,7 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph - * **communityProperty** - *(Required)* The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their modularity score computed. *Default*: n/a. + * **communityProperty** - The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their modularity score computed. * **nodeLabels** - *(Optional)* Filter the named graph using the given node labels. Nodes with any of the given labels will be included. *Default*: ['*']. From 7f75b5ccbe88403ce362b477dd99cb95098439fb Mon Sep 17 00:00:00 2001 From: Nicola Vitucci Date: Sat, 8 Jun 2024 08:26:32 +0100 Subject: [PATCH 13/21] Temporarily add script and conf file --- doc/sphinx/algorithms-conf.json | 1883 +++++++++++++++++++++++++++ doc/sphinx/create_algorithms_rst.py | 130 +- 2 files changed, 2012 insertions(+), 1 deletion(-) create mode 100644 doc/sphinx/algorithms-conf.json diff --git a/doc/sphinx/algorithms-conf.json b/doc/sphinx/algorithms-conf.json new file mode 100644 index 000000000..6c0b8f366 --- /dev/null +++ b/doc/sphinx/algorithms-conf.json @@ -0,0 +1,1883 @@ +{ + "modes": { + "stream": { + "name": "stream", + "config": [ + { + "name": "nodeLabels", + "type": "List of String", + "default": ["*"], + "optional": true, + "description": "Filter the named graph using the given node labels. Nodes with any of the given labels will be included." + }, + { + "name": "relationshipTypes", + "type": "List of String", + "default": ["*"], + "optional": true, + "description": "Filter the named graph using the given relationship types. Relationships with any of the given types will be included." + }, + { + "name": "concurrency", + "type": "Integer", + "default": 4, + "optional": true, + "description": "The number of concurrent threads used for running the algorithm." + }, + { + "name": "jobId", + "type": "String", + "default": null, + "default_placeholder": "Generated internally", + "optional": true, + "description": "An ID that can be provided to more easily track the algorithm’s progress." + }, + { + "name": "logProgress", + "type": "Boolean", + "default": true, + "optional": true, + "description": "If disabled the progress percentage will not be logged." + } + ] + } + }, + "algorithms": [ + { + "name": "Article Rank", + "procedure": "gds.articleRank", + "config": [ + { + "name": "dampingFactor", + "type": "Float", + "default": "0.85", + "optional": true, + "description": "The damping factor of the Page Rank calculation. Must be in [0, 1)." + }, + { + "name": "maxIterations", + "type": "Integer", + "default": "20", + "optional": true, + "description": "The maximum number of iterations of Article Rank to run." + }, + { + "name": "tolerance", + "type": "Float", + "default": "0.0000001", + "optional": true, + "description": "Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable, and the algorithm returns." + }, + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted." + }, + { + "name": "sourceNodes", + "type": "List or Node or Number", + "default": "[]", + "optional": true, + "description": "The nodes or node ids to use for computing Personalized Page Rank." + }, + { + "name": "scaler", + "type": "String or Map", + "default": "None", + "optional": true, + "description": "The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`." + } + ], + "page_path": "algorithms/article-rank/" + }, + { + "name": "Betweenness Centrality", + "procedure": "gds.betweenness", + "config": [ + { + "name": "samplingSize", + "type": "Integer", + "default": "node count", + "optional": true, + "description": "The number of source nodes to consider for computing centrality scores." + }, + { + "name": "samplingSeed", + "type": "Integer", + "default": "null", + "optional": true, + "description": "The seed value for the random number generator that selects start nodes." + }, + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted." + } + ], + "page_path": "algorithms/betweenness-centrality/" + }, + { + "name": "CELF", + "procedure": "gds.influenceMaximization.celf", + "config": [ + { + "name": "seedSetSize", + "type": "Integer", + "default": "n/a", + "optional": false, + "description": "The number of nodes that maximize the expected spread in the network." + }, + { + "name": "monteCarloSimulations", + "type": "Integer", + "default": "100", + "optional": true, + "description": "The number of Monte-Carlo simulations." + }, + { + "name": "propagationProbability", + "type": "Float", + "default": "0.1", + "optional": true, + "description": "The probability of a node being activated by an active neighbour node." + }, + { + "name": "randomSeed", + "type": "Integer", + "default": "n/a", + "optional": true, + "description": "The seed value to control the randomness of the algorithm." + } + ], + "page_path": "algorithms/celf/" + }, + { + "name": "Closeness Centrality", + "procedure": "gds.closeness", + "config": [ + { + "name": "useWassermanFaust", + "type": "Boolean", + "default": "false", + "optional": true, + "description": "Use the improved Wasserman-Faust formula for closeness computation." + } + ], + "page_path": "algorithms/closeness-centrality/" + }, + { + "name": "Degree Centrality", + "procedure": "gds.degree", + "config": [ + { + "name": "orientation", + "type": "String", + "default": "NATURAL", + "optional": true, + "description": "The orientation used to compute node degrees. Supported orientations are `NATURAL`, `REVERSE` and `UNDIRECTED`." + }, + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "Name of the relationship property to use for weighted degree computation. If unspecified, the algorithm runs unweighted." + } + ], + "page_path": "algorithms/degree-centrality/" + }, + { + "name": "Eigenvector Centrality", + "procedure": "gds.eigenvector", + "config": [ + { + "name": "maxIterations", + "type": "Integer", + "default": "20", + "optional": true, + "description": "The maximum number of iterations of Eigenvector Centrality to run." + }, + { + "name": "tolerance", + "type": "Float", + "default": "0.0000001", + "optional": true, + "description": "Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable and the algorithm returns." + }, + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted." + }, + { + "name": "sourceNodes", + "type": "List or Node or Number", + "default": "[]", + "optional": true, + "description": "The nodes or node ids to use for computing Personalized Page Rank." + }, + { + "name": "scaler", + "type": "String or Map", + "default": "None", + "optional": true, + "description": "The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`." + } + ], + "page_path": "algorithms/eigenvector-centrality/" + }, + { + "name": "PageRank", + "procedure": "gds.pageRank", + "config": [ + { + "name": "dampingFactor", + "type": "Float", + "default": "0.85", + "optional": true, + "description": "The damping factor of the Page Rank calculation. Must be in [0, 1)." + }, + { + "name": "maxIterations", + "type": "Integer", + "default": "20", + "optional": true, + "description": "The maximum number of iterations of Page Rank to run." + }, + { + "name": "tolerance", + "type": "Float", + "default": "0.0000001", + "optional": true, + "description": "Minimum change in scores between iterations. If all scores change less than the tolerance value the result is considered stable and the algorithm returns." + }, + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted." + }, + { + "name": "sourceNodes", + "type": "List of Node or Number", + "default": "[]", + "optional": true, + "description": "The nodes or node ids to use for computing Personalized Page Rank." + }, + { + "name": "scaler", + "type": "String or Map", + "default": "None", + "optional": true, + "description": "The name of the scaler applied for the final scores. Supported values are `None`, `MinMax`, `Max`, `Mean`, `Log`, and `StdScore`. To apply scaler-specific configuration, use the Map syntax: `{scaler: 'name', ...}`." + } + ], + "page_path": "algorithms/page-rank/" + }, + { + "name": "Harmonic Centrality", + "procedure": "gds.closeness.harmonic", + "config": [], + "page_path": "algorithms/harmonic-centrality/" + }, + { + "name": "HITS", + "procedure": "gds.hits", + "config": [ + { + "name": "hitsIterations", + "type": "Integer", + "default": "20", + "optional": true, + "description": "The number of hits iterations to run. The number of pregel iterations will be equal to hitsIterations * 4" + }, + { + "name": "authProperty", + "type": "String", + "default": "\"auth\"", + "optional": true, + "description": "The name that is used for the auth property when using STREAM, MUTATE or WRITE modes." + }, + { + "name": "hubProperty", + "type": "String", + "default": "\"hub\"", + "optional": true, + "description": "The name that is used for the hub property when using STREAM, MUTATE or WRITE modes." + }, + { + "name": "partitioning", + "type": "String", + "default": "\"AUTO\"", + "optional": true, + "description": "The partitioning scheme used to divide the work between threads. Available options are AUTO, RANGE, DEGREE." + } + ], + "page_path": "algorithms/hits/" + }, + { + "name": "Conductance metric", + "procedure": "gds.conductance", + "config": [ + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted." + }, + { + "name": "communityProperty", + "type": "String", + "default": "n/a", + "optional": false, + "description": "The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their conductance computed." + } + ], + "page_path": "algorithms/conductance/" + }, + { + "name": "K-Core Decomposition", + "procedure": "gds.kcore", + "config": [], + "page_path": "algorithms/k-core/" + }, + { + "name": "K-1 Coloring", + "procedure": "gds.k1coloring", + "config": [ + { + "name": "maxIterations", + "type": "Integer", + "default": "10", + "optional": true, + "description": "The maximum number of iterations of K1 Coloring to run." + }, + { + "name": "minCommunitySize", + "type": "Integer", + "default": "0", + "optional": true, + "description": "Only nodes inside communities larger or equal the given value are returned." + } + ], + "page_path": "algorithms/k1coloring/" + }, + { + "name": "K-Means Clustering", + "procedure": "gds.kmeans", + "config": [ + { + "name": "nodeProperty", + "type": "String", + "default": "n/a", + "optional": false, + "description": "A node property corresponding to an array of floats used by K-Means to cluster nodes into communities." + }, + { + "name": "k", + "type": "Integer", + "default": "10", + "optional": true, + "description": "Number of desired clusters." + }, + { + "name": "maxIterations", + "type": "Integer", + "default": "10", + "optional": true, + "description": "The maximum number of iterations of K-Means to run." + }, + { + "name": "deltaThreshold", + "type": "Float", + "default": "0.05", + "optional": true, + "description": "Value as a percentage to determine when to stop early. If fewer than `deltaThreshold * |nodes|` nodes change their cluster , the algorithm stops. Value must be between 0 (exclusive) and 1 (inclusive)." + }, + { + "name": "numberOfRestarts", + "type": "Integer", + "default": "1", + "optional": true, + "description": "Number of times to execute K-Means with different initial centers. The communities returned are those minimizing the average node-center distances." + }, + { + "name": "randomSeed", + "type": "Integer", + "default": "n/a", + "optional": true, + "description": "The seed value to control the initial centroid assignment." + }, + { + "name": "initialSampler", + "type": "String", + "default": "\"uniform\"", + "optional": true, + "description": "The method used to sample the first k centroids. \"uniform\" and \"kmeans++\", both case-insensitive, are valid inputs." + }, + { + "name": "seedCentroids", + "type": "List of List of Float", + "default": "[]", + "optional": true, + "description": "Parameter to explicitly give the initial centroids. It cannot be enabled together with a non-default value of the numberOfRestarts parameter." + }, + { + "name": "computeSilhouette", + "type": "Boolean", + "default": "false", + "optional": true, + "description": "If set to true, the silhouette scores are computed once the clustering has been determined. Silhouette is a metric on how well the nodes have been clustered." + } + ], + "page_path": "algorithms/kmeans/" + }, + { + "name": "Label Propagation", + "procedure": "gds.labelPropagation", + "config": [ + { + "name": "maxIterations", + "type": "Integer", + "default": "10", + "optional": true, + "description": "The maximum number of iterations to run." + }, + { + "name": "nodeWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "The name of a node property that contains node weights." + }, + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted." + }, + { + "name": "seedProperty", + "type": "String", + "default": "n/a", + "optional": true, + "description": "The name of a node property that defines an initial numeric label." + }, + { + "name": "consecutiveIds", + "type": "Boolean", + "default": "false", + "optional": true, + "description": "Flag to decide whether component identifiers are mapped into a consecutive id space (requires additional memory)." + }, + { + "name": "minCommunitySize", + "type": "Integer", + "default": "0", + "optional": true, + "description": "Only nodes inside communities larger or equal the given value are returned." + } + ], + "page_path": "algorithms/label-propagation/" + }, + { + "name": "Leiden", + "procedure": "gds.leiden", + "config": [ + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted." + }, + { + "name": "maxLevels", + "type": "Integer", + "default": "10", + "optional": true, + "description": "The maximum number of levels in which the graph is clustered and then condensed." + }, + { + "name": "gamma", + "type": "Float", + "default": "1.0", + "optional": true, + "description": "Resolution parameter used when computing the modularity. Internally the value is divided by the number of relationships for an unweighted graph, or the sum of weights of all relationships otherwise. [1]" + }, + { + "name": "theta", + "type": "Float", + "default": "0.01", + "optional": true, + "description": "Controls the randomness while breaking a community into smaller ones." + }, + { + "name": "tolerance", + "type": "Float", + "default": "0.0001", + "optional": true, + "description": "Minimum change in modularity between iterations. If the modularity changes less than the tolerance value, the result is considered stable and the algorithm returns." + }, + { + "name": "includeIntermediateCommunities", + "type": "Boolean", + "default": "false", + "optional": true, + "description": "Indicates whether to write intermediate communities. If set to false, only the final community is persisted." + }, + { + "name": "seedProperty", + "type": "String", + "default": "n/a", + "optional": true, + "description": "Used to set the initial community for a node. The property value needs to be a non-negative number." + }, + { + "name": "minCommunitySize", + "type": "Integer", + "default": "0", + "optional": true, + "description": "Only nodes inside communities larger or equal the given value are returned." + } + ], + "page_path": "algorithms/leiden/" + }, + { + "name": "Local Clustering Coefficient", + "procedure": "gds.localClusteringCoefficient", + "config": [ + { + "name": "triangleCountProperty", + "type": "String", + "default": "n/a", + "optional": true, + "description": "Node property that contains pre-computed triangle count." + } + ], + "page_path": "algorithms/local-clustering-coefficient/" + }, + { + "name": "Louvain", + "procedure": "gds.louvain", + "config": [ + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted." + }, + { + "name": "seedProperty", + "type": "String", + "default": "n/a", + "optional": true, + "description": "Used to set the initial community for a node. The property value needs to be a non-negative number." + }, + { + "name": "maxLevels", + "type": "Integer", + "default": "10", + "optional": true, + "description": "The maximum number of levels in which the graph is clustered and then condensed." + }, + { + "name": "maxIterations", + "type": "Integer", + "default": "10", + "optional": true, + "description": "The maximum number of iterations that the modularity optimization will run for each level." + }, + { + "name": "tolerance", + "type": "Float", + "default": "0.0001", + "optional": true, + "description": "Minimum change in modularity between iterations. If the modularity changes less than the tolerance value, the result is considered stable and the algorithm returns." + }, + { + "name": "includeIntermediateCommunities", + "type": "Boolean", + "default": "false", + "optional": true, + "description": "Indicates whether to write intermediate communities. If set to false, only the final community is persisted." + }, + { + "name": "consecutiveIds", + "type": "Boolean", + "default": "false", + "optional": true, + "description": "Flag to decide whether component identifiers are mapped into a consecutive id space (requires additional memory). Cannot be used in combination with the includeIntermediateCommunities flag." + }, + { + "name": "minCommunitySize", + "type": "Integer", + "default": "0", + "optional": true, + "description": "Only nodes inside communities larger or equal the given value are returned." + } + ], + "page_path": "algorithms/louvain/" + }, + { + "name": "Modularity metric", + "procedure": "gds.modularity", + "config": [ + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted." + }, + { + "name": "communityProperty", + "type": "String", + "default": "n/a", + "optional": false, + "description": "The node property that holds the community ID as an integer for each node. Note that only non-negative community IDs are considered valid and will have their modularity score computed." + } + ], + "page_path": "algorithms/modularity/" + }, + { + "name": "Modularity Optimization", + "procedure": "gds.modularityOptimization", + "config": [ + { + "name": "maxIterations", + "type": "Integer", + "default": "10", + "optional": true, + "description": "The maximum number of iterations to run." + }, + { + "name": "tolerance", + "type": "Float", + "default": "0.0001", + "optional": true, + "description": "Minimum change in modularity between iterations. If the modularity changes less than the tolerance value, the result is considered stable and the algorithm returns." + }, + { + "name": "seedProperty", + "type": "String", + "default": "n/a", + "optional": true, + "description": "Used to define initial set of labels (must be a non-negative number)." + }, + { + "name": "consecutiveIds", + "type": "Boolean", + "default": "false", + "optional": true, + "description": "Flag to decide whether component identifiers are mapped into a consecutive id space (requires additional memory)." + }, + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted." + }, + { + "name": "minCommunitySize", + "type": "Integer", + "default": "0", + "optional": true, + "description": "Only nodes inside communities larger or equal the given value are returned." + } + ], + "page_path": "algorithms/modularity-optimization/" + }, + { + "name": "Strongly Connected Components", + "procedure": "gds.scc", + "config": [ + { + "name": "consecutiveIds", + "type": "Boolean", + "default": "false", + "optional": true, + "description": "Flag to decide whether component identifiers are mapped into a consecutive id space (requires additional memory)." + } + ], + "page_path": "algorithms/strongly-connected-components/" + }, + { + "name": "Triangle Count", + "procedure": "gds.triangleCount", + "config": [ + { + "name": "maxDegree", + "type": "Integer", + "default": "2^63^ - 1", + "optional": true, + "description": "If a node has a degree higher than this it will not be considered by the algorithm. The triangle count for these nodes will be `-1`." + } + ], + "page_path": "algorithms/triangle-count/" + }, + { + "name": "Weakly Connected Components", + "procedure": "gds.wcc", + "config": [ + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted." + }, + { + "name": "seedProperty", + "type": "String", + "default": "n/a", + "optional": true, + "description": "Used to set the initial component for a node. The property value needs to be a number." + }, + { + "name": "threshold", + "type": "Float", + "default": "null", + "optional": true, + "description": "The value of the weight above which the relationship is considered in the computation." + }, + { + "name": "consecutiveIds", + "type": "Boolean", + "default": "false", + "optional": true, + "description": "Flag to decide whether component identifiers are mapped into a consecutive id space (requires additional memory)." + }, + { + "name": "minComponentSize", + "type": "Integer", + "default": "0", + "optional": true, + "description": "Only nodes inside communities larger or equal the given value are returned." + } + ], + "page_path": "algorithms/wcc/" + }, + { + "name": "Approximate Maximum k-cut", + "procedure": "gds.maxkcut", + "config": [ + { + "name": "k", + "type": "Integer", + "default": "2", + "optional": true, + "description": "The number of disjoint communities the nodes will be divided into." + }, + { + "name": "iterations", + "type": "Integer", + "default": "8", + "optional": true, + "description": "The number of iterations the algorithm will run before returning the best solution among all the iterations." + }, + { + "name": "vnsMaxNeighborhoodOrder", + "type": "Integer", + "default": "0 (VNS off)", + "optional": true, + "description": "The maximum number of nodes VNS will swap when perturbing solutions." + }, + { + "name": "randomSeed", + "type": "Integer", + "default": "n/a", + "optional": true, + "description": "A random seed which is used for all randomness in the computation. Requires concurrency = 1." + }, + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "If set, the values stored at the given property are used as relationship weights during the computation. If not set, the graph is considered unweighted." + }, + { + "name": "minCommunitySize", + "type": "Integer", + "default": "0", + "optional": true, + "description": "Only nodes inside communities larger or equal the given value are returned." + } + ], + "page_path": "algorithms/approx-max-k-cut/" + }, + { + "name": "Speaker-Listener Label Propagation", + "procedure": "gds.sllpa", + "config": [ + { + "name": "maxIterations", + "type": "Integer", + "default": "n/a", + "optional": false, + "description": "Maximum number of iterations to run." + }, + { + "name": "minAssociationStrength", + "type": "String", + "default": "0.2", + "optional": true, + "description": "Minimum influence required for a community to retain a node." + }, + { + "name": "partitioning", + "type": "String", + "default": "\"RANGE\"", + "optional": true, + "description": "The partitioning scheme used to divide the work between threads. Available options are AUTO, RANGE, DEGREE." + } + ], + "page_path": "algorithms/sllpa/" + }, + { + "name": "Node Similarity", + "procedure": "gds.nodeSimilarity", + "config": [ + { + "name": "similarityCutoff", + "type": "Float", + "default": "1e-42", + "optional": true, + "description": "Lower limit for the similarity score to be present in the result.\nValues must be between 0 and 1." + }, + { + "name": "degreeCutoff", + "type": "Integer", + "default": "1", + "optional": true, + "description": "Inclusive lower bound on the node degree for a node to be considered in the comparisons.\nThis value can not be lower than 1." + }, + { + "name": "upperDegreeCutoff", + "type": "Integer", + "default": "2147483647", + "optional": true, + "description": "Inclusive upper bound on the node degree for a node to be considered in the comparisons.\nThis value can not be lower than 1." + }, + { + "name": "topK", + "type": "Integer", + "default": "10", + "optional": true, + "description": "Limit on the number of scores per node.\nThe K largest results are returned.\nThis value cannot be lower than 1." + }, + { + "name": "bottomK", + "type": "Integer", + "default": "10", + "optional": true, + "description": "Limit on the number of scores per node.\nThe K smallest results are returned.\nThis value cannot be lower than 1." + }, + { + "name": "topN", + "type": "Integer", + "default": "0", + "optional": true, + "description": "Global limit on the number of scores computed.\nThe N largest total results are returned.\nThis value cannot be negative, a value of 0 means no global limit." + }, + { + "name": "bottomN", + "type": "Integer", + "default": "0", + "optional": true, + "description": "Global limit on the number of scores computed.\nThe N smallest total results are returned.\nThis value cannot be negative, a value of 0 means no global limit." + }, + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "Name of the relationship property to use as weights.\nIf unspecified, the algorithm runs unweighted." + }, + { + "name": "similarityMetric", + "type": "String", + "default": "JACCARD", + "optional": true, + "description": "The metric used to compute similarity.\nCan be either `JACCARD`, `OVERLAP` or `COSINE`." + }, + { + "name": " useComponents", + "type": "Boolean or String", + "default": "false", + "optional": true, + "description": "If enabled, Node Similarity will use components to improve the performance of the computation, skipping comparisons of nodes in different components.\nSet to `false` (Default): the algorithm does not use components, but computes similarity across the entire graph.\nSet to `true`: the algorithm uses components, and will compute these components before computing similarity.\nSet to *String*: use pre-computed components stored in graph, *String* is the key for a node property representing components." + } + ], + "page_path": "algorithms/node-similarity/" + }, + { + "name": "Filtered Node Similarity", + "procedure": "gds.nodeSimilarity.filtered", + "config": [ + { + "name": "similarityCutoff", + "type": "Float", + "default": "1e-42", + "optional": true, + "description": "Lower limit for the similarity score to be present in the result.\nValues must be between 0 and 1." + }, + { + "name": "degreeCutoff", + "type": "Integer", + "default": "1", + "optional": true, + "description": "Inclusive lower bound on the node degree for a node to be considered in the comparisons.\nThis value can not be lower than 1." + }, + { + "name": "upperDegreeCutoff", + "type": "Integer", + "default": "2147483647", + "optional": true, + "description": "Inclusive upper bound on the node degree for a node to be considered in the comparisons.\nThis value can not be lower than 1." + }, + { + "name": "topK", + "type": "Integer", + "default": "10", + "optional": true, + "description": "Limit on the number of scores per node.\nThe K largest results are returned.\nThis value cannot be lower than 1." + }, + { + "name": "bottomK", + "type": "Integer", + "default": "10", + "optional": true, + "description": "Limit on the number of scores per node.\nThe K smallest results are returned.\nThis value cannot be lower than 1." + }, + { + "name": "topN", + "type": "Integer", + "default": "0", + "optional": true, + "description": "Global limit on the number of scores computed.\nThe N largest total results are returned.\nThis value cannot be negative, a value of 0 means no global limit." + }, + { + "name": "bottomN", + "type": "Integer", + "default": "0", + "optional": true, + "description": "Global limit on the number of scores computed.\nThe N smallest total results are returned.\nThis value cannot be negative, a value of 0 means no global limit." + }, + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "Name of the relationship property to use as weights.\nIf unspecified, the algorithm runs unweighted." + }, + { + "name": "similarityMetric", + "type": "String", + "default": "JACCARD", + "optional": true, + "description": "The metric used to compute similarity.\nCan be either JACCARD, OVERLAP or COSINE." + }, + { + "name": " useComponents", + "type": "Boolean or String", + "default": "false", + "optional": true, + "description": "If enabled, Node Similarity will use components to improve the performance of the computation, skipping comparisons of nodes in different components.\nSet to false (Default): the algorithm does not use components, but computes similarity across the entire graph.\nSet to true: the algorithm uses components, and will compute these components before computing similarity.\nSet to String: use pre-computed components stored in the graph, with String as the key for a node property representing components" + }, + { + "name": "sourceNodeFilter", + "type": "Integer or List of Integer or String", + "default": "n/a", + "optional": false, + "description": "The source node filter to apply.\nAccepts a single node id,\na List of node ids,\nor a single label." + }, + { + "name": "targetNodeFilter", + "type": "Integer or List of Integer or String", + "default": "n/a", + "optional": false, + "description": "The target node filter to apply.\nAccepts a single node id,\na List of node ids,\nor a single label." + } + ], + "page_path": "algorithms/filtered-node-similarity/" + }, + { + "name": "K-Nearest Neighbors", + "procedure": "gds.knn", + "config": [ + { + "name": "nodeProperties", + "type": "String or Map or List of Strings / Maps", + "default": "n/a", + "optional": false, + "description": "The node properties to use for similarity computation along with their selected similarity metrics.\nAccepts a single property key,\na Map of property keys to metrics,\nor a List of property keys and/or Maps, as above.\nSee Node properties and metrics configuration for details." + }, + { + "name": "topK", + "type": "Integer", + "default": "10", + "optional": true, + "description": "The number of neighbors to find for each node.\nThe K-nearest neighbors are returned.\nThis value cannot be lower than 1." + }, + { + "name": "sampleRate", + "type": "Float", + "default": "0.5", + "optional": true, + "description": "Sample rate to limit the number of comparisons per node.\nValue must be between 0 (exclusive) and 1 (inclusive)." + }, + { + "name": "deltaThreshold", + "type": "Float", + "default": "0.001", + "optional": true, + "description": "Value as a percentage to determine when to stop early.\nIf fewer updates than the configured value happen, the algorithm stops.\nValue must be between 0 (exclusive) and 1 (inclusive)." + }, + { + "name": "maxIterations", + "type": "Integer", + "default": "100", + "optional": true, + "description": "Hard limit to stop the algorithm after that many iterations." + }, + { + "name": "randomJoins", + "type": "Integer", + "default": "10", + "optional": true, + "description": "The number of random attempts per node to connect new node neighbors based on random selection, for each iteration." + }, + { + "name": "initialSampler", + "type": "String", + "default": "\"uniform\"", + "optional": true, + "description": "The method used to sample the first k random neighbors for each node. \"uniform\" and \"randomWalk\", both case-insensitive, are valid inputs." + }, + { + "name": "randomSeed", + "type": "Integer", + "default": "n/a", + "optional": true, + "description": "The seed value to control the randomness of the algorithm.\nNote that concurrency must be set to 1 when setting this parameter." + }, + { + "name": "similarityCutoff", + "type": "Float", + "default": "0.0", + "optional": true, + "description": "Filter out from the list of K-nearest neighbors nodes with similarity below this threshold." + }, + { + "name": "perturbationRate", + "type": "Float", + "default": "0.0", + "optional": true, + "description": "The probability of replacing the least similar known neighbor with an encountered neighbor of equal similarity." + } + ], + "page_path": "algorithms/knn/" + }, + { + "name": "Filtered K-Nearest Neighbors", + "procedure": "gds.knn.filtered", + "config": [ + { + "name": "nodeProperties", + "type": "String or Map or List of Strings / Maps", + "default": "n/a", + "optional": false, + "description": "The node properties to use for similarity computation along with their selected similarity metrics.\nAccepts a single property key,\na Map of property keys to metrics,\nor a List of property keys and/or Maps, as above.\nSee Node properties and metrics configuration for details." + }, + { + "name": "topK", + "type": "Integer", + "default": "10", + "optional": true, + "description": "The number of neighbors to find for each node.\nThe K-nearest neighbors are returned.\nThis value cannot be lower than 1." + }, + { + "name": "sampleRate", + "type": "Float", + "default": "0.5", + "optional": true, + "description": "Sample rate to limit the number of comparisons per node.\nValue must be between 0 (exclusive) and 1 (inclusive)." + }, + { + "name": "deltaThreshold", + "type": "Float", + "default": "0.001", + "optional": true, + "description": "Value as a percentage to determine when to stop early.\nIf fewer updates than the configured value happen, the algorithm stops.\nValue must be between 0 (exclusive) and 1 (inclusive)." + }, + { + "name": "maxIterations", + "type": "Integer", + "default": "100", + "optional": true, + "description": "Hard limit to stop the algorithm after that many iterations." + }, + { + "name": "randomJoins", + "type": "Integer", + "default": "10", + "optional": true, + "description": "The number of random attempts per node to connect new node neighbors based on random selection, for each iteration." + }, + { + "name": "initialSampler", + "type": "String", + "default": "\"uniform\"", + "optional": true, + "description": "The method used to sample the first k random neighbors for each node. \"uniform\" and \"randomWalk\", both case-insensitive, are valid inputs." + }, + { + "name": "randomSeed", + "type": "Integer", + "default": "n/a", + "optional": true, + "description": "The seed value to control the randomness of the algorithm.\nNote that concurrency must be set to 1 when setting this parameter." + }, + { + "name": "similarityCutoff", + "type": "Float", + "default": "0.0", + "optional": true, + "description": "Filter out from the list of K-nearest neighbors nodes with similarity below this threshold." + }, + { + "name": "perturbationRate", + "type": "Float", + "default": "0.0", + "optional": true, + "description": "The probability of replacing the least similar known neighbor with an encountered neighbor of equal similarity." + }, + { + "name": "sourceNodeFilter", + "type": "Integer or List of Integer or String", + "default": "n/a", + "optional": false, + "description": "The source node filter to apply.\nAccepts a single node id,\na List of node ids,\nor a single label." + }, + { + "name": "targetNodeFilter", + "type": "Integer or List of Integer or String", + "default": "n/a", + "optional": false, + "description": "The target node filter to apply.\nAccepts a single node id,\na List of node ids,\nor a single label." + }, + { + "name": "seedTargetNodes", + "type": "Boolean", + "default": "false", + "optional": true, + "description": "Enable seeding of target nodes." + } + ], + "page_path": "algorithms/filtered-knn/" + }, + { + "name": "Delta-Stepping Single-Source Shortest Path", + "procedure": "gds.allShortestPaths.delta", + "config": [ + { + "name": "sourceNode", + "type": "Integer", + "default": "n/a", + "optional": false, + "description": "The Neo4j source node or node id." + }, + { + "name": "delta", + "type": "Float", + "default": "2.0", + "optional": true, + "description": "The bucket width for grouping nodes with the same tentative distance to the source node." + }, + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted." + } + ], + "page_path": "algorithms/delta-single-source/" + }, + { + "name": "Dijkstra Source-Target Shortest Path", + "procedure": "gds.shortestPath.dijkstra", + "config": [ + { + "name": "sourceNode", + "type": "Integer", + "default": "n/a", + "optional": false, + "description": "The Neo4j source node or node id." + }, + { + "name": "targetNode", + "type": "Integer", + "default": "n/a", + "optional": false, + "description": "The Neo4j target node or node id." + }, + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted." + } + ], + "page_path": "algorithms/dijkstra-source-target/" + }, + { + "name": "Dijkstra Single-Source Shortest Path", + "procedure": "gds.allShortestPaths.dijkstra", + "config": [ + { + "name": "sourceNode", + "type": "Integer", + "default": "n/a", + "optional": false, + "description": "The Neo4j source node or node id." + }, + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted." + } + ], + "page_path": "algorithms/dijkstra-single-source/" + }, + { + "name": "A* Shortest Path", + "procedure": "gds.shortestPath.astar", + "config": [ + { + "name": "sourceNode", + "type": "Integer", + "default": "n/a", + "optional": false, + "description": "The Neo4j source node or node id." + }, + { + "name": "targetNode", + "type": "Integer", + "default": "n/a", + "optional": false, + "description": "The Neo4j target node or node id." + }, + { + "name": "latitudeProperty", + "type": "Float", + "default": "n/a", + "optional": false, + "description": "The node property that stores the latitude value." + }, + { + "name": "longitudeProperty", + "type": "Float", + "default": "n/a", + "optional": false, + "description": "The node property that stores the longitude value." + }, + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted." + } + ], + "page_path": "algorithms/astar/" + }, + { + "name": "Yen's Shortest Path algorithm", + "procedure": "gds.shortestPath.yens", + "config": [ + { + "name": "sourceNode", + "type": "Integer", + "default": "n/a", + "optional": false, + "description": "The Neo4j source node or node id." + }, + { + "name": "targetNode", + "type": "Integer", + "default": "n/a", + "optional": false, + "description": "The Neo4j target node or node id." + }, + { + "name": "k", + "type": "Integer", + "default": "1", + "optional": true, + "description": "The number of shortest paths to compute between source and target node." + }, + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted." + } + ], + "page_path": "algorithms/yens/" + }, + { + "name": "Minimum Weight Spanning Tree", + "procedure": "gds.spanningTree", + "config": [ + { + "name": "sourceNode", + "type": "Integer", + "default": "null", + "optional": false, + "description": "The starting source node ID." + }, + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted." + }, + { + "name": "objective", + "type": "String", + "default": "'minimum'", + "optional": true, + "description": "If specified, the parameter dictates whether to find the minimum or the maximum weight spanning tree. By default, a minimum weight spanning tree is returned. Permitted values are 'minimum' and 'maximum'." + } + ], + "page_path": "algorithms/minimum-weight-spanning-tree/" + }, + { + "name": "Minimum Directed Steiner Tree", + "procedure": "gds.steinerTree", + "config": [ + { + "name": "sourceNode", + "type": "Integer", + "default": "null", + "optional": false, + "description": "The starting source node ID." + }, + { + "name": "targetNodes", + "type": "List of Integer", + "default": "null", + "optional": false, + "description": "The list of target nodes" + }, + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted." + }, + { + "name": "delta", + "type": "Float", + "default": "2.0", + "optional": true, + "description": "The bucket width for grouping nodes with the same tentative distance to the source node. Look into the Delta-Stepping documentation for more information." + }, + { + "name": "applyRerouting", + "type": "Boolean", + "default": "false", + "optional": true, + "description": "If specified, the algorithm will try to improve the outcome via an additional post-processing heuristic." + } + ], + "page_path": "algorithms/directed-steiner-tree/" + }, + { + "name": "Random Walk", + "procedure": "gds.randomWalk", + "config": [ + { + "name": "sourceNodes", + "type": "List of Integer", + "default": "List of all nodes", + "optional": true, + "description": "The list of nodes from which to do a random walk." + }, + { + "name": "walkLength", + "type": "Integer", + "default": "80", + "optional": true, + "description": "The number of steps in a single random walk." + }, + { + "name": "walksPerNode", + "type": "Integer", + "default": "10", + "optional": true, + "description": "The number of random walks generated for each node." + }, + { + "name": "inOutFactor", + "type": "Float", + "default": "1.0", + "optional": true, + "description": "Tendency of the random walk to stay close to the start node or fan out in the graph. Higher value means stay local." + }, + { + "name": "returnFactor", + "type": "Float", + "default": "1.0", + "optional": true, + "description": "Tendency of the random walk to return to the last visited node. A value below 1.0 means a higher tendency." + }, + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "Name of the relationship property to use as weights to influence the probabilities of the random walks. The weights need to be >= 0. If unspecified, the algorithm runs unweighted." + }, + { + "name": "randomSeed", + "type": "Integer", + "default": "random", + "optional": true, + "description": "Seed value for the random number generator used to generate the random walks." + }, + { + "name": "walkBufferSize", + "type": "Integer", + "default": "1000", + "optional": true, + "description": "The number of random walks to complete before starting training." + } + ], + "page_path": "algorithms/random-walk/" + }, + { + "name": "Breadth First Search", + "procedure": "gds.bfs", + "config": [ + { + "name": "sourceNode", + "type": "Integer", + "default": "n/a", + "optional": false, + "description": "The node id of the node where to start the traversal." + }, + { + "name": "targetNodes", + "type": "List of Integer", + "default": "empty list", + "optional": true, + "description": "Ids for target nodes. Traversal terminates when any target node is visited." + }, + { + "name": "maxDepth", + "type": "Integer", + "default": "-1", + "optional": true, + "description": "The maximum distance from the source node at which nodes are visited." + } + ], + "page_path": "algorithms/bfs/" + }, + { + "name": "Depth First Search", + "procedure": "gds.dfs", + "config": [ + { + "name": "sourceNode", + "type": "Integer", + "default": "n/a", + "optional": false, + "description": "The node id of the node where to start the traversal." + }, + { + "name": "targetNodes", + "type": "List of Integer", + "default": "empty list", + "optional": true, + "description": "Ids for target nodes. Traversal terminates when any target node is visited." + }, + { + "name": "maxDepth", + "type": "Integer", + "default": "-1", + "optional": true, + "description": "The maximum distance from the source node at which nodes are visited." + } + ], + "page_path": "algorithms/dfs/" + }, + { + "name": "Bellman-Ford Single-Source Shortest Path", + "procedure": "gds.bellmanFord", + "config": [ + { + "name": "sourceNode", + "type": "Integer", + "default": "n/a", + "optional": false, + "description": "The Neo4j source node or node id." + }, + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted." + } + ], + "page_path": "algorithms/bellman-ford-single-source/" + }, + { + "name": "Longest Path for DAG", + "procedure": "gds.dag.longestPath", + "config": [ + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted." + } + ], + "page_path": "algorithms/dag/longest-path/" + }, + { + "name": "All Pairs Shortest Path", + "procedure": "gds.allShortestPaths", + "config": [ + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted." + } + ], + "page_path": "algorithms/all-pairs-shortest-path/" + }, + { + "name": "Topological Sort", + "procedure": "gds.dag.topologicalSort", + "config": [ + { + "name": "computeMaxDistanceFromSource", + "type": "Boolean", + "default": "false", + "optional": true, + "description": "Whether to enable computation of the maximal distance from source" + } + ], + "page_path": "algorithms/dag/topological-sort/" + }, + { + "name": "Longest Path for DAG", + "procedure": "gds.dag.longestPath", + "config": [ + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "Name of the relationship property to use as weights. If unspecified, the algorithm runs unweighted." + } + ], + "page_path": "algorithms/dag/longest-path/" + }, + { + "name": "Fast Random Projection", + "procedure": "gds.fastRP", + "config": [ + { + "name": "propertyRatio", + "type": "Float", + "default": "0.0", + "optional": true, + "description": "The desired ratio of the property embedding dimension to the total `embeddingDimension`. A positive value requires `featureProperties` to be non-empty." + }, + { + "name": "featureProperties", + "type": "List of String", + "default": "[]", + "optional": true, + "description": "The names of the node properties that should be used as input features. All property names must exist in the projected graph and be of type Float or List of Float." + }, + { + "name": "embeddingDimension", + "type": "Integer", + "default": "n/a", + "optional": false, + "description": "The dimension of the computed node embeddings. Minimum value is 1." + }, + { + "name": "iterationWeights", + "type": "List of Float", + "default": "[0.0, 1.0, 1.0]", + "optional": true, + "description": "Contains a weight for each iteration. The weight controls how much the intermediate embedding from the iteration contributes to the final embedding." + }, + { + "name": "nodeSelfInfluence", + "type": "Float", + "default": "0.0", + "optional": true, + "description": "Controls for each node how much its initial random vector contributes to its final embedding." + }, + { + "name": "normalizationStrength", + "type": "Float", + "default": "0.0", + "optional": true, + "description": "The initial random vector for each node is scaled by its degree to the power of `normalizationStrength`." + }, + { + "name": "randomSeed", + "type": "Integer", + "default": "n/a", + "optional": true, + "description": "A random seed which is used for all randomness in computing the embeddings." + }, + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "Name of the relationship property to use for weighted random projection. If unspecified, the algorithm runs unweighted." + } + ], + "config_notes": [ + "The number of iterations is equal to the length of `iterationWeights`.", + "It is required that `iterationWeights` is non-empty or `nodeSelfInfluence` is non-zero." + ], + "page_path": "machine-learning/node-embeddings/fastrp/" + }, + { + "name": "GraphSAGE", + "procedure": "gds.beta.graphSage", + "config": [ + { + "name": "batchSize", + "type": "Integer", + "default": "100", + "optional": true, + "description": "The number of nodes per batch." + } + ], + "page_path": "machine-learning/node-embeddings/graph-sage/" + }, + { + "name": "Node2Vec", + "procedure": "gds.node2vec", + "config": [ + { + "name": "walkLength", + "type": "Integer", + "default": "80", + "optional": true, + "description": "The number of steps in a single random walk." + }, + { + "name": "walksPerNode", + "type": "Integer", + "default": "10", + "optional": true, + "description": "The number of random walks generated for each node." + }, + { + "name": "inOutFactor", + "type": "Float", + "default": "1.0", + "optional": true, + "description": "Tendency of the random walk to stay close to the start node or fan out in the graph. Higher value means stay local." + }, + { + "name": "returnFactor", + "type": "Float", + "default": "1.0", + "optional": true, + "description": "Tendency of the random walk to return to the last visited node. A value below 1.0 means a higher tendency." + }, + { + "name": "relationshipWeightProperty", + "type": "String", + "default": "null", + "optional": true, + "description": "Name of the relationship property to use as weights to influence the probabilities of the random walks. The weights need to be >= 0. If unspecified, the algorithm runs unweighted." + }, + { + "name": "windowSize", + "type": "Integer", + "default": "10", + "optional": true, + "description": "Size of the context window when training the neural network." + }, + { + "name": "negativeSamplingRate", + "type": "Integer", + "default": "5", + "optional": true, + "description": "Number of negative samples to produce for each positive sample." + }, + { + "name": "positiveSamplingFactor", + "type": "Float", + "default": "0.001", + "optional": true, + "description": "Factor for influencing the distribution for positive samples. A higher value increases the probability that frequent nodes are down-sampled." + }, + { + "name": "negativeSamplingExponent", + "type": "Float", + "default": "0.75", + "optional": true, + "description": "Exponent applied to the node frequency to obtain the negative sampling distribution. A value of 1.0 samples proportionally to the frequency. A value of 0.0 samples each node equally." + }, + { + "name": "embeddingDimension", + "type": "Integer", + "default": "128", + "optional": true, + "description": "Size of the computed node embeddings." + }, + { + "name": "embeddingInitializer", + "type": "String", + "default": "NORMALIZED", + "optional": true, + "description": "Method to initialize embeddings. Values are sampled uniformly from a range `[-a, a]`. With `NORMALIZED`, `a=0.5/embeddingDimension` and with `UNIFORM` instead `a=1`." + }, + { + "name": "iterations", + "type": "Integer", + "default": "1", + "optional": true, + "description": "Number of training iterations." + }, + { + "name": "initialLearningRate", + "type": "Float", + "default": "0.01", + "optional": true, + "description": "Learning rate used initially for training the neural network. The learning rate decreases after each training iteration." + }, + { + "name": "minLearningRate", + "type": "Float", + "default": "0.0001", + "optional": true, + "description": "Lower bound for learning rate as it is decreased during training." + }, + { + "name": "randomSeed", + "type": "Integer", + "default": "random", + "optional": true, + "description": "Seed value used to generate the random walks, which are used as the training set of the neural network. Note, that the generated embeddings are still nondeterministic." + }, + { + "name": "walkBufferSize", + "type": "Integer", + "default": "1000", + "optional": true, + "description": "The number of random walks to complete before starting training." + } + ], + "page_path": "machine-learning/node-embeddings/node2vec/" + }, + { + "name": "HashGNN", + "procedure": "gds.hashgnn", + "config": [ + { + "name": "featureProperties", + "type": "List of String", + "default": "[]", + "optional": true, + "description": "The names of the node properties that should be used as input features. All property names must exist in the projected graph and be of type Float or List of Float." + }, + { + "name": "iterations", + "type": "Integer", + "default": "n/a", + "optional": false, + "description": "The number of iterations to run HashGNN. Must be at least 1." + }, + { + "name": "embeddingDensity", + "type": "Integer", + "default": "n/a", + "optional": false, + "description": "The number of features to sample per node in each iteration. Called `K` in the original paper. Must be at least 1." + }, + { + "name": "heterogeneous", + "type": "Boolean", + "default": "false", + "optional": true, + "description": "Whether different relationship types should be treated differently." + }, + { + "name": "neighborInfluence", + "type": "Float", + "default": "1.0", + "optional": true, + "description": "Controls how often neighbors' features are sampled in each iteration relative to sampling the node's own features. Must be non-negative." + }, + { + "name": "binarizeFeatures", + "type": "Map", + "default": "n/a", + "optional": true, + "description": "A map with keys `dimension` and `threshold`. If given, features are transformed into `dimension` binary features via hyperplane rounding. Increasing `threshold` makes the output more sparse, and it defaults to `0`. The value of `dimension` must be at least 1." + }, + { + "name": "generateFeatures", + "type": "Map", + "default": "n/a", + "optional": true, + "description": "A map with keys `dimension` and `densityLevel`. Should be given if and only if `featureProperties` is empty. If given, `dimension` binary features are generated with approximately `densityLevel` active features per node. Both must be at least 1 and `densityLevel` at most `dimension`." + }, + { + "name": "outputDimension", + "type": "Integer", + "default": "n/a", + "optional": true, + "description": "If given, the embeddings are projected randomly into `outputDimension` dense features. Must be at least 1." + }, + { + "name": "randomSeed", + "type": "Integer", + "default": "n/a", + "optional": true, + "description": "A random seed which is used for all randomness in computing the embeddings." + } + ], + "page_path": "machine-learning/node-embeddings/hashgnn/" + } + ] +} \ No newline at end of file diff --git a/doc/sphinx/create_algorithms_rst.py b/doc/sphinx/create_algorithms_rst.py index 1dc8c9b10..f3478a058 100644 --- a/doc/sphinx/create_algorithms_rst.py +++ b/doc/sphinx/create_algorithms_rst.py @@ -1,6 +1,74 @@ import json from textwrap import dedent +INCLUDED_ALGORITHMS = { + "Article Rank", + "Betweenness Centrality", + # "CELF", + # "Closeness Centrality", + "Degree Centrality", + "Eigenvector Centrality", + "PageRank", + # "Harmonic Centrality", + # "HITS", + "Conductance metric", + # "K-Core Decomposition", + # "K-1 Coloring", + # "K-Means Clustering", + # "Label Propagation", + # "Leiden", + "Local Clustering Coefficient", + # "Louvain", + "Modularity metric", + # "Modularity Optimization", + # "Strongly Connected Components", + "Triangle Count", + # "Weakly Connected Components", + # "Approximate Maximum k-cut", + # "Speaker-Listener Label Propagation", + "Node Similarity", + # "Filtered Node Similarity", + # "K-Nearest Neighbors", + # "Filtered K-Nearest Neighbors", + "Delta-Stepping Single-Source Shortest Path", + # "Dijkstra Source-Target Shortest Path", + # "Dijkstra Single-Source Shortest Path", + # "A* Shortest Path", + # "Yen's Shortest Path algorithm", + # "Minimum Weight Spanning Tree", + # "Minimum Directed Steiner Tree", + # "Random Walk", + "Breadth First Search", + "Depth First Search", + # "Bellman-Ford Single-Source Shortest Path", + # "Longest Path for DAG", + # "All Pairs Shortest Path", + # "Topological Sort", + # "Longest Path for DAG", + "Fast Random Projection", + "GraphSAGE", + "Node2Vec", + "HashGNN", +} + +def write_param(param, optional): + name, description, default = conf["name"], conf["description"], conf["default"] + default_placeholder = f' ({conf["default_placeholder"]})' if "default_placeholder" in conf else "" + description = description.replace("\n", "\n ") + + if optional: + return f" * **{name}** - *(Optional)* {description} *Default*: {default}{default_placeholder}." + else: + return f" * **{name}** - {description}" + +configs = [] +with open("algorithms-conf.json") as f: + j = json.load(f) + configs = j["algorithms"] + modes = j["modes"] + +procedures = {config["procedure"]: config for config in configs if config["name"] in INCLUDED_ALGORITHMS} + with open("algorithms.json") as f, open("source/algorithms.rst", "w") as fw: functions = json.load(f) @@ -25,7 +93,41 @@ function["function"]["signature"], function["function"]["return_type"], ) - fw.write(f".. py:function:: {name}({sig}) -> {ret_type}\n\n") + + conf_string = [] + proc_name = name.rsplit(".", maxsplit=1) + if proc_name[0] in procedures and len(procedures[proc_name[0]]["config"]) and proc_name[1] == "stream": + required = [conf for conf in procedures[proc_name[0]]["config"] if not conf["optional"]] + optional = [conf for conf in procedures[proc_name[0]]["config"] if conf["optional"]] + optional = [conf for conf in modes["stream"]["config"] if conf["optional"]] + optional + + for conf in required: + conf_string.append(conf["name"]) + + for conf in optional: + conf_name, conf_type, conf_default = conf["name"], conf["type"], conf["default"] + # if conf_type == "Float": + # try: + # conf_default = float(conf_default) + # except: + # print(f"{conf_default} not a float") + # elif conf_type == "Integer": + # try: + # conf_default = int(conf_default) + # except: + # print(f"{conf_default} not an int") + + if conf_default == "null": + conf_default = None + + conf_string.append(f"{conf_name}={conf_default}") + + if conf_string: + sig_fixed = sig.replace("**config: Any", f"*, {', '.join(conf_string)}") + else: + sig_fixed = sig + + fw.write(f".. py:function:: {name}({sig_fixed}) -> {ret_type}\n\n") if "description" in function: description = function["description"].strip() @@ -38,3 +140,29 @@ version, message = function["deprecated"]["version"], function["deprecated"]["message"] fw.write(f".. deprecated:: {version}\n") fw.write(f" {message}\n\n") + + fw.write(" |\n\n") + fw.write(" **Parameters:**\n\n") + + for param in sig.split(","): + param_name, param_type = param.split(":") + param_name = param_name.strip() + param_type = param_type.strip() + + if param_name != "**config": + fw.write(f" * **{param_name}** - {param_type}\n\n") + else: + proc_name = name.rsplit(".", maxsplit=1) + if proc_name[0] in procedures and len(procedures[proc_name[0]]["config"]) and proc_name[1] == "stream": + required = [conf for conf in procedures[proc_name[0]]["config"] if not conf["optional"]] + optional = [conf for conf in procedures[proc_name[0]]["config"] if conf["optional"]] + + optional = [conf for conf in modes["stream"]["config"] if conf["optional"]] + optional + + for conf in required: + fw.write(write_param(conf, False) + "\n\n") + + for conf in optional: + fw.write(write_param(conf, True) + "\n\n") + + fw.write("\n\n") From c6c1c07f9e4bbf228aa3869963fa4137f0bb58b1 Mon Sep 17 00:00:00 2001 From: Nicola Vitucci Date: Thu, 8 Aug 2024 11:43:35 +0100 Subject: [PATCH 14/21] Refactor conf write code --- doc/sphinx/create_algorithms_rst.py | 111 ++++++++++++++++------------ 1 file changed, 62 insertions(+), 49 deletions(-) diff --git a/doc/sphinx/create_algorithms_rst.py b/doc/sphinx/create_algorithms_rst.py index f3478a058..c6e8e4cb0 100644 --- a/doc/sphinx/create_algorithms_rst.py +++ b/doc/sphinx/create_algorithms_rst.py @@ -60,32 +60,65 @@ def write_param(param, optional): return f" * **{name}** - *(Optional)* {description} *Default*: {default}{default_placeholder}." else: return f" * **{name}** - {description}" + +def get_required_conf(config): + return [conf for conf in config if not conf["optional"]] + +def get_optional_conf(config): + return [conf for conf in config if conf["optional"]] + +def enrich_conf_string(config, proc_mode): + conf_string = [] + + if config and proc_mode == "stream": + required = get_required_conf(config) + optional = get_optional_conf(config) + # TODO: refactor this + optional = get_optional_conf(modes[proc_mode]["config"]) + optional + + for conf in required: + conf_string.append(conf["name"]) + + for conf in optional: + conf_name, conf_type, conf_default = conf["name"], conf["type"], conf["default"] + # if conf_type == "Float": + # try: + # conf_default = float(conf_default) + # except: + # print(f"{conf_default} not a float") + # elif conf_type == "Integer": + # try: + # conf_default = int(conf_default) + # except: + # print(f"{conf_default} not an int") + + if conf_default == "null": + conf_default = None + + conf_string.append(f"{conf_name}={conf_default}") + + return conf_string -configs = [] with open("algorithms-conf.json") as f: j = json.load(f) - configs = j["algorithms"] modes = j["modes"] + algorithms = {algo["procedure"]: algo for algo in j["algorithms"] if algo["name"] in INCLUDED_ALGORITHMS} -procedures = {config["procedure"]: config for config in configs if config["name"] in INCLUDED_ALGORITHMS} +PREAMBLE = """\ + .. + DO NOT EDIT - File generated automatically -with open("algorithms.json") as f, open("source/algorithms.rst", "w") as fw: - functions = json.load(f) + Algorithms procedures + ---------------------- + Listing of all algorithm procedures in the Neo4j Graph Data Science Python Client API. + These all assume that an object of :class:`.GraphDataScience` is available as `gds`. - fw.write( - dedent( - """\ - .. - DO NOT EDIT - File generated automatically +""" - Algorithms procedures - ---------------------- - Listing of all algorithm procedures in the Neo4j Graph Data Science Python Client API. - These all assume that an object of :class:`.GraphDataScience` is available as `gds`. +with open("algorithms.json") as f, open("source/algorithms.rst", "w") as fw: + functions = json.load(f) - """ - ) - ) + fw.write(dedent(PREAMBLE)) for function in functions: name, sig, ret_type = ( @@ -94,33 +127,11 @@ def write_param(param, optional): function["function"]["return_type"], ) + # Example: gds.triangleCount.stream -> (gds.triangleCount, stream) + proc_name, proc_mode = name.rsplit(".", maxsplit=1) conf_string = [] - proc_name = name.rsplit(".", maxsplit=1) - if proc_name[0] in procedures and len(procedures[proc_name[0]]["config"]) and proc_name[1] == "stream": - required = [conf for conf in procedures[proc_name[0]]["config"] if not conf["optional"]] - optional = [conf for conf in procedures[proc_name[0]]["config"] if conf["optional"]] - optional = [conf for conf in modes["stream"]["config"] if conf["optional"]] + optional - - for conf in required: - conf_string.append(conf["name"]) - - for conf in optional: - conf_name, conf_type, conf_default = conf["name"], conf["type"], conf["default"] - # if conf_type == "Float": - # try: - # conf_default = float(conf_default) - # except: - # print(f"{conf_default} not a float") - # elif conf_type == "Integer": - # try: - # conf_default = int(conf_default) - # except: - # print(f"{conf_default} not an int") - - if conf_default == "null": - conf_default = None - - conf_string.append(f"{conf_name}={conf_default}") + if proc_name in algorithms: + conf_string = enrich_conf_string(algorithms[proc_name]["config"], proc_mode) if conf_string: sig_fixed = sig.replace("**config: Any", f"*, {', '.join(conf_string)}") @@ -152,12 +163,14 @@ def write_param(param, optional): if param_name != "**config": fw.write(f" * **{param_name}** - {param_type}\n\n") else: - proc_name = name.rsplit(".", maxsplit=1) - if proc_name[0] in procedures and len(procedures[proc_name[0]]["config"]) and proc_name[1] == "stream": - required = [conf for conf in procedures[proc_name[0]]["config"] if not conf["optional"]] - optional = [conf for conf in procedures[proc_name[0]]["config"] if conf["optional"]] - - optional = [conf for conf in modes["stream"]["config"] if conf["optional"]] + optional + proc_name, proc_mode = name.rsplit(".", maxsplit=1) + if proc_name in algorithms and len(algorithms[proc_name]["config"]) and proc_mode == "stream": + config = algorithms[proc_name]["config"] + + required = get_required_conf(config) + optional = get_optional_conf(config) + # TODO: refactor this + optional = get_optional_conf(modes[proc_mode]["config"]) + optional for conf in required: fw.write(write_param(conf, False) + "\n\n") From 5afb512659c5356490ec8eef1de738b7bb172d2d Mon Sep 17 00:00:00 2001 From: Nicola Vitucci Date: Thu, 8 Aug 2024 11:50:37 +0100 Subject: [PATCH 15/21] Add new algorithm --- doc/sphinx/algorithms.json | 16 ++++++++++++++++ doc/sphinx/source/algorithms.rst | 20 ++++++++++++++++++++ 2 files changed, 36 insertions(+) diff --git a/doc/sphinx/algorithms.json b/doc/sphinx/algorithms.json index b7df422cc..42a510690 100644 --- a/doc/sphinx/algorithms.json +++ b/doc/sphinx/algorithms.json @@ -1413,6 +1413,22 @@ }, "description": "BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth\nprior to moving on to the nodes at the next depth level." }, + { + "function": { + "name": "gds.bridges.stream", + "signature": "G: Graph, **config: Any", + "return_type": "DataFrame" + }, + "description": "An algorithm to find Bridge edges in a graph." + }, + { + "function": { + "name": "gds.bridges.stream.estimate", + "signature": "G: Graph, **config: Any", + "return_type": "Series[Any]" + }, + "description": "An algorithm to find Bridge edges in a graph." + }, { "function": { "name": "gds.closeness.mutate", diff --git a/doc/sphinx/source/algorithms.rst b/doc/sphinx/source/algorithms.rst index 7630fbda5..d889fcdd0 100644 --- a/doc/sphinx/source/algorithms.rst +++ b/doc/sphinx/source/algorithms.rst @@ -1858,6 +1858,26 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph +.. py:function:: gds.bridges.stream(G: Graph, **config: Any) -> DataFrame + + An algorithm to find Bridge edges in a graph. + + | + + **Parameters:** + + * **G** - Graph + +.. py:function:: gds.bridges.stream.estimate(G: Graph, **config: Any) -> Series[Any] + + An algorithm to find Bridge edges in a graph. + + | + + **Parameters:** + + * **G** - Graph + .. py:function:: gds.closeness.mutate(G: Graph, **config: Any) -> Series[Any] Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. From 3a0e7df36dac913e1b9d59cf52d26d705c7793d3 Mon Sep 17 00:00:00 2001 From: Nicola Vitucci Date: Thu, 8 Aug 2024 13:27:00 +0100 Subject: [PATCH 16/21] Remove new algorithm --- doc/sphinx/algorithms.json | 16 ---------------- doc/sphinx/source/algorithms.rst | 20 -------------------- 2 files changed, 36 deletions(-) diff --git a/doc/sphinx/algorithms.json b/doc/sphinx/algorithms.json index 42a510690..b7df422cc 100644 --- a/doc/sphinx/algorithms.json +++ b/doc/sphinx/algorithms.json @@ -1413,22 +1413,6 @@ }, "description": "BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth\nprior to moving on to the nodes at the next depth level." }, - { - "function": { - "name": "gds.bridges.stream", - "signature": "G: Graph, **config: Any", - "return_type": "DataFrame" - }, - "description": "An algorithm to find Bridge edges in a graph." - }, - { - "function": { - "name": "gds.bridges.stream.estimate", - "signature": "G: Graph, **config: Any", - "return_type": "Series[Any]" - }, - "description": "An algorithm to find Bridge edges in a graph." - }, { "function": { "name": "gds.closeness.mutate", diff --git a/doc/sphinx/source/algorithms.rst b/doc/sphinx/source/algorithms.rst index d889fcdd0..7630fbda5 100644 --- a/doc/sphinx/source/algorithms.rst +++ b/doc/sphinx/source/algorithms.rst @@ -1858,26 +1858,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph -.. py:function:: gds.bridges.stream(G: Graph, **config: Any) -> DataFrame - - An algorithm to find Bridge edges in a graph. - - | - - **Parameters:** - - * **G** - Graph - -.. py:function:: gds.bridges.stream.estimate(G: Graph, **config: Any) -> Series[Any] - - An algorithm to find Bridge edges in a graph. - - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.closeness.mutate(G: Graph, **config: Any) -> Series[Any] Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. From 9742920f704be716e7a4ce1c7995e72fd38c9984 Mon Sep 17 00:00:00 2001 From: Nicola Vitucci Date: Thu, 8 Aug 2024 13:28:58 +0100 Subject: [PATCH 17/21] Re-add new algorithm --- doc/sphinx/algorithms.json | 16 ++++++++++++++++ doc/sphinx/source/algorithms.rst | 20 ++++++++++++++++++++ 2 files changed, 36 insertions(+) diff --git a/doc/sphinx/algorithms.json b/doc/sphinx/algorithms.json index b7df422cc..42a510690 100644 --- a/doc/sphinx/algorithms.json +++ b/doc/sphinx/algorithms.json @@ -1413,6 +1413,22 @@ }, "description": "BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth\nprior to moving on to the nodes at the next depth level." }, + { + "function": { + "name": "gds.bridges.stream", + "signature": "G: Graph, **config: Any", + "return_type": "DataFrame" + }, + "description": "An algorithm to find Bridge edges in a graph." + }, + { + "function": { + "name": "gds.bridges.stream.estimate", + "signature": "G: Graph, **config: Any", + "return_type": "Series[Any]" + }, + "description": "An algorithm to find Bridge edges in a graph." + }, { "function": { "name": "gds.closeness.mutate", diff --git a/doc/sphinx/source/algorithms.rst b/doc/sphinx/source/algorithms.rst index 7630fbda5..d889fcdd0 100644 --- a/doc/sphinx/source/algorithms.rst +++ b/doc/sphinx/source/algorithms.rst @@ -1858,6 +1858,26 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g * **G** - Graph +.. py:function:: gds.bridges.stream(G: Graph, **config: Any) -> DataFrame + + An algorithm to find Bridge edges in a graph. + + | + + **Parameters:** + + * **G** - Graph + +.. py:function:: gds.bridges.stream.estimate(G: Graph, **config: Any) -> Series[Any] + + An algorithm to find Bridge edges in a graph. + + | + + **Parameters:** + + * **G** - Graph + .. py:function:: gds.closeness.mutate(G: Graph, **config: Any) -> Series[Any] Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. From ae81eeb244043b5ab7c6617244f438deca5fd446 Mon Sep 17 00:00:00 2001 From: Nicola Vitucci Date: Thu, 8 Aug 2024 13:53:57 +0100 Subject: [PATCH 18/21] Simplify conf script --- doc/sphinx/create_algorithms_rst.py | 93 +++++++++++++---------------- 1 file changed, 42 insertions(+), 51 deletions(-) diff --git a/doc/sphinx/create_algorithms_rst.py b/doc/sphinx/create_algorithms_rst.py index c6e8e4cb0..80f5dbdde 100644 --- a/doc/sphinx/create_algorithms_rst.py +++ b/doc/sphinx/create_algorithms_rst.py @@ -67,37 +67,35 @@ def get_required_conf(config): def get_optional_conf(config): return [conf for conf in config if conf["optional"]] -def enrich_conf_string(config, proc_mode): +def enrich_signature(sig, required, optional): conf_string = [] - if config and proc_mode == "stream": - required = get_required_conf(config) - optional = get_optional_conf(config) - # TODO: refactor this - optional = get_optional_conf(modes[proc_mode]["config"]) + optional - - for conf in required: - conf_string.append(conf["name"]) - - for conf in optional: - conf_name, conf_type, conf_default = conf["name"], conf["type"], conf["default"] - # if conf_type == "Float": - # try: - # conf_default = float(conf_default) - # except: - # print(f"{conf_default} not a float") - # elif conf_type == "Integer": - # try: - # conf_default = int(conf_default) - # except: - # print(f"{conf_default} not an int") - - if conf_default == "null": - conf_default = None - - conf_string.append(f"{conf_name}={conf_default}") + for conf in required: + conf_string.append(conf["name"]) + + for conf in optional: + conf_name, conf_type, conf_default = conf["name"], conf["type"], conf["default"] + # if conf_type == "Float": + # try: + # conf_default = float(conf_default) + # except: + # print(f"{conf_default} not a float") + # elif conf_type == "Integer": + # try: + # conf_default = int(conf_default) + # except: + # print(f"{conf_default} not an int") + + if conf_default == "null": + conf_default = None + + conf_string.append(f"{conf_name}={conf_default}") + + if conf_string: + return sig.replace("**config: Any", f"*, {', '.join(conf_string)}") + else: + return sig - return conf_string with open("algorithms-conf.json") as f: j = json.load(f) @@ -129,16 +127,17 @@ def enrich_conf_string(config, proc_mode): # Example: gds.triangleCount.stream -> (gds.triangleCount, stream) proc_name, proc_mode = name.rsplit(".", maxsplit=1) - conf_string = [] - if proc_name in algorithms: - conf_string = enrich_conf_string(algorithms[proc_name]["config"], proc_mode) - - if conf_string: - sig_fixed = sig.replace("**config: Any", f"*, {', '.join(conf_string)}") - else: - sig_fixed = sig + required = [] + optional = [] - fw.write(f".. py:function:: {name}({sig_fixed}) -> {ret_type}\n\n") + if proc_name in algorithms and proc_mode == "stream": + mode_config = modes[proc_mode]["config"] + config = algorithms[proc_name]["config"] + + required = get_required_conf(mode_config) + get_required_conf(config) + optional = get_optional_conf(mode_config) + get_optional_conf(config) + + fw.write(f".. py:function:: {name}({enrich_signature(sig, required, optional)}) -> {ret_type}\n\n") if "description" in function: description = function["description"].strip() @@ -163,19 +162,11 @@ def enrich_conf_string(config, proc_mode): if param_name != "**config": fw.write(f" * **{param_name}** - {param_type}\n\n") else: - proc_name, proc_mode = name.rsplit(".", maxsplit=1) - if proc_name in algorithms and len(algorithms[proc_name]["config"]) and proc_mode == "stream": - config = algorithms[proc_name]["config"] - - required = get_required_conf(config) - optional = get_optional_conf(config) - # TODO: refactor this - optional = get_optional_conf(modes[proc_mode]["config"]) + optional + for conf in required: + fw.write(write_param(conf, False) + "\n\n") - for conf in required: - fw.write(write_param(conf, False) + "\n\n") - - for conf in optional: - fw.write(write_param(conf, True) + "\n\n") - + for conf in optional: + fw.write(write_param(conf, True) + "\n\n") + + if required or optional: fw.write("\n\n") From a0f827e924a7036394a4c6239c53fbceba550462 Mon Sep 17 00:00:00 2001 From: Nicola Vitucci Date: Thu, 8 Aug 2024 13:57:34 +0100 Subject: [PATCH 19/21] Refactor conf write code --- doc/sphinx/create_algorithms_rst.py | 22 +++++++++++++--------- 1 file changed, 13 insertions(+), 9 deletions(-) diff --git a/doc/sphinx/create_algorithms_rst.py b/doc/sphinx/create_algorithms_rst.py index 80f5dbdde..a10e7f050 100644 --- a/doc/sphinx/create_algorithms_rst.py +++ b/doc/sphinx/create_algorithms_rst.py @@ -51,6 +51,7 @@ "HashGNN", } + def write_param(param, optional): name, description, default = conf["name"], conf["description"], conf["default"] default_placeholder = f' ({conf["default_placeholder"]})' if "default_placeholder" in conf else "" @@ -60,13 +61,16 @@ def write_param(param, optional): return f" * **{name}** - *(Optional)* {description} *Default*: {default}{default_placeholder}." else: return f" * **{name}** - {description}" - + + def get_required_conf(config): return [conf for conf in config if not conf["optional"]] + def get_optional_conf(config): return [conf for conf in config if conf["optional"]] - + + def enrich_signature(sig, required, optional): conf_string = [] @@ -85,17 +89,17 @@ def enrich_signature(sig, required, optional): # conf_default = int(conf_default) # except: # print(f"{conf_default} not an int") - + if conf_default == "null": conf_default = None - + conf_string.append(f"{conf_name}={conf_default}") if conf_string: return sig.replace("**config: Any", f"*, {', '.join(conf_string)}") else: return sig - + with open("algorithms-conf.json") as f: j = json.load(f) @@ -125,7 +129,7 @@ def enrich_signature(sig, required, optional): function["function"]["return_type"], ) - # Example: gds.triangleCount.stream -> (gds.triangleCount, stream) + # Example: gds.triangleCount.stream -> (gds.triangleCount, stream) proc_name, proc_mode = name.rsplit(".", maxsplit=1) required = [] optional = [] @@ -135,7 +139,7 @@ def enrich_signature(sig, required, optional): config = algorithms[proc_name]["config"] required = get_required_conf(mode_config) + get_required_conf(config) - optional = get_optional_conf(mode_config) + get_optional_conf(config) + optional = get_optional_conf(mode_config) + get_optional_conf(config) fw.write(f".. py:function:: {name}({enrich_signature(sig, required, optional)}) -> {ret_type}\n\n") @@ -167,6 +171,6 @@ def enrich_signature(sig, required, optional): for conf in optional: fw.write(write_param(conf, True) + "\n\n") - - if required or optional: + + if required or optional: fw.write("\n\n") From 3f0ac7009f47a632a9b9002313688dba6c944f14 Mon Sep 17 00:00:00 2001 From: Nicola Vitucci Date: Thu, 8 Aug 2024 14:09:00 +0100 Subject: [PATCH 20/21] Simplify conf script --- doc/sphinx/create_algorithms_rst.py | 28 +- doc/sphinx/source/algorithms.rst | 2352 +-------------------------- 2 files changed, 34 insertions(+), 2346 deletions(-) diff --git a/doc/sphinx/create_algorithms_rst.py b/doc/sphinx/create_algorithms_rst.py index a10e7f050..5b6611693 100644 --- a/doc/sphinx/create_algorithms_rst.py +++ b/doc/sphinx/create_algorithms_rst.py @@ -155,22 +155,22 @@ def enrich_signature(sig, required, optional): fw.write(f".. deprecated:: {version}\n") fw.write(f" {message}\n\n") - fw.write(" |\n\n") - fw.write(" **Parameters:**\n\n") + if required or optional: + fw.write(" |\n\n") + fw.write(" **Parameters:**\n\n") - for param in sig.split(","): - param_name, param_type = param.split(":") - param_name = param_name.strip() - param_type = param_type.strip() + for param in sig.split(","): + param_name, param_type = param.split(":") + param_name = param_name.strip() + param_type = param_type.strip() - if param_name != "**config": - fw.write(f" * **{param_name}** - {param_type}\n\n") - else: - for conf in required: - fw.write(write_param(conf, False) + "\n\n") + if param_name != "**config": + fw.write(f" * **{param_name}** - {param_type}\n\n") + else: + for conf in required: + fw.write(write_param(conf, False) + "\n\n") - for conf in optional: - fw.write(write_param(conf, True) + "\n\n") + for conf in optional: + fw.write(write_param(conf, True) + "\n\n") - if required or optional: fw.write("\n\n") diff --git a/doc/sphinx/source/algorithms.rst b/doc/sphinx/source/algorithms.rst index d889fcdd0..f2682b258 100644 --- a/doc/sphinx/source/algorithms.rst +++ b/doc/sphinx/source/algorithms.rst @@ -11,43 +11,19 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g The Delta Stepping shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph. The computation is run multi-threaded. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.allShortestPaths.delta.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for allShortestPaths.dealta.mutate. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.allShortestPaths.delta.stats(G: Graph, **config: Any) -> Series[Any] The Delta Stepping shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph. The computation is run multi-threaded - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.allShortestPaths.delta.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for allShortestPaths.delta.stats. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.allShortestPaths.delta.stream(G: Graph, *, sourceNode, nodeLabels=['*'], relationshipTypes=['*'], concurrency=4, jobId=None, logProgress=True, delta=2.0, relationshipWeightProperty=None) -> DataFrame The Delta Stepping shortest path algorithm computes the shortest (weighted) path @@ -81,107 +57,47 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Returns an estimation of the memory consumption for allShortestPaths.delta.strema. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.allShortestPaths.delta.write(G: Graph, **config: Any) -> Series[Any] The Delta Stepping shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph. The computation is run multi-threaded. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.allShortestPaths.delta.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.allShortestPaths.dijkstra.mutate(G: Graph, **config: Any) -> Series[Any] The Dijkstra shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.allShortestPaths.dijkstra.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.allShortestPaths.dijkstra.stream(G: Graph, **config: Any) -> DataFrame The Dijkstra shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.allShortestPaths.dijkstra.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.allShortestPaths.dijkstra.write(G: Graph, **config: Any) -> Series[Any] The Dijkstra shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.allShortestPaths.dijkstra.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.allShortestPaths.stream(G: Graph, **config: Any) -> DataFrame The All Pairs Shortest Path (APSP) calculates the shortest (weighted) path between all pairs of nodes. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.allShortestPaths.stream(G: Graph, **config: Any) -> DataFrame The All Pairs Shortest Path (APSP) calculates the shortest (weighted) path @@ -190,12 +106,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.allShortestPaths.stream` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.closeness.harmonic.stream(G: Graph, **config: Any) -> DataFrame Harmonic centrality is a way of detecting nodes that are able to spread information @@ -204,12 +114,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.closeness.harmonic.stream` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.closeness.harmonic.write(G: Graph, **config: Any) -> Series[Any] Harmonic centrality is a way of detecting nodes that are able to spread information @@ -218,23 +122,11 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.closeness.harmonic.write` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.conductance.stream(G: Graph, **config: Any) -> DataFrame Evaluates a division of nodes into communities based on the proportion of relationships that cross community boundaries. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.graph.sample.rwr(graph_name: str, from_G: Graph, **config: Any) -> GraphCreateResult Constructs a random subgraph based on random walks with restarts. @@ -242,14 +134,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.4.0 Since GDS server version 2.4.0 you should use the endpoint :func:`gds.graph.sample.rwr` instead. - | - - **Parameters:** - - * **graph_name** - str - - * **from_G** - Graph - .. py:function:: gds.alpha.hits.mutate(G: Graph, **config: Any) -> Series[Any] Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes. @@ -257,12 +141,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.hits.mutate` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.hits.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -270,12 +148,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.hits.mutate.estimate` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.hits.stats(G: Graph, **config: Any) -> Series[Any] Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes. @@ -283,12 +155,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.hits.stats` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.hits.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -296,12 +162,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.hits.stats.estimate` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.hits.stream(G: Graph, **config: Any) -> DataFrame Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes. @@ -309,12 +169,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.hits.stream` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.hits.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -322,12 +176,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.hits.stream.estimate` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.hits.write(G: Graph, **config: Any) -> Series[Any] Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes. @@ -335,12 +183,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.hits.write` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.hits.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -348,12 +190,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.hits.write.estimate` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.kSpanningTree.write(G: Graph, **config: Any) -> Series[Any] The K-spanning tree algorithm starts from a root node and returns a spanning tree with exactly k nodes @@ -361,12 +197,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kSpanningTree.write` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.knn.filtered.mutate(G: Graph, **config: Any) -> Series[Any] The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance @@ -374,12 +204,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g KNN computes distances based on the similarity of node properties. Filtered KNN extends this functionality, allowing filtering on source nodes and target nodes, respectively. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.knn.filtered.stats(G: Graph, **config: Any) -> Series[Any] The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance @@ -387,12 +211,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g KNN computes distances based on the similarity of node properties. Filtered KNN extends this functionality, allowing filtering on source nodes and target nodes, respectively. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.knn.filtered.stream(G: Graph, **config: Any) -> DataFrame The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance @@ -400,12 +218,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g KNN computes distances based on the similarity of node properties. Filtered KNN extends this functionality, allowing filtering on source nodes and target nodes, respectively. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.knn.filtered.write(G: Graph, **config: Any) -> Series[Any] The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance @@ -413,72 +225,30 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g KNN computes distances based on the similarity of node properties. Filtered KNN extends this functionality, allowing filtering on source nodes and target nodes, respectively. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.maxkcut.mutate(G: Graph, **config: Any) -> Series[Any] Approximate Maximum k-cut maps each node into one of k disjoint communities trying to maximize the sum of weights of relationships between these communities. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.maxkcut.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Approximate Maximum k-cut maps each node into one of k disjoint communities trying to maximize the sum of weights of relationships between these communities. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.maxkcut.stream(G: Graph, **config: Any) -> DataFrame Approximate Maximum k-cut maps each node into one of k disjoint communities trying to maximize the sum of weights of relationships between these communities. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.maxkcut.stream.estimate(G: Graph, **config: Any) -> Series[Any] Approximate Maximum k-cut maps each node into one of k disjoint communities trying to maximize the sum of weights of relationships between these communities. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.modularity.stats(G: Graph, **config: Any) -> Series[Any] - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.modularity.stream(G: Graph, **config: Any) -> DataFrame - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.nodeSimilarity.filtered.mutate(G: Graph, **config: Any) -> Series[Any] The Filtered Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. @@ -486,22 +256,10 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g The algorithm computes pair-wise similarities based on Jaccard or Overlap metrics. The filtered variant supports limiting which nodes to compare via source and target node filters. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.nodeSimilarity.filtered.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.nodeSimilarity.filtered.stats(G: Graph, **config: Any) -> Series[Any] The Filtered Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. @@ -509,22 +267,10 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g The algorithm computes pair-wise similarities based on Jaccard or Overlap metrics. The filtered variant supports limiting which nodes to compare via source and target node filters. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.nodeSimilarity.filtered.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.nodeSimilarity.filtered.stream(G: Graph, **config: Any) -> DataFrame The Filtered Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. @@ -532,21 +278,9 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g The algorithm computes pair-wise similarities based on Jaccard or Overlap metrics. The filtered variant supports limiting which nodes to compare via source and target node filters. - | +.. py:function:: gds.alpha.nodeSimilarity.filtered.stream.estimate(G: Graph, **config: Any) -> Series[Any] - **Parameters:** - - * **G** - Graph - -.. py:function:: gds.alpha.nodeSimilarity.filtered.stream.estimate(G: Graph, **config: Any) -> Series[Any] - - Returns an estimation of the memory consumption for that procedure. - - | - - **Parameters:** - - * **G** - Graph + Returns an estimation of the memory consumption for that procedure. .. py:function:: gds.alpha.nodeSimilarity.filtered.write(G: Graph, **config: Any) -> Series[Any] @@ -555,22 +289,10 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g The algorithm computes pair-wise similarities based on Jaccard or Overlap metrics. The filtered variant supports limiting which nodes to compare via source and target node filters. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.nodeSimilarity.filtered.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.scaleProperties.mutate(G: Graph, **config: Any) -> Series[Any] Scale node properties @@ -578,12 +300,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.4.0 Since GDS server version 2.4.0 you should use the endpoint :func:`gds.scaleProperties.mutate` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.scaleProperties.stream(G: Graph, **config: Any) -> DataFrame Scale node properties @@ -591,34 +307,16 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.4.0 Since GDS server version 2.4.0 you should use the endpoint :func:`gds.scaleProperties.stream` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.scc.stream(G: Graph, **config: Any) -> DataFrame The SCC algorithm finds sets of connected nodes in an directed graph, where all nodes in the same set form a connected component. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.scc.write(G: Graph, **config: Any) -> Series[Any] The SCC algorithm finds sets of connected nodes in an directed graph, where all nodes in the same set form a connected component. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.sllpa.mutate(G: Graph, **config: Any) -> Series[Any] The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph. @@ -626,12 +324,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.sllpa.mutate` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.sllpa.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -639,12 +331,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.sllpa.mutate.estimate` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.sllpa.stats(G: Graph, **config: Any) -> Series[Any] The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph. @@ -652,12 +338,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.sllpa.stats` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.sllpa.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -665,12 +345,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.sllpa.stats.estimate` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.sllpa.stream(G: Graph, **config: Any) -> DataFrame The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph. @@ -678,12 +352,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.sllpa.stream` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.sllpa.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -691,12 +359,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.sllpa.stream.estimate` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.sllpa.write(G: Graph, **config: Any) -> Series[Any] The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph. @@ -704,12 +366,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.sllpa.write` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.sllpa.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -717,12 +373,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.sllpa.write.estimate` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.triangles(G: Graph, **config: Any) -> DataFrame Triangles streams the nodeIds of each triangle in the graph. @@ -730,52 +380,22 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.triangles` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.articleRank.mutate(G: Graph, **config: Any) -> Series[Any] Article Rank is a variant of the Page Rank algorithm, which measures the transitive influence or connectivity of nodes. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.articleRank.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.articleRank.stats(G: Graph, **config: Any) -> Series[Any] Executes the algorithm and returns result statistics without writing the result to Neo4j. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.articleRank.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.articleRank.stream(G: Graph, *, nodeLabels=['*'], relationshipTypes=['*'], concurrency=4, jobId=None, logProgress=True, dampingFactor=0.85, maxIterations=20, tolerance=0.0000001, relationshipWeightProperty=None, sourceNodes=[], scaler=None) -> DataFrame Article Rank is a variant of the Page Rank algorithm, which measures the transitive influence or connectivity of nodes. @@ -814,331 +434,139 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.articleRank.write(G: Graph, **config: Any) -> Series[Any] Article Rank is a variant of the Page Rank algorithm, which measures the transitive influence or connectivity of nodes. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.articleRank.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.bellmanFord.mutate(G: Graph, **config: Any) -> Series[Any] The Bellman-Ford shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph without negative cycles. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.bellmanFord.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.bellmanFord.stats(G: Graph, **config: Any) -> Series[Any] The Bellman-Ford shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph without negative cycles. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.bellmanFord.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.bellmanFord.stream(G: Graph, **config: Any) -> DataFrame The Bellman-Ford shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph without negative cycles. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.bellmanFord.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.bellmanFord.write(G: Graph, **config: Any) -> Series[Any] The Bellman-Ford shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph without negative cycles. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.bellmanFord.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.closeness.mutate(G: Graph, **config: Any) -> Series[Any] Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.closeness.stats(G: Graph, **config: Any) -> Series[Any] Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.closeness.stream(G: Graph, **config: Any) -> DataFrame Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.closeness.write(G: Graph, **config: Any) -> Series[Any] Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.collapsePath.mutate(G: Graph, **config: Any) -> Series[Any] Collapse Path algorithm is a traversal algorithm capable of creating relationships between the start and end nodes of a traversal - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.influenceMaximization.celf.mutate(G: Graph, **config: Any) -> Series[Any] The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes that maximize the expected spread of influence in the network. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.influenceMaximization.celf.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.influenceMaximization.celf.stats(G: Graph, **config: Any) -> Series[Any] Executes the algorithm and returns result statistics without writing the result to Neo4j. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.influenceMaximization.celf.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.influenceMaximization.celf.stream(G: Graph, **config: Any) -> DataFrame The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes that maximize the expected spread of influence in the network. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.influenceMaximization.celf.stream.estimate(G: Graph, **config: Any) -> Series[Any] The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes that maximize the expected spread of influence in the network. - | - - **Parameters:** - - * **G** - Graph - -.. py:function:: gds.beta.influenceMaximization.celf.write(G: Graph, **config: Any) -> Series[Any] +.. py:function:: gds.beta.influenceMaximization.celf.write(G: Graph, **config: Any) -> Series[Any] The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes that maximize the expected spread of influence in the network. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.influenceMaximization.celf.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.k1coloring.mutate(G: Graph, **config: Any) -> Series[Any] The K-1 Coloring algorithm assigns a color to every node in the graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.k1coloring.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.k1coloring.stats(G: Graph, **config: Any) -> Series[Any] The K-1 Coloring algorithm assigns a color to every node in the graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.k1coloring.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.k1coloring.stream(G: Graph, **config: Any) -> DataFrame The K-1 Coloring algorithm assigns a color to every node in the graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.k1coloring.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.k1coloring.write(G: Graph, **config: Any) -> Series[Any] The K-1 Coloring algorithm assigns a color to every node in the graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.k1coloring.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.kmeans.mutate(G: Graph, **config: Any) -> Series[Any] The Kmeans algorithm clusters nodes into different communities based on Euclidean distance @@ -1146,12 +574,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.mutate` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.kmeans.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1159,12 +581,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.mutate.estimate` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.kmeans.stats(G: Graph, **config: Any) -> Series[Any] The Kmeans algorithm clusters nodes into different communities based on Euclidean distance @@ -1172,12 +588,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.stats` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.kmeans.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1185,12 +595,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.stats.estimate` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.kmeans.stream(G: Graph, **config: Any) -> DataFrame The Kmeans algorithm clusters nodes into different communities based on Euclidean distance @@ -1198,12 +602,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.stream` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.kmeans.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1211,12 +609,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.stream.estimate` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.kmeans.write(G: Graph, **config: Any) -> Series[Any] The Kmeans algorithm clusters nodes into different communities based on Euclidean distance @@ -1224,12 +616,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.write` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.kmeans.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -1237,487 +623,205 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. deprecated:: 2.5.0 Since GDS server version 2.5.0 you should use the endpoint :func:`gds.kmeans.write.estimate` instead. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.leiden.mutate(G: Graph, **config: Any) -> Series[Any] Leiden is a community detection algorithm, which guarantees that communities are well connected - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.leiden.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.leiden.stats(G: Graph, **config: Any) -> Series[Any] Executes the algorithm and returns result statistics without writing the result to Neo4j. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.leiden.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.leiden.stream(G: Graph, **config: Any) -> DataFrame Leiden is a community detection algorithm, which guarantees that communities are well connected - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.leiden.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.leiden.write(G: Graph, **config: Any) -> Series[Any] Leiden is a community detection algorithm, which guarantees that communities are well connected - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.leiden.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.modularityOptimization.mutate(G: Graph, **config: Any) -> Series[Any] The Modularity Optimization algorithm groups the nodes in the graph by optimizing the graphs modularity. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.modularityOptimization.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.modularityOptimization.stream(G: Graph, **config: Any) -> DataFrame The Modularity Optimization algorithm groups the nodes in the graph by optimizing the graphs modularity. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.modularityOptimization.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.modularityOptimization.write(G: Graph, **config: Any) -> Series[Any] The Modularity Optimization algorithm groups the nodes in the graph by optimizing the graphs modularity. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.modularityOptimization.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.scaleProperties.mutate(G: Graph, **config: Any) -> Series[Any] Scale node properties - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.scaleProperties.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.scaleProperties.stats(G: Graph, **config: Any) -> Series[Any] Scale node properties - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.scaleProperties.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.scaleProperties.stream(G: Graph, **config: Any) -> DataFrame Scale node properties - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.scaleProperties.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.scaleProperties.write(G: Graph, **config: Any) -> Series[Any] Scale node properties - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.scaleProperties.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.scc.mutate(G: Graph, **config: Any) -> Series[Any] The SCC algorithm finds sets of connected nodes in an directed graph, where all nodes in the same set form a connected component. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.scc.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for SCC. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.scc.stats(G: Graph, **config: Any) -> Series[Any] The SCC algorithm finds sets of connected nodes in an directed graph, where all nodes in the same set form a connected component. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.scc.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for SCC. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.scc.stream(G: Graph, **config: Any) -> DataFrame The SCC algorithm finds sets of connected nodes in an directed graph, where all nodes in the same set form a connected component. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.scc.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for SCC. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.scc.write(G: Graph, **config: Any) -> Series[Any] The SCC algorithm finds sets of connected nodes in an directed graph, where all nodes in the same set form a connected component. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.scc.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for SCC. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.spanningTree.mutate(G: Graph, **config: Any) -> Series[Any] The spanning tree algorithm visits all nodes that are in the same connected component as the starting node, and returns a spanning tree of all nodes in the component where the total weight of the relationships is either minimized or maximized. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.spanningTree.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.spanningTree.stats(G: Graph, **config: Any) -> Series[Any] The spanning tree algorithm visits all nodes that are in the same connected component as the starting node, and returns a spanning tree of all nodes in the component where the total weight of the relationships is either minimized or maximized. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.spanningTree.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.spanningTree.stream(G: Graph, **config: Any) -> DataFrame The spanning tree algorithm visits all nodes that are in the same connected component as the starting node, and returns a spanning tree of all nodes in the component where the total weight of the relationships is either minimized or maximized. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.spanningTree.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.spanningTree.write(G: Graph, **config: Any) -> Series[Any] The spanning tree algorithm visits all nodes that are in the same connected component as the starting node, and returns a spanning tree of all nodes in the component where the total weight of the relationships is either minimized or maximized. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.spanningTree.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.steinerTree.mutate(G: Graph, **config: Any) -> Series[Any] The steiner tree algorithm accepts a source node, as well as a list of target nodes. It then attempts to find a spanning tree where there is a path from the source node to each target node, such that the total weight of the relationships is as low as possible. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.steinerTree.stats(G: Graph, **config: Any) -> Series[Any] The steiner tree algorithm accepts a source node, as well as a list of target nodes. It then attempts to find a spanning tree where there is a path from the source node to each target node, such that the total weight of the relationships is as low as possible. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.steinerTree.stream(G: Graph, **config: Any) -> DataFrame The steiner tree algorithm accepts a source node, as well as a list of target nodes. It then attempts to find a spanning tree where there is a path from the source node to each target node, such that the total weight of the relationships is as low as possible. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.beta.steinerTree.write(G: Graph, **config: Any) -> Series[Any] The steiner tree algorithm accepts a source node, as well as a list of target nodes. It then attempts to find a spanning tree where there is a path from the source node to each target node, such that the total weight of the relationships is as low as possible. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.betweenness.mutate(G: Graph, **config: Any) -> Series[Any] Betweenness centrality measures the relative information flow that passes through a node. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.betweenness.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Betweenness centrality measures the relative information flow that passes through a node. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.betweenness.stats(G: Graph, **config: Any) -> Series[Any] Betweenness centrality measures the relative information flow that passes through a node. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.betweenness.stats.estimate(G: Graph, **config: Any) -> Series[Any] Betweenness centrality measures the relative information flow that passes through a node. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.betweenness.stream(G: Graph, *, nodeLabels=['*'], relationshipTypes=['*'], concurrency=4, jobId=None, logProgress=True, samplingSize=node count, samplingSeed=None, relationshipWeightProperty=None) -> DataFrame Betweenness centrality measures the relative information flow that passes through a node. @@ -1750,74 +854,32 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Betweenness centrality measures the relative information flow that passes through a node. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.betweenness.write(G: Graph, **config: Any) -> Series[Any] Betweenness centrality measures the relative information flow that passes through a node. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.betweenness.write.estimate(G: Graph, **config: Any) -> Series[Any] Betweenness centrality measures the relative information flow that passes through a node. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.bfs.mutate(G: Graph, **config: Any) -> Series[Any] BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.bfs.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.bfs.stats(G: Graph, **config: Any) -> Series[Any] BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.bfs.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.bfs.stream(G: Graph, *, sourceNode, nodeLabels=['*'], relationshipTypes=['*'], concurrency=4, jobId=None, logProgress=True, targetNodes=empty list, maxDepth=-1) -> DataFrame BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth @@ -1852,127 +914,55 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.bridges.stream(G: Graph, **config: Any) -> DataFrame An algorithm to find Bridge edges in a graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.bridges.stream.estimate(G: Graph, **config: Any) -> Series[Any] An algorithm to find Bridge edges in a graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.closeness.mutate(G: Graph, **config: Any) -> Series[Any] Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.closeness.stats(G: Graph, **config: Any) -> Series[Any] Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.closeness.stream(G: Graph, **config: Any) -> DataFrame Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.closeness.write(G: Graph, **config: Any) -> Series[Any] Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.closeness.harmonic.mutate(G: Graph, **config: Any) -> DataFrame Harmonic centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.closeness.harmonic.stats(G: Graph, **config: Any) -> DataFrame Harmonic centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.closeness.harmonic.stream(G: Graph, **config: Any) -> DataFrame Harmonic centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.closeness.harmonic.write(G: Graph, **config: Any) -> Series[Any] Harmonic centrality is a way of detecting nodes that are able to spread information very efficiently through a graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.collapsePath.mutate(G: Graph, **config: Any) -> Series[Any] Collapse Path algorithm is a traversal algorithm capable of creating relationships between the start and end nodes of a traversal - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.conductance.stream(G: Graph, *, communityProperty, nodeLabels=['*'], relationshipTypes=['*'], concurrency=4, jobId=None, logProgress=True, relationshipWeightProperty=None) -> DataFrame Evaluates a division of nodes into communities based on the proportion of relationships @@ -2004,62 +994,26 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Returns a topological ordering of the nodes in a directed acyclic graph (DAG). - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.dag.longestPath.stream(G: Graph, **config: Any) -> DataFrame Finds the longest path that leads to a node in a directed acyclic graph (DAG). - | +.. py:function:: gds.degree.mutate(G: Graph, **config: Any) -> Series[Any] - **Parameters:** - - * **G** - Graph - -.. py:function:: gds.degree.mutate(G: Graph, **config: Any) -> Series[Any] - - Degree centrality measures the number of incoming and outgoing relationships from a node. - - | - - **Parameters:** - - * **G** - Graph + Degree centrality measures the number of incoming and outgoing relationships from a node. .. py:function:: gds.degree.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Degree centrality measures the number of incoming and outgoing relationships from a node. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.degree.stats(G: Graph, **config: Any) -> Series[Any] Degree centrality measures the number of incoming and outgoing relationships from a node. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.degree.stats.estimate(G: Graph, **config: Any) -> Series[Any] Degree centrality measures the number of incoming and outgoing relationships from a node. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.degree.stream(G: Graph, *, nodeLabels=['*'], relationshipTypes=['*'], concurrency=4, jobId=None, logProgress=True, orientation=NATURAL, relationshipWeightProperty=None) -> DataFrame Degree centrality measures the number of incoming and outgoing relationships from a node. @@ -2090,54 +1044,24 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Degree centrality measures the number of incoming and outgoing relationships from a node. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.degree.write(G: Graph, **config: Any) -> Series[Any] Degree centrality measures the number of incoming and outgoing relationships from a node. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.degree.write.estimate(G: Graph, **config: Any) -> Series[Any] Degree centrality measures the number of incoming and outgoing relationships from a node. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.dfs.mutate(G: Graph, **config: Any) -> Series[Any] Depth-first search (DFS) is an algorithm for traversing or searching tree or graph data structures. The algorithm starts at the root node (selecting some arbitrary node as the root node in the case of a graph) and explores as far as possible along each branch before backtracking. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.dfs.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.dfs.stream(G: Graph, *, sourceNode, nodeLabels=['*'], relationshipTypes=['*'], concurrency=4, jobId=None, logProgress=True, targetNodes=empty list, maxDepth=-1) -> DataFrame Depth-first search (DFS) is an algorithm for traversing or searching tree or graph data structures. @@ -2174,52 +1098,22 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g The algorithm starts at the root node (selecting some arbitrary node as the root node in the case of a graph) and explores as far as possible along each branch before backtracking. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.eigenvector.mutate(G: Graph, **config: Any) -> Series[Any] Eigenvector Centrality is an algorithm that measures the transitive influence or connectivity of nodes. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.eigenvector.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.eigenvector.stats(G: Graph, **config: Any) -> Series[Any] Eigenvector Centrality is an algorithm that measures the transitive influence or connectivity of nodes. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.eigenvector.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.eigenvector.stream(G: Graph, *, nodeLabels=['*'], relationshipTypes=['*'], concurrency=4, jobId=None, logProgress=True, maxIterations=20, tolerance=0.0000001, relationshipWeightProperty=None, sourceNodes=[], scaler=None) -> DataFrame Eigenvector Centrality is an algorithm that measures the transitive influence or connectivity of nodes. @@ -2256,558 +1150,230 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.eigenvector.write(G: Graph, **config: Any) -> Series[Any] Eigenvector Centrality is an algorithm that measures the transitive influence or connectivity of nodes. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.eigenvector.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.graph.sample.cnarw(graph_name: str, from_G: Graph, **config: Any) -> GraphCreateResult Constructs a random subgraph based on common-neighbour-aware random walks. - | - - **Parameters:** - - * **graph_name** - str - - * **from_G** - Graph - .. py:function:: gds.graph.sample.cnarw.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.graph.sample.rwr(graph_name: str, from_G: Graph, **config: Any) -> GraphCreateResult Constructs a random subgraph based on random walks with restarts. - | - - **Parameters:** - - * **graph_name** - str - - * **from_G** - Graph - .. py:function:: gds.hits.mutate(G: Graph, **config: Any) -> Series[Any] Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.hits.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.hits.stats(G: Graph, **config: Any) -> Series[Any] Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.hits.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.hits.stream(G: Graph, **config: Any) -> DataFrame Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.hits.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.hits.write(G: Graph, **config: Any) -> Series[Any] Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.hits.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.influenceMaximization.celf.mutate(G: Graph, **config: Any) -> Series[Any] The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes that maximize the expected spread of influence in the network. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.influenceMaximization.celf.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.influenceMaximization.celf.stats(G: Graph, **config: Any) -> Series[Any] Executes the algorithm and returns result statistics without writing the result to Neo4j. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.influenceMaximization.celf.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.influenceMaximization.celf.stream(G: Graph, **config: Any) -> DataFrame The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes that maximize the expected spread of influence in the network. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.influenceMaximization.celf.stream.estimate(G: Graph, **config: Any) -> Series[Any] The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes that maximize the expected spread of influence in the network. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.influenceMaximization.celf.write(G: Graph, **config: Any) -> Series[Any] The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes that maximize the expected spread of influence in the network. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.influenceMaximization.celf.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.kmeans.mutate(G: Graph, **config: Any) -> Series[Any] The Kmeans algorithm clusters nodes into different communities based on Euclidean distance - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.kmeans.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.kmeans.stats(G: Graph, **config: Any) -> Series[Any] The Kmeans algorithm clusters nodes into different communities based on Euclidean distance - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.kmeans.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.kmeans.stream(G: Graph, **config: Any) -> DataFrame The Kmeans algorithm clusters nodes into different communities based on Euclidean distance - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.kmeans.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | +.. py:function:: gds.kmeans.write(G: Graph, **config: Any) -> Series[Any] - **Parameters:** - - * **G** - Graph - -.. py:function:: gds.kmeans.write(G: Graph, **config: Any) -> Series[Any] - - The Kmeans algorithm clusters nodes into different communities based on Euclidean distance - - | - - **Parameters:** - - * **G** - Graph + The Kmeans algorithm clusters nodes into different communities based on Euclidean distance .. py:function:: gds.kmeans.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.k1coloring.mutate(G: Graph, **config: Any) -> Series[Any] The K-1 Coloring algorithm assigns a color to every node in the graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.k1coloring.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.k1coloring.stats(G: Graph, **config: Any) -> Series[Any] The K-1 Coloring algorithm assigns a color to every node in the graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.k1coloring.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.k1coloring.stream(G: Graph, **config: Any) -> DataFrame The K-1 Coloring algorithm assigns a color to every node in the graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.k1coloring.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.k1coloring.write(G: Graph, **config: Any) -> Series[Any] The K-1 Coloring algorithm assigns a color to every node in the graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.k1coloring.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.kcore.mutate(G: Graph, **config: Any) -> Series[Any] Computes the k-core values in a network - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.kcore.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.kcore.stats(G: Graph, **config: Any) -> Series[Any] Computes the k-core values in a network - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.kcore.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.kcore.stream(G: Graph, **config: Any) -> Series[Any] Computes the k-core values in a network - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.kcore.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.kcore.write(G: Graph, **config: Any) -> Series[Any] Computes the k-core values in a network - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.kcore.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.knn.mutate(G: Graph, **config: Any) -> Series[Any] The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance between two nodes is among the k nearest distances compared to other nodes. KNN computes distances based on the similarity of node properties - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.knn.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.knn.stats(G: Graph, **config: Any) -> Series[Any] The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance between two nodes is among the k nearest distances compared to other nodes. KNN computes distances based on the similarity of node properties - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.knn.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.knn.stream(G: Graph, **config: Any) -> DataFrame The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance between two nodes is among the k nearest distances compared to other nodes. KNN computes distances based on the similarity of node properties - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.knn.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.knn.write(G: Graph, **config: Any) -> Series[Any] The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance between two nodes is among the k nearest distances compared to other nodes. KNN computes distances based on the similarity of node properties - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.knn.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.knn.filtered.mutate(G: Graph, **config: Any) -> Series[Any] The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance @@ -2819,12 +1385,6 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.knn.filtered.stats(G: Graph, **config: Any) -> Series[Any] The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance @@ -2832,22 +1392,10 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g KNN computes distances based on the similarity of node properties. Filtered KNN extends this functionality, allowing filtering on source nodes and target nodes, respectively. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.knn.filtered.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.knn.filtered.stream(G: Graph, **config: Any) -> DataFrame The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance @@ -2855,22 +1403,10 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g KNN computes distances based on the similarity of node properties. Filtered KNN extends this functionality, allowing filtering on source nodes and target nodes, respectively. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.knn.filtered.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.knn.filtered.write(G: Graph, **config: Any) -> Series[Any] The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance @@ -2878,232 +1414,94 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g KNN computes distances based on the similarity of node properties. Filtered KNN extends this functionality, allowing filtering on source nodes and target nodes, respectively. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.knn.filtered.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.kSpanningTree.write(G: Graph, **config: Any) -> Series[Any] The K-spanning tree algorithm starts from a root node and returns a spanning tree with exactly k nodes - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.labelPropagation.mutate(G: Graph, **config: Any) -> Series[Any] The Label Propagation algorithm is a fast algorithm for finding communities in a graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.labelPropagation.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.labelPropagation.stats(G: Graph, **config: Any) -> Series[Any] The Label Propagation algorithm is a fast algorithm for finding communities in a graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.labelPropagation.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.labelPropagation.stream(G: Graph, **config: Any) -> DataFrame The Label Propagation algorithm is a fast algorithm for finding communities in a graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.labelPropagation.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.labelPropagation.write(G: Graph, **config: Any) -> Series[Any] The Label Propagation algorithm is a fast algorithm for finding communities in a graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.labelPropagation.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.leiden.mutate(G: Graph, **config: Any) -> Series[Any] Leiden is a community detection algorithm, which guarantees that communities are well connected - | - - **Parameters:** - - * **G** - Graph - -.. py:function:: gds.leiden.mutate.estimate(G: Graph, **config: Any) -> Series[Any] - - Returns an estimation of the memory consumption for that procedure. - - | - - **Parameters:** - - * **G** - Graph - -.. py:function:: gds.leiden.stats(G: Graph, **config: Any) -> Series[Any] - - Executes the algorithm and returns result statistics without writing the result to Neo4j. - - | - - **Parameters:** - - * **G** - Graph - -.. py:function:: gds.leiden.stats.estimate(G: Graph, **config: Any) -> Series[Any] +.. py:function:: gds.leiden.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | +.. py:function:: gds.leiden.stats(G: Graph, **config: Any) -> Series[Any] - **Parameters:** + Executes the algorithm and returns result statistics without writing the result to Neo4j. - * **G** - Graph +.. py:function:: gds.leiden.stats.estimate(G: Graph, **config: Any) -> Series[Any] + + Returns an estimation of the memory consumption for that procedure. .. py:function:: gds.leiden.stream(G: Graph, **config: Any) -> DataFrame Leiden is a community detection algorithm, which guarantees that communities are well connected - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.leiden.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.leiden.write(G: Graph, **config: Any) -> Series[Any] Leiden is a community detection algorithm, which guarantees that communities are well connected - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.leiden.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.localClusteringCoefficient.mutate(G: Graph, **config: Any) -> Series[Any] The local clustering coefficient is a metric quantifying how connected the neighborhood of a node is. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.localClusteringCoefficient.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.localClusteringCoefficient.stats(G: Graph, **config: Any) -> Series[Any] Executes the algorithm and returns result statistics without writing the result to Neo4j. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.localClusteringCoefficient.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.localClusteringCoefficient.stream(G: Graph, *, nodeLabels=['*'], relationshipTypes=['*'], concurrency=4, jobId=None, logProgress=True, triangleCountProperty=n/a) -> DataFrame The local clustering coefficient is a metric quantifying how connected the neighborhood of a node is. @@ -3132,172 +1530,70 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.localClusteringCoefficient.write(G: Graph, **config: Any) -> Series[Any] The local clustering coefficient is a metric quantifying how connected the neighborhood of a node is. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.localClusteringCoefficient.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.louvain.mutate(G: Graph, **config: Any) -> Series[Any] The Louvain method for community detection is an algorithm for detecting communities in networks. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.louvain.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.louvain.stats(G: Graph, **config: Any) -> Series[Any] Executes the algorithm and returns result statistics without writing the result to Neo4j. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.louvain.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.louvain.stream(G: Graph, **config: Any) -> DataFrame The Louvain method for community detection is an algorithm for detecting communities in networks. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.louvain.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.louvain.write(G: Graph, **config: Any) -> Series[Any] The Louvain method for community detection is an algorithm for detecting communities in networks. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.louvain.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.maxkcut.mutate(G: Graph, **config: Any) -> Series[Any] Approximate Maximum k-cut maps each node into one of k disjoint communities trying to maximize the sum of weights of relationships between these communities. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.maxkcut.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Approximate Maximum k-cut maps each node into one of k disjoint communities trying to maximize the sum of weights of relationships between these communities. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.maxkcut.stream(G: Graph, **config: Any) -> DataFrame Approximate Maximum k-cut maps each node into one of k disjoint communities trying to maximize the sum of weights of relationships between these communities. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.maxkcut.stream.estimate(G: Graph, **config: Any) -> Series[Any] Approximate Maximum k-cut maps each node into one of k disjoint communities trying to maximize the sum of weights of relationships between these communities. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.modularity.stats(G: Graph, **config: Any) -> Series[Any] - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.modularity.stats.estimate(G: Graph, **config: Any) -> Series[Any] - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.modularity.stream(G: Graph, *, communityProperty, nodeLabels=['*'], relationshipTypes=['*'], concurrency=4, jobId=None, logProgress=True, relationshipWeightProperty=None) -> DataFrame | @@ -3324,136 +1620,58 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g .. py:function:: gds.modularity.stream.estimate(G: Graph, **config: Any) -> Series[Any] - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.modularityOptimization.mutate(G: Graph, **config: Any) -> Series[Any] The Modularity Optimization algorithm groups the nodes in the graph by optimizing the graphs modularity. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.modularityOptimization.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.modularityOptimization.stats(G: Graph, **config: Any) -> Series[Any] The Modularity Optimization algorithm groups the nodes in the graph by optimizing the graphs modularity. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.modularityOptimization.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.modularityOptimization.stream(G: Graph, **config: Any) -> DataFrame The Modularity Optimization algorithm groups the nodes in the graph by optimizing the graphs modularity. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.modularityOptimization.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.modularityOptimization.write(G: Graph, **config: Any) -> Series[Any] The Modularity Optimization algorithm groups the nodes in the graph by optimizing the graphs modularity. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.modularityOptimization.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.nodeSimilarity.mutate(G: Graph, **config: Any) -> Series[Any] The Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. Two nodes are considered similar if they share many of the same neighbors. Node Similarity computes pair-wise similarities based on the Jaccard metric. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.nodeSimilarity.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.nodeSimilarity.stats(G: Graph, **config: Any) -> Series[Any] The Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. Two nodes are considered similar if they share many of the same neighbors. Node Similarity computes pair-wise similarities based on the Jaccard metric. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.nodeSimilarity.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.nodeSimilarity.stream(G: Graph, *, nodeLabels=['*'], relationshipTypes=['*'], concurrency=4, jobId=None, logProgress=True, similarityCutoff=1e-42, degreeCutoff=1, upperDegreeCutoff=2147483647, topK=10, bottomK=10, topN=0, bottomN=0, relationshipWeightProperty=None, similarityMetric=JACCARD, useComponents=false) -> DataFrame The Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. @@ -3518,33 +1736,15 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.nodeSimilarity.write(G: Graph, **config: Any) -> Series[Any] The Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. Two nodes are considered similar if they share many of the same neighbors. Node Similarity computes pair-wise similarities based on the Jaccard metric. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.nodeSimilarity.write.estimate(G: Graph, **config: Any) -> Series[Any] - Returns an estimation of the memory consumption for that procedure. - - | - - **Parameters:** - - * **G** - Graph + Returns an estimation of the memory consumption for that procedure. .. py:function:: gds.nodeSimilarity.filtered.mutate(G: Graph, **config: Any) -> Series[Any] @@ -3553,22 +1753,10 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g The algorithm computes pair-wise similarities based on Jaccard or Overlap metrics. The filtered variant supports limiting which nodes to compare via source and target node filters. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.nodeSimilarity.filtered.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.nodeSimilarity.filtered.stats(G: Graph, **config: Any) -> Series[Any] The Filtered Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. @@ -3576,22 +1764,10 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g The algorithm computes pair-wise similarities based on Jaccard or Overlap metrics. The filtered variant supports limiting which nodes to compare via source and target node filters. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.nodeSimilarity.filtered.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.nodeSimilarity.filtered.stream(G: Graph, **config: Any) -> DataFrame The Filtered Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. @@ -3599,22 +1775,10 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g The algorithm computes pair-wise similarities based on Jaccard or Overlap metrics. The filtered variant supports limiting which nodes to compare via source and target node filters. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.nodeSimilarity.filtered.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.nodeSimilarity.filtered.write(G: Graph, **config: Any) -> Series[Any] The Filtered Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. @@ -3622,62 +1786,26 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g The algorithm computes pair-wise similarities based on Jaccard or Overlap metrics. The filtered variant supports limiting which nodes to compare via source and target node filters. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.nodeSimilarity.filtered.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.pageRank.mutate(G: Graph, **config: Any) -> Series[Any] Page Rank is an algorithm that measures the transitive influence or connectivity of nodes. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.pageRank.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.pageRank.stats(G: Graph, **config: Any) -> Series[Any] Executes the algorithm and returns result statistics without writing the result to Neo4j. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.pageRank.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.pageRank.stream(G: Graph, *, nodeLabels=['*'], relationshipTypes=['*'], concurrency=4, jobId=None, logProgress=True, dampingFactor=0.85, maxIterations=20, tolerance=0.0000001, relationshipWeightProperty=None, sourceNodes=[], scaler=None) -> DataFrame Page Rank is an algorithm that measures the transitive influence or connectivity of nodes. @@ -3716,555 +1844,237 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.pageRank.write(G: Graph, **config: Any) -> Series[Any] Page Rank is an algorithm that measures the transitive influence or connectivity of nodes. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.pageRank.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.randomWalk.stats(G: Graph, **config: Any) -> Series[Any] Random Walk is an algorithm that provides random paths in a graph. It’s similar to how a drunk person traverses a city. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.randomWalk.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.randomWalk.stream(G: Graph, **config: Any) -> DataFrame Random Walk is an algorithm that provides random paths in a graph. It’s similar to how a drunk person traverses a city. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.randomWalk.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.shortestPath.astar.mutate(G: Graph, **config: Any) -> Series[Any] The A* shortest path algorithm computes the shortest path between a pair of nodes. It uses the relationship weight property to compare path lengths. In addition, this implementation uses the haversine distance as a heuristic to converge faster. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.shortestPath.astar.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.shortestPath.astar.stream(G: Graph, **config: Any) -> DataFrame The A* shortest path algorithm computes the shortest path between a pair of nodes. It uses the relationship weight property to compare path lengths. In addition, this implementation uses the haversine distance as a heuristic to converge faster. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.shortestPath.astar.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.shortestPath.astar.write(G: Graph, **config: Any) -> Series[Any] The A* shortest path algorithm computes the shortest path between a pair of nodes. It uses the relationship weight property to compare path lengths. In addition, this implementation uses the haversine distance as a heuristic to converge faster. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.shortestPath.astar.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.shortestPath.dijkstra.mutate(G: Graph, **config: Any) -> Series[Any] The Dijkstra shortest path algorithm computes the shortest (weighted) path between a pair of nodes. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.shortestPath.dijkstra.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.shortestPath.dijkstra.stream(G: Graph, **config: Any) -> DataFrame The Dijkstra shortest path algorithm computes the shortest (weighted) path between a pair of nodes. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.shortestPath.dijkstra.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.shortestPath.dijkstra.write(G: Graph, **config: Any) -> Series[Any] The Dijkstra shortest path algorithm computes the shortest (weighted) path between a pair of nodes. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.shortestPath.dijkstra.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.shortestPath.yens.mutate(G: Graph, **config: Any) -> Series[Any] The Yen's shortest path algorithm computes the k shortest (weighted) paths between a pair of nodes. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.shortestPath.yens.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.shortestPath.yens.stream(G: Graph, **config: Any) -> DataFrame The Yen's shortest path algorithm computes the k shortest (weighted) paths between a pair of nodes. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.shortestPath.yens.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.shortestPath.yens.write(G: Graph, **config: Any) -> Series[Any] The Yen's shortest path algorithm computes the k shortest (weighted) paths between a pair of nodes. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.shortestPath.yens.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.sllpa.mutate(G: Graph, **config: Any) -> Series[Any] The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.sllpa.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - -.. py:function:: gds.sllpa.stats(G: Graph, **config: Any) -> Series[Any] - - The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph. - - | - - **Parameters:** - - * **G** - Graph - -.. py:function:: gds.sllpa.stats.estimate(G: Graph, **config: Any) -> Series[Any] - - Returns an estimation of the memory consumption for that procedure. - - | - - **Parameters:** - - * **G** - Graph - -.. py:function:: gds.sllpa.stream(G: Graph, **config: Any) -> DataFrame +.. py:function:: gds.sllpa.stats(G: Graph, **config: Any) -> Series[Any] The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph. - | +.. py:function:: gds.sllpa.stats.estimate(G: Graph, **config: Any) -> Series[Any] - **Parameters:** + Returns an estimation of the memory consumption for that procedure. - * **G** - Graph +.. py:function:: gds.sllpa.stream(G: Graph, **config: Any) -> DataFrame + + The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph. .. py:function:: gds.sllpa.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.sllpa.write(G: Graph, **config: Any) -> Series[Any] The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.sllpa.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.spanningTree.mutate(G: Graph, **config: Any) -> Series[Any] The spanning tree algorithm visits all nodes that are in the same connected component as the starting node, and returns a spanning tree of all nodes in the component where the total weight of the relationships is either minimized or maximized. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.spanningTree.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.spanningTree.stats(G: Graph, **config: Any) -> Series[Any] The spanning tree algorithm visits all nodes that are in the same connected component as the starting node, and returns a spanning tree of all nodes in the component where the total weight of the relationships is either minimized or maximized. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.spanningTree.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.spanningTree.stream(G: Graph, **config: Any) -> DataFrame The spanning tree algorithm visits all nodes that are in the same connected component as the starting node, and returns a spanning tree of all nodes in the component where the total weight of the relationships is either minimized or maximized. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.spanningTree.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.spanningTree.write(G: Graph, **config: Any) -> Series[Any] The spanning tree algorithm visits all nodes that are in the same connected component as the starting node, and returns a spanning tree of all nodes in the component where the total weight of the relationships is either minimized or maximized. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.spanningTree.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.steinerTree.mutate(G: Graph, **config: Any) -> Series[Any] The steiner tree algorithm accepts a source node, as well as a list of target nodes. It then attempts to find a spanning tree where there is a path from the source node to each target node, such that the total weight of the relationships is as low as possible. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.steinerTree.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.steinerTree.stats(G: Graph, **config: Any) -> Series[Any] The steiner tree algorithm accepts a source node, as well as a list of target nodes. It then attempts to find a spanning tree where there is a path from the source node to each target node, such that the total weight of the relationships is as low as possible. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.steinerTree.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.steinerTree.stream(G: Graph, **config: Any) -> DataFrame The steiner tree algorithm accepts a source node, as well as a list of target nodes. It then attempts to find a spanning tree where there is a path from the source node to each target node, such that the total weight of the relationships is as low as possible. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.steinerTree.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.steinerTree.write(G: Graph, **config: Any) -> Series[Any] The steiner tree algorithm accepts a source node, as well as a list of target nodes. It then attempts to find a spanning tree where there is a path from the source node to each target node, such that the total weight of the relationships is as low as possible. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.steinerTree.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.triangleCount.mutate(G: Graph, **config: Any) -> Series[Any] Triangle counting is a community detection graph algorithm that is used to determine the number of triangles passing through each node in the graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.triangleCount.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.triangleCount.stats(G: Graph, **config: Any) -> Series[Any] Triangle counting is a community detection graph algorithm that is used to determine the number of triangles passing through each node in the graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.triangleCount.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.triangleCount.stream(G: Graph, *, nodeLabels=['*'], relationshipTypes=['*'], concurrency=4, jobId=None, logProgress=True, maxDegree=2^63^ - 1) -> DataFrame Triangle counting is a community detection graph algorithm that is used to @@ -4294,198 +2104,76 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.triangleCount.write(G: Graph, **config: Any) -> Series[Any] Triangle counting is a community detection graph algorithm that is used to determine the number of triangles passing through each node in the graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.triangleCount.write.estimate(G: Graph, **config: Any) -> Series[Any] Triangle counting is a community detection graph algorithm that is used to determine the number of triangles passing through each node in the graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.triangles(G: Graph, **config: Any) -> DataFrame Triangles streams the nodeIds of each triangle in the graph. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.wcc.mutate(G: Graph, **config: Any) -> Series[Any] The WCC algorithm finds sets of connected nodes in an undirected graph, where all nodes in the same set form a connected component. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.wcc.mutate.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.wcc.stats(G: Graph, **config: Any) -> Series[Any] Executes the algorithm and returns result statistics without writing the result to Neo4j. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.wcc.stats.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.wcc.stream(G: Graph, **config: Any) -> DataFrame The WCC algorithm finds sets of connected nodes in an undirected graph, where all nodes in the same set form a connected component. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.wcc.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.wcc.write(G: Graph, **config: Any) -> Series[Any] The WCC algorithm finds sets of connected nodes in an undirected graph, where all nodes in the same set form a connected component. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.wcc.write.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. - | - - **Parameters:** - - * **G** - Graph - .. py:function:: gds.alpha.linkprediction.adamicAdar(node1: int, node2: int, **config: Any) -> float Given two nodes, calculate Adamic Adar similarity - | - - **Parameters:** - - * **node1** - int - - * **node2** - int - .. py:function:: gds.alpha.linkprediction.commonNeighbors(node1: int, node2: int, **config: Any) -> float Given two nodes, returns the number of common neighbors - | - - **Parameters:** - - * **node1** - int - - * **node2** - int - .. py:function:: gds.alpha.linkprediction.preferentialAttachment(node1: int, node2: int, **config: Any) -> float Given two nodes, calculate Preferential Attachment - | - - **Parameters:** - - * **node1** - int - - * **node2** - int - .. py:function:: gds.alpha.linkprediction.resourceAllocation(node1: int, node2: int, **config: Any) -> float Given two nodes, calculate Resource Allocation similarity - | - - **Parameters:** - - * **node1** - int - - * **node2** - int - .. py:function:: gds.alpha.linkprediction.sameCommunity(node1: int, node2: int, communityProperty: Optional[str] = None) -> float Given two nodes, indicates if they have the same community - | - - **Parameters:** - - * **node1** - int - - * **node2** - int - - * **communityProperty** - Optional[str] = None - .. py:function:: gds.alpha.linkprediction.totalNeighbors(node1: int, node2: int, **config: Any) -> float Given two nodes, calculate Total Neighbors - | - - **Parameters:** - - * **node1** - int - - * **node2** - int - From 8da411a38ab90a69aaca9da766e98c32f5a7897a Mon Sep 17 00:00:00 2001 From: Nicola Vitucci Date: Wed, 14 Aug 2024 16:23:28 +0100 Subject: [PATCH 21/21] Add new algos --- doc/sphinx/algorithms-conf.json | 12 +++++++++ doc/sphinx/create_algorithms_rst.py | 2 ++ doc/sphinx/source/algorithms.rst | 40 +++++++++++++++++++++++++++-- 3 files changed, 52 insertions(+), 2 deletions(-) diff --git a/doc/sphinx/algorithms-conf.json b/doc/sphinx/algorithms-conf.json index 6c0b8f366..5d9ef51ac 100644 --- a/doc/sphinx/algorithms-conf.json +++ b/doc/sphinx/algorithms-conf.json @@ -92,6 +92,12 @@ ], "page_path": "algorithms/article-rank/" }, + { + "name": "Articulation Points", + "procedure": "gds.articulationPoints", + "config": [], + "page_path": "algorithms/articulation-points/" + }, { "name": "Betweenness Centrality", "procedure": "gds.betweenness", @@ -120,6 +126,12 @@ ], "page_path": "algorithms/betweenness-centrality/" }, + { + "name": "Bridges", + "procedure": "gds.bridges", + "config": [], + "page_path": "algorithms/bridges/" + }, { "name": "CELF", "procedure": "gds.influenceMaximization.celf", diff --git a/doc/sphinx/create_algorithms_rst.py b/doc/sphinx/create_algorithms_rst.py index 5b6611693..a3c5bd4cf 100644 --- a/doc/sphinx/create_algorithms_rst.py +++ b/doc/sphinx/create_algorithms_rst.py @@ -3,7 +3,9 @@ INCLUDED_ALGORITHMS = { "Article Rank", + "Articulation Points", "Betweenness Centrality", + "Bridges", # "CELF", # "Closeness Centrality", "Degree Centrality", diff --git a/doc/sphinx/source/algorithms.rst b/doc/sphinx/source/algorithms.rst index 07b94d8b7..fcd4f10b2 100644 --- a/doc/sphinx/source/algorithms.rst +++ b/doc/sphinx/source/algorithms.rst @@ -458,10 +458,28 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g Returns an estimation of the memory consumption for that procedure. -.. py:function:: gds.articulationPoints.stream(G: Graph, **config: Any) -> Series[Any] +.. py:function:: gds.articulationPoints.stream(G: Graph, *, nodeLabels=['*'], relationshipTypes=['*'], concurrency=4, jobId=None, logProgress=True) -> Series[Any] Articulation Points is an algorithm that finds nodes that disconnect components if removed. + | + + **Parameters:** + + * **G** - Graph + + * **nodeLabels** - *(Optional)* Filter the named graph using the given node labels. Nodes with any of the given labels will be included. *Default*: ['*']. + + * **relationshipTypes** - *(Optional)* Filter the named graph using the given relationship types. Relationships with any of the given types will be included. *Default*: ['*']. + + * **concurrency** - *(Optional)* The number of concurrent threads used for running the algorithm. *Default*: 4. + + * **jobId** - *(Optional)* An ID that can be provided to more easily track the algorithm’s progress. *Default*: None (Generated internally). + + * **logProgress** - *(Optional)* If disabled the progress percentage will not be logged. *Default*: True. + + + .. py:function:: gds.articulationPoints.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure. @@ -946,10 +964,28 @@ These all assume that an object of :class:`.GraphDataScience` is available as `g BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level. -.. py:function:: gds.bridges.stream(G: Graph, **config: Any) -> Series[Any] +.. py:function:: gds.bridges.stream(G: Graph, *, nodeLabels=['*'], relationshipTypes=['*'], concurrency=4, jobId=None, logProgress=True) -> Series[Any] An algorithm to find Bridge edges in a graph. + | + + **Parameters:** + + * **G** - Graph + + * **nodeLabels** - *(Optional)* Filter the named graph using the given node labels. Nodes with any of the given labels will be included. *Default*: ['*']. + + * **relationshipTypes** - *(Optional)* Filter the named graph using the given relationship types. Relationships with any of the given types will be included. *Default*: ['*']. + + * **concurrency** - *(Optional)* The number of concurrent threads used for running the algorithm. *Default*: 4. + + * **jobId** - *(Optional)* An ID that can be provided to more easily track the algorithm’s progress. *Default*: None (Generated internally). + + * **logProgress** - *(Optional)* If disabled the progress percentage will not be logged. *Default*: True. + + + .. py:function:: gds.bridges.stream.estimate(G: Graph, **config: Any) -> Series[Any] Returns an estimation of the memory consumption for that procedure.