Aims

By the end of this tutorial, you should be able to:

•   Calculate degree centrality by hand and with node_by_degree(), including in- and out-degree for directed networks and strength for weighted ones
•   Compute betweenness, closeness, and eigenvector centrality and interpret what each one means
•   Recognise the wider betweenness-, closeness-, and eigenvector-type families, and choose an appropriate variant (e.g. reach, pagerank, or power)
•   Highlight the most central node(s) on a graph with node_is_max() and graphr()
•   Read a measure’s distribution with plot(), and see how its shape drives a network’s centralisation , computed with net_by_*()
•   Know when scores are normalised, and how to obtain the raw scores

Choose your own data: The worked examples below use ison_brandes, a small, tidy teaching network bundled with {manynet}. But wherever there is an exercise box, you are encouraged to swap in a network that interests you. Remember the three flavours of bundled data as a rough difficulty ladder — Classic (ison_*, small & tidy), Fiction (fict_*, mid-sized & fun), Real-world (irps_*, larger & realistic) — and that you can browse the full list with table_data().

Setting up

For this exercise, we’ll use the ison_brandes dataset in {manynet}. This dataset is in a ‘tidygraph’ format, but manynet makes it easy to coerce this into other forms to be compatible with other packages. We can create a two-mode version of the dataset by renaming the nodal attribute “twomode_type” to just “type”. Let’s begin by graphing these datasets using graphr().

# Let's graph the one-mode version
graphr(____)

# Now, let's create a two-mode version 'ison_brandes2' and graph it.
ison_brandes2 <- ison_brandes |> rename_nodes(type = twomode_type)
graphr(____)

# plot the one-mode version
graphr(ison_brandes)
ison_brandes2 <- ison_brandes |> rename_nodes(type = twomode_type)
# plot the two-mode version
graphr(ison_brandes2, layout = "bipartite")

The network is anonymous, but I think it would be nice to add some names, even if it’s just pretend. Luckily, {manynet} has a function for this: to_named(). This makes plotting the network just a wee bit more accessible and interpretable:

ison_brandes <- to_named(ison_brandes)

# Now, let's graph using the object names: "ison_brandes"
graphr(____)

ison_brandes <- to_named(ison_brandes)
# plot network with names
graphr(ison_brandes)

Note that you will likely get a different set of names (though still alphabetical), as they are assigned randomly from a pool of (American) first names.

Counting ties

Let’s start with calculating degree . Remember that degree centrality is just the number of incident edges/ties to each node. It is therefore easy to calculate yourself. Just sum the rows or columns of the matrix!

# We can calculate degree centrality like this:
(mat <- as_matrix(ison_brandes))
(degrees <- rowSums(mat))
rowSums(mat) == colSums(mat)

# Or by using a built in command in netrics like this:
node_by_degree(ison_brandes, normalized = FALSE)
# node_by_deg() is a shortcut for exactly this unnormalised version:
node_by_deg(ison_brandes)

# manually calculate degree centrality
mat <- as_matrix(ison_brandes)
degrees <- rowSums(mat)
rowSums(mat) == colSums(mat)
# You can also just use a built in command in netrics though:
node_by_degree(ison_brandes, normalized = FALSE)
# node_by_deg() is a shortcut for exactly this unnormalised version:
node_by_deg(ison_brandes)

A node’s degree is the most immediate sense in which it can be “central”: a well-connected node has more opportunities to send or receive whatever flows through the network, and more visibility to the nodes around it. But degree is a local measure — it counts a node’s ties without regard to where those ties lead — so a high-degree node is best read as an active or busy one, not necessarily a powerful or well-positioned one. The other measures in this tutorial each capture a different, less local sense of importance.

Degrees of direction

So far each node has had a single degree, because ison_brandes is undirected . In a directed network, ties are sent from one node to another, so every node has two degrees: an in-degree (ties received) and an out-degree (ties sent). These can tell quite different stories: in an advice network, for example, a high in-degree suggests a sought-after source of advice, while a high out-degree marks an eager asker.

