A big challenge for applied Bayesian inference is computation: converting the mathematical expression of the posterior distribution into specific inferences or predictions such as the posterior probability that some coefficient is positive, or a 90% predictive interval for some future outcome. For even moderately large or complex problems, such quantities are expressed mathematically in terms of high-dimensional integrals with no closed-form expressions.

Over the past fifty years, a series of advances in computational statistics have allowed these intergrals to be computed using approximations and simulations. The simulations use random numbers and are called “Monte Carlo methods,” named after the city in Europe that is famous for its gambling casinos. These methods were originally developed in the 1940s for aiding in large computations for the military, and in the 1980s it became clear how to apply them for general problems in Bayesian inference.

So: since the 1970s–1980s, methods have been developed to perform approximate computations for Bayesian inferences that would otherwise require intractable intervals. These approximations needed to be developed one model at a time. In the 1990s–2000s, the WinBugs software was developed, which allowed automatic computation for a large class of Bayesian models. WinBugs (and its successors, OpenBugs and Jags) can be slow, and starting in 2011 we developed Stan, which uses more efficient computations (Hamilton Monte Carlo, the no-U-turn sampler, and algorithmic autodifferentiation) so that automatic Bayesian computation can be applied to larger and more complex problems.

Where we stand now is that, for a fairly broad class of models and data of moderate size, we can transparently program our Bayesian models in Stan and perform inference automatically. This represent the culmination of decades of work in computational statistics, along with corresponding decades of experience fitting and understanding these models. The challenge is not just fitting the model; it is also deciding what models to fit.

Future work, by ourselves and others, will increase the speed and scalability of Stan in various ways, including more seamless implantation of parallel processing.

谢谢你的分享

Appealing features of Bayesian inference
Here are some reasons we like to use Bayesian methods:

Integration of data and prior information

Quantification of uncertainty, including probabilistic predictions

Ability to pipe inference directly into decision analysis

Ability to handle uncertainty in large numbers of parameters

It is said that the most important aspect of a statistical analysis is not what you do with the data, it’s what data you use. A key advantage of modern statistical methods (including Bayesian methods but also various non-Bayesian or semi-Bayesian approaches in machine learning) is that they allow you to incorporate different sorts of information into your analysis.

RStan is the R interface to Stan. For more information on Stan and its modeling language visit the Stan website at http://mc-stan.org/

Almost all install instructions below are for the aforementioned version of RStan, which requires that you have R version 3.4.0 or later. If necessary you can install the latest version of R from here.

In addition, we strongly recommend that you use RStudio version 1.2.x or later because it has great support for Stan.

Installation of RStan
To be on the safe side, it is sometimes necessary to remove any existing RStan via

remove.packages("rstan")
if (file.exists(".RData")) file.remove(".RData")
Then, restart R.

In most cases, you can simply type (exactly like this)

install.packages("rstan", repos = "https://cloud.r-project.org/", dependencies = TRUE)
However, if you use Linux or if getOption("pkgType") has been set to "source" or if R asks you whether you want to install the latest version of RStan from source, then go to the corresponding page for Windows, Mac, or Linux.

Checking the C++ Toolchain
In RStudio (preferably) or otherwise in R, execute once

pkgbuild::has_build_tools(debug = TRUE)
to check your C++ toolchain using the pkgbuild package that gets installed when you install RStan. If this line ultimately returns TRUE, then your C++ toolchain is properly installed and you can jump to the next section.

Otherwise,

If you use Windows and RStudio (recommended), a pop-up will appear asking if you want to install Rtools. Click Yes and wait until the installation is finished.
If you use Windows but not RStudio, a message will appear in the R console telling you to install Rtools. Further information to download and install rtools may be helpful, but you do NOT ordinarily need to continue to the section titled "Installing RStan from source".
If you use a Mac, a link will appear but do not click on it. Instead go here
If you use Linux (including Windows Subsystem for Linux), then go here.
If you follow the above instructions but are not successful you can get help from the Stan Discourse Forum but be sure to tell us what your operating system is, whether you use RStudio, and what is the output when you try the above.

