An Introduction to Greta

By R Views

(This article was first published on R Views, and kindly contributed to R-bloggers)

I was surprised by greta. I had assumed that the tensorflow and reticulate packages would eventually enable R developers to look beyond deep learning applications and exploit the TensorFlow platform to create all manner of production-grade statistical applications. But I wasn’t thinking Bayesian. After all, Stan is probably everything a Bayesian modeler could want. Stan is a powerful, production-level probability distribution modeling engine with a slick R interface, deep documentation, and a dedicated development team.

But greta lets users write TensorFlow-based Bayesian models directly in R! What could be more charming? greta removes the barrier of learning an intermediate modeling language while still promising to deliver high-performance MCMC models that run anywhere TensorFlow can go.

In this post, I’ll introduce you to greta with a simple model used by Richard McElreath in section 8.3 of his iconoclastic book: Statistical Rethinking: A Bayesian Course with Examples in R and Stan. This model seeks to explain the log of a country’s GDP based on a measure of terrain ruggedness while controlling for whether or not the country is in Africa. I am going to use it just to illustrate MCMC sampling with greta. The extended example in McElreath’s book, however, is a meditation on the subtleties of modeling interactions, and is well worth studying.

First, we load the required packages and fetch the data. DiagrammeR is for plotting the TensorFlow flow diagram of the model, and bayesplot is used to plot trace diagrams of the Markov chains. The rugged data set which provides 52 variables for 234 is fairly interesting, but we will use a trimmed-down data set with only 170 counties and three variables.

library(rethinking)
library(greta)
library(DiagrammeR)
library(bayesplot)
library(ggplot2)

# Example from section 8.3 Statistical Rethinking
data(rugged)
d 
##     log_gdp rugged cont_africa
## 3  7.492609  0.858           1
## 5  8.216929  3.427           0
## 8  9.933263  0.769           0
## 9  9.407032  0.775           0
## 10 7.792343  2.688           0
## 12 9.212541  0.006           0
set.seed(1234)

In this section of code, we set up the TensorFlow data structures. The first step is to move the data into greta arrays. These data structures behave similarly to R arrays in that they can be manipulated with functions. However, greta doesn’t immediately calculate values for new arrays. It works out the size and shape of the result and creates a place-holder data structure.

#data
g_log_gdp 

In this section, we set up the Bayesian model. All parameters need prior probability distributions. Note that the parameters a, bR, bA, bAR, sigma, and mu are all new greta arrays that don’t contain any data. a is 1 x 1 array and mu is a 170 x 1 array with one slot for each observation.

The distribution() function sets up the likelihood function for the model.

# Variables and Priors

a 
## greta array (variable following a normal distribution)
## 
##      [,1]
## [1,]  ?
# operations
mu 
## [1] 170   1
# likelihood
distribution(g_log_gdp) = normal(mu, sigma)

The model() function does all of the work. It fits the model and produces a fairly complicated object organized as three lists that contain, respectively, the R6 class, TensorFlow structures, and the various greta data arrays.

# defining the model
mod 
## List of 3
##  $ dag                 :Classes 'dag_class', 'R6' 
##   Public:
##     adjacency_matrix: function () 
##     build_dag: function (greta_array_list) 
##     clone: function (deep = FALSE) 
##     compile: TRUE
##     define_gradients: function () 
##     define_joint_density: function () 
##     define_tf: function () 
##     example_parameters: function (flat = TRUE) 
##     find_node_neighbours: function () 
##     get_tf_names: function (types = NULL) 
##     gradients: function (adjusted = TRUE) 
##     initialize: function (target_greta_arrays, tf_float = tf$float32, n_cores = 2L, 
##     log_density: function (adjusted = TRUE) 
##     make_names: function () 
##     n_cores: 4
##     node_list: list
##     node_tf_names: variable_1 distribution_1 data_1 data_2 operation_1 oper ...
##     node_types: variable distribution data data operation operation oper ...
##     parameters_example: list
##     send_parameters: function (parameters, flat = TRUE) 
##     subgraph_membership: function () 
##     target_nodes: list
##     tf_environment: environment
##     tf_float: tensorflow.python.framework.dtypes.DType, python.builtin.object
##     tf_name: function (node) 
##     trace_values: function ()  
##  $ target_greta_arrays :List of 5
##  $ visible_greta_arrays:List of 9

Plotting mod produces the TensorFlow flow diagram that shows the structure of the underlying TensorFlow model, which is simple for this model and easily interpretable.

# plotting
plot(mod)

Next, we use the greta function mcmc() to sample from the posterior distributions defined in the model.

# sampling
draws 
## 
## Iterations = 1:1000
## Thinning interval = 1 
## Number of chains = 1 
## Sample size per chain = 1000 
## 
## 1. Empirical mean and standard deviation for each variable,
##    plus standard error of the mean:
## 
##          Mean      SD Naive SE Time-series SE
## a      9.2225 0.13721 0.004339       0.004773
## bR    -0.2009 0.07486 0.002367       0.002746
## bA    -1.9485 0.23033 0.007284       0.004435
## bAR    0.3992 0.13271 0.004197       0.003136
## sigma  0.9527 0.04892 0.001547       0.001744
## 
## 2. Quantiles for each variable:
## 
##          2.5%     25%     50%     75%    97.5%
## a      8.9575  9.1284  9.2306  9.3183  9.47865
## bR    -0.3465 -0.2501 -0.1981 -0.1538 -0.05893
## bA    -2.3910 -2.1096 -1.9420 -1.7876 -1.50781
## bAR    0.1408  0.3054  0.3954  0.4844  0.66000
## sigma  0.8616  0.9194  0.9520  0.9845  1.05006

Now that we have the samples of the posterior distributions of the parameters in the model, it is straightforward to examine them. Here, we plot the posterior distribution of the interaction term.

mat 

Finally, we examine the trace plots for the MCMC samples using the greta function mcmc_trace(). The plots for each parameter appear to be stationary (flat, i.e., centered on a constant value) and well-mixed (there is no obvious correlation between points). mcmc_intervals() plots the uncertainty intervals for each parameter computed from posterior draws with all chains merged.

mcmc_trace(draws)

mcmc_intervals(draws)

So there it is – a Bayesian model using Hamiltonian Monte Carlo sampling built in R and evaluated by TensorFlow.

For an expert discussion of the model, have a look at McElreath’s book, described at the link above. For more on greta, see the package documentation. And please, do take the time to read about greta‘s namesake: Greta Hermann, a remarkable woman – mathematician, philosopher, educator, social activist, and theoretical physicist who found the error in John von Neuman’s “proof” of the “No hidden variables theorem” of Quantum Mechanics.

To leave a comment for the author, please follow the link and comment on their blog: R Views.

R-bloggers.com offers daily e-mail updates about R news and tutorials on topics such as: Data science, Big Data, R jobs, visualization (ggplot2, Boxplots, maps, animation), programming (RStudio, Sweave, LaTeX, SQL, Eclipse, git, hadoop, Web Scraping) statistics (regression, PCA, time series, trading) and more…

Source:: R News

Leave a Reply

Your email address will not be published. Required fields are marked *

Time limit is exhausted. Please reload CAPTCHA.