Performs crossvalidation of BTLLasso, including the BTLLasso algorithm for the whole data set.

1 2 3 | ```
cv.BTLLasso(Y, X = NULL, Z1 = NULL, Z2 = NULL, folds = 10, lambda,
control = ctrl.BTLLasso(), cores = folds, trace = TRUE,
trace.cv = TRUE, cv.crit = c("RPS", "Deviance"))
``` |

`Y` |
A |

`X` |
Matrix containing all |

`Z1` |
Matrix containing all |

`Z2` |
Matrix containing all |

`folds` |
Number of folds for the crossvalidation. Default is 10. |

`lambda` |
Vector of tuning parameters. |

`control` |
Function for control arguments, mostly for internal use. See
also |

`cores` |
Number of cores used for (parallelized) cross-validation. By default, equal to the number of folds. |

`trace` |
Should the trace of the BTLLasso algorithm be printed? |

`trace.cv` |
Should the trace fo the cross-validation be printed? If parallelized, the trace is not working on Windows machines. |

`cv.crit` |
Which criterion should be used to evaluate cross-validation. Choice is
between Ranked probability score and deviance. Only |

Cross validation can be performed parallel, default is 10-fold cross
validation on 10 cores. Output is a cv.BTLLasso object which can then be
used for bootstrap confidence intervalls using `boot.BTLLasso`

and `ci.BTLLasso`

.

`coefs` |
Matrix containing all (original) coefficients, one row per tuning parameter, one column per coefficient. |

`coefs.repar` |
Matrix containing all reparameterized (for symmetric side constraint) coefficients, one row per tuning parameter, one column per coefficient. |

`logLik` |
Vector of log-likelihoods, one value per tuning parameter. |

`design` |
List containing design matrix and several additional information like, e.g., number and names of covariates. |

`Y` |
Response object. |

`penalty` |
List containing all penalty matrices and some further information on penalties |

`response` |
Vector containing 0-1 coded response. |

`X` |
X matrix containing subject-specific covariates. |

`Z1` |
Z1 matrix containing subject-object-specific covariates. |

`Z2` |
Z2 matrix containing (subject)-object-specific covariates. |

`lambda` |
Vector of tuning parameters. |

`control` |
Control argument, specified by |

`criterion` |
Vector containing values of the chosen cross-validation criterion, one value per tuning parameter. |

`folds` |
Number of folds in cross validation. |

`cv.crit` |
Cross-validation criterion, either |

Gunther Schauberger

gunther@stat.uni-muenchen.de

http://www.statistik.lmu.de/~schauberger/

Schauberger, Gunther and Tutz, Gerhard (2015): Modelling
Heterogeneity in Paired Comparison Data - an L1 Penalty Approach with an
Application to Party Preference Data, *Department of Statistics, LMU
Munich*, Technical Report 183

Schauberger, Gunther, Groll Andreas and Tutz, Gerhard (2016): Modelling
Football Results in the German Bundesliga Using Match-specific Covariates,
*Department of Statistics, LMU Munich*, Technical Report 197

`BTLLasso`

, `boot.BTLLasso`

, `ctrl.BTLLasso`

,
`singlepaths`

, `paths`

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 | ```
## Not run:
##### Example with simulated data set containing X, Z1 and Z2
data(SimData)
## Specify tuning parameters
lambda <- exp(seq(log(151), log(1.05), length = 30)) - 1
## Specify control argument
## -> allow for object-specific order effects and penalize intercepts
ctrl <- ctrl.BTLLasso(penalize.intercepts = TRUE, object.order.effect = TRUE,
penalize.order.effect.diffs = TRUE)
## Simple BTLLasso model for tuning parameters lambda
m.sim <- BTLLasso(Y = SimData$Y, X = SimData$X, Z1 = SimData$Z1,
Z2 = SimData$Z2, lambda = lambda, control = ctrl)
print(m.sim)
singlepaths(m.sim)
## Cross-validate BTLLasso model for tuning parameters lambda
set.seed(5)
m.sim.cv <- cv.BTLLasso(Y = SimData$Y, X = SimData$X, Z1 = SimData$Z1,
Z2 = SimData$Z2, lambda = lambda, control = ctrl)
print(m.sim.cv)
singlepaths(m.sim.cv, plot.order.effect = FALSE,
plot.intercepts = FALSE, plot.Z2 = FALSE)
paths(m.sim.cv, y.axis = 'L2')
## Example for bootstrap confidence intervals for illustration only
## Don't calculate bootstrap confidence intervals with B = 10!!!!
set.seed(5)
m.sim.boot <- boot.BTLLasso(m.sim.cv, B = 10, cores = 10)
print(m.sim.boot)
ci.BTLLasso(m.sim.boot)
##### Example with small version from GLES data set
data(GLESsmall)
## extract data and center covariates for better interpretability
Y <- GLESsmall$Y
X <- scale(GLESsmall$X, scale = FALSE)
Z1 <- scale(GLESsmall$Z1, scale = FALSE)
## vector of subtitles, containing the coding of the X covariates
subs.X <- c('', 'female (1); male (0)')
## vector of tuning parameters
lambda <- exp(seq(log(61), log(1), length = 30)) - 1
## compute BTLLasso model
m.gles <- BTLLasso(Y = Y, X = X, Z1 = Z1, lambda = lambda)
print(m.gles)
singlepaths(m.gles, subs.X = subs.X)
paths(m.gles, y.axis = 'L2')
## Cross-validate BTLLasso model
m.gles.cv <- cv.BTLLasso(Y = Y, X = X, Z1 = Z1, lambda = lambda)
print(m.gles.cv)
singlepaths(m.gles.cv, subs.X = subs.X)
## End(Not run)
``` |

Questions? Problems? Suggestions? Tweet to @rdrrHQ or email at ian@mutexlabs.com.

Please suggest features or report bugs with the GitHub issue tracker.

All documentation is copyright its authors; we didn't write any of that.