ison_brandes has no natural direction, but {manynet}’s to_directed() will assign a random direction to each tie — just as to_named() assigned random names — which is all we need for a worked comparison. Run the code, and check whether the row and column sums still agree.

ison_brandes_dir <- to_directed(ison_brandes)
node_by_indegree(ison_brandes_dir, normalized = FALSE)
node_by_outdegree(ison_brandes_dir, normalized = FALSE)
mat <- as_matrix(ison_brandes_dir)
rowSums(mat) == colSums(mat)

Now the row sums (out-degree) and column sums (in-degree) part ways — the answer to the earlier quiz question flips as soon as direction enters. Because the directions here are assigned at random, your in- and out-degrees will differ from run to run; with real directed data they would of course be meaningful and stable. node_by_indegree() and node_by_outdegree() are shortcuts for node_by_degree()’s direction = "in" and direction = "out" arguments.

Strength of ties

What about weighted networks, where ties record not just presence but amounts — messages exchanged, hours worked together, tonnes traded? There, counting ties is only half the story: two nodes with three ties each are hardly equivalent if one’s ties are ten times heavier. Summing the weights of a node’s ties instead of counting them yields what is often called strength centrality.

Again {manynet} can conjure the missing property for practice purposes: to_weighted() assigns random weights to the ties. The alpha argument to node_by_deg() then trades off between counting ties and summing weights: alpha = 0 ignores the weights entirely (pure degree), alpha = 1 ignores the counts entirely (pure strength), and values in between mix the two. Compare the two extremes.

ison_brandes_wtd <- to_weighted(ison_brandes)
node_by_deg(ison_brandes_wtd)             # alpha = 0: count ties
node_by_deg(ison_brandes_wtd, alpha = 1)  # alpha = 1: sum tie weights

Note that on a weighted network, node_by_degree() itself defaults to strength (alpha = 1) — the assumption being that if you have measured weights, you probably care about them.

Betweenness centrality

Betweenness measures how often a node lies on the shortest paths ( geodesics ) between other pairs of nodes. A node with high betweenness sits at a crossroads: whatever passes between otherwise-distant parts of the network has to go through it, giving it the opportunity to broker, filter, or bottleneck that flow. Calculate the betweenness centralities for ison_brandes.

# Use the node_by_betweenness() function to calculate the
# betweenness centralities of nodes in a network
node_by_betweenness(____)

node_by_betweenness(ison_brandes)

Ties can be between too

Nodes are not the only things that can lie between: tie_by_betweenness() counts the shortest paths that run through each tie. Ties with high betweenness often act as bridges between otherwise separate parts of the network — indeed this score is the basis of a famous community-detection algorithm (Girvan-Newman), which you will meet in the community tutorial. Map tie betweenness onto tie width to see the network’s main thoroughfares.

ison_brandes %>%
  mutate_ties(bridgeness = tie_by_betweenness(ison_brandes)) %>%
  graphr(edge_size = "bridgeness")

The widest ties are the ones the network can least afford to lose: cut one and many shortest paths between nodes lengthen — or disappear.

Induced and other variants

The rest of the betweenness family keeps the “who depends on whom” logic but varies the assumptions:

• node_by_induced() measures induced or vitality betweenness: how much the network’s total betweenness changes when the node is removed. It answers “what would we lose without this node?” rather than “how often is this node in between?”.
• node_by_flow() measures flow betweenness, which models spreading as electrical current across all paths, not just the shortest ones — useful when whatever flows does not know the shortest route.
• node_by_stress() counts the shortest paths through each node without weighting them by how many alternatives exist — an older, “rawer” cousin of betweenness.

Compare classic and induced betweenness — do they agree here?

node_by_betweenness(ison_brandes, normalized = FALSE)
node_by_induced(ison_brandes, normalized = FALSE)

For this network the rankings broadly agree, but on networks with more redundancy they can diverge: a node can lie on few shortest paths itself yet still be sorely missed when removed. For formal definitions and references, see ?measure_central_between.

Closeness centrality

