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, offset=NULL,method="REML",control=gam.control(),
scale=0,gamma=1,knots=NULL,sp=NULL,min.sp=NULL,paraPen=NULL,
chunk.size=10000,...)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.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.gam.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 easy to justify in the case of GCV or Cp/UBRE/AIC based model selection, and also for REML/ML with known scale parameter. It is slightly less well justified in the REML/ML unknown scale parameter case, but it seems unlikely that this case actually behaves any less well.
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 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.
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())
b1Run the code above in your browser using DataLab