Nothing
#### A "fast" and simplified version of demo(TGforecasts)
#### see ../demo/TGforecasts.R
#### ~~~~~~~~~~~~~~~~~~~~~
require(simsalapar)
## also require(fGarch)
### Variable list ##############################################################
## Create varlist (default type is 'frozen'; default expressions are generated)
## note: no n.sim here
vList <-
varlist(forecaster = list(type="grid", expr = quote(italic(forecaster)),
value = c("statistician", "optimist", "pessimist")),
scoringfun = list(type="inner", expr = quote(S),
value = list(SE = function(x, y) mean((x-y)^2),
AE = function(x, y) mean(abs(x-y)))),
## GARCH(1,1): X_t = sigma_t * eps_t,
## sigma_t^2 = alpha_0 + alpha_1*X_{t-1}^2 + beta_1*sigma_{t-1}^2
alpha0 = list(expr = quote(alpha[0]), value = 0.05),
alpha1 = list(expr = quote(alpha[1]), value = 0.2),
beta1 = list(expr = quote(beta[1]), value = 0.75),
## constant prediction of optimist:
pred.optimist = list(expr = "Optimist", value = 5),
## constant prediction of pessimist:
pred.pessimist = list(expr = "Pessimist", value = 0.05),
## n
n = list(value = 64),
## simulation method
method = list(value = "fGarch"))
### doOne() including ingredient functions #####################################
## -------
## instead of 'local', use a construction like
## doOne <- function(x, <nonGrids>, simGARCH11, predictTG)
doOne <- local({
## function for simulating a squared GARCH(1,1)
simGARCH11 <- function(n, a0, a1, b1, method=c("fGarch", "Gneiting"))
{
method <- match.arg(method)
switch(method,
"fGarch" = {
## specify the GARCH(1,1) process
spec <- fGarch::garchSpec(model =
list(omega = a0, alpha = a1, beta = b1))
## simulate; extended=TRUE => data.frame
## with columns garch, sigma, eps time series
fGarch::garchSim(spec, n=n, extended=TRUE)
},
"Gneiting" = { # Gneiting's code (with minor adjustments)
alpha <- a1
beta <- b1
gamma <- a0
z <- rep(0, n+1)
y <- rep(0, n+1)
sigmasq <- rep(1, n+1)
z[1] <- rnorm(1)
for (t in 2:(n+1)) {
sigmasq[t] <- alpha*z[t-1]^2 + beta*sigmasq[t-1] + gamma
z[t] <- rnorm(1, sd=sqrt(sigmasq[t]))
}
ts(cbind(garch=z[-1], sigma=sqrt(sigmasq[-1])))
},
stop("wrong 'method'"))
}
## prediction function
predictTG <- function(x, n, forecaster, pred.opt, pred.pes) {
stopifnot(is.character(forecaster))
switch(forecaster,
"optimist" = rep(pred.opt, n),
"pessimist" = rep(pred.pes, n),
## statistician predicts hat{X}_t = E[Y_t | sigma_t^2] = sigma_t^2
"statistician" = x[,"sigma"]^2,
stop("forecaster not supported"))
}
##' Statistic (use it like this to include simulation in time measurement)
##' @title Function to Compute the Simulation Results for One Grid Line
##' @param x one-line data.frame containing a combination of grid variables
##' @param nonGrids values of non-"grid"-variables
##' @return return value of doCallWE()
##' @author Marius Hofert
function(n, alpha0, alpha1, beta1, forecaster,
pred.optimist, pred.pessimist, method, scoringfun)
{
## simulate squared GARCH(1,1)
X <- simGARCH11(n, a0=alpha0, a1=alpha1, b1=beta1, method=method)
Y <- X[,"garch"]^2 # see (2) in Gneiting (2011)
## predict
pred <- predictTG(X, n=n, forecaster=forecaster,
pred.opt=pred.optimist, pred.pes=pred.pessimist)
## basic check
stopifnot(length(pred)==length(Y))
## compute scoring functions (for all 'inner' variables simultaneously)
c(SE = scoringfun[["SE"]](pred, y=Y),
AE = scoringfun[["AE"]](pred, y=Y))
}
})
## build grid and non-grid variables
stopifnot(dim(pGrid <- mkGrid(vList)) == c(3,1), # only the forecaster here
get.nonGrids(vList)$n.sim == 1) # the "automatic n.sim" if there is none
tex.vl <- toLatex(vList)
### Computation ################################################################
S.T <- system.time
## 'reproducing' Table 4 in Gneiting (2011)
## sequentially
S.T(res <- doLapply(vList, doOne=doOne, monitor=TRUE))
## our own monitoring function:
myMoni <- function(i.sim, j, pGrid, res4, n.sim) {
cat(SysI(),": ",formG(pGrid, j), "; SE=",
format(res4$value[["SE"]], digits=9, width=15), "\n", sep = "")
}
# Trick, so we can use the printInfo utility functions:
environment(myMoni) <- environment(printInfo[["default"]])
## in parallel
## due to 'R CMD check --as-cran' allowing only <= 2 cores
## note: if doExtras, the check with '--as-cran' fails
(doExtras <- simsalapar:::doExtras())
(nc <- if(.Platform$OS.type == "windows") {
1 # otherwise win-builder fails
} else min(simsalapar:::nCores4test(), 2)) # otherwise CRAN fails
## if simsalapar no longer *depends* on parallel:
makeCluster <- parallel::makeCluster
S.T(resM.<- doMclapply (vList, cores = nc, doOne=doOne, monitor=TRUE))
S.T(resM <- doMclapply (vList, cores = nc, doOne=doOne, monitor=myMoni))
S.T(resF <- doForeach (vList, cluster=makeCluster(nc, type="PSOCK"),
doOne=doOne, monitor=printInfo[["fileEach"]]))
## For this problem, these are much slower on a typical 4-core desktop:
S.T(resC <- doClusterApply(vList, cluster=makeCluster(nc, type="PSOCK"),
doOne=doOne, monitor=printInfo[["gfile"]]))
## Note: Rmpi has a bug under openmpi-2.x (see https://stat.ethz.ch/pipermail/r-sig-hpc/2017-September/002063.html)
if(FALSE) {
(hasRmpi <- .Platform$OS.type!="windows" # <- as Rmpi produces errors on the winbuilder
&& require("Rmpi"))
}
hasRmpi <- FALSE # for now...
if(hasRmpi)
S.T(resR <- doRmpi(vList, nslaves=nc, doOne=doOne, monitor=TRUE))
if(doExtras) { # use all available cores
print(S.T(resC.<- doClusterApply(vList, cluster=makeCluster(nc, type="PSOCK"),
doOne=doOne, monitor=myMoni)))
if(hasRmpi)
print(S.T(resR.<- doRmpi(vList, nslaves=nc, doOne=doOne, monitor=myMoni)))
}
## check that we have the same results
stopifnot(doRes.equal(resM, res),
doRes.equal(resM, resM.),
doRes.equal(resC, res),
if(hasRmpi) doRes.equal(resR, res) else TRUE,
if(doExtras)
doRes.equal(resC, resC.) &&
(if(hasRmpi) doRes.equal(resR, resR.) else TRUE) else TRUE,
doRes.equal(resF, res))
### Analysis ###################################################################
## extract results
val <- getArray(res) # array of values
err <- getArray(res, "error") # array of error indicators
warn <- getArray(res, "warning") # array of warning indicators
time <- getArray(res, "time") # array of user times in ms
## warnings, errors
if(any(err > 0))
ftable(100* err, col.vars="forecaster") # percentage of errors
if(any(warn > 0))
ftable(100*warn, col.vars="forecaster") # percentage of warnings
## 'reproduce' Table 4 of Gneiting (2011)
tab1 <- apply(val, c("forecaster", "scoringfun"), mean)
print(apply(tab1, 2, format, digits=3, scipen=-1), quote=FALSE)
names(attributes(tab1)[["dim"]]) <- NULL # so that check below works
## not ok names(dim(tab1)) <- NULL # so that check below works
## *without* mkAL (as check):
res0 <- doLapply(vList, doAL=FALSE, doOne=doOne, monitor=FALSE)
tab0 <- t(sapply(res0, `[[`, "value")) # values for the 3 forecasters: statistician, optimist, pessimist (see monitoring output)
dimnames(tab0)[[1]] <- c("statistician", "optimist", "pessimist")
names(dimnames(tab0)) <- c("forecaster", "scoringfun")
stopifnot(identical(tab0, tab1)) # check
### Testing other demo()s etc
if(doExtras) {
.checking <- TRUE # to run a smaller demo:
demo(robcovMCD)
}
Any scripts or data that you put into this service are public.
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.