graphoskop 0.4.8__tar.gz

graphoskop-0.4.8/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: graphoskop
+Version: 0.4.8
+Summary: Analysis of networks and of vectors defined on their nodes.
+Project-URL: Homepage, https://github.com/mikk-c/graphoskop
+Project-URL: Issues, https://github.com/mikk-c/graphoskop/issues
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scipy
+Requires-Dist: torch
+Requires-Dist: torch_geometric
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinx_rtd_theme; extra == "docs"
+
+# Graphoskop
+
+Analysis of networks and of vectors defined on their nodes.
+
+## Install
+
+    pip install graphoskop
+
+## Usage
+
+    import graphoskop as gsk
+    net = gsk.load_network("edges.tsv", "nodes.tsv")
+    net = gsk.load_network(edges_df, nodes_df)          # or from pandas DataFrames
+    edges_df, nodes_df = net.to_pandas_dataframes()     # and back
+    gsk.save_network(net, "out/net")                    # out/net_edges.tsv, out/net_nodes.tsv (and _interlayer.tsv)
+    gsk.save_network(net, "out/net", pickle = True)     # out/net.pt, read with gsk.load_pickled_network
+
+Directed networks can be symmetrized, combining the attributes of the two directions:
+
+    und = gsk.to_undirected(net, combine = "sum")       # or "mean", "max"; sign: disagree = "zero", "positive", "negative"
+    core = gsk.remove_isolates(net)                     # drop nodes without edges
+    clean = gsk.remove_self_loops(net)                  # drop edges from a node to itself
+    simple = gsk.remove_parallel_edges(net)             # merge parallel edges (same direction, same layer)
+    ego = gsk.subgraph(net, ["alice", "bob"])           # induced subgraph
+    scc = gsk.to_strongly_connected(net)                # directed: split into strongly connected components
+
+Degree and clustering:
+
+    gsk.connected_components_count(net, type = "strong"), gsk.connected_components_nodes(net)
+    gsk.degree(net, "alice"), gsk.degree(net, distribution = "ccdf")
+    gsk.degree(net, "alice", weight = "weight")         # weighted degree (strength)
+    gsk.degree_power_law(net)                           # exponent, k_min and cutoff, after likelihood ratio tests (Clauset et al.)
+    gsk.degree_power_law(net, ccdf = True)["ccdf"]     # empirical and fitted ccdf, to plot
+    gsk.degree_power_law(net)["formula"]                # best fit written out, e.g. "P(k) = 0.27 * k^(-2.37) / 0.026, for k >= 12"
+    gsk.degree_centralization(net)["centralization"]    # degree entropy vs random networks of the same size
+    gsk.average_degree(net)                             # 2m / n (undirected), m / n (directed)
+    gsk.density(net)                                    # also directed, bipartite, multilayer (per layer)
+    gsk.reciprocity(net), gsk.reciprocity(net, normalized = True)   # directed networks
+    gsk.average_shortest_path_length(net)               # same paths as the shortest_paths module
+    gsk.shortest_path_length_distribution(net)          # number of node pairs at each distance (edges)
+    gsk.diameter(net)                                   # longest shortest path
+    net.is_planar()                                     # drawable without edge crossings
+    gsk.maximally_filtered_graph(net, "weight")         # planar backbone (PMFG), a new network
+    gsk.triangulated_filtered_graph(net, "weight")      # faster planar backbone (TMFG), on the GPU
+    gsk.bfs(net, "alice", max_depth = 2), gsk.dfs(net, "alice")   # exploration: node, depth, parent in visit order
+
+Random walks: `gsk.stationary_distribution(net)`, `gsk.effective_resistance(net)`, and hitting times
+`H = gsk.hitting_time(net)` (`H[i, j]`: expected steps from `i` to reach `j`; `alpha` for teleportation).
+
+Centralities (closeness, harmonic, betweenness of nodes and edges) can share precomputed shortest path lengths:
+
+    P = gsk.all_pairs_shortest_path_lengths(net)
+    b = gsk.betweenness_centrality(net, lengths = P)    # also closeness_centrality, harmonic_centrality
+    eb = gsk.edge_betweenness_centrality(net, lengths = P)   # per stored edge: net.set_edge_attribute("eb", eb)
+    c = gsk.closeness_centrality(net, component = None, lin = True)   # all components, comparable
+    f = gsk.flow_centrality(net)                        # random walk betweenness (Newman, 2005)
+    gsk.eigenvector_centrality(net, weight = "weight")   # power iteration on the device
+    gsk.pagerank(net, component = None, personalization = {"alice": 1})   # personalized PageRank
+    hubs, authorities = gsk.hits(net)                   # HITS
+    gsk.k_core_centrality(net)                          # core number of every node
+    gsk.centralization(net, gsk.betweenness_centrality)   # Freeman centralization of any centrality
+    gsk.structural_equivalence(net, "alice", "bob")   # Jaccard coefficient of their neighbors
+    gsk.automorphic_equivalence(net, "alice", "bob")  # 1 if some automorphism swaps them
+    gsk.pairwise_structural_equivalence(net), gsk.pairwise_automorphic_equivalence(net)   # all pairs, n x n
+    gsk.pairwise_regular_equivalence(dnet)              # REGE: directed or valued networks
+    gsk.pairwise_path_regular_equivalence(net, alpha = 0.97)   # Leicht, Holme and Newman similarity
+    gsk.katz_centrality(net, alpha = 0.05)              # alpha below 1 / largest eigenvalue
+    gsk.alpha_centrality(net, alpha = 0.5, exo = "wealth")   # Bonacich alpha centrality, any alpha
+    gsk.reach_centrality(dnet)                          # directed networks: fraction of nodes reached
+    gsk.global_reach_centrality(dnet)                   # hierarchy of a directed network
+    gsk.modularity(net, "party")                        # partition from a node attribute, a dict or a list
+    gsk.maximal_cliques(net)                            # node sets of maximal cliques with 3+ nodes
+    gsk.graph_coloring(net), gsk.maximum_independent_set(net)   # exact when proven within time_limit
+    gsk.local_clustering(net, "alice")                  # or a vector over a component
+    gsk.global_clustering(net), gsk.average_clustering(net)
+    gsk.assortativity(net), gsk.assortativity(net, "age"), gsk.assortativity(net, "city")   # degree, numeric, qualitative
+
+Numeric node attributes go to the chosen `device` (e.g. `"cuda"`); qualitative ones (strings,
+categories) always stay in CPU memory.
+
+Bipartite networks need a `bipartite_type` column in the node table, with two values:
+
+    net = gsk.load_network("edges.tsv", "nodes.tsv", bipartite = True)
+    users = gsk.simple_count_projection(net, "user")   # projection onto the "user" nodes
+    users = gsk.hyperbolic_projection(net, "user")     # also hist_intersection_projection
+    items = gsk.resource_allocation_projection(net, "item", lambd = 1)   # ProbS; 0 HeatS, 0.5 hybrid
+    items = gsk.random_walk_projection(net, "item")    # YCN random walks
+
+Multilayer networks need a `layer` column in the edge table; nodes become copies `(entity, layer)`:
+
+    net = gsk.load_network("edges.tsv", "nodes.tsv", multilayer = True, coupling = "all")   # or "ordinal", "temporal"
+    gsk.laplacian(net)                                  # supra-Laplacian
+    gsk.degree(net, ("alice", "work")), gsk.degree(net, "alice")   # in one layer, summed over layers
+    work = gsk.layer_network(net, "work")               # one layer as an ordinary network
+    flat = gsk.aggregate_network(net)                   # all layers flattened
+
+Signed networks carry a +1 / -1 `sign` edge attribute; build them from a positive and a negative
+layer, or by thresholding an edge weight:
+
+    signed = gsk.signed_network(net, positive = "ally", negative = "enemy")   # multilayer net
+    signed = gsk.signed_network(net, weight = "score", threshold = 0)         # >= 0 positive
+    A = gsk.signed_adjacency(signed)                    # sparse, per component
+    gsk.structural_balance(signed)                      # Tr(A^3) / Tr(|A|^3)
+    gsk.structural_balance(signed, beta = 0.5)          # Tr(e^(beta A)) / Tr(e^(beta |A|)), all closed walks
+    gsk.signed_triangle_counts(signed)                  # per sign pattern, vs. shuffled signs (exact)
+
+Synthetic networks: every generator takes its parameters, or an existing network to randomize
+(same nodes and attributes, new random edges, edge attributes shuffled over them):
+
+    g = gsk.gnm_random_graph(1000, 5000, seed = 1)       # random: 1000 nodes, 5000 random edges
+    g = gsk.gnp_random_graph(1000, 0.01, seed = 1)       # random: each pair an edge with probability 0.01
+    b = gsk.gnm_random_graph((100, 300), 1000)           # bipartite
+    c = gsk.caveman_graph(10, 5, connected = True)       # clustered: 10 cliques of 5 in a ring; node attribute "cave"
+    w = gsk.watts_strogatz_graph(1000, 6, 0.1)           # clustered: small world; rewire = "target", "both" or "add"
+    ba = gsk.barabasi_albert_graph(10000, 6)             # broad degree: preferential attachment, average degree 6 (m = 3)
+    ls = gsk.link_selection_graph(10000, 6)              # broad degree: new nodes link to an end of random links
+    cp = gsk.copying_graph(10000, 6)                     # broad degree: new nodes copy a link of random nodes
+    hk = gsk.holme_kim_graph(10000, 6, 0.8)              # broad degree with clustering: triangles closed with probability 0.8
+    rnd = gsk.gnm_random_graph(net = net)                # randomization of net, same n and m
+    rnd = gsk.gnp_random_graph(net = net)                # same n, p = density of net
+    rnd = gsk.caveman_graph(net = net)                   # nodes in random caves, cave size from the average degree
+    rnd = gsk.watts_strogatz_graph(net = net, p = 0.1)   # nodes on a ring, same n and m, then rewired
+    rnd = gsk.barabasi_albert_graph(net = net)           # same n and m, nodes arrive in random order
+    rnd = gsk.link_selection_graph(net = net)            # same n and m, nodes arrive in random order
+    rnd = gsk.copying_graph(net = net)                   # same n and m, nodes arrive in random order
+    rnd = gsk.holme_kim_graph(net = net)                 # same n, m and average clustering (p inferred)
+

