# Analyzing Graphs with Julia

## A brief tutorial on how to use Julia to analyze graphs using the JuliaGraphs packages

First of all, let’s be clear. The goal of this article is to ** briefly introduce** how to use Julia for analyzing graphs. Besides the many types of graphs (undirected, directed, bipartite, weighted…), there are also many methods for analyzing them (degree distribution, centrality measures, clustering measures, visual layouts …). Hence, a comprehensive introduction to Graph Analysis with Julia would be too large of a task.

Therefore, this tutorial focuses on **undirected weighted graphs,** since they encompass weightless graphs, and are* usually more common than directed graphs*¹.

# JuliaGraphs Project

Almost every package you will need can be found in the JuliaGraphs Project. The project contains specific packages for plotting, network layouts, weighted graphs, and more. In our example, we’ll be using GraphPlot.jl and SimpleWeightedGraphs.jl. The good thing about the project is that these packages work together and are very similar in design. Hence, the functions you use for creating a weighted graph are very similar to the ones you use for creating a simple graph with LightGraphs.jl.

**Creating your first Graph**

Let’s create a DataFrame using the DataFrames.jl package. Each column will represent a person, and each row will represent an attribute. Therefore, our graph will be composed of nodes (people) and edges (people share the same attribute).

After creating the DataFrame, we create the graph. Note here that they are actually separate objects. To create the graph, you only need to specify the number of nodes, which is the number of columns. Below I present the code for the creation of the DataFrame and the Graph.

The nodes were inserted, now we have to create the appropriate edges. This is done by using the command `add_edge!()`

which takes the graph, the nodes that must be connected, and the edge weight.

In our example, the the weight is equal to the number of shared attributes between two columns. For example, the first and second column both have 1’s in rows **1** and **7**. Therefore, they share an edge with weight 2:

`add_edge!(g,1,2,2) # add_edge!(graph, node_1, node_2, weight)`

The following code loops through the data, and adds the edges to the graph.

**Visualizing the Graph**

With this, our graph is ready to be visualized. This can be easily done with the following command:

`gplot(g,nodelabel=names(df),edgelinewidth=ew)`

There are several different layouts to chose from, just take a look at the GraphPlots.jl page. Here is another example:

`gplot(g,nodelabel=names(df),edgelinewidth=ew,layout=circular_layout)`

# Centrality and Minimum Spanning Tree

Let’s do some analysis in this graph. As I said in the beginning, there are many way to analyze a graph. Two very common methods are studying the centrality of each node, and creating a Minimum Spanning Tree (MST). The goal of this article is not to explain theoretical aspects of graphs, so I’ll assume that the reader knows what I’m talking about.

Here is an example of how to calculate the *betweeness centrality* and visualizing the results. Note that I added 1 in the first line of code just to enable a better visualization.

Finally, one can also easily create a MST. To do so, we must create a new graph, since we’ll be removing edges and adjusting the nodes’ locations. The code below shows how to do this. The only new function here is the `kruskal_mst()`

which will give us the MST. You can choose if the MST is minimizing of maximizing the path. In our case, we want to create a tree the contains only the “strongest” connections, hence, we are maximizing.

# Conclusion

This is the end of this brief tutorial. There are much more functionalities in the JuliaGraphs project, enabling a much more thorough analysis than the one presented here. Also, one can create more interactive visualizations using VegaLite.jl, but I’ll leave that for another article.

¹ Authors opinion.