Configuration of the C++ Toolchain
This step is optional, but it can result in compiled Stan programs that execute much faster than they otherwise would. Simply paste the following into R once

dotR <- file.path(Sys.getenv("HOME"), ".R")
if (!file.exists(dotR)) dir.create(dotR)
M <- file.path(dotR, ifelse(.Platform$OS.type == "windows", "Makevars.win", "Makevars"))
if (!file.exists(M)) file.create(M)
cat("\nCXX14FLAGS=-O3 -march=native -mtune=native",
    if( grepl("^darwin", R.version$os)) "CXX14FLAGS += -arch x86_64 -ftemplate-depth-256" else
    if (.Platform$OS.type == "windows") "CXX11FLAGS=-O3 -march=native -mtune=native" else
    "CXX14FLAGS += -fPIC",
    file = M, sep = "\n", append = TRUE)

How to Use RStan
The rest of this document assumes that you have already installed RStan by following the instructions above.

Loading the package
The package name is rstan (all lowercase), so we start by executing

library("rstan") # observe startup messages
As the startup message says, if you are using rstan locally on a multicore machine and have plenty of RAM to estimate your model in parallel, at this point execute

options(mc.cores = parallel::detectCores())
In addition, you should follow the second startup message that says to execute

rstan_options(auto_write = TRUE)
which allows you to automatically save a bare version of a compiled Stan program to the hard disk so that it does not need to be recompiled (unless you change it).

Finally, if you use Windows, there will be a third startup message saying to execute

Sys.setenv(LOCAL_CPPFLAGS = '-march=native')
which is not necessary if you followed the C++ toolchain configuration advice in the previous section.

How to Use RStan
The rest of this document assumes that you have already installed RStan by following the instructions above.

Loading the package
The package name is rstan (all lowercase), so we start by executing

library("rstan") # observe startup messages
As the startup message says, if you are using rstan locally on a multicore machine and have plenty of RAM to estimate your model in parallel, at this point execute

options(mc.cores = parallel::detectCores())
In addition, you should follow the second startup message that says to execute

rstan_options(auto_write = TRUE)
which allows you to automatically save a bare version of a compiled Stan program to the hard disk so that it does not need to be recompiled (unless you change it).

Finally, if you use Windows, there will be a third startup message saying to execute

Sys.setenv(LOCAL_CPPFLAGS = '-march=native')
which is not necessary if you followed the C++ toolchain configuration advice in the previous section.

How to Use RStan
The rest of this document assumes that you have already installed RStan by following the instructions above.

Loading the package
The package name is rstan (all lowercase), so we start by executing

library("rstan") # observe startup messages
As the startup message says, if you are using rstan locally on a multicore machine and have plenty of RAM to estimate your model in parallel, at this point execute

options(mc.cores = parallel::detectCores())
In addition, you should follow the second startup message that says to execute

rstan_options(auto_write = TRUE)
which allows you to automatically save a bare version of a compiled Stan program to the hard disk so that it does not need to be recompiled (unless you change it).

Finally, if you use Windows, there will be a third startup message saying to execute

Sys.setenv(LOCAL_CPPFLAGS = '-march=native')
which is not necessary if you followed the C++ toolchain configuration advice in the previous section.

How to Use RStan
The rest of this document assumes that you have already installed RStan by following the instructions above.

Loading the package
The package name is rstan (all lowercase), so we start by executing

library("rstan") # observe startup messages
As the startup message says, if you are using rstan locally on a multicore machine and have plenty of RAM to estimate your model in parallel, at this point execute

options(mc.cores = parallel::detectCores())
In addition, you should follow the second startup message that says to execute

rstan_options(auto_write = TRUE)
which allows you to automatically save a bare version of a compiled Stan program to the hard disk so that it does not need to be recompiled (unless you change it).

Finally, if you use Windows, there will be a third startup message saying to execute