Closeness measures how short a node’s paths are to all other nodes — the smaller the total geodesic distance, the higher the closeness. A node with high closeness can reach the rest of the network in few steps, so it is well placed to spread (or hear) something quickly. Calculate the closeness centralities for ison_brandes.

# Use the node_by_closeness() function to calculate the
# closeness centrality of nodes in a network
node_by_closeness(____)

node_by_closeness(ison_brandes)

Reach and distance

Sometimes what matters is not the average distance to everyone, but a more concrete question: how much of the network can this node reach within k steps? That is node_by_reach(), which by default counts the proportion of the network within two steps — a good proxy for “who could mobilise the most others quickly?”. And sometimes the question is about one node in particular: node_by_distance() returns every node’s geodesic distance from (or to) a given node — the network equivalent of dropping a pin on a map. Try both: how far does the first-named node’s reach extend?

node_by_reach(ison_brandes)
node_by_distance(ison_brandes, from = node_names(ison_brandes)[1])

Note that node_by_reach() takes a cutoff argument to change the number of steps considered: cutoff = 1 reduces it to degree, while a large cutoff approaches a measure of component membership.

Harmonic and other variants

Classic closeness has a well-known weakness: in a disconnected network, some distances are infinite, and the measure breaks down. The family includes several responses to this, and other refinements:

• node_by_harmonic() sums the reciprocals of distances, so unreachable nodes simply contribute zero — the recommended drop-in replacement for closeness on disconnected networks.
• node_by_eccentricity() reports each node’s worst case: the distance to whatever node is furthest from it.
• node_by_information() measures current-flow closeness, crediting all paths (weighted by efficiency) rather than only the shortest.
• node_by_vitality() measures how much the network’s total closeness would change without the node — the closeness analogue of induced betweenness.

For formal definitions and references, see ?measure_central_close.

Eigenvector centrality

Eigenvector centrality weights a node’s ties by how central its neighbours are: you are important if you are connected to important others. It captures influence rather than mere activity — a node with only a few ties, but to very well-connected nodes, can outscore a node with many ties to peripheral ones. Calculate the eigenvector centralities for ison_brandes.

# Use the node_by_eigenvector() function to calculate
# the eigenvector centrality of nodes in a network
node_by_eigenvector(____)

node_by_eigenvector(ison_brandes)

Power and influence

Bonacich famously argued that power and influence are not the same thing. Under eigenvector logic, well-connected neighbours always raise your score. But in bargaining or exchange, the reverse can hold: being connected to poorly-connected others makes them dependent on you — that is power. node_by_power() implements Bonacich’s measure, and its exponent argument sets the sign of the recursion: a positive exponent rewards well-connected neighbours (influence-like), while a negative one rewards dependent, poorly-connected neighbours (power). Compare the two.

node_by_power(ison_brandes, exponent = 1)
node_by_power(ison_brandes, exponent = -1)

Try to answer the following questions for yourself:

• which nodes swap fortunes when the exponent flips, and what do their neighbourhoods look like?
• can you think of a real-world example when an actor might be central but not powerful, or powerful but not central?

Pagerank, hubs, and authorities

Two further members of this family were developed for the web, and shine on directed networks:

• node_by_pagerank() measures pagerank, the algorithm behind early Google: a random surfer follows ties and occasionally teleports to a random node, and a node’s score is how often the surfer visits. The teleporting makes it robust on disconnected and directed networks where plain eigenvector centrality struggles.
• node_by_hub() and node_by_authority() split reputation in two: authorities are nodes that many point to, while hubs are nodes that point to many good authorities — think review sites (hubs) versus the restaurants they recommend (authorities).
• node_by_alpha() measures alpha or Katz centrality, which extends eigenvector logic to count longer walks at a discount — see ?measure_central_eigen for details on the whole family.

Try these on a directed version of our network.

ison_brandes_dir <- to_directed(ison_brandes)
node_by_pagerank(ison_brandes_dir)
node_by_hub(ison_brandes_dir)
node_by_authority(ison_brandes_dir)

Since the directions are again assigned at random, run the code a few times: watch how a node’s authority score rises and falls with the arrows pointing at it.

You have now met all four families of centrality — degree, betweenness, closeness, and eigenvector — each ranking the nodes by a different notion of importance. With four families (and many variants within each) to choose from, how do you decide? That is the subject of the next page.

Highlighting the most central node

It is straightforward in {autograph} to highlight nodes and ties with maximum or minimum (e.g. degree) scores. If the vector is numeric (i.e. a “measure”), then this can be easily converted into a logical vector that identifies the node/tie with the maximum/minimum score using e.g. node_is_max() or tie_is_min(). By passing this attribute to the graphr() argument “node_color” we can highlight which node or nodes hold the maximum score in a different colour.

# plot the network, highlighting the node with the highest centrality score with a different color
ison_brandes %>%
  mutate_nodes(color = node_is_max(node_by_degree())) %>%
  graphr(node_color = "color")

ison_brandes %>%
  mutate_nodes(color = node_is_max(node_by_betweenness())) %>%
  graphr(node_color = "color")

ison_brandes %>%
  mutate_nodes(color = node_is_max(node_by_closeness())) %>%
  graphr(node_color = "color")

ison_brandes %>%
  mutate_nodes(color = node_is_max(node_by_eigenvector())) %>%
  graphr(node_color = "color")

How neat! Notice whether the same node lights up across the four measures or whether different nodes do — because the measures capture different things, a node can be top of one ranking and unremarkable on another.

The two-mode version

Try it with the two-mode version. What can you see?

# Instead of "ison_brandes", use "ison_brandes2"

ison_brandes2 %>%
  add_node_attribute("color", node_is_max(node_by_degree(ison_brandes2))) %>%
  graphr(node_color = "color", layout = "bipartite")

ison_brandes2 %>%
  add_node_attribute("color", node_is_max(node_by_betweenness(ison_brandes2))) %>%
  graphr(node_color = "color", layout = "bipartite")

ison_brandes2 %>%
  add_node_attribute("color", node_is_max(node_by_closeness(ison_brandes2))) %>%
  graphr(node_color = "color", layout = "bipartite")

ison_brandes2 %>%
  add_node_attribute("color", node_is_max(node_by_eigenvector(ison_brandes2))) %>%
  graphr(node_color = "color", layout = "bipartite")

Reading a distribution

Rather than reduce a measure to a single summary number, we can look at its whole distribution across the nodes. {autograph} offers a way to get a pretty good first look at this, though there are more elaborate ways to do this in base and grid graphics. Plot the degree distribution of ison_brandes.

# distribution of degree centrality scores of nodes
plot(node_by_degree(ison_brandes))

What’s plotted here by default is both the degree distribution as a histogram, as well as a density plot overlaid on it in red. Reading a distribution rather than a single summary number lets you see shape: whether ties are spread fairly evenly across nodes, or concentrated on a few.

The same works for any node measure, not just degree. Plot the distributions of the other three centralities you have met.

plot(node_by_betweenness(ison_brandes))
plot(node_by_closeness(ison_brandes))
plot(node_by_eigenvector(ison_brandes))

From distribution to centralisation

Here is the key idea. The shape of a degree distribution and the network’s centralisation are two views of the same thing. When degrees are spread evenly — a symmetric, roughly normal bell where most nodes are near-average — no node dominates, and centralisation is low. When the distribution is skewed into a long, exponential tail — a few hubs with very high degree, and many nodes with very little — a handful of nodes dominate, and centralisation is high.

To see this, let’s conjure two networks of the same size with deliberately different degree distributions: a random network (whose degrees cluster around a typical value) and a scale-free network (which grows a few dominant hubs). The seed just fixes the random draw so everyone sees the same picture. Run it, and compare both the plots and the two centralisation scores.

set.seed(7)
rand <- generate_random(50, 0.1)     # bell-shaped degree distribution
scaf <- generate_scalefree(50, 1.3)  # heavy-tailed degree distribution
plot(node_by_degree(rand)) + plot(node_by_degree(scaf))
net_by_degree(rand)   # low centralisation
net_by_degree(scaf)   # much higher centralisation

