Description Usage Arguments Details Author(s) See Also Examples

View source: R/classBayesianSetup.R

Creates a standardized collection of prior, likelihood and posterior functions, including error checks etc.

1 2 3 4 5 |

`likelihood` |
log likelihood density function |

`prior` |
either a prior class (see |

`priorSampler` |
if a prior density (and not a prior class) is provided to prior, the optional prior sampling function can be provided here |

`parallel` |
parallelization option. Default is F. Other options are T, or "external". See details. |

`lower` |
vector with lower prior limits |

`upper` |
vector with upper prior limits |

`best` |
vector with best prior values |

`names` |
optional vector with parameter names |

`parallelOptions` |
list containing three lists. First "packages" determines the R packages necessary to run the likelihood function. Second "variables" the objects in the global envirnment needed to run the likelihood function and third "dlls" the DLLs needed to run the likelihood function (see Details and Examples). |

`catchDuplicates` |
Logical, determines whether unique parameter combinations should only be evaluated once. Only used when the likelihood accepts a matrix with parameter as columns. |

`plotLower` |
vector with lower limits for plotting |

`plotUpper` |
vector with upper limits for plotting |

`plotBest` |
vector with best values for plotting |

If prior is of class prior (e.g. create with `createPrior`

), priorSampler, lower, upper and best will be ignored.

If prior is a function (log prior density), priorSampler (custom sampler), or lower/upper (uniform sampler) is required.

If prior is NULL, and lower and upper are passed, a uniform prior (see `createUniformPrior`

) will be created with boundaries lower and upper.

For parallelization, option parallel = T means that an automatic parallelization via a standard R socket cluster is attempted. By default, a copy of your workspace, including DLLs and objects are exporte to the cluster workers. Because this can be very inefficient, you can explictly specify the packages, objects and DLLs that are to be exported via parallelOptions.

Using parallel = T requires that the function to be parallelized is well encapsulate, i.e. can run on a shared memory / shared hard disk machine in parallel without interfering with each other. For some functions and programs, this is not the case, so that a custom-programmed parallelization is required.

In this case, and only in this case, you should specify parallel = "external". In this case, it is assumed that the likelihood is programmed such that it accepts a matrix with parameters as columns and the different model runs as rows. It is then up to the user if and how to parallelize this function. This option gives most flexibility to the user, in particular for complicated parallel architecture or shared memory problems.

For more details on parallelization, make sure to read the vignette (run vignette("BayesianTools", package="BayesianTools"))

Florian Hartig, Tankred Ott

`checkBayesianSetup`

`createLikelihood`

`createPrior`

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 | ```
ll <- function(x) sum(dnorm(x, log = TRUE))
test <- createBayesianSetup(ll, prior = NULL, priorSampler = NULL, lower = -10, upper = 10)
str(test)
test$prior$density(0)
test$likelihood$density(c(1,1))
test$likelihood$density(1)
test$posterior$density(1)
test$posterior$density(1, returnAll = TRUE)
test$likelihood$density(matrix(rep(1,4), nrow = 2))
#test$posterior$density(matrix(rep(1,4), nrow = 2), returnAll = TRUE)
test$likelihood$density(matrix(rep(1,4), nrow = 4))
## Not run:
## Example of how to use parallelization using the VSEM model
# Note that the parallelization produces overhead and is not always
# speeding things up. In this example, due to the small
# computational cost of the VSEM the parallelization is
# most likely to reduce the speed of the sampler.
# Creating reference data
PAR <- VSEMcreatePAR(1:1000)
refPars <- VSEMgetDefaults()
refPars[12,] <- c(0.2, 0.001, 1)
rownames(refPars)[12] <- "error-sd"
referenceData <- VSEM(refPars$best[1:11], PAR)
obs = apply(referenceData, 2, function(x) x + rnorm(length(x),
sd = abs(x) * refPars$best[12]))
# Selecting parameters
parSel = c(1:6, 12)
## Builidng the likelihood function
likelihood <- function(par, sum = TRUE){
x = refPars$best
x[parSel] = par
predicted <- VSEM(x[1:11], PAR)
diff = c(predicted[,1:3] - obs[,1:3])
llValues = dnorm(diff, sd = max(abs(c(predicted[,1:3])),0.0001) * x[12], log = TRUE)
if (sum == False) return(llValues)
else return(sum(llValues))
}
# Prior
prior <- createUniformPrior(lower = refPars$lower[parSel], upper = refPars$upper[parSel])
####
## Definition of the packages and objects that are exported to the cluster.
# These are the objects that are used in the likelihood function.
opts <- list(packages = list("BayesianTools"), variables = list("refPars", "obs", "PAR" ),
dlls = NULL)
# Create Bayesian Setup
BSVSEM <- createBayesianSetup(likelihood, prior, best = refPars$best[parSel],
names = rownames(refPars)[parSel], parallel = 2,
parallelOptions = opts)
## The bayesianSetup can now be used in the runMCMC function.
# Note that not all samplers can make use of parallel
# computing.
# Remove the Bayesian Setup and close the cluster
stopParallel(BSVSEM)
rm(BSVSEM)
## End(Not run)
``` |

Embedding an R snippet on your website

Add the following code to your website.

For more information on customizing the embed code, read Embedding Snippets.