NetworKit User Guide¶

About NetworKit¶

NetworKit is an open-source toolkit for high-performance network analysis. Its aim is to provide tools for the analysis of large networks in the size range from thousands to billions of edges. For this purpose, it implements efficient graph algorithms, many of them parallel to utilize multicore architectures. These are meant to compute standard measures of network analysis, such as degree sequences, clustering coefficients and centrality. In this respect, NetworKit is comparable to packages such as NetworkX, albeit with a focus on parallelism and scalability. NetworKit is also a testbed for algorithm engineering and contains a few novel algorithms from recently published research, especially in the area of community detection.

Introduction¶

This notebook provides an interactive introduction to the features of NetworKit, consisting of text and executable code. We assume that you have read the Readme and successfully built the core library and the Python module. Code cells can be run one by one (e.g. by selecting the cell and pressing shift+enter), or all at once (via the Cell->Run All command). Try running all cells now to verify that NetworKit has been properly built and installed.

Preparation¶

This notebook creates some plots. To show them in the notebook, matplotlib must be imported and we need to activate matplotlib's inline mode:

In [1]:

%matplotlib inline
import matplotlib.pyplot as plt

NetworKit is a hybrid built from C++ and Python code: Its core functionality is implemented in C++ for performance reasons, and then wrapped for Python using the Cython toolchain. This allows us to expose high-performance parallel code as a normal Python module. On the surface, NetworKit is just that and can be imported accordingly:

In [2]:

from networkit import * 

IPython lets us use familiar shell commands in a Python interpreter. Use one of them now to change into the directory of your NetworKit download:

In [4]:

cd /home/cobalt/iPython/NetworKit

/home/cobalt/iPython/NetworKit

Reading and Writing Graphs¶

Let us start by reading a network from a file on disk: PGPgiantcompo.graph. In the course of this tutorial, we are going to work on the PGPgiantcompo network, a social network/web of trust in which nodes are PGP keys and an edge represents a signature from one key on another. It is distributed with NetworKit as a good starting point.

There is a convenient function in the top namespace which tries to guess the input format and select the appropriate reader:

In [5]:

G = readGraph("input/PGPgiantcompo.graph", Format.METIS)
# is the same as: G = readGraph("input/PGPgiantcompo.graph", Format.METIS)

There is a large variety of formats for storing graph data in files. For NetworKit, the currently best supported format is the METIS adjacency format. Various example graphs in this format can be found here. The readGraph function tries to be an intelligent wrapper for various reader classes. In this example, it uses the METISGraphReader which is located in the graphio submodule, alongside other readers. These classes can also be used explicitly:

In [7]:

graphio.METISGraphReader().read("input/PGPgiantcompo.graph");
# is the same as: readGraph("input/PGPgiantcompo.graph", Format.METIS)

Out[7]:

<_NetworKit.Graph at 0xae6c1728>

It is also possible to specify the format for readGraph() and writeGraph(). Supported formats can be found via [graphio.]Format. However, graph formats are most likely only supported as far as the NetworKit::Graph can hold and use the data. Please note, that not all graph formats are supported for reading and writing.

Thus, it is possible to use NetworKit to convert graphs between formats. Let's say I need the previously read PGP graph in the Graphviz format:

In [8]:

graphio.writeGraph(G,"output/PGPgiantcompo.graphviz",Format.GraphViz)

NetworKit also provides a function to convert graphs directly:

In [9]:

graphio.convertGraph(Format.LFR, Format.GML, "input/example.edgelist", "output/example.gml")

converted input/example.edgelist to output/example.gml

The Graph Object¶

Graph is the central class of NetworKit. An object of this type represents an undirected, optionally weighted network. Let us inspect several of the methods which the class provides.

In [10]:

n = G.numberOfNodes()
m = G.numberOfEdges()
print(n, m)

10680 24316

In [11]:

G.toString()

Out[11]:

b'Graph(name=PGPgiantcompo, n=10680, m=24316)'

Nodes are simply integer indices, and edges are pairs of such indices.

In [13]:

V = G.nodes()
print(V[:20])
E = G.edges()
print(E[:20])

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
[(42, 11), (101, 28), (111, 92), (128, 87), (141, 0), (165, 125), (169, 111), (176, 143), (187, 38), (192, 105), (236, 33), (263, 224), (267, 219), (274, 22), (275, 111), (343, 92), (343, 111), (347, 139), (347, 179), (349, 327)]

In [15]:

G.hasEdge(42, 11)

Out[15]:

True

This network is unweighted, meaning that each edge has the default weight of 1.

In [17]:

G.weight(42, 11)

Out[17]:

1.0

Drawing Graphs¶

Network Properties Overview¶

We now demonstrate the properties module, which contains tools that will give you an overview of standard properties of a network.

For a quick overview of the most frequently used properties, call the following function:

In [18]:

properties.overview(G)

/home/cobalt/iPython/NetworKit/networkit/powerlaw.py:546: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
  if data!=None and not (parameter_range and self.parent_Fit):
/home/cobalt/iPython/NetworKit/networkit/powerlaw.py:1047: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
  if data==None and hasattr(self, 'parent_Fit'):
/home/cobalt/iPython/NetworKit/networkit/powerlaw.py:598: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
  if data==None and hasattr(self, 'parent_Fit'):
/home/cobalt/iPython/NetworKit/networkit/powerlaw.py:671: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
  if data==None and hasattr(self, 'parent_Fit'):
/home/cobalt/iPython/NetworKit/networkit/powerlaw.py:556: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
  if data==None and hasattr(self, 'parent_Fit'):

Calculating best minimal value for power law fit
<_NetworKit.PLM object at 0xae564f6c>

Network Properties: PGPgiantcompo
==================
Basic Properties
-------------------------  ----------------
nodes, edges               10680, 24316
directed?                  False
weighted?                  False
isolated nodes             0
self-loops                 0
density                    0.000426
clustering coefficient     0.446365
max. core number           31
connected components       1
size of largest component  10680 (100.00 %)
estimated diameter range   (24, 24)
-------------------------  ----------------
Node Degree Properties
-----------------------------  --------------------
min./max. degree               (1, 205)
avg. degree                    4.553558
power law?, likelihood, gamma  True, 2.0415, 4.4185
degree assortativity           0.2382
-----------------------------  --------------------
Community Structure
-------------------------  -----------  --------
community detection (PLM)
                           communities  107
                           modularity   0.882111
-------------------------  -----------  --------
Degree Distribution
-------------------
0-   :  â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡9394.00
9-   :  â–‡â–‡â–‡â–‡ 781.00
18-  :  â–‡ 240.00
27-  :  | 101.00
36-  :  |  91.00
45-  :  |  28.00
54-  :  |  17.00
63-  :  |  12.00
72-  :  |   5.00
81-  :  |   3.00
90-  :  |   2.00
99-  :  |   1.00
108- :  |   2.00
117- :  |   0.00
126- :  |   1.00
135- :  |   0.00
144- :  |   0.00
153- :  |   0.00
162- :  |   1.00
171- :  |   0.00
180- :  |   0.00
189- :  |   0.00
198- :  |   1.00
207- :  |   0.00
216- :  |   0.00

/home/cobalt/iPython/NetworKit/networkit/powerlaw.py:1166: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
  if data==None and hasattr(self, 'parent_Fit'):
/home/cobalt/iPython/NetworKit/networkit/powerlaw.py:725: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
  if data==None and hasattr(self, 'parent_Fit'):

Some values are missing because it was decided that calculation would take too long for this particular graph. We are working on adding efficient algorithms so that even large networks can be profiled in seconds.

Connected Components¶

A connected component is a set of nodes in which each pair of nodes is connected by a path. The following function determines the connected components of a graph and returns the number of components as well as a map from component index to component size:

In [19]:

properties.components(G)

Out[19]:

(1, {0: 10680})

For more fine-grained access, one can use the connected component algorithm class directly, i.e. the wrapper around the underlying C++ implementation. This is a recurring pattern throughout NetworKit.

In [20]:

cc = properties.ConnectedComponents(G)
cc.run()
print("number of components ", cc.numberOfComponents())
v = 0
print("component of node ", v , ": " , cc.componentOfNode(0))
#print("map of component sizes: ", cc.getComponentSizes())

number of components  1
component of node  0 :  0

Degree Distribution¶

Node degree, the number of edges connected to a node, is one of the most studied properties of networks. Types of networks are often characterized in terms of their distribution of node degrees. We obtain and visualize the degree distribution of our example network as follows.

In [21]:

dd = properties.degreeDistribution(G)
plt.xscale("log")
plt.xlabel("degree")
plt.yscale("log")
plt.ylabel("number of nodes")
plt.plot(dd)

Out[21]:

[<matplotlib.lines.Line2D at 0xae3af92c>]

We choose a logarithmic scale on both axes because a powerlaw degree distribution, a characteristic feature of complex networks, would show up as a straight line from the top left to the bottom right on such a plot. As we see, the degree distribution of the PGPgiantcompo network is definitely skewed, with few high-degree nodes and many low-degree nodes. But does the distribution actually obey a power law? In order to study this, we need can apply the powerlaw module that is distributed with NetworKit. Call the following function:

In [22]:

properties.degreePowerLaw(G)

/home/cobalt/iPython/NetworKit/networkit/powerlaw.py:546: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
  if data!=None and not (parameter_range and self.parent_Fit):
/home/cobalt/iPython/NetworKit/networkit/powerlaw.py:1047: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
  if data==None and hasattr(self, 'parent_Fit'):
/home/cobalt/iPython/NetworKit/networkit/powerlaw.py:598: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
  if data==None and hasattr(self, 'parent_Fit'):
/home/cobalt/iPython/NetworKit/networkit/powerlaw.py:671: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
  if data==None and hasattr(self, 'parent_Fit'):
/home/cobalt/iPython/NetworKit/networkit/powerlaw.py:556: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
  if data==None and hasattr(self, 'parent_Fit'):

Calculating best minimal value for power law fit

/home/cobalt/iPython/NetworKit/networkit/powerlaw.py:1166: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
  if data==None and hasattr(self, 'parent_Fit'):
/home/cobalt/iPython/NetworKit/networkit/powerlaw.py:725: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
  if data==None and hasattr(self, 'parent_Fit'):

Out[22]:

(True, 2.0415397435064913, 4.4185071392443582)

In [18]:

properties.degreePowerLaw(G)

Calculating best minimal value for power law fit

Out[18]:

(True, 2.0415397435064913, 4.4185071392443591)

The three return values are a) whether a power law is considered a good fit, b) the goodness of the fit and c) the exponent of the power law distribution. Quoting from the documentation of the powerlaw module, the goodness of the fit is the following:

"R is the loglikelihood ratio between the two candidate distributions. This number will be positive

if the data is more likely in the first distribution, and negative if the data is more likely in the second distribution. The exponential distribution is the absolute minimum alternative candidate for evaluating the heavy- tailedness of the distribution. The reason is definitional: the typical quantitative definition of a â€heavy- tailâ€ is that it is not exponentially bounded. Thus if a power law is not a better fit than an exponential distribution (as in the above example) there is scarce ground for considering the distribution to be heavy-tailed at all, let alone a power law."

Transitivity / Clustering Coefficients¶

In the most general sense, transitivity measures quantify how likely it is that the relations out of which the network is built are transitive. The clustering coefficient is the most prominent of such measures. We need to distinguish between global and local clustering coefficient: The global clustering coefficient for a network gives the fraction of closed triads. The local clustering coefficient focuses on a single node and counts how many of the possible edges between neighbors of the node exist. The average of this value over all nodes is a good indicator for the degreee of transitivity and the presence of community structures in a network, and this is what the following function returns:

