gam, except that the numerical methods
are designed for datasets containing upwards of several tens of thousands of data. The advantage
of bam is much lower memory footprint than gam, but it can also be much faster,
for large datasets.bam(formula,family=gaussian(),data=list(),weights=NULL,subset=NULL,
na.action=na.omit, offset=NULL,method="REML",control=list(),
scale=0,gamma=1,knots=NULL,sp=NULL,min.sp=NULL,paraPen=NULL,
chunk.size=10000,rho=0,sparse=FALSE,...)formula.gam and also gam.models).
This is exactly like the formula for a GLM except that smooth terms, s and teenvironment(formula): typically the environment from
which gam is called.formula: this conforms to the behaviour of
lm and glm."GCV.Cp" to use GCV for unknown scale parameter and
Mallows' Cp/UBRE/AIC for known scale. "GACV.Cp" is equivalent, but using GACV in place of GCV. "REML"
for REML estimatiogam.control. Any control parameters not supplied stay at their default values.k value
supplied (note that the number of knots is nfull.sp, in the
returned object, will need to be added to what is supplied here to get the
smoothing parameters actuagam.models explains more.te(...,bs="ps",np=FALSE)
then in principle computation could be made faster using sparse matrix methods, and you could set this to TRUE.
In practice the speedgam.fit (such as mustart)."gam" as described in gamObject."tp" basis is used. You must have more unique combinations of covariates than the model has total parameters. (Total parameters is sum of basis dimensions plus sum of non-spline terms less the number of spline terms).
This routine is less stable than `gam' for a the same dataset.
The negbin family is only supported for the *known theta* case.
bam operates by first setting up the basis characteristics for the smooths, using a representative subsample
of the data. Then the model matrix is constructed in blocks using predict.gam. For each block the factor R,
from the QR decomposition of the whole model matrix is updated, along with Q'y. and the sum of squares of y. At the end of
block processing, fitting takes place, without the need to ever form the whole model matrix. In the generalized case, the same trick is used with the weighted model matrix and weighted pseudodata, at each step of the PIRLS. Smoothness selection is performed on the working model at each stage (performance oriented iteration), to maintain the small memory footprint. This is trivial to justify in the case of GCV or Cp/UBRE/AIC based model selection, and for REML/ML is justified via the asymptotic multivariate normality of Q'z where z is the IRLS pseudodata.
Note that POI is not as stable as the default nested iteration used with gam, but that for very large, information rich,
datasets, this is unlikely to matter much.
Note also that it is possible to spend most of the computational time on basis evaluation, if an expensive basis is used. In practice
this means that the default "tp" basis should be avoided: almost any other basis (e.g. "cr" or "ps")
can be used in the 1D case, and tensor product smooths (te) are typically much less costly in the multi-dimensional case.
If the argument sparse=TRUE then QR updating is replaced by an alternative scheme, in which the model matrix is stored whole
as a sparse matrix. This only makes sense if all smooths are P-splines and all tensor products are of the
form te(...,bs="ps",np=FALSE), but no check is made. The computations are then based on the Choleski decomposition of
the crossproduct of the sparse model matrix. Although this crossproduct is nearly dense, sparsity should make its
formation efficient, which is useful as it is the leading order term in the operations count. However there is no benefit
in using sparse methods to form the Choleski decomposition, given that the crossproduct is dense.
In practice the sparse matrix handling overheads mean that modest or no speed ups are produced
by this approach, while the computation is less stable than the default, and the memory footprint often higher
(but please let the author know if you find an example where the speedup is really worthwhile).
mgcv-package, gamObject, gam.models, smooth.terms,
linear.functional.terms, s,
te predict.gam,
plot.gam, summary.gam, gam.side,
gam.selection,mgcv, gam.control
gam.check, linear.functional.terms negbin, magic,vis.gamlibrary(mgcv)
## following is not *very* large, for obvious reasons...
dat <- gamSim(1,n=15000,dist="normal",scale=20)
bs <- "ps";k <- 20
b <- bam(y ~ s(x0,bs=bs,k=k)+s(x1,bs=bs,k=k)+s(x2,bs=bs,k=k)+
s(x3,bs=bs,k=k),data=dat,method="REML")
summary(b)
plot(b,pages=1,rug=FALSE) ## plot smooths, but not rug
plot(b,pages=1,rug=FALSE,seWithMean=TRUE) ## `with intercept' CIs
ba <- bam(y ~ s(x0,bs=bs,k=k)+s(x1,bs=bs,k=k)+s(x2,bs=bs,k=k)+
s(x3,bs=bs,k=k),data=dat,method="GCV.Cp") ## use GCV
summary(ba)
## A Poisson example...
dat <- gamSim(1,n=15000,dist="poisson",scale=.1)
b1 <- bam(y ~ s(x0,bs=bs,k=k)+s(x1,bs=bs,k=k)+s(x2,bs=bs,k=k)+
s(x3,bs=bs,k=k),data=dat,method="ML",family=poisson())
b1
## Sparse smoothers example...
b2 <- bam(y ~ te(x0,x1,bs="ps",k=10,np=FALSE)+s(x2,bs="ps",k=30)+
s(x3,bs="ps",k=30),data=dat,method="ML",
family=poisson(),sparse=TRUE)
b2Run the code above in your browser using DataLab