Key features

Can be used to easily create an interactive sankey diagram, as well as, other network layout such as dendrogram, radial and diagnonal networks.

Key R functions and options

Key R functions:

forceNetwork(). Creates a D3 JavaScript force directed network graph

forceNetwork(Links, Nodes, Source, Target,
             Value, NodeID, Nodesize, Group)

Key Arguments:

• Links: edges list. Edge IDs should start with 0
• Nodes: Nodes list. Node IDs should start with 0
• Source, Target: the names of the column, in the edges data, containing the network source and target variables, respectively.
• Value: the name of the column, in the edge data, containing the weight values for edges. Used to indicate how wide the links are.
• NodeID: the name of the column, in the nodes data, containing the node IDs. Used for labeling the nodes.
• Nodesize: the name of the column, in the nodes data, with some value to vary the node radius’s with.
• Group: the name of the column, in the nodes data, specifying the group of each node.

Prepare nodes and edes data

1. Prepare the nodes and the edges data:

nodes_d3 <- mutate(nodes, id = id - 1)
edges_d3 <- mutate(edges, from = from - 1, to = to - 1)

2. Create the interactive network:

library(networkD3)

forceNetwork(
  Links = edges_d3, Nodes = nodes_d3,  
  Source = "from", Target = "to",      # so the network is directed.
  NodeID = "label", Group = "id", Value = "weight", 
  opacity = 1, fontSize = 16, zoom = TRUE
  )

Create sankey diagram

You can create a d3-styled sankey diagram. A Sankey diagram is a good fit for the phone call data. There are not too many nodes in the data, making it easier to visualize the flow of phone calls.

Create a sankey diagram:

sankeyNetwork(
  Links = edges_d3, Nodes = nodes_d3, 
  Source = "from", Target = "to", 
  NodeID = "label", Value = "weight", 
  fontSize = 16, unit = "Letter(s)")

Other hierarchical layouts exist in the network3D package to visualize tree-like graphs. In the example below, we start by computing hierarchical clustering using a sample of the USArrests data set:

set.seed(123)
hc <- USArrests %>% sample_n(15) %>%
  scale() %>% dist() %>%
  hclust(method = "complete")

Other network layouts

• dendroNetwork:

dendroNetwork(hc, fontSize = 15)

Other alternatives are:

• radialNetwork:

radialNetwork(
  as.radialNetwork(hc), fontSize = 15
  )

• diagonalNetwork:

diagonalNetwork(
  as.radialNetwork(hc), fontSize = 15
  )

Key features

• Creates interactive network graphs.
• Possible to customize nodes and edge as you want.
• Can be used to directly visualize interactively a network generated with the igraph package.
• Can be used to visualize recursive partitioning and regression trees generated with the rpart package.
• Possible to use images and icons for node shapes.
• Supports igraph layouts

Key R function and options

Key R function:

visNetwork( 
  nodes = NULL, edges = NULL,
  width = NULL, height = NULL, 
  main = NULL, submain = NULL, footer = NULL
  )

Key Arguments:

• nodes: nodes list information. Should contain at least the column “id”. See visNodes() for more options to control nodes. Other colums can be included in the data, such as:
  • “id” : id of the node, needed in edges information
  • “label” : label of the node
  • “group” : group of the node. Groups can be configure with visGroups().
  • “value” : size of the node
  • “title” : tooltip of the node
  • …
• edges: edges list information. Required at least columns “from” and “to”. See visEdges() for more options to control edges.
  • “from” : node id of begin of the edge
  • “to” : node id of end of the edge
  • “label” : label of the edge
  • “value” : size of the node
  • “title” : tooltip of the node
  • …

Create a classic network graphs

To have always the same network, you can use the function visLayout(randomSeed = 12):

library("visNetwork")

visNetwork(nodes, edges) %>%
  visLayout(randomSeed = 12) 

If you want to control the width of edges according to a variable, you should include the column “width” in the edge list data. You should manually calculate and scale the edge width.

In the following R code, we’ll customize the visNetwork() output by using an igraph layout and changing the edges width.

First add the column width in the edges list data frame. Set the minimum width to 1:

edges <- mutate(edges, width = 1 + weight/5)

Create the network graph with the variable edge widths and the igraph layout = “layout_with_fr”.

visNetwork(nodes, edges) %>% 
  visIgraphLayout(layout = "layout_with_fr") %>% 
  visEdges(arrows = "middle") %>%
  visLayout(randomSeed = 1234)  

Visualize classification and regression trees

As mentioned above, you can visualize classification and regression trees generated using the rpart package.

Key function: visTree() [in visNetwork version >= 2.0.0].

For example, to visualize a classification tree, type the following R code:

# Compute
library(rpart)
res <- rpart(Species~., data=iris)
# Visualize
visTree(res, main = "Iris classification Tree",
        width = "80%",  height = "400px")

Use tbl_graph

• Create a tbl_graph network object using the phone call data:

library("navdata")
data("phone.call2")
phone.net <- tbl_graph(
  nodes = phone.call2$nodes, 
  edges = phone.call2$edges,
  directed = TRUE
  )

• Visualize:

ggraph(phone.net, layout = "graphopt") + 
  geom_edge_link(width = 1, colour = "lightgray") +
  geom_node_point(size = 4, colour = "#00AFBB") +
  geom_node_text(aes(label = label), repel = TRUE)+
  theme_graph()

Use as_tbl_graph R function

One can also use the as_tbl_graph() function to converts the following data structure and network objects:

• data.frame, list and matrix data [R base]
• igraph network objects [igraph package]
• network network objects [network pakage]
• dendrogram and hclust [stats package]
• Node [data.tree package]
• phylo and evonet [ape package]
• graphNEL, graphAM, graphBAM [graph package (in Bioconductor)]

In the following example, we’ll create a correlation matrix network graph. The mtcars data set will be used.

Compute the correlation matrix between cars using the corrr package:

• 1. Use the mtcars data set
• 2. Compute the correlation matrix: correlate()
• 3. Convert the upper triangle to NA: shave()
• 4. Stretch the correlation data frame into long format
• 5. Keep only high correlation

library(corrr)
res.cor <- mtcars [, c(1, 3:6)] %>%  # (1)
  t() %>% correlate() %>%            # (2)
  shave(upper = TRUE) %>%            # (3)
  stretch(na.rm = TRUE) %>%          # (4)
  filter(r >= 0.998)                 # (5)
res.cor

## # A tibble: 59 x 3
##               x             y     r
##                     
## 1     Mazda RX4 Mazda RX4 Wag 1.000
## 2     Mazda RX4      Merc 230 1.000
## 3     Mazda RX4      Merc 280 0.999
## 4     Mazda RX4     Merc 280C 0.999
## 5     Mazda RX4    Merc 450SL 0.998
## 6 Mazda RX4 Wag      Merc 230 1.000
## # ... with 53 more rows

Create the correlation network graph:

set.seed(1)
cor.graph <- as_tbl_graph(res.cor, directed = FALSE)
ggraph(cor.graph) + 
  geom_edge_link() + 
  geom_node_point() +
  geom_node_text(
    aes(label = name), size = 3, repel = TRUE
    ) +
  theme_graph()

Centrality

Centrality is an important concept when analyzing network graph. The centrality of a node / edge measures how central (or important) is a node or edge in the network.

We consider an entity important, if he has connections to many other entities. Centrality describes the number of edges that are connected to nodes.

There many types of scores that determine centrality. One of the famous ones is the pagerank algorithm that was powering Google Search in the beginning.

Examples of common approaches of measuring centrality include:

• betweenness centrality. The betweenness centrality for each nodes is the number of the shortest paths that pass through the nodes.

• closeness centrality. Closeness centrality measures how many steps is required to access every other nodes from a given nodes. It describes the distance of a node to all other nodes. The more central a node is, the closer it is to all other nodes.

• eigenvector centrality. A node is important if it is linked to by other important nodes. The centrality of each node is proportional to the sum of the centralities of those nodes to which it is connected. In general, nodes with high eigenvector centralities are those which are linked to many other nodes which are, in turn, connected to many others (and so on).

• Hub and authority centarlities are generalization of eigenvector centrality. A high hub node points to many good authorities and a high authority node receives from many good hubs.

The tidygraph package contains more than 10 centrality measures, prefixed with the term centrality_. These measures include:

centrality_authority()

centrality_betweenness()

centrality_closeness()

centrality_hub()

centrality_pagerank()

centrality_eigen()

centrality_edge_betweenness()

All of these centrality functions returns a numeric vector matching the nodes (or edges in the case of `centrality_edge_betweenness()).

In the following examples, we’ll use the phone call network graph. We’ll change the color and the size of nodes according to their values of centrality.

set.seed(123)
phone.net %>%
  activate(nodes) %>%
  mutate(centrality = centrality_authority()) %>% 
  ggraph(layout = "graphopt") + 
  geom_edge_link(width = 1, colour = "lightgray") +
  geom_node_point(aes(size = centrality, colour = centrality)) +
  geom_node_text(aes(label = label), repel = TRUE)+
  scale_color_gradient(low = "yellow", high = "red")+
  theme_graph()

Clustering

Clustering is a common operation in network analysis and it consists of grouping nodes based on the graph topology.

It’s sometimes referred to as community detection based on its commonality in social network analysis.

Many clustering algorithms from are available in the tidygraph package and prefixed with the term group_. These include:

• Infomap community finding. It groups nodes by minimizing the expected description length of a random walker trajectory. R function: group_infomap()
• Community structure detection based on edge betweenness. It groups densely connected nodes. R function: group_edge_betweenness().

In the following example, we’ll use the correlation network graphs to detect clusters or communities:

set.seed(123)
cor.graph %>%
  activate(nodes) %>%
   mutate(community = as.factor(group_infomap())) %>% 
  ggraph(layout = "graphopt") + 
  geom_edge_link(width = 1, colour = "lightgray") +
  geom_node_point(aes(colour = community), size = 4) +
  geom_node_text(aes(label = label), repel = TRUE)+
  theme_graph()

Demo data set

We’ll use a fake demo data set containing the number of phone calls between the president of some EU countries.

library("navdata")
data("phone.call")
head(phone.call, 3)

## # A tibble: 3 x 3
##    source destination n.call
##              
## 1  France     Germany      9
## 2 Belgium      France      4
## 3  France       Spain      3

To visualize the network graph, we need to create two data frames from the demo data sets:

• nodes list: containing nodes labels and other nodes attributes
• edges list: containing the relationship between the nodes. It consists of the edge list and any additional edge attributes.

In the following sections, we start by creating nodes and edges lists. Next, we’ll use the different packages to create network graphs.

Create nodes list

First, load the tidyverse R package for data manipulation:

library(tidyverse)

Then, compute the following key steps to create nodes list:

1. Take the distinct countries from both the “source” and “destination” columns
2. Change the column name to label
3. Join the information from the two columns together.

#  Get distinct source names
sources <- phone.call %>%
  distinct(source) %>%
  rename(label = source)

# Get distinct destination names
destinations <- phone.call %>%
  distinct(destination) %>%
  rename(label = destination)

# Join the two data to create node
# Add unique ID for each country
nodes <- full_join(sources, destinations, by = "label") 
nodes <- nodes %>%
  mutate(id = 1:nrow(nodes)) %>%
  select(id, everything())

head(nodes, 3)

## # A tibble: 3 x 2
##      id   label
##      
## 1     1  France
## 2     2 Belgium
## 3     3 Germany

Create edges list

Key steps:

1. Take the phone.call data, which are already in edges list format, showing the connection between nodes. Rename the column “n.call” to “weight”.
2. Join the node IDs to the edges list data
   1. Do this for the “source” column and rename the id column that are brought over from nodes. New name: “from”.
   2. Do this for the “destination” column and rename the id column. New name: “to”
   3. Select only the columns “from” and “to” in the edge data. We don’t need to keep the column “source” and “destination” containing the names of countries. These information are already present in the node data.

# Rename the n.call column to weight
phone.call <- phone.call %>%
  rename(weight = n.call)

# (a) Join nodes id for source column
edges <- phone.call %>% 
  left_join(nodes, by = c("source" = "label")) %>% 
  rename(from = id)

# (b) Join nodes id for destination column
edges <- edges %>% 
  left_join(nodes, by = c("destination" = "label")) %>% 
  rename(to = id)

# (c) Select/keep only the columns from and to
edges <- select(edges, from, to, weight)
head(edges, 3)

## # A tibble: 3 x 3
##    from    to weight
##      
## 1     1     3      9
## 2     2     1      4
## 3     1     8      3

igraph

1. Create an igraph network object:

• Key R function: graph_from_data_frame().

• Key arguments:
  • d: edge list
  • vertices: node list
  • directed: can be either TRUE or FALSE depending on whether the data is directed or undirected.

library(igraph)
net.igraph <- graph_from_data_frame(
  d = edges, vertices = nodes, 
  directed = TRUE
  )

2. Create a network graph with igraph

set.seed(123)
plot(net.igraph, edge.arrow.size = 0.2,
     layout = layout_with_graphopt)

tidygraph and ggraph

tidygraph and ggraph are modern R packages for network data manipulation (tidygraph) and visualization (ggraph). They leverage the power of igraph.

1. Create a network object using tidygraph:

• Key function: tbl_graph().
• key arguments: nodes, edges and directed.

library(tidygraph)
net.tidy <- tbl_graph(
  nodes = nodes, edges = edges, directed = TRUE
  )

2. Visualize network using ggraph

Key functions:

• geom_node_point(): Draws node points.

• geom_edge_link(): Draws edge links. To control the width of edge line according to the weight variable, specify the option aes(width = weight), where, the weight specify the number of phone.call sent along each route. In this case, you can control the maximum and minimum width of the edges, by using the function scale_edge_width() to set the range (minimum and maximum width value). For example: scale_edge_width(range = c(0.2, 2)).

• geom_node_text(): Adds text labels for nodes, by specifying the argument aes(label = label). To avoid text overlapping, indicate the option repel = TRUE.

• labs(): Change main titles, axis labels and legend titles.

Create a classic node-edge diagrams. Possible values for the argument layout include: 'star', 'circle', 'gem', 'dh', 'graphopt', 'grid', 'mds', 'randomly', 'fr', 'kk', 'drl', 'lgl'.

library(ggraph)
ggraph(net.tidy, layout = "graphopt") + 
  geom_node_point() +
  geom_edge_link(aes(width = weight), alpha = 0.8) + 
  scale_edge_width(range = c(0.2, 2)) +
  geom_node_text(aes(label = label), repel = TRUE) +
  labs(edge_width = "phone.call") +
  theme_graph()

Arc diagram layout

In the following example, we’ll:

• Layout the nodes linearly (horizontal line) using layout = "linear".
• Create an arc diagram by drawing the edges as arcs
• Add only the label names, instead of including node points.

# Arc diagram
ggraph(net.tidy, layout = "linear") + 
  geom_edge_arc(aes(width = weight), alpha = 0.8) + 
  scale_edge_width(range = c(0.2, 2)) +
  geom_node_text(aes(label = label), repel = TRUE) +
  labs(edge_width = "Number of calls") +
  theme_graph()+
  theme(legend.position = "top") 

# Coord diagram, circular
ggraph(net.tidy, layout = "linear", circular = TRUE) + 
  geom_edge_arc(aes(width = weight), alpha = 0.8) + 
  scale_edge_width(range = c(0.2, 2)) +
  geom_node_text(aes(label = label), repel = TRUE) +
  labs(edge_width = "Number of calls") +
  theme_graph()+
  theme(legend.position = "top")

Treemap layout

A treemap is a visual method for displaying hierarchical data that uses nested rectangles to represent the branches of a tree diagram. Each rectangles has an area proportional to the amount of data it represents.

To illustrate this layout, we’ll use the france.trade demo data set [ in navdata package]. It contains the trading percentage between France and different countries.

data("france.trade")
france.trade

## # A tibble: 251 x 3
##   source destination trade.percentage
##                       
## 1 France       Aruba            0.035
## 2 France Afghanistan            0.035
## 3 France      Angola            0.035
## 4 France    Anguilla            0.035
## 5 France     Albania            0.035
## 6 France     Finland            0.035
## # ... with 245 more rows

# Distinct countries
countries <- c(
  france.trade$source, france.trade$destination
) %>%
  unique()
# Create nodes list
nodes <- data_frame(
  id = 1:length(countries),
  label = countries
)

nodes <- nodes %>%
  left_join(
    france.trade[, c("destination", "trade.percentage")],
    by = c("label" = "destination" )
    ) %>%
  mutate(
    trade.percentage = ifelse(
      is.na(trade.percentage), 0, trade.percentage
      )
  )
head(nodes, 3)

## # A tibble: 3 x 3
##      id       label trade.percentage
##                      
## 1     1      France            0.000
## 2     2       Aruba            0.035
## 3     3 Afghanistan            0.035

per_route <- france.trade %>%  
  select(source, destination)

# (a) Join nodes id for source column
edges <- per_route %>% 
  left_join(nodes, by = c("source" = "label")) %>% 
  rename(from = id)

# (b) Join nodes id for destination column
edges <- edges %>% 
  left_join(nodes, by = c("destination" = "label")) %>% 
  rename(to = id)

# (c) Select/keep only the columns from and to
edges <- select(edges, from, to)
head(edges, 3)

## # A tibble: 3 x 2
##    from    to
##    
## 1     1     2
## 2     1     3
## 3     1     4

trade.graph <- tbl_graph(
  nodes = nodes, edges = edges, directed = TRUE
  )

# Generate colors for each country
require(ggpubr)
cols <- get_palette("Dark2", nrow(france.trade)+1)

# Visualize
set.seed(123)
ggraph(trade.graph, &#39;treemap&#39;, weight = "trade.percentage") + 
    geom_node_tile(aes(fill = label), size = 0.25, color = "white")+
  geom_node_text(
    aes(label = paste(label, trade.percentage, sep = "\n"),
        size = trade.percentage), color = "white"
    )+
  scale_fill_manual(values = cols)+
  scale_size(range = c(0, 6) )+
  theme_void()+
  theme(legend.position = "none")

require("map")
# (1)
world_map <- map_data("world")
france.trade <- france.trade %>%
  left_join(world_map, by = c("destination" = "region")) 
# (2)
ggplot(france.trade, aes(long, lat, group = group))+
  geom_polygon(aes(fill = trade.percentage ), color = "white")+
  geom_polygon(data = subset(world_map, region == "France"),
               fill = "red")+ # draw france in red
  scale_fill_gradientn(colours =c("lightgray", "yellow", "green"))+
  theme_void()

Dendrogram layout

Dendrogram layout are suited for hierarchical graph visualization, that is graph structures including trees and hierarchies.

In this section, we’ll compute hierarchical clustering using the USArrests data set. The output is visualized as a dendrogram tree.

1. compute hierarchical clustering using the USArrests data set;
2. then convert the result into a tbl_graph.

res.hclust <- scale(USArrests) %>%
  dist() %>% hclust() 
res.tree <- as.dendrogram(res.hclust)

3. Visualize the dendrogram tree. Key function: geom_edge_diagonal() and geom_edge_elbow()

# Diagonal layout
ggraph(res.tree, layout = "dendrogram") + 
  geom_edge_diagonal() +
  geom_node_text(
    aes(label = label), angle = 90, hjust = 1,
    size = 3
    )+
  ylim(-1.5, NA)+
  theme_minimal()

# Elbow layout
ggraph(res.tree, layout = "dendrogram") + 
  geom_edge_elbow() +
  geom_node_text(
    aes(label = label), angle = 90, hjust = 1,
    size = 3
    )+
  ylim(-1.5, NA)+theme_minimal()