Sys.setenv(LOCAL_CPPFLAGS = '-march=native')
which is not necessary if you followed the C++ toolchain configuration advice in the previous section.

Example 1: Eight Schools
This is an example in Section 5.5 of Gelman et al (2003), which studied coaching effects from eight schools. For simplicity, we call this example "eight schools."

We start by writing a Stan program for the model in a text file. If you are using RStudio version 1.2.x or greater, click on File -> New File -> Stan File . Otherwise, open your favorite text editor. Either way, paste in the following and save your work to a file called 8schools.stan in R's working directory (which can be seen by executing getwd())

We start by writing a Stan program for the model in a text file. If you are using RStudio version 1.2.x or greater, click on File -> New File -> Stan File . Otherwise, open your favorite text editor. Either way, paste in the following and save your work to a file called 8schools.stan in R's working directory (which can be seen by executing getwd())

// saved as 8schools.stan
data {
  int<lower=0> J;         // number of schools
  real y[J];              // estimated treatment effects
  real<lower=0> sigma[J]; // standard error of effect estimates
}
parameters {
  real mu;                // population treatment effect
  real<lower=0> tau;      // standard deviation in treatment effects
  vector[J] eta;          // unscaled deviation from mu by school
}
transformed parameters {
  vector[J] theta = mu + tau * eta;        // school treatment effects
}
model {
  target += normal_lpdf(eta | 0, 1);       // prior log-density
  target += normal_lpdf(y | theta, sigma); // log-likelihood
}

// saved as 8schools.stan
data {
  int<lower=0> J;         // number of schools
  real y[J];              // estimated treatment effects
  real<lower=0> sigma[J]; // standard error of effect estimates
}
parameters {
  real mu;                // population treatment effect
  real<lower=0> tau;      // standard deviation in treatment effects
  vector[J] eta;          // unscaled deviation from mu by school
}
transformed parameters {
  vector[J] theta = mu + tau * eta;        // school treatment effects
}
model {
  target += normal_lpdf(eta | 0, 1);       // prior log-density
  target += normal_lpdf(y | theta, sigma); // log-likelihood
}

// saved as 8schools.stan
data {
  int<lower=0> J;         // number of schools
  real y[J];              // estimated treatment effects
  real<lower=0> sigma[J]; // standard error of effect estimates
}
parameters {
  real mu;                // population treatment effect
  real<lower=0> tau;      // standard deviation in treatment effects
  vector[J] eta;          // unscaled deviation from mu by school
}
transformed parameters {
  vector[J] theta = mu + tau * eta;        // school treatment effects
}
model {
  target += normal_lpdf(eta | 0, 1);       // prior log-density
  target += normal_lpdf(y | theta, sigma); // log-likelihood
}

// saved as 8schools.stan
data {
  int<lower=0> J;         // number of schools
  real y[J];              // estimated treatment effects
  real<lower=0> sigma[J]; // standard error of effect estimates
}
parameters {
  real mu;                // population treatment effect
  real<lower=0> tau;      // standard deviation in treatment effects
  vector[J] eta;          // unscaled deviation from mu by school
}
transformed parameters {
  vector[J] theta = mu + tau * eta;        // school treatment effects
}
model {
  target += normal_lpdf(eta | 0, 1);       // prior log-density
  target += normal_lpdf(y | theta, sigma); // log-likelihood
}

Be sure that your Stan programs ends in a blank line without any characters including spaces and comments.

In this Stan program, we let theta be a transformation of mu, eta, and tau instead of declaring theta in the parameters block, which allows the sampler will run more efficiently (see detailed explanation). We can prepare the data (which typically is a named list) in R with:

Be sure that your Stan programs ends in a blank line without any characters including spaces and comments.

In this Stan program, we let theta be a transformation of mu, eta, and tau instead of declaring theta in the parameters block, which allows the sampler will run more efficiently (see detailed explanation). We can prepare the data (which typically is a named list) in R with: