This notebook covers the plot functions implemented in NetworKit. The plots help to evaluate and visualize certain properties of a graph.
Note: The matplotlib
library, as well as the seaborn
library needs to be installed on your device. For example use pip install matplotlib
to obtain it.
The first step is to import NetworKit.
[1]:
import networkit as nk
The degreeDistribution
of a graph describes the degree (incoming and outgoing edges) that each node has. Networkit.plot.degreeDistribution
plots how many nodes of each degree exist within a graph.
We start by creating a graph G
.
[2]:
G=nk.Graph(7)
G.addEdge(0,1)
G.addEdge(0,2)
G.addEdge(1,2)
G.addEdge(2,3)
G.addEdge(2,4)
G.addEdge(3,5)
G.addEdge(5,6)
[2]:
True
Plotting the degreeDistribution
of a graph G
can be done the following way:
[3]:
nk.plot.degreeDistribution(G)
The connectedComponentsSizes
describe how many nodes of the graph the individual connected components contain. Networkit.plot.connectedComponentsSizes
plots for each indivual component how many nodes of the graph it contains. By default it shows the size relative (as percentages) to the entire population, if relativeSizes
is set to False
, it shows the absolute number of nodes in each component.
Note: See networkit.components.ConnectedComponents for a description of the algorithm.
For the next example we create a new graph G2
with 3 components: the first component contains the nodes 0-3, the second contains the nodes 4 and 5, and the third contains only node 6 (component of size 1).
[4]:
G2=nk.Graph(7)
G2.addEdge(0,1)
G2.addEdge(1,2)
G2.addEdge(2,3)
G2.addEdge(4,5)
[4]:
True
Plotting the connectedComponentsSizes
of a graph G
can be done the following way:
[5]:
nk.plot.connectedComponentsSizes(G2, relativeSizes=True)
The nodeAttributes
are useful in order to efficiently incorporate additional information in the graph data structure.
Note: See networkit.GraphTutorial in section NodeAttributes
for a detailed description.
For this example we create a new graph G_attr
which contains additional graph attributes.
[6]:
G_attr=nk.Graph(4)
G_attr.addEdge(0,1)
G_attr.addEdge(1,2)
G_attr.addEdge(2,3)
#attaching the attributes to the graph
attrFloat = G_attr.attachNodeAttribute("myFloat", float)
attrStr = G_attr.attachNodeAttribute("myStr", str)
#setting attribute values
attrFloat[0] = 0.5
attrFloat[1] = 1.5
attrStr[1] = "tutorial"
attrStr[2] = "again"
Note: The nk.plot.nodeAttributes
can only be called with either one nodeAttribute
or a tuple
of exactly two nodeAttributes
.
If called with a single nodeAttribute
, it plots how frequent each value of the nodeAttribute
is present in the graph.
If called with two nodeAttributes
, it plots the 2-Dimensional distribution of the nodes according to the given nodeAttributes
Plotting the nodeAttributes
of a graph G
can be done the following way:
[7]:
#example with a single attribute
nk.plot.nodeAttributes(G_attr, attrFloat)
#example with two attributes
nk.plot.nodeAttributes(G_attr, (attrFloat, attrStr))
ClusteringPerDegree
can be used as centrality
measure of the graph. Networkit.plot.ClusteringPerDegree
plots for each degree (obtained by DegreeCentrality) the so called Clustering Coefficient (cc)
that measures how tight adjacent nodes are clustered together.
For this example we read a medium sized graph given by the networkit.input
graphs.
[8]:
# read a graph
G_jazz = nk.readGraph("../input/jazz.graph", nk.Format.METIS)
Note: The pandas
library, as well as the seaborn
library needs to be installed on your device.
Plotting the ClusteringPerDegree
of a graph G
can be done the following way:
[9]:
nk.plot.clusteringPerDegree(G_jazz)
The CoreDecomposition
algorithm computes the k-core decomposition of a graph, which is the largest induced subgraph, only consisting of nodes, whose degree is greater than or equal to k
. Networkit.plot.coreDecompositionSequence
plots the size (number of nodes) of each k-induced subgraph.
See networkit.centrality.coreDecomposition for a description of the algorithm.
For the next example we create a new graph G3
, whose k2-shell has size 4 (nodes: 1,3,4,5) and whose k1-shell has size 2 (nodes 0 and 2).
[10]:
G3=nk.Graph(6)
G3.addEdge(0,3) # G3: 0
G3.addEdge(1,3) # |
G3.addEdge(2,3) # 1 - 3 - 2
G3.addEdge(1,4) # | X |
G3.addEdge(1,5) # 4 - 5
G3.addEdge(3,4)
G3.addEdge(4,5)
G3.addEdge(3,5)
[10]:
True
Plotting the coreDecompositionSequence
of a graph G
can be done the following way:
[11]:
nk.plot.coreDecompositionSequence(G3)
The hopPlot
is the set of pairs (d, g(d))
for each natural number d
, where g(d)
is the fraction of connected node pairs whose shortest connecting path has length at most d
. The networkit.plot.hopPlot
plots the percentage of connected node pairs, that have a connecting path of length at most d
.
Note: The algorithm is approximative. See networkit.distance.hopPlotApproximation for a detailed description of the algorithm.
For this example we read a medium sized graph given by the networkit.input
graphs.
[12]:
#larger example
G_big = nk.readGraph("../input/power.graph", nk.Format.METIS)
Plotting the hopPlot
of a graph G
can be done the following way:
[13]:
nk.plot.hopPlot(G_big)