In [23]:

properties.clustering(G)

Out[23]:

0.4442803787023365

Search and Shortest Paths¶

A simple breadth-first search from a starting node can be performed as follows:

In [24]:

v = 0
bfs = graph.BFS(G, v)
bfs.run()

bfsdist = bfs.getDistances()

The return value is a list of distances from v to other nodes - indexed by node id. For example, we can now calculate the mean distance from the starting node to all other nodes:

In [25]:

sum(bfsdist) / len(bfsdist)

Out[25]:

11.339044943820225

Similarly, Dijkstra's algorithm yields shortest path distances from a starting node to all other nodes in a weighted graph. Because PGPgiantcompo is an unweighted graph, the result is the same here:

In [26]:

dijkstra = graph.Dijkstra(G, v)
dijkstra.run()
spdist = dijkstra.getDistances()
sum(spdist) / len(spdist)

Out[26]:

11.339044943820225

Core Decomposition¶

A $k$ -core decomposition of a graph is performed by successicely peeling away nodes with degree less than $k$ . The remaining nodes form the $k$ -core of the graph.

In [27]:

K = readGraph("input/karate.graph",Format.METIS)
coreDec = properties.CoreDecomposition(K)
coreDec.run();

Core decomposition assigns a core number to each node, being the maximum $k$ for which a node is contained in the $k$ -core. For this small graph, core numbers have the following range:

In [30]:

set(coreDec.coreNumbers())

Out[30]:

{1, 2, 3, 4}

The $k$ -shell is the set of nodes with core number $k$ .

In [31]:

coreDec.shells()

Out[31]:

[set(),
 {11},
 {9, 12, 14, 15, 16, 17, 18, 20, 21, 22, 26},
 {4, 5, 6, 10, 19, 23, 24, 25, 27, 28, 29, 31},
 {0, 1, 2, 3, 7, 8, 13, 30, 32, 33}]

In this drawing of the Karate club graph, node size corresponds to core number.

In [32]:

viztasks.drawGraph(K, nodeSizes=[(k**2)*20 for k in coreDec.coreNumbers()])

Community Detection¶

This section demonstrates the community detection capabilities of NetworKit. Community detection is concerned with identifying groups of nodes which are significantly more densely connected to eachother than to the rest of the network.

Code for community detection is contained in the community module. The module provides a top-level function to quickly perform community detection with a suitable algorithm and print some stats about the result.

In [34]:

community.detectCommunities(G);

PLM(balanced,pc) detected communities in 0.33330535888671875 [s]
solution properties:
-------------------  ---------
# communities        101
min community size     6
max community size   750
avg. community size  105.743
modularity             0.88198
-------------------  ---------

The function prints some statistics and returns the partition object representing the communities in the network as an assignment of node to community label. Let's capture this result of the last function call.

In [36]:

communities = community.detectCommunities(G)

PLM(balanced,pc) detected communities in 0.32004284858703613 [s]
solution properties:
-------------------  ----------
# communities         98
min community size     6
max community size   674
avg. community size  108.98
modularity             0.883255
-------------------  ----------

Modularity is the primary measure for the quality of a community detection solution. The value is in the range [-0.5,1] and usually depends both on the performance of the algorithm and the presence of distinctive community structures in the network.

In [37]:

community.Modularity().getQuality(communities, G)

Out[37]:

0.8832548686698775

The Partition Data Structure¶

The result of community detection is a partition of the node set into disjoint subsets. It is represented by the Partition data strucure, which provides several methods for inspecting and manipulating a partition of a set of elements (which need not be the nodes of a graph).

In [38]:

type(communities)

Out[38]:

_NetworKit.Partition

In [39]:

print("{0} elements assigned to {1} subsets".format(communities.numberOfElements(), communities.numberOfSubsets()))

10680 elements assigned to 98 subsets

In [32]:

print("the biggest subset has size {0}".format(max(communities.subsetSizes())))

the biggest subset has size 667

The contents of a partition object can be written to file in a simple format, in which each line i contains the subset id of node i.

In [40]:

community.writeCommunities(communities, "output/communties.partition")

wrote communities to: output/communties.partition

Choice of Algorithm¶

The community detection function used a good default choice for an algorithm: PLM, our parallel implementation of the well-known Louvain method. It yields a high-quality solution at reasonably fast running times. Let us now apply a variation of this algorithm.

In [34]:

community.detectCommunities(G, algo=community.PLP(G))

PLP detected communities in 0.014676094055175781 [s]
solution properties:
-------------------  ---------
# communities        949
min community size     2
max community size   545
avg. community size   11.254
modularity             0.79711
-------------------  ---------

Out[34]:

<_NetworKit.Partition at 0x116c585d0>

We have switched on refinement, and we can see how modularity is slightly improved. For a small network like this, this takes only marginally longer.

Visualizing the Result¶

We can easily plot the distribution of community sizes as follows. While the distribution is skewed, it does not seem to fit a power-law, as shown by a log-log plot.

In [42]:

sizes = communities.subsetSizes()
sizes.sort(reverse=True)
ax1 = plt.subplot(2,1,1)
ax1.set_ylabel("size")
ax1.plot(sizes)

ax2 = plt.subplot(2,1,2)
ax2.set_xscale("log")
ax2.set_yscale("log")
ax2.set_ylabel("size")
ax2.plot(sizes);

The visualization module provides a function which draws the community graph for a community detection solution: Communities are contracted into single nodes whose size corresponds to the community size.

In [43]:

viztasks.drawCommunityGraph(G, communities)

Subgraph¶

NetworKit supports the creation of Subgraphs depending on an original graph and a set of nodes. This might be useful in case you want to analyze certain communities of a graph. Let's say that community 2 of the above result is of further interest, so we want a new graph that consists of nodes and intra cluster edges of community 2.

In [44]:

from networkit.graph import Subgraph
c2 = communities.getMembers(2)
sg = Subgraph()
g2 = sg.fromNodes(G,c2)

In [45]:

communities.subsetSizeMap()[2]

Out[45]:

In [46]:

g2.numberOfNodes()

Out[46]:

As we can see, the number of nodes in our subgraph matches the number of nodes of community 2. The subgraph can be used like any other graph object, e.g. further community analysis:

In [47]:

communities2 = community.detectCommunities(g2)

PLM(balanced,pc) detected communities in 0.2783164978027344 [s]
solution properties:
-------------------  ---------
# communities         9
min community size    5
max community size   34
avg. community size  17.1111
modularity            0.720017
-------------------  ---------

In [41]:

viztasks.drawCommunityGraph(g2,communities2)

Centrality¶

Centrality measures the relative importance of a node within a graph. Code for centrality analysis is grouped into the centrality module.

Betweenness Centrality¶

We implement Brandes' algorithm for the exact calculation of betweenness centrality. While the algorithm is efficient, it still needs to calculate shortest paths between all pairs of nodes, so its scalability is limited. We demonstrate it here on the small Karate club graph.

In [48]:

K = readGraph("input/karate.graph", Format.METIS)

In [49]:

bc = centrality.Betweenness(K)
bc.run();

We have now calculated centrality values for the given graph, and can retrieve them either as an ordered ranking of nodes or as a list of values indexed by node id.

In [50]:

bc.ranking()[:10] # the 10 most central nodes

Out[50]:

[(0, 462.1428571224335),
 (33, 321.10317458491784),
 (32, 153.3809523686038),
 (2, 151.70158729127758),
 (31, 146.0190476059217),
 (8, 59.058730149790804),
 (1, 56.9571428529264),
 (13, 48.43174602601552),
 (19, 34.29365078890204),
 (6, 31.666666665620316)]

In [51]:

viztasks.drawGraph(K, nodeSizes=bc.scores()) # the more central the node, the bigger it is drawn

Approximation of Betweenness¶

Since exact calculation of betweenness scores is often out of reach, NetworKit provides an approximation algorithm based on path sampling. Here we estimate betweenness centrality in PGPgiantcompo, with a probabilistic guarantee that the error is no larger than an additive constant $\epsilon$ .

In [52]:

abc = centrality.ApproxBetweenness(G, epsilon=0.1)
abc.run();

The 10 most central nodes according to betweenness are then

In [53]:

abc.ranking()[:10]

Out[53]:

[(6932, 0.11708860759493672),
 (1143, 0.11708860759493672),
 (6655, 0.11392405063291139),
 (7297, 0.10443037974683544),
 (6555, 0.08227848101265822),
 (7324, 0.06645569620253165),
 (2258, 0.06645569620253164),
 (3156, 0.06645569620253164),
 (6744, 0.056962025316455694),
 (6098, 0.053797468354430375)]

Eigenvector Centrality and PageRank¶

Eigenvector centrality and its variant PageRank assign relative importance to nodes according to their connections, incorporating the idea that edges to high-scoring nodes contribute more. PageRank is a version of eigenvector centrality which introduces a damping factor, modeling a random web surfer which at some point stops following links and jumps to a random page. In PageRank theory, centrality is understood as the probability of such a web surfer to arrive on a certain page. Our implementation of both measures is based on parallel power iteration, a relatively simple eigensolver.

In [54]:

# Eigenvector centrality
ec = centrality.EigenvectorCentrality(K)
ec.run()
ec.ranking()[:10] # the 10 most central nodes

Out[54]:

[(33, 0.37337121301323506),
 (0, 0.35548349418519426),
 (2, 0.3171893899684447),
 (32, 0.3086510477336959),
 (1, 0.2659538704545024),
 (8, 0.22740509147166046),
 (13, 0.22646969838808145),
 (3, 0.21117407832057056),
 (31, 0.191036269797917),
 (30, 0.17476027834493088)]

In [55]:

# PageRank
pr = centrality.PageRank(K, 1e-6)
pr.run()
pr.ranking()[:10] # the 10 most central nodes

Out[55]:

[(33, 0.029411904901855565),
 (0, 0.029411888071820158),
 (32, 0.029411844867300342),
 (1, 0.029411804779381063),
 (2, 0.029411798733649144),
 (3, 0.02941177128267691),
 (31, 0.02941177072521248),
 (5, 0.029411768995095997),
 (6, 0.029411768995095997),
 (23, 0.02941176398501433)]

NetworkX Compatibility¶

NetworkX is a popular Python package for network analysis. It is currently much richer in features than NetworKit, but unlike NetworkX, NetworKit is able to process graphs with millions to billions of edges. To let both packages complement eachother, and to enable the adaptation of existing NetworkX-based code, we support the conversion of the respective graph data structures.

In [56]:

import networkx as nx
nxG = nk2nx(G) # convert from NetworKit.Graph to networkx.Graph
print(nx.degree_assortativity_coefficient(nxG))

0.238211371708

In [57]:

nxG = nx.generators.watts_strogatz_graph(42, 2, 0.01)
nkG = nx2nk(nxG)
viztasks.drawGraph(nkG)

Generating Graphs¶

An important subfield of network science is the design and analysis of generative models. A variety of generative models have been proposed with the aim of reproducing one or several of the properties we find in real-world complex networks. NetworKit includes generator algorithms for several of them.

The ErdÃ¶s-Renyi model is the most basic random graph model, in which each edge exists with the same uniform probability. NetworKit provides an efficient generator:

In [58]:

ERG = generators.ErdosRenyiGenerator(1000, 0.1).generate()

In [59]:

properties.overview(ERG)

/home/cobalt/iPython/NetworKit/networkit/powerlaw.py:546: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
  if data!=None and not (parameter_range and self.parent_Fit):
