Visualizing interesting world facts with FsLab

In case you missed my recent official FsLab announcement, FsLab is a data-science package for .NET built around F# that makes it easy to get data using type providers, analyze them interactively (with great R integration) and visualize the results. You can find more on on fslab.org, which also has links to some videos and download page with templates and other instructions.

Last time, I mentioned that we are working on integrating FsLab with the XPlot charting library. XPlot is a wonderful F# library built by Taha Hachana that wraps two powerful HTML5 visualization libraries - Google Charts and plot.ly.

I thought I'd see what interesting visualizations I can built with XPlot, so I opened the World Bank type provider to get some data about the world and Euro area, to make the blog post relevant to what is happening in the world today.

With type providers, getting data is amazingly easy. So if you have not seen much F# before, the following 9 lines is all I need to set things up:

1: 
2: 
3: 
4: 
5: 
6: 
7: 
8: 
9: 

#load "packages/FsLab/FsLab.fsx"
open System
open FSharp.Data
open XPlot.GoogleCharts
open XPlot.Plotly

// Pass hidden credentials to Plotly & load WorldBank
Plotly.Signin MyCredentials.userAndKey
let wb = WorldBankData.GetDataContext()

Visualization #1: Structure of GDP in the Euro area

In the first visualization, let's look at the countries that contribute the most to the total GDP of the Euro area (this is countries within the European Union that are using the Euro currency). To get the countries, we can use WorldBank type provider which exposes the region as wb.Regions.``Euro area``. We first return the data for the root element (the whole Euro area) and then yield data for each of the member countries:

1: 
2: 
3: 
4: 
5: 

let euroGDP = 
 [ let euro = wb.Regions.``Euro area``
   yield "EU","",euro.Indicators.``GDP (current US$)``.[2010] 
   for c in euro.Countries do
     yield c.Name,"EU",c.Indicators.``GDP (current US$)``.[2010]]

When writing the code in an F#-enabled editor, you get auto-completion support on the indicators, so you can choose ``GDP (current US$)`` among thousands of indicators available from the World Bank.

Now we can pass the data to Chart.Treemap (which takes a sequence of node name, parent node and value) and set some options to make the visualization nicer:

1: 
2: 
3: 
4: 

Chart.Treemap(euroGDP)
|> Chart.WithOptions 
    (Options(minColor="#B24590", midColor="#449AB5", 
      maxColor="#76B747", headerHeight=0, showScale=true))

The tree map gives us a very nice overview of how different countries in the Euro area contribute to the total GDP of the region. As you can see above, we are showing total GDP (in current US$) and so larger countries obviously contribute more with Germany, France and Italy producing over half of the GDP.

Visualization #2: GDP per capita in the Euro area

Another interesting indicator we can get from the World Bank data is GDP per capita. Using this indicator, we can find smaller countries that have higher GDP (which was not visible in the previous visualization). This time, we'll use the Plotly bindings and create a bar chart using the Bar trace. To follow the visual theme of the previous visualization, I also added a bit of code to calculate the colour (which you can find in the full blog post source

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 

let euroGDPperCap = 
 [ for c in wb.Regions.``Euro area``.Countries ->
   c.Name, c.Indicators.``GDP per capita (current US$)``.[2010]]
 |> List.sortBy snd |> List.rev

Calculating colours omitted

let barChart = Bar(
  x = List.map fst euroGDPperCap,
  y = List.map snd euroGDPperCap,
  marker = Marker(color=List.map getColor euroGDPperCap),
  orientation = "v")
Figure(Data([barChart]), Layout(title="GDP per capita in Euro area"))

Here, we can see that most countries in the Euro area are fairly ballanced, except for Luxembourg which has two times the GDP per capita than the second country. As one would expect, the new member countries are at the end of the scale and western countries are at the beginning of the scale.

Visualization #3: GDP growth in Euro area

There is yet another interesting indicator in the World Bank that we can look at. This is the GDP growth indicator, which gives us annual growth rate of the GDP. In this visualization, we'll look how the growth has been changing over the last 50 years. For most countries, this is very homogeneous, but there are some interesting spikes.

We'll use Plotly again. One nice feature is that we can get data for all countries, but make only a few of them visible by default. Click on the country name on the right to add/remove them from the cart!

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 

let visible = set ["Greece";"Ireland";"Latvia";"Malta"]
let data = 
 [ for ct in wb.Regions.``Euro area``.Countries ->
   let data = ct.Indicators.``GDP growth (annual %)``
   let vis = if visible.Contains ct.Name then "" else "legendonly"
   Scatter(x=Seq.map fst data, y=Seq.map snd data, 
     name=ct.Name, visible=vis) ]

Figure
 ( Data.From data, 
   Layout(title="GDP growth (annual %) in Euro area") )

Here, we can see (and you can also zoom in!) that there is a big spike in the economy of Malta (20% growth in 1975) and big spike in Latvia (-32% in 1992, followed by a fairly quick recovery). Most countries also suffered after the 2008 crisis.

Visualization #4: Correlating GDP and life expectancy

So far, I was looking at GDP, because it is one of the economic indicators that is easy to get from the World Bank. Let's look if GDP is correlated with some other indicators we can obtain. The following gets the GDP (per capita) and Life expectancy (in years) for all countries of the world (looking at Europe would not tell us much).