graphoskop-0.4.8/README.md

@@ -0,0 +1,127 @@
+# Graphoskop
+
+Analysis of networks and of vectors defined on their nodes.
+
+## Install
+
+    pip install graphoskop
+
+## Usage
+
+    import graphoskop as gsk
+    net = gsk.load_network("edges.tsv", "nodes.tsv")
+    net = gsk.load_network(edges_df, nodes_df)          # or from pandas DataFrames
+    edges_df, nodes_df = net.to_pandas_dataframes()     # and back
+    gsk.save_network(net, "out/net")                    # out/net_edges.tsv, out/net_nodes.tsv (and _interlayer.tsv)
+    gsk.save_network(net, "out/net", pickle = True)     # out/net.pt, read with gsk.load_pickled_network
+
+Directed networks can be symmetrized, combining the attributes of the two directions:
+
+    und = gsk.to_undirected(net, combine = "sum")       # or "mean", "max"; sign: disagree = "zero", "positive", "negative"
+    core = gsk.remove_isolates(net)                     # drop nodes without edges
+    clean = gsk.remove_self_loops(net)                  # drop edges from a node to itself
+    simple = gsk.remove_parallel_edges(net)             # merge parallel edges (same direction, same layer)
+    ego = gsk.subgraph(net, ["alice", "bob"])           # induced subgraph
+    scc = gsk.to_strongly_connected(net)                # directed: split into strongly connected components
+
+Degree and clustering:
+
+    gsk.connected_components_count(net, type = "strong"), gsk.connected_components_nodes(net)
+    gsk.degree(net, "alice"), gsk.degree(net, distribution = "ccdf")
+    gsk.degree(net, "alice", weight = "weight")         # weighted degree (strength)
+    gsk.degree_power_law(net)                           # exponent, k_min and cutoff, after likelihood ratio tests (Clauset et al.)
+    gsk.degree_power_law(net, ccdf = True)["ccdf"]     # empirical and fitted ccdf, to plot
+    gsk.degree_power_law(net)["formula"]                # best fit written out, e.g. "P(k) = 0.27 * k^(-2.37) / 0.026, for k >= 12"
+    gsk.degree_centralization(net)["centralization"]    # degree entropy vs random networks of the same size
+    gsk.average_degree(net)                             # 2m / n (undirected), m / n (directed)
+    gsk.density(net)                                    # also directed, bipartite, multilayer (per layer)
+    gsk.reciprocity(net), gsk.reciprocity(net, normalized = True)   # directed networks
+    gsk.average_shortest_path_length(net)               # same paths as the shortest_paths module
+    gsk.shortest_path_length_distribution(net)          # number of node pairs at each distance (edges)
+    gsk.diameter(net)                                   # longest shortest path
+    net.is_planar()                                     # drawable without edge crossings
+    gsk.maximally_filtered_graph(net, "weight")         # planar backbone (PMFG), a new network
+    gsk.triangulated_filtered_graph(net, "weight")      # faster planar backbone (TMFG), on the GPU
+    gsk.bfs(net, "alice", max_depth = 2), gsk.dfs(net, "alice")   # exploration: node, depth, parent in visit order
+
+Random walks: `gsk.stationary_distribution(net)`, `gsk.effective_resistance(net)`, and hitting times
+`H = gsk.hitting_time(net)` (`H[i, j]`: expected steps from `i` to reach `j`; `alpha` for teleportation).
+
+Centralities (closeness, harmonic, betweenness of nodes and edges) can share precomputed shortest path lengths:
+
+    P = gsk.all_pairs_shortest_path_lengths(net)
+    b = gsk.betweenness_centrality(net, lengths = P)    # also closeness_centrality, harmonic_centrality
+    eb = gsk.edge_betweenness_centrality(net, lengths = P)   # per stored edge: net.set_edge_attribute("eb", eb)
+    c = gsk.closeness_centrality(net, component = None, lin = True)   # all components, comparable
+    f = gsk.flow_centrality(net)                        # random walk betweenness (Newman, 2005)
+    gsk.eigenvector_centrality(net, weight = "weight")   # power iteration on the device
+    gsk.pagerank(net, component = None, personalization = {"alice": 1})   # personalized PageRank
+    hubs, authorities = gsk.hits(net)                   # HITS
+    gsk.k_core_centrality(net)                          # core number of every node
+    gsk.centralization(net, gsk.betweenness_centrality)   # Freeman centralization of any centrality
+    gsk.structural_equivalence(net, "alice", "bob")   # Jaccard coefficient of their neighbors
+    gsk.automorphic_equivalence(net, "alice", "bob")  # 1 if some automorphism swaps them
+    gsk.pairwise_structural_equivalence(net), gsk.pairwise_automorphic_equivalence(net)   # all pairs, n x n
+    gsk.pairwise_regular_equivalence(dnet)              # REGE: directed or valued networks
+    gsk.pairwise_path_regular_equivalence(net, alpha = 0.97)   # Leicht, Holme and Newman similarity
+    gsk.katz_centrality(net, alpha = 0.05)              # alpha below 1 / largest eigenvalue
+    gsk.alpha_centrality(net, alpha = 0.5, exo = "wealth")   # Bonacich alpha centrality, any alpha
+    gsk.reach_centrality(dnet)                          # directed networks: fraction of nodes reached
+    gsk.global_reach_centrality(dnet)                   # hierarchy of a directed network
+    gsk.modularity(net, "party")                        # partition from a node attribute, a dict or a list
+    gsk.maximal_cliques(net)                            # node sets of maximal cliques with 3+ nodes
+    gsk.graph_coloring(net), gsk.maximum_independent_set(net)   # exact when proven within time_limit
+    gsk.local_clustering(net, "alice")                  # or a vector over a component
+    gsk.global_clustering(net), gsk.average_clustering(net)
+    gsk.assortativity(net), gsk.assortativity(net, "age"), gsk.assortativity(net, "city")   # degree, numeric, qualitative
+
+Numeric node attributes go to the chosen `device` (e.g. `"cuda"`); qualitative ones (strings,
+categories) always stay in CPU memory.
+
+Bipartite networks need a `bipartite_type` column in the node table, with two values:
+
+    net = gsk.load_network("edges.tsv", "nodes.tsv", bipartite = True)
+    users = gsk.simple_count_projection(net, "user")   # projection onto the "user" nodes
+    users = gsk.hyperbolic_projection(net, "user")     # also hist_intersection_projection
+    items = gsk.resource_allocation_projection(net, "item", lambd = 1)   # ProbS; 0 HeatS, 0.5 hybrid
+    items = gsk.random_walk_projection(net, "item")    # YCN random walks
+
+Multilayer networks need a `layer` column in the edge table; nodes become copies `(entity, layer)`:
+
+    net = gsk.load_network("edges.tsv", "nodes.tsv", multilayer = True, coupling = "all")   # or "ordinal", "temporal"
+    gsk.laplacian(net)                                  # supra-Laplacian
+    gsk.degree(net, ("alice", "work")), gsk.degree(net, "alice")   # in one layer, summed over layers
+    work = gsk.layer_network(net, "work")               # one layer as an ordinary network
+    flat = gsk.aggregate_network(net)                   # all layers flattened
+
+Signed networks carry a +1 / -1 `sign` edge attribute; build them from a positive and a negative
+layer, or by thresholding an edge weight:
+
+    signed = gsk.signed_network(net, positive = "ally", negative = "enemy")   # multilayer net
+    signed = gsk.signed_network(net, weight = "score", threshold = 0)         # >= 0 positive
+    A = gsk.signed_adjacency(signed)                    # sparse, per component
+    gsk.structural_balance(signed)                      # Tr(A^3) / Tr(|A|^3)
+    gsk.structural_balance(signed, beta = 0.5)          # Tr(e^(beta A)) / Tr(e^(beta |A|)), all closed walks
+    gsk.signed_triangle_counts(signed)                  # per sign pattern, vs. shuffled signs (exact)
+
+Synthetic networks: every generator takes its parameters, or an existing network to randomize
+(same nodes and attributes, new random edges, edge attributes shuffled over them):
+
+    g = gsk.gnm_random_graph(1000, 5000, seed = 1)       # random: 1000 nodes, 5000 random edges
+    g = gsk.gnp_random_graph(1000, 0.01, seed = 1)       # random: each pair an edge with probability 0.01
+    b = gsk.gnm_random_graph((100, 300), 1000)           # bipartite
+    c = gsk.caveman_graph(10, 5, connected = True)       # clustered: 10 cliques of 5 in a ring; node attribute "cave"
+    w = gsk.watts_strogatz_graph(1000, 6, 0.1)           # clustered: small world; rewire = "target", "both" or "add"
+    ba = gsk.barabasi_albert_graph(10000, 6)             # broad degree: preferential attachment, average degree 6 (m = 3)
+    ls = gsk.link_selection_graph(10000, 6)              # broad degree: new nodes link to an end of random links
+    cp = gsk.copying_graph(10000, 6)                     # broad degree: new nodes copy a link of random nodes
+    hk = gsk.holme_kim_graph(10000, 6, 0.8)              # broad degree with clustering: triangles closed with probability 0.8
+    rnd = gsk.gnm_random_graph(net = net)                # randomization of net, same n and m
+    rnd = gsk.gnp_random_graph(net = net)                # same n, p = density of net
+    rnd = gsk.caveman_graph(net = net)                   # nodes in random caves, cave size from the average degree
+    rnd = gsk.watts_strogatz_graph(net = net, p = 0.1)   # nodes on a ring, same n and m, then rewired
+    rnd = gsk.barabasi_albert_graph(net = net)           # same n and m, nodes arrive in random order
+    rnd = gsk.link_selection_graph(net = net)            # same n and m, nodes arrive in random order
+    rnd = gsk.copying_graph(net = net)                   # same n and m, nodes arrive in random order
+    rnd = gsk.holme_kim_graph(net = net)                 # same n, m and average clustering (p inferred)
+

graphoskop-0.4.8/graphoskop/__init__.py

@@ -0,0 +1,64 @@
+"""
+Graphoskop: analysis of networks and of vectors defined on their nodes.
+
+All public functions and classes are available at the top level of the package.
+
+Quick start, with an edge list ``edges.tsv``::
+
+   source   target   weight
+   alice    bob      1.5
+   bob      carol    2.0
+
+and a node table ``nodes.tsv``::
+
+   id       age   height   city
+   alice    34    170      Rome
+   carol    29    165      Oslo
+
+.. code-block:: python
+
+   import graphoskop as gsk
+
+   net = gsk.load_network("edges.tsv", "nodes.tsv")
+   g = net.components[0]      # largest weakly connected component
+   g.edge_index               # edges, internal node ids
+   g.edge_attr                # weight, one row per edge
+   g.node_attr                # age and height (numeric), one row per node
+   net.qualitative_node_attr  # city (qualitative), always in CPU memory
+   net.node_map["alice"]      # (component, index)
+
+Multilayer networks are loaded with ``multilayer = True`` from an edge list with a ``layer``
+column; nodes are then copies ``(entity, layer)`` (see :doc:`multilayer`). Signed networks carry
+a +1 / -1 sign on their edges, built from a positive and a negative layer or by thresholding a
+weight (see :doc:`signed`).
+
+Synthetic networks come from generators, which can also randomize an existing network, keeping
+its nodes and their attributes (see :doc:`generators`).
+"""
+
+from importlib.metadata import version, PackageNotFoundError
+
+from .network import BIPARTITE, LAYER, Network, load_network, save_network, load_pickled_network
+from .multilayer import layer_network, aggregate_network
+from .transformations import to_undirected, remove_isolates, remove_self_loops, remove_parallel_edges, subgraph, to_strongly_connected
+from .signed import SIGN, signed_network, signed_adjacency, structural_balance, signed_triangle_counts
+from .utils import laplacian, laplacian_pinv, laplacian_solver, stationary_distribution, effective_resistance, hitting_time
+from .shortest_paths import shortest_path, shortest_path_length, single_source_shortest_paths, single_source_shortest_path_lengths, all_pairs_shortest_paths, all_pairs_shortest_path_lengths, shortest_path_length_distribution, diameter
+from .communities import modularity, maximal_cliques
+from .coloring import graph_coloring, maximum_independent_set
+from .exploration import bfs, dfs
+from .centrality import closeness_centrality, harmonic_centrality, betweenness_centrality, edge_betweenness_centrality, flow_centrality, reach_centrality, eigenvector_centrality, pagerank, katz_centrality, alpha_centrality, hits, k_core_centrality, centralization
+from .hierarchy import global_reach_centrality
+from .equivalence import structural_equivalence, automorphic_equivalence, pairwise_structural_equivalence, pairwise_automorphic_equivalence, regular_equivalence, pairwise_regular_equivalence, path_regular_equivalence, pairwise_path_regular_equivalence
+from .network_statistics import connected_components_count, connected_components_nodes, degree, average_degree, degree_power_law, degree_centralization, density, reciprocity, average_shortest_path_length, local_clustering, global_clustering, average_clustering, assortativity
+from .backboning import noise_corrected, disparity_filter, doubly_stochastic, high_salience_skeleton, extract_backbone, test_bb_thresholds, find_bb_thresholds, spanning_tree, maximally_filtered_graph, triangulated_filtered_graph
+from .bipartite_projections import simple_count_projection, hist_intersection_projection, hyperbolic_projection, resource_allocation_projection, random_walk_projection
+from .generators import gnm_random_graph, gnp_random_graph, caveman_graph, watts_strogatz_graph, barabasi_albert_graph, link_selection_graph, copying_graph, holme_kim_graph
+from .node_vector_analysis import generalized_euclidean, pairwise_generalized_euclidean, network_correlation, pairwise_network_correlation, network_variance, network_entropy
+
+try:
+   __version__ = version("graphoskop")
+except PackageNotFoundError:
+   __version__ = "unknown"
+
+__all__ = ["BIPARTITE", "LAYER", "Network", "load_network", "save_network", "load_pickled_network", "layer_network", "aggregate_network", "to_undirected", "remove_isolates", "remove_self_loops", "remove_parallel_edges", "subgraph", "to_strongly_connected", "SIGN", "signed_network", "signed_adjacency", "structural_balance", "signed_triangle_counts", "laplacian", "laplacian_pinv", "laplacian_solver", "stationary_distribution", "generalized_euclidean", "pairwise_generalized_euclidean", "effective_resistance", "hitting_time", "network_correlation", "pairwise_network_correlation", "network_variance", "network_entropy", "shortest_path", "shortest_path_length", "single_source_shortest_paths", "single_source_shortest_path_lengths", "all_pairs_shortest_paths", "all_pairs_shortest_path_lengths", "shortest_path_length_distribution", "diameter", "noise_corrected", "disparity_filter", "doubly_stochastic", "high_salience_skeleton", "extract_backbone", "test_bb_thresholds", "find_bb_thresholds", "spanning_tree", "maximally_filtered_graph", "triangulated_filtered_graph", "connected_components_count", "connected_components_nodes", "degree", "average_degree", "degree_power_law", "degree_centralization", "density", "reciprocity", "average_shortest_path_length", "local_clustering", "global_clustering", "average_clustering", "assortativity", "modularity", "maximal_cliques", "graph_coloring", "maximum_independent_set", "bfs", "dfs", "closeness_centrality", "harmonic_centrality", "betweenness_centrality", "edge_betweenness_centrality", "flow_centrality", "reach_centrality", "eigenvector_centrality", "pagerank", "hits", "k_core_centrality", "centralization", "katz_centrality", "alpha_centrality", "global_reach_centrality", "structural_equivalence", "automorphic_equivalence", "pairwise_structural_equivalence", "pairwise_automorphic_equivalence", "regular_equivalence", "pairwise_regular_equivalence", "path_regular_equivalence", "pairwise_path_regular_equivalence", "simple_count_projection", "hist_intersection_projection", "hyperbolic_projection", "resource_allocation_projection", "random_walk_projection", "gnm_random_graph", "gnp_random_graph", "caveman_graph", "watts_strogatz_graph", "barabasi_albert_graph", "link_selection_graph", "copying_graph", "holme_kim_graph"]