The random network’s degrees pile up in a bell, and its degree centralisation is low — no node is far above the crowd. The scale-free network’s degrees trail off into a long tail, and its centralisation is several times higher — a few hubs carry the network. Our ison_brandes example sits somewhere between these two extremes.

Measuring centralisation

{netrics} also implements network centralisation functions. Here we are no longer interested in the level of the node, but in the level of the whole network, so the syntax replaces node_ with net_:

net_by_degree(ison_brandes)
net_by_betweenness(ison_brandes)
net_by_closeness(ison_brandes)
print(net_by_eigenvector(ison_brandes), digits = 5)

By default, scores are printed up to 3 decimal places, but this can be modified and, in any case, the unrounded values are retained internally. This means that even if rounded values are printed (to respect console space), as much precision as is available is used in further calculations.

Comparing the measures

What if we want to have a single image/figure with multiple plots? This can be a little tricky with gg-based plots, but fortunately the {patchwork} package is here to help. We use | to place graphs side-by-side and / to stack them, and ggtitle() to record each measure’s centralisation score as a subtitle.

ison_brandes <- ison_brandes |>
  add_node_attribute("degree", node_is_max(node_by_degree(ison_brandes)))  |>
  add_node_attribute("betweenness", node_is_max(node_by_betweenness(ison_brandes))) |>
  add_node_attribute("closeness", node_is_max(node_by_closeness(ison_brandes)))  |>
  add_node_attribute("eigenvector", node_is_max(node_by_eigenvector(ison_brandes)))
gd <- graphr(ison_brandes, node_color = "degree") +
  ggtitle("Degree", subtitle = round(net_by_degree(ison_brandes), 2))
gc <- graphr(ison_brandes, node_color = "closeness") +
  ggtitle("Closeness", subtitle = round(net_by_closeness(ison_brandes), 2))
gb <- graphr(ison_brandes, node_color = "betweenness") +
  ggtitle("Betweenness", subtitle = round(net_by_betweenness(ison_brandes), 2))
ge <- graphr(ison_brandes, node_color = "eigenvector") +
  ggtitle("Eigenvector", subtitle = round(net_by_eigenvector(ison_brandes), 2))
(gd | gb) / (gc | ge)
# ggsave("brandes-centralities.pdf")

Glossary

Here are some of the terms that we have covered in this tutorial:

Authority

An authority is a node pointed to by many hubs.

Betweenness

The betweenness centrality of a node is the proportion of shortest paths between all pairs of nodes that pass through that node.

Bridge

A bridge or isthmus is a tie whose deletion increases the number of components.

Centralization

A measure of how unequal the centralities of the nodes in a network are.

Closeness

The closeness centrality of a node is the reciprocal of the sum of its distances to all other nodes.

Component

A component is a connected subgraph not part of a larger connected subgraph.

Connected

A connected network is one with a single (strong) component.

Degree

The degree of a node is the number of connections it has.

Directed

A directed network is a network where the ties have a direction, from a sender to a receiver.

Distribution

A degree distribution is the frequency distribution of the degrees of the nodes in a network.

Eigenvector

The eigenvector centrality of a node is the corresponding value in the dominant eigenvector of the adjacency matrix.

Geodesic

A geodesic is a shortest path between two nodes.

Hub

A hub is a node connected to many authorities.

Multiplex

A network that includes multiple types of tie.

Network

A network comprises one or more sets of nodes, one or more sets of ties among them, and potentially some node, tie, or network-level attributes.

Node

A node or vertex is an entity or actor within a network.

Power

An eigenvector-style centrality that allows being connected to more peripheral nodes to contribute centrality.

Signed

A signed network is one where ties are marked as positive or negative, such as friendship and enmity or alliance and conflict.

Twomode

A two-mode (or bipartite) network is a network with two different sets of nodes, where ties connect only nodes from different sets, such as people and the events they attend.

Undirected

An undirected or line network is one in which tie direction is undefined.

Weighted

A weighted network is where the ties have been assigned weights.