Now we draw a scatter plot showing life expectancy (on the Y axis) and logarithm (base 10) of the GDP per capita (on the X axis). The following uses Google charts and also uses the trendlines parameter to add a linear trendline to the chart:

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 

let gdpVsLifeExp = 
 [ for c in wb.Countries -> 
   log10 c.Indicators.``GDP per capita (current US$)``.[2010],
   c.Indicators.``Life expectancy at birth, total (years)``.[2010]]

let options = Options(pointSize=3, colors=[|"#3B8FCC"|], 
  trendlines=[|Trendline(opacity=0.5,lineWidth=10,color="#C0D9EA")|],
  hAxis=Axis(title="Log of GDP (per capita)"), 
  vAxis=Axis(title="Life expectancy (years)"))

Chart.Scatter(gdpVsLifeExp)
|> Chart.WithOptions(options)

If we look at the trendline, we can roughly say that countries with life expectancy greater by 10 years have 10 times larger GDP per capita. (That said, we are looking just at the data from 2010 here and we are also not checking any statistical significance, just building an interesting visualization!)

Visualization #5: EU is getting older

Another interesting fact we can nicely visualize is how the EU is getting older. We look at the enitre European Union here (which contains more countries than just the Euro area). In this visualization, we build three overlaying histograms that show the percentage of population over 65 years. To do that, we use Plotly, which lets us nicely compose histograms.

1: 
2: 
3: 
4: 
5: 
6: 
7: 
8: 
9: 

let getGrowths y = 
  let data = [ for c in wb.Regions.``European Union``.Countries -> 
    c.Indicators.``Population ages 65 and above (% of total)``.[y] ]
  Histogram(x=data, name=string y, opacity=0.6)

Figure
  ( Data.From(List.map getGrowths [1960; 1985; 2010]), 
    Layout(barmode="overlay",
      title="Population ages 65 and above (% of total)"))

We can see that in 1960, most countries had 10-12% of population over the age of 65 (with just one country having 12-14%). 25 years later, in 1985, most countries had 12-14% of elderly population. In 2010, most countries have 16-18% of population over the age of 65 and for some countries, this is even 20-20%.

Visualization #6: World's biggest polluters

For the next two visualizations, we'll change the topic and look at green issues rather than the Europe. The XPlot wrapper for Google Charts has a nice wrapper for creating geo charts, and so we can easily take the CO2 emissions indicator from the World Bank and plot the biggest polluters, based on the values from 2010, on a map:

1: 
2: 
3: 
4: 
5: 
6: 
7: 
8: 
9: 

let emissions =
 [ for c in wb.Countries do
   let v = c.Indicators.``CO2 emissions (kt)``.[2010]
   if not(Double.IsNaN(v)) then yield c.Name, v ]

Chart.Geo(emissions)
|> Chart.WithLabels ["Name"; "Emissions (total kt)"]
|> Chart.WithOptions
    (Options(colorAxis=ColorAxis(colors=(color scale))))

This shows the expected results. The world's biggest polluters are China, followed by USA, India and Russia. The next polluters are smaller and include Germany, UK, Canada and Brazil. This indicator returns the total number of CO2 emissions in kilotons, so larger countries are bigger polluters. What if we look at emissions per capita?

Visualization #7: CO2 emissions per capita

The World Bank data set does not directly include an indicator for CO2 emissions per capita, but it contains CO2 emissions and total population, so we can do the math ourselves. The following is very similar to the previous snippet, except that we get both of the indicators return the ratio:

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 

let emissionPerCapita =
 [ for c in wb.Countries do
   let emissions = c.Indicators.``CO2 emissions (kt)``.[2010]
   let population = c.Indicators.``Population, total``.[2010]
   if not(Double.IsNaN(emissions)) then
     yield c.Name, emissions / population ]

emissionPerCapita |> List.sortBy snd |> List.rev

Chart.Geo(emissionPerCapita)
|> Chart.WithLabels ["Name"; "Emissions (per capita)"]
|> Chart.WithOptions
    (Options(colorAxis=ColorAxis(colors=(color scale))))

Here, we can see quite different picture from the previous visualization. The biggest polluters per capita include small Persian Gulf states including Quatar, Kuwait, UAR and Oman, followed by large developed countries (USA, Canada and Australia). We can still see China among the polluters too, but India almost completely disappears from this picture.

Building your own visualizations

I'm not a journalist or a statistician, so I'm sure many of the readers could build much more interesting visualizations than I did. The main point of this article is to show just how easy it is to put together data source like the World Bank with nice visualization libraries available thanks to XPlot. So, if you want to build your own visualizations, here are some links to get you started:

• Go to the FsLab download page and either download a template (the easiest option) or reference the FsLab package from NuGet.
• If you have any questions, ask on StackOverflow with 'fslab' tag or open a GitHub issue.
• The XPlot library has comprehensive documentation with many examples on using the Google Charts wrapper as well as the Plotly wrapper.
• To get data, check out the other F# Data type providers these give you easy ways to read CSV, XML and call JSON-based REST services. There are also nice libraries for calling Twitter and accessing SQL databases.

Finally, if you are interested in using some of the libraries in a commercial setting and are interested in help, support or trainings, get in touch with me and my colleagues at fsharpWorks. We'll be happy to help.