/home/cobalt/iPython/NetworKit/networkit/powerlaw.py:1047: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
  if data==None and hasattr(self, 'parent_Fit'):
/home/cobalt/iPython/NetworKit/networkit/powerlaw.py:598: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
  if data==None and hasattr(self, 'parent_Fit'):
/home/cobalt/iPython/NetworKit/networkit/powerlaw.py:671: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
  if data==None and hasattr(self, 'parent_Fit'):
/home/cobalt/iPython/NetworKit/networkit/powerlaw.py:556: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
  if data==None and hasattr(self, 'parent_Fit'):

Calculating best minimal value for power law fit
<_NetworKit.PLM object at 0xaa2bc52c>

Network Properties: G#108
==================
Basic Properties
-------------------------  ---------------
nodes, edges               1000, 49904
directed?                  False
weighted?                  False
isolated nodes             0
self-loops                 0
density                    0.099908
clustering coefficient     0.100799
max. core number           81
connected components       1
size of largest component  1000 (100.00 %)
estimated diameter range   (3, 3)
-------------------------  ---------------
Node Degree Properties
-----------------------------  -----------------------
min./max. degree               (72, 125)
avg. degree                    99.808000
power law?, likelihood, gamma  False, -6.5809, 17.9536
degree assortativity           -0.0061
-----------------------------  -----------------------
Community Structure
-------------------------  -----------  --------
community detection (PLM)
                           communities  9
                           modularity   0.080920
-------------------------  -----------  --------
Degree Distribution
-------------------
0-   :  |   0.00
6-   :  |   0.00
12-  :  |   0.00
18-  :  |   0.00
24-  :  |   0.00
30-  :  |   0.00
36-  :  |   0.00
42-  :  |   0.00
48-  :  |   0.00
54-  :  |   0.00
60-  :  |   0.00
66-  :  |   0.00
72-  :  â–‡   6.00
78-  :  â–‡â–‡â–‡â–‡â–‡  30.00
84-  :  â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡  92.00
90-  :  â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡ 196.00
96-  :  â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡ 253.00
102- :  â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡ 225.00
108- :  â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡ 125.00
114- :  â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡  61.00
120- :  â–‡â–‡  12.00
126- :  |   0.00
132- :  |   0.00
138- :  |   0.00
144- :  |   0.00

/home/cobalt/iPython/NetworKit/networkit/powerlaw.py:1166: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
  if data==None and hasattr(self, 'parent_Fit'):
/home/cobalt/iPython/NetworKit/networkit/powerlaw.py:725: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
  if data==None and hasattr(self, 'parent_Fit'):

A simple way to generate a random graph with community structure is to use the ClusteredRandomGraphGenerator. It uses a simple variant of the ErdÃ¶s-Renyi model: The node set is partitioned into a given number of subsets. Nodes within the same subset have a higher edge probability.

In [60]:

CRG = generators.ClusteredRandomGraphGenerator(200, 4, 0.2, 0.002).generate()

In [61]:

community.detectCommunities(CRG)

PLM(balanced,pc) detected communities in 0.23123574256896973 [s]
solution properties:
-------------------  ---------
# communities         4
min community size   42
max community size   59
avg. community size  50
modularity            0.709597
-------------------  ---------

Out[61]:

<_NetworKit.Partition at 0xabf05890>

The Chung-Lu model (also called configuration model) generates a random graph which corresponds to a given degree sequence, i.e. has the same expected degree sequence. It can therefore be used to replicate some of the properties of a given real networks, while others are not retained, such as high clustering and the specific community structure.

In [62]:

degreeSequence = [G.degree(v) for v in G.nodes()]
clgen = generators.ChungLuGenerator(degreeSequence)
properties.overview(clgen.generate())

/home/cobalt/iPython/NetworKit/networkit/powerlaw.py:546: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
  if data!=None and not (parameter_range and self.parent_Fit):
/home/cobalt/iPython/NetworKit/networkit/powerlaw.py:1047: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
  if data==None and hasattr(self, 'parent_Fit'):
/home/cobalt/iPython/NetworKit/networkit/powerlaw.py:598: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
  if data==None and hasattr(self, 'parent_Fit'):
/home/cobalt/iPython/NetworKit/networkit/powerlaw.py:671: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
  if data==None and hasattr(self, 'parent_Fit'):
/home/cobalt/iPython/NetworKit/networkit/powerlaw.py:556: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
  if data==None and hasattr(self, 'parent_Fit'):

Value 0 in data. Throwing out 0 values
Calculating best minimal value for power law fit
<_NetworKit.PLM object at 0xaa2bc80c>

Network Properties: G#122
==================
Basic Properties
-------------------------  --------------
nodes, edges               10680, 24300
directed?                  False
weighted?                  False
isolated nodes             1890
self-loops                 0
density                    0.000426
clustering coefficient     0.006818
max. core number           7
connected components       1957
size of largest component  8656 (81.05 %)
estimated diameter range   (13, 14)
-------------------------  --------------
Node Degree Properties
-----------------------------  --------------------
min./max. degree               (0, 208)
avg. degree                    4.550562
power law?, likelihood, gamma  True, 1.5294, 3.0156
degree assortativity           0.0018
-----------------------------  --------------------
Community Structure
-------------------------  -----------  --------
community detection (PLM)
                           communities  1986
                           modularity   0.410308
-------------------------  -----------  --------
Degree Distribution
-------------------
0-   :  â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡â–‡9302.00
9-   :  â–‡â–‡â–‡â–‡ 841.00
18-  :  â–‡ 273.00
27-  :  | 113.00
36-  :  |  67.00
45-  :  |  32.00
54-  :  |  21.00
63-  :  |  13.00
72-  :  |   7.00
81-  :  |   2.00
90-  :  |   2.00
99-  :  |   2.00
108- :  |   2.00
117- :  |   0.00
126- :  |   1.00
135- :  |   0.00
144- :  |   1.00
153- :  |   0.00
162- :  |   0.00
171- :  |   0.00
180- :  |   0.00
189- :  |   0.00
198- :  |   0.00
207- :  |   1.00
216- :  |   0.00

/home/cobalt/iPython/NetworKit/networkit/powerlaw.py:1166: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
  if data==None and hasattr(self, 'parent_Fit'):
/home/cobalt/iPython/NetworKit/networkit/powerlaw.py:725: FutureWarning: comparison to `None` will result in an elementwise object comparison in the future.
  if data==None and hasattr(self, 'parent_Fit'):

Settings¶

In this section we discuss global settings.

Logging¶

When using NetworKit from the command line, the verbosity of console output can be controlled via several loglevels, from least to most verbose: FATAL, ERROR, WARN, INFO, DEBUG and TRACE. (Currently, logging is only available on the console and not visible in the IPython Notebook).

In [63]:

getLogLevel() # the default loglevel

Out[63]:

'ERROR'

In [64]:

setLogLevel("TRACE") # set to most verbose mode
setLogLevel("ERROR") # set back to default

Please note, that the default build setting is optimized (--optimize=Opt) and thus, every LOG statement below INFO is removed. If you need DEBUG and TRACE statements, please build the extension module by appending --optimize=Dbg when calling the setup script.

Parallelism¶

The degree of parallelism can be controlled and monitored in the following way:

In [61]:

setNumberOfThreads(4) # set the maximum number of available threads

In [62]:

getMaxNumberOfThreads() # see maximum number of available threads

Out[62]:

In [63]:

getCurrentNumberOfThreads() # the number of threads currently executing

Out[63]:

Support¶

NetworKit is an open-source project that improves with suggestions and contributions from its users. The email list networkit@ira.uni-karlsruhe.de is the place for general discussion and questions. Also feel free to contact the authors with questions on how NetworKit can be applied to your research.

-- Christian L. Staudt and Henning Meyerhenke

In [63]: