riskRegression

https://github.com/tagteam/riskregression
Admin
riskRegression is an R package for risk regression models and prediction scores in survival analysis...
Tokens:212,318
Snippets:1,314
Trust Score:8.4
Update:1 week ago
Show doc for...
Tokens:
Raw
### Load libraries and set up data for influenceTest

Source: https://github.com/tagteam/riskregression/blob/master/man/influenceTest.Rd

Loads required packages (lava, survival, prodlim, data.table) and sets the sample size to 100. This setup is used by all subsequent examples.

```R
library(lava)
library(survival)
library(prodlim)
library(data.table)
n <- 100
```

--------------------------------

### Load required libraries for anova.ate example

Source: https://github.com/tagteam/riskregression/blob/master/man/anova.ate.Rd

Loads the survival, data.table, and ggplot2 packages needed for the example.

```R
library(survival)
library(data.table)
library(ggplot2)
```

--------------------------------

### getSplitMethod examples

Source: https://github.com/tagteam/riskregression/blob/master/man/getSplitMethod.Rd

Three examples show how to call getSplitMethod with different splitting methods and parameters: 3-fold cross-validation, bootstrap with replacement, and bootstrap without replacement.

```r
# 3-fold crossvalidation
getSplitMethod("cv3",B=4,N=37)
```

```r
# bootstrap with replacement
getSplitMethod("loob",B=4,N=37)
```

```r
# bootstrap without replacement
getSplitMethod("loob",B=4,N=37,M=20)
```

--------------------------------

### rowSumsCrossprod example with transposeY = 0

Source: https://github.com/tagteam/riskregression/blob/master/man/rowSumsCrossprod.Rd

Example using a 5x2 matrix X and a 5x4 matrix Y with transposeY = 0, computing crossprod(rowSums(X), Y).

```r
x <- matrix(1:10,nrow=5)
y <- matrix(1:20,ncol=4)
rowSumsCrossprod(x,y,0)
```

--------------------------------

### rowSumsCrossprod example with transposeY = 1

Source: https://github.com/tagteam/riskregression/blob/master/man/rowSumsCrossprod.Rd

Example using a 5x2 matrix X and a 5x5 matrix Y with transposeY = 1, computing crossprod(rowSums(X), Y) after transposing Y.

```r
x <- matrix(1:10,nrow=5)
y <- matrix(1:20,ncol=5)
rowSumsCrossprod(x,y,1)
```

--------------------------------

### boot2pvalue usage and examples

Source: https://github.com/tagteam/riskregression/blob/master/man/boot2pvalue.Rd

The usage section shows the function signature with default arguments. The examples demonstrate computing p-values for no effect, positive effect, and negative effect scenarios, with expected values commented. The function returns 1 for test statistics close to 0, and for positive statistics with alternative 'less' or negative statistics with alternative 'greater'.

```r
boot2pvalue(
  x,
  null,
  estimate = NULL,
  alternative = "two.sided",
  FUN.ci = quantileCI,
  tol = .Machine$double.eps^0.5
)
```

```r
set.seed(10)

#### no effect ####
x <- rnorm(1e3) 
boot2pvalue(x, null = 0, estimate = mean(x), alternative = "two.sided")
## expected value of 1
boot2pvalue(x, null = 0, estimate = mean(x), alternative = "greater")
## expected value of 0.5
boot2pvalue(x, null = 0, estimate = mean(x), alternative = "less")
## expected value of 0.5

#### positive effect ####
x <- rnorm(1e3, mean = 1) 
boot2pvalue(x, null = 0, estimate = 1, alternative = "two.sided")
## expected value of 0.32 = 2*pnorm(q = 0, mean = -1) = 2*mean(x<=0)
boot2pvalue(x, null = 0, estimate = 1, alternative = "greater")  
## expected value of 0.16 = pnorm(q = 0, mean = 1) = mean(x<=0)
boot2pvalue(x, null = 0, estimate = 1, alternative = "less")
## expected value of 0.84 = 1-pnorm(q = 0, mean = 1) = mean(x>=0)

#### negative effect ####
x <- rnorm(1e3, mean = -1) 
boot2pvalue(x, null = 0, estimate = -1, alternative = "two.sided") 
## expected value of 0.32 = 2*(1-pnorm(q = 0, mean = -1)) = 2*mean(x>=0)
boot2pvalue(x, null = 0, estimate = -1, alternative = "greater")
## expected value of 0.84 = pnorm(q = 0, mean = -1) = mean(x<=0)
boot2pvalue(x, null = 0, estimate = -1, alternative = "less") # pnorm(q = 0, mean = -1)
## expected value of 0.16 = 1-pnorm(q = 0, mean = -1) = mean(x>=0)
```

--------------------------------

### Ctree example with SimSurv and predictRisk

Source: https://github.com/tagteam/riskregression/blob/master/man/Ctree.Rd

Example usage of Ctree with the party package. It requires the party package, sets a seed, simulates survival data, creates new data, fits a conditional inference tree, and predicts risks at specified times.

```R
if (require("party",quietly=TRUE)){
library(prodlim)
library(party)
library(survival)
set.seed(50)
d <- SimSurv(50)
nd <- data.frame(X1=c(0,1,0),X2=c(-1,0,1))
f <- Ctree(Surv(time,status)~X1+X2,data=d)
predictRisk(f,newdata=nd,times=c(3,8))
}
```

--------------------------------

### Example: Compare sweep and colCenter_cpp

Source: https://github.com/tagteam/riskregression/blob/master/man/colCenter_cpp.Rd

Shows how to use colCenter_cpp to subtract a vector of row means from a matrix, and compares it with the equivalent base R sweep call. The example creates a 6x5 matrix of ones and centers it by subtracting the sequence 1:6.

```R
x <- matrix(1,6,5)
sweep(x, MARGIN = 1, FUN = "-", STATS = 1:6)
colCenter_cpp(x, 1:6 )
```

--------------------------------

### Install riskRegression from GitHub using devtools

Source: https://github.com/tagteam/riskregression/blob/master/README.md

Use this R code to install the riskRegression package directly from its GitHub repository. Requires the devtools package to be installed beforehand.

```R
library(devtools)
install_github("tagteam/riskRegression")
```

--------------------------------

### Load libraries for ATE estimation

Source: https://github.com/tagteam/riskregression/blob/master/man/ate.Rd

Loads the survival, prodlim, and data.table packages required for the example.

```R
library(survival)
library(prodlim)
library(data.table)
```

--------------------------------

### Use future and doFuture for parallel Score with Cox model in riskRegression

Source: https://github.com/tagteam/riskregression/blob/master/man/Score.Rd

Setup for parallel computation using the future and doFuture packages, registering all available cores. The example fits a Cox model on simulated survival data and scores it with a bootstrap cross-validation, setting the 'parallel' argument to 'as.registered' to use registered parallel workers.

```r
library(riskRegression)
library(future)
library(foreach)
library(doFuture)
library(survival)
# Register all available cores for parallel operation
plan(multiprocess, workers = availableCores())
registerDoFuture()
set.seed(10)
trainSurv <- sampleData(400,outcome="survival")
cox1 = coxph(Surv(time,event)~X1+X2+X7+X9,data=trainSurv,
             y=TRUE, x = TRUE)
# Bootstrapping on multiple cores
x1 = Score(list("Cox(X1+X2+X7+X9)"=cox1),
     formula=Surv(time,event)~1,data=trainSurv, times=c(5,8),
     parallel = "as.registered", split.method="bootcv",B=100)
```

--------------------------------

### rowCumSum example

Source: https://github.com/tagteam/riskregression/blob/master/man/rowCumSum.Rd

Create a matrix and apply rowCumSum to it. The result is a matrix of the same size as the input.

```r
x <- matrix(1:8,ncol=2)
rowCumSum(x)
```

--------------------------------

### Example: rowCenter_cpp and sweep comparison

Source: https://github.com/tagteam/riskregression/blob/master/man/rowCenter_cpp.Rd

Creates a 6x5 matrix of ones, then demonstrates the equivalent base R sweep operation and the rowCenter_cpp function with a vector of 1:5, and finally with column means.

```r
x <- matrix(1,6,5)
sweep(x, MARGIN = 2, FUN = "-", STATS = 1:5)
rowCenter_cpp(x, 1:5 )

rowCenter_cpp(x, colMeans(x) )
```

--------------------------------

### Load Melanoma dataset with data()

Source: https://github.com/tagteam/riskregression/blob/master/man/Melanoma.Rd

Loads the Melanoma dataset into the R environment. This is the only example provided on the page.

```R
data(Melanoma)
```

--------------------------------

### colMultiply_cpp usage example

Source: https://github.com/tagteam/riskregression/blob/master/man/colMultiply_cpp.Rd

Shows how to use colMultiply_cpp to multiply each column of a matrix by a scaling vector, and compares it with the equivalent sweep call. The example creates a 6x5 matrix of ones and scales each column by 1:6.

```R
x <- matrix(1,6,5)
sweep(x, MARGIN = 1, FUN = "*", STATS = 1:6)
colMultiply_cpp(x, 1:6 )
```

--------------------------------

### Example: Fit ridge and lasso models, predict, and score

Source: https://github.com/tagteam/riskregression/blob/master/man/penalizedS3.Rd

This example fits ridge and lasso penalized logistic regression models using penalizedS3 on simulated data, then predicts risk and evaluates with Score. It is wrapped in \dontrun{} because it is too slow. The elastic net fit is commented out. Requires the prodlim and penalized packages.

```r
library(prodlim)
\dontrun{
## too slow
if (require("penalized",quietly=TRUE)){
library(penalized)
set.seed(8)
d <- sampleData(200,outcome="binary")
newd <- sampleData(80,outcome="binary")
fitridge <- penalizedS3(Y~X1+X2+pen(7:8), data=d, type="ridge",
                standardize=TRUE, model="logistic",trace=FALSE)
fitlasso <- penalizedS3(Y~X1+X2+pen(7:8), data=d, type="lasso",
                standardize=TRUE, model="logistic",trace=FALSE)
# fitnet <- penalizedS3(Y~X1+X2+pen(7:8), data=d, type="elastic.net",
# standardize=TRUE, model="logistic",trace=FALSE)
predictRisk(fitridge,newdata=newd)
predictRisk(fitlasso,newdata=newd)
# predictRisk(fitnet,newdata=newd)
Score(list(fitridge),data=newd,formula=Y~1)
Score(list(fitridge),data=newd,formula=Y~1,split.method="bootcv",B=2)
data(nki70) ## S4 fit
fitS4 <- penalized(Surv(time, event), penalized = nki70[,8:77],
                 unpenalized = ~ER+Age+Diam+N+Grade, data = nki70,
                 lambda1 = 1)
fitS3 <- penalizedS3(Surv(time,event)~ER+Age+Diam+pen(8:77)+N+Grade,
                     data=nki70, lambda1=1)
## or
penS3 <- penalizedS3(Surv(time,event)~ER+pen(TSPYL5,Contig63649_RC)+pen(10:77)+N+Grade,
                     data=nki70, lambda1=1)
## also this works
penS3 <- penalizedS3(Surv(time,event)~ER+Age+pen(8:33)+Diam+pen(34:77)+N+Grade,
                    data=nki70, lambda1=1)
}}
```

--------------------------------

### SurvResponseVar usage examples with Surv and Hist formulas

Source: https://github.com/tagteam/riskregression/blob/master/man/SurvResponseVar.Rd

Example calls to SurvResponseVar with different formula types: Surv(time,event)~X1+X2, Hist(time,event==0)~X1+X2, counting process formulas with Surv(start,time,status,type="counting") and Surv(start,event=status,time2=time,type="counting"), a namespaced survival::Surv version, a plain status formula, an I(status == 1) formula, and a list of two Hist formulas. Wrapped in \dontrun{} so they are not executed automatically.

```r
SurvResponseVar(Surv(time,event)~X1+X2)
SurvResponseVar(Hist(time,event==0)~X1+X2)
SurvResponseVar(Surv(start,time, status,type="counting") ~ X3+X5)
SurvResponseVar(Surv(start,event=status, time2=time,type="counting") ~ X3+X5)

SurvResponseVar(survival::Surv(start,event=status, time2=time,type="counting") ~ X3+X5)
SurvResponseVar(status ~ X3+X5)
SurvResponseVar(I(status == 1) ~ X3+X5)
SurvResponseVar(list(Hist(time, event) ~ X1+X6,Hist(time, event) ~ X6))
```

--------------------------------

### Example: Compute confidence intervals for predicted survival from a Cox model

Source: https://github.com/tagteam/riskregression/blob/master/man/confint.predictCox.Rd

This example loads the survival package, generates sample data, fits a stratified Cox model, computes individual survival probabilities with standard errors and confidence bands, and then demonstrates how to manually verify the standard error and confidence interval calculations. It also shows how to use confint with the 'none' transformation.

```r
library(survival)

#### generate data ####
set.seed(10)
d <- sampleData(40,outcome="survival") 

#### estimate a stratified Cox model ####
fit <- coxph(Surv(time,event)~X1 + strata(X2) + X6,
             data=d, ties="breslow", x = TRUE, y = TRUE)

#### compute individual specific survival probabilities  
fit.pred <- predictCox(fit, newdata=d[1:3], times=c(3,8), type = "survival",
                       se = TRUE, iid = TRUE, band = TRUE)
fit.pred

## check standard error
sqrt(rowSums(fit.pred$survival.iid[,,1]^2)) ## se for individual 1

## check confidence interval
newse <- fit.pred$survival.se/(-fit.pred$survival*log(fit.pred$survival))
cbind(lower = as.double(exp(-exp(log(-log(fit.pred$survival)) + 1.96 * newse))),
      upper = as.double(exp(-exp(log(-log(fit.pred$survival)) - 1.96 * newse)))
)

#### compute confidence intervals without transformation
confint(fit.pred, survival.transform = "none")
cbind(lower = as.double(fit.pred$survival - 1.96 * fit.pred$survival.se),
      upper = as.double(fit.pred$survival + 1.96 * fit.pred$survival.se)
)
```

--------------------------------

### Load riskRegression and survival packages

Source: https://github.com/tagteam/riskregression/blob/master/examples/demo.org

Loads the riskRegression and survival packages and prints the installed version of riskRegression.

```R
library(riskRegression)
library(survival)
packageVersion("riskRegression")
```

--------------------------------

### FGR with explicit noFun transformation for X2

Source: https://github.com/tagteam/riskregression/blob/master/man/FGR.Rd

Shows the same result as the previous example but more explicit, using noFun for X2 and printing only the crrFit component.

```r
## still same result, but more explicit
f5a <- FGR(Hist(time,cause)~cov2(X1,tf=qFun)+cov2(X2,tf=noFun),data=d)
f5a$crrFit
```

--------------------------------

### subsetIndex examples with matrix and vector

Source: https://github.com/tagteam/riskregression/blob/master/man/subsetIndex.Rd

Shows how to use subsetIndex on a matrix and a vector. For matrices, index 0 sets the column to the default value, and NA sets it to NA. For vectors, the same index semantics apply.

```r
M <- matrix(rnorm(50),5,10)
subsetIndex(M, index = c(0,0,1), default = 0)
subsetIndex(M, index = c(0,2,3,NA), default = 0)
subsetIndex(M, index = c(0,NA,2,3,NA), default = 0)

C <- 1:10
subsetIndex(C, index = c(0,0,1,5,NA), default = 0)
```

--------------------------------

### Example: autoplot and plotAUC for survival AUC

Source: https://github.com/tagteam/riskregression/blob/master/man/autoplot.Score.Rd

This example loads survival and ggplot2 packages, creates sample data, fits two Cox models, computes AUC scores, and generates plots using autoplot and plotAUC. It demonstrates basic AUC plotting, confidence intervals, and contrasts.

```R
library(survival)
library(ggplot2)
set.seed(10)
d=sampleData(100,outcome="survival")
nd=sampleData(100,outcome="survival")
f1=coxph(Surv(time,event)~X1+X6+X8,data=d,x=TRUE,y=TRUE)
f2=coxph(Surv(time,event)~X2+X5+X9,data=d,x=TRUE,y=TRUE)
xx=Score(list(f1,f2), formula=Surv(time,event)~1,
data=nd, metrics="auc", null.model=FALSE, times=seq(3:10))
g <- autoplot(xx)
print(g)
aucgraph <- plotAUC(xx)
plotAUC(xx,conf.int=TRUE)
plotAUC(xx,which="contrasts")
plotAUC(xx,which="contrasts",conf.int=TRUE)
```

--------------------------------

### rowPaste example: collapse rows of a matrix

Source: https://github.com/tagteam/riskregression/blob/master/man/rowPaste.Rd

Creates a 26x2 matrix of letters and applies rowPaste to collapse each row into a single string. The example is wrapped in \dontrun{} and is not executed during package checks.

```r
M <- matrix(letters,nrow = 26, ncol = 2)
rowPaste(M)
```

--------------------------------

### rowScale_cpp usage example

Source: https://github.com/tagteam/riskregression/blob/master/man/rowScale_cpp.Rd

Creates a 6x5 matrix of ones and demonstrates scaling by a vector 1:5 using both sweep and rowScale_cpp, then shows scaling by column means.

```r
x <- matrix(1,6,5)
sweep(x, MARGIN = 2, FUN = "/", STATS = 1:5)
rowScale_cpp(x, 1:5 )

rowScale_cpp(x, colMeans(x) )
```

--------------------------------

### Competing risk outcome example (not run)

Source: https://github.com/tagteam/riskregression/blob/master/man/plotRisk.Rd

Fits a Fine-Gray and a Cause-Specific Cox model on a competing risk outcome and plots predicted risks at a specified time. This example is wrapped in \dontrun and is not executed by default.

```R
## competing risk
\dontrun{
library(prodlim)
library(survival)
set.seed(8)
learndat = sampleData(80,outcome="competing.risk")
testdat = sampleData(140,outcome="competing.risk")
m1 = FGR(Hist(time,event)~X2+X7+X9,data=learndat,cause=1)
m2 = CSC(Hist(time,event)~X2+X7+X9,data=learndat,cause=1)
xcr=Score(list("FGR"=m1,"CSC"=m2),formula=Hist(time,event)~1,
         data=testdat,summary="risks",null.model=0L,times=c(3,5))
plotRisk(xcr,times=3)
}
```

--------------------------------

### colCumSum example

Source: https://github.com/tagteam/riskregression/blob/master/man/colCumSum.Rd

Creates a 4x2 matrix with values 1 to 8 and applies colCumSum to compute column-wise cumulative sums.

```r
x <- matrix(1:8,ncol=2)
colCumSum(x)
```

--------------------------------

### Example: simActiveSurveillance(3)

Source: https://github.com/tagteam/riskregression/blob/master/man/simActiveSurveillance.Rd

Sets the random seed to 71 and simulates a data table of size 3 using simActiveSurveillance.

```r
set.seed(71)
simActiveSurveillance(3)
```

--------------------------------

### Setup training and test data with logistic regression models

Source: https://github.com/tagteam/riskregression/blob/master/simulation/k-fold-CV.html

Sets up training and test datasets using simActiveSurveillance, creates binary outcome Y1, and fits two logistic regression models (exclusive and inclusive ERG).

```R
set.seed(18)
astrain <- simActiveSurveillance(278)
astest <- simActiveSurveillance(208)
astrain[,Y1:=1*(event==1 & time<=1)]
astest[,Y1:=1*(event==1 & time<=1)]
lrfit.ex <- glm(Y1~age+lpsaden+ppb5+lmax+ct1+diaggs,data=astrain,family="binomial")
lrfit.inc <- glm(Y1~age+lpsaden+ppb5+lmax+ct1+diaggs+erg.status,data=astrain,family="binomial")
## Score(list("Exclusive ERG"=lrfit.ex,"Inclusive ERG"=lrfit.inc),data=astest,formula=Y1~1,se.fit=0L,metrics="brier",contrasts=FALSE)
```

--------------------------------

### Simulate Melanoma-like data with simMelanoma

Source: https://github.com/tagteam/riskregression/blob/master/man/simMelanoma.Rd

Simulates a data table of size n. The example sets a seed for reproducibility and generates 3 rows.

```r
set.seed(71)
simMelanoma(3)
```

--------------------------------

### Package versions used in the vignette

Source: https://github.com/tagteam/riskregression/blob/master/vignettes/IPA.html

Lists the versions of data.table, survival, riskRegression, and Publish packages used in the examples.

```text
data.table:[1] ‘1.17.8’

survival:[1] ‘3.8.3’

riskRegression:[1] ‘2025.9.5’

Publish:[1] ‘2025.7.24’
```

--------------------------------

### Load glmnet package for CSC

Source: https://github.com/tagteam/riskregression/blob/master/man/CSC.Rd

Loads the glmnet package, presumably to be used as a fitter for CSC. This is the beginning of an example that is not fully shown.

```r
library(glmnet)
```

--------------------------------

### FGR with cov2 and cov1 for explicit time transformations

Source: https://github.com/tagteam/riskregression/blob/master/man/FGR.Rd

Shows the same model as the previous example but more explicit, using cov2 for X1 and cov1 for X2.

```r
## same thing, but more explicit:
f3 <- FGR(Hist(time,cause)~cov2(X1)+cov1(X2),data=d)
print(f3)
```

--------------------------------

### Load R packages and show versions

Source: https://github.com/tagteam/riskregression/blob/master/vignettes/IPA.org

Loads required R packages (data.table, survival, riskRegression, Publish) and prints their installed versions. Used to verify the package versions used in the vignette.

```R
library(data.table)
library(survival)
library(riskRegression)
library(Publish)
cat("data.table:")
packageVersion("data.table")
cat("\nsurvival:")
packageVersion("survival")
cat("\nriskRegression:")
packageVersion("riskRegression")
cat("\nPublish:")
packageVersion("Publish")
```

--------------------------------

### selectCox example with simulated survival data

Source: https://github.com/tagteam/riskregression/blob/master/man/selectCox.Rd

Loads the survival package, sets a seed for reproducibility, generates a sample survival dataset with 89 observations, and applies selectCox to select variables for a Cox model. The rule argument defaults to 'aic'.

```R
library(survival)
set.seed(74)
d <- sampleData(89,outcome="survival")
f <- selectCox(Surv(time,event)~X1+X2+X3+X4+X6+X7+X8+X9, data=d)
```

--------------------------------

### Generate survival data for ATE example

Source: https://github.com/tagteam/riskregression/blob/master/man/ate.Rd

Creates a simulated survival dataset with 100 observations, rounds the time variable, and adds a factor treatment variable X1 with three levels.

```R
n <- 100
set.seed(10)
dtS <- sampleData(n, outcome="survival")
dtS$time <- round(dtS$time,1)
dtS$X1 <- factor(rbinom(n, prob = c(0.3,0.4) , size = 2), labels = paste0("T",0:2))
```

--------------------------------

### ATE with glm: confidence intervals and lava alternative

Source: https://github.com/tagteam/riskregression/blob/master/man/ate.Rd

Shows two approaches for ATE with confidence intervals: using ate with se=TRUE and summary, and using the lava package's estimate function with a custom function to compute risk differences. The lava example is wrapped in \dontrun.

```R
## with confidence intervals
ateFit1b <- ate(fit.glm, data = dtB, treatment = "X1",
               times = 5) ## just for having a nice output not used in computations
summary(ateFit1b, short = TRUE)

## using the lava package
library(lava)
ateLava <- estimate(fit.glm, function(p, data){
a <- p["(Intercept)"] ; b <- p["X11"] ; c <- p["X2"] ;
R.X11 <- expit(a + b + c * data[["X2"]])
R.X10 <- expit(a + c * data[["X2"]])
list(risk0=R.X10,risk1=R.X11,riskdiff=R.X11-R.X10)},
average=TRUE)
ateLava
```

--------------------------------

### Binary outcome with cross-validation (not run)

Source: https://github.com/tagteam/riskregression/blob/master/man/plotROC.Rd

Computes scores with bootstrap cross-validation (B=3, split.method="bootcv") for binary data. This example is wrapped in \dontrun and is not executed by default.

```r
# with cross-validation
\dontrun{
xb3 <- Score(list("glm"=fb1,"rf"=fb2),y~1,data=bdl,
            plots="roc",B=3,split.method="bootcv",
            metrics=c("auc"))
}
```

--------------------------------

### Survival analysis example with riskLevelPlot

Source: https://github.com/tagteam/riskregression/blob/master/man/riskLevelPlot.Rd

Simulates survival data, fits a Cox regression model, and creates a level plot of predicted risks at a chosen time horizon. Requires the survival and prodlim packages.

```R
# ---------- survival analysis --------------------

# --simulate an artificial data frame
# with survival response and three predictors

library(survival)
library(prodlim)
set.seed(140515)
sdat <- sampleData(43,outcome="survival")
# -- fit a Cox regression model 
survForm = Surv(time,event) ~ X8 + X9
cox <- coxph(survForm, data = sdat,x=TRUE)

# --choose a time horizon for the predictions and plot the risks
timeHorizon <- floor(median(sdat$time))
riskLevelPlot(cox, survForm, data = sdat, horizon = timeHorizon)
```

--------------------------------

### Return simulation code with return_code=TRUE

Source: https://github.com/tagteam/riskregression/blob/master/man/synthesize.Rd

Shows how to use the return_code=TRUE argument to get the R code for simulation instead of the lava object. The first call uses the default recursive=FALSE, the second uses recursive=TRUE to create a structural equation model.

```r
# return the simulation code instead of the object 
synthesize(object=Hist(time,status)~logbili+age+sex,data=pbc,return_code=TRUE)
```

```r
# option recursive creates a structural equation model
synthesize(object=Hist(time,status)~logbili+age+sex,
             data=pbc,
      return_code=TRUE,
        recursive=TRUE)
```

```r
synthesize(object=logbili~age+sex,
             data=pbc,
      return_code=TRUE,
        recursive=TRUE)
```

--------------------------------

### Compare ARR with power and timevar transformations

Source: https://github.com/tagteam/riskregression/blob/master/man/riskRegression.Rd

Fits two ARR models: one with tp(thick, power=1) and one with timevar(thick), then prints summaries for each. These models are later used in the Score example.

```R
fit.arr2a <- ARR(Hist(time,status)~tp(thick,power=1),data=Melanoma,cause=1)
summary(fit.arr2a)
fit.arr2b <- ARR(Hist(time,status)~timevar(thick),data=Melanoma,cause=1)
summary(fit.arr2b)
```

--------------------------------

### Bootstrap Sampling with Replacement for bootcv

Source: https://github.com/tagteam/riskregression/blob/master/man/Score.Rd

This example demonstrates the bootstrap sampling procedure with replacement, which is used in the bootcv method. It sets a seed for reproducibility, generates a small dataset, and computes the in-bag and out-of-bag indices. The final line calls an internal function to obtain the actual split indices used by the package.

```r
set.seed(13)
N=17
data = data.frame(id=1:N, y=rbinom(N,1,.3),x=rnorm(N))
boot.index = sample(1:N,size=N,replace=TRUE)
boot.index
inbag = 1:N %in% boot.index
outofbag = !inbag
learn.data = data[inbag]
val.data = data[outofbag]
riskRegression:::getSplitMethod("bootcv",B=10,N=17)$index
```

--------------------------------

### Logistic regression example with riskLevelPlot

Source: https://github.com/tagteam/riskregression/blob/master/man/riskLevelPlot.Rd

Simulates data for a logistic regression model and creates a level plot of predicted risks. The example defines helper functions expit and partyData, fits a glm model, and calls riskLevelPlot. A dontrun block shows an optional randomForest example.

```R
# ---------- logistic regression --------------------
expit <- function(x){exp(x)/(1+exp(x))}
partyData <- function(N){
  Age <- runif(N,.5,15)
  Parasites <- rnorm(N,mean=3.5-0.03*Age)
  Fever <- factor(rbinom(N,1,expit(-3.5-.3*Age+.55*Parasites+0.15*Age*Parasites)))
  data.frame(Fever,Age,Parasites)
}
d <- partyData(100)
f <- glm(Fever~Age+Parasites,data=d,family="binomial")
riskLevelPlot(f,Fever~Age+Parasites,d)
\dontrun{
if (require("randomForest",quietly=TRUE)){
rf <- randomForest::randomForest(Fever~Age+Parasites,data=d)
riskLevelPlot(f,Fever~Age+Parasites,d)
riskLevelPlot(rf,Fever~Age+Parasites,d)
}
}
```

--------------------------------

### Load libraries and simulate data for subjectWeights

Source: https://github.com/tagteam/riskregression/blob/master/man/subjectWeights.Rd

Loads prodlim and survival, simulates 300 subjects with SimSurv, and orders the data by time and -status as required for correct weight ordering.

```r
library(prodlim)
library(survival)
dat=SimSurv(300)

dat <- dat[order(dat$time,-dat$status),]
```

--------------------------------

### Bootstrap Sampling without Replacement with M=0.7

Source: https://github.com/tagteam/riskregression/blob/master/man/Score.Rd

This example demonstrates the bootstrap sampling procedure without replacement, used when the training size is set to a fraction (e.g., 70%) of the data. The code uses a fixed seed and a small dataset to illustrate the split. The final line calls the internal function with the M parameter to obtain the actual indices.

```r
set.seed(13)
N=17
data = data.frame(id=1:N, y=rbinom(N,1,.3),x=rnorm(N))
boot.index = sample(1:N,size=M,replace=FALSE)
boot.index
inbag = 1:N %in% boot.index
outofbag = !inbag
learn.data = data[inbag]
val.data = data[outofbag]
riskRegression:::getSplitMethod("bootcv",B=10,N=17,M=.7)$index
```

--------------------------------

### Load packages and simulate survival data

Source: https://github.com/tagteam/riskregression/blob/master/man/ipcw.Rd

Loads required packages and creates a simulated survival dataset with 30 subjects, then orders the data by time as required for correct IPCW.subject.times values.

```r
library(prodlim)
library(rms)
dat=SimSurv(30)

dat <- dat[order(dat$time),]
```

--------------------------------

### Fit SuperPredictor and evaluate risk

Source: https://github.com/tagteam/riskregression/blob/master/man/SuperPredictor.Rd

Example wrapped in \dontrun{} that requires the SuperLearner package. It loads SuperLearner and data.table, generates a binary outcome dataset with sampleData, fits a SuperPredictor model using a formula with predictors X1 through X10, then calls predictRisk and Score to evaluate the model.

```r
if(require("SuperLearner",quietly=TRUE)){
library(SuperLearner)
library(data.table)
set.seed(10)
d = sampleData(338, outcome="binary")
spfit = SuperPredictor(Y~X1+X2+X3+X4+X5+X6+X7+X8+X9+X10,data=d)
predictRisk(spfit)
x <- Score(list(spfit),data=d,formula=Y~1)
}
```

--------------------------------

### Plot time-dependent AUC curves with plotAUC

Source: https://github.com/tagteam/riskregression/blob/master/man/plotAUC.Rd

Example from the plotAUC documentation. It creates survival data, fits two Cox models, computes AUC scores with the Score function, and then plots the AUC curves. The example shows basic plotting, plotting with confidence intervals, and plotting contrasts (differences between AUC).

```r
set.seed(9)
library(survival)
library(prodlim)
set.seed(10)
d=sampleData(100,outcome="survival")
nd=sampleData(100,outcome="survival")
f1=coxph(Surv(time,event)~X1+X6+X8,data=d,x=TRUE,y=TRUE)
f2=coxph(Surv(time,event)~X2+X5+X9,data=d,x=TRUE,y=TRUE)
xx=Score(list("X1+X6+X8"=f1,"X2+X5+X9"=f2), formula=Surv(time,event)~1,
data=nd, metrics="auc", null.model=FALSE, times=seq(3:10))
aucgraph <- plotAUC(xx)
plotAUC(xx,conf.int=TRUE)
## difference between
plotAUC(xx,which="contrasts",conf.int=TRUE)
```

--------------------------------

### Synthesize from lvm object with eventTime and regression

Source: https://github.com/tagteam/riskregression/blob/master/man/synthesize.Rd

Builds a lava model with distributions for sex, age, trt, and logbili, defines an event time with eventTime, sets regressions, transforms logbili, synthesizes from the model, saves it, simulates 1000 observations, and compares Cox models on simulated vs real data.

```r
u <- lvm()
distribution(u,~sex) <- binomial.lvm()
distribution(u,~age) <- normal.lvm()
distribution(u,~trt) <- binomial.lvm()
distribution(u,~logbili) <- normal.lvm()
u <-eventTime(u,time~min(time.cens=0,time.transplant=1,time.death=2), "status")
lava::regression(u,logbili~age+sex) <- 1
lava::regression(u,time.transplant~sex+age+logbili) <- 1
lava::regression(u,time.death~sex+age+logbili) <- 1
lava::regression(u,time.cens~1) <- 1
transform(u,logbili~bili) <- function(x){log(x)}
u_synt <- synthesize(object=u, data=na.omit(pbc))
saveSynth(u_synt)
set.seed(8)
d <- simsynth(u_synt,n=1000)
# note: synthesize may relabel status variable
fit_sim <- coxph(Surv(time,status==1)~age+sex+logbili,data=d)
fit_real <- coxph(Surv(time,status==1)~age+sex+log(bili),data=pbc)
# compare estimated log-hazard ratios between simulated and real data
cbind(coef(fit_sim),coef(fit_real))
```

--------------------------------

### Estimate the survival model

Source: https://github.com/tagteam/riskregression/blob/master/man/ate.Rd

Placeholder for the survival model estimation step in the ATE example.

```R
##### estimate the survival model ####
```

--------------------------------

### Compare with prodlim

Source: https://github.com/tagteam/riskregression/blob/master/man/predict.CauseSpecificCox.Rd

Fits a product-limit estimator using the prodlim package and compares the absolute risk estimates with the predict output. The range of differences should be near zero.

```R
GS.AE <- prodlim(Hist(time, event) ~ 1, data = d)
range(ePL.AE$absRisk - GS.AE$cuminc[[1]])
```

--------------------------------

### Simulate and compare pbc-like data with simPBC

Source: https://github.com/tagteam/riskregression/blob/master/man/simPBC.Rd

Simulates a dataset of size 847, prepares variables, fits survival and regression models on simulated and real pbc data, and compares coefficients. Requires the survival and lava packages.

```r
library(survival)
library(lava)
# simulate data alike pbc data
set.seed(98)
d=simPBC(847)
d$protimegrp1 <- d$protimegrp=="10-11"
d$protimegrp2 <- d$protimegrp==">11"
d$sex <- factor(d$sex,levels=0:1,labels=c("m","f"))
sF1 <- survreg(Surv(time,status==1)~sex+age+logbili+protimegrp1+protimegrp2+stage3+stage4,
data=d)
coxF1 <- coxph(Surv(time,status==1)~sex+age+logbili+protimegrp1+protimegrp2+stage3+stage4,
data=d)
# load real pbc data
data(pbc,package="survival")
pbc <- na.omit(pbc[,c("time","status","age","sex","stage","bili","protime","trt")])
pbc$stage <- factor(pbc$stage)
levels(pbc$stage) <- list("1/2"=c(1,2),"3"=3,"4"=4)
pbc$logbili <- log(pbc$bili)
pbc$logprotime <- log(pbc$protime)
pbc$stage3 <- 1*(pbc$stage=="3")
pbc$stage4 <- 1*(pbc$stage=="4")
pbc$protimegrp <- cut(pbc$protime,c(-Inf,10,11,Inf),labels=c("<=10","10-11",">11"))
pbc$protimegrp1 <- pbc$protimegrp=="10-11"
pbc$protimegrp2 <- pbc$protimegrp==">11"
form1=Surv(time,status==1)~sex+age+logbili+protimegrp1+protimegrp2+stage3+stage4
F1 <- survival::survreg(form1,data=pbc)
form2=Surv(time,status==2)~sex+age+logbili+protimegrp1+protimegrp2+stage3+stage4
F2 <- survival::survreg(form1,data=pbc)
sF2 <- survreg(Surv(time,status==2)~sex+age+logbili+protimegrp1+protimegrp2+stage3+stage4,
data=d)
G <- survreg(Surv(time,status==0)~sex+age+logbili+protimegrp1+protimegrp2+stage3+stage4,
data=pbc)
sG <- survreg(Surv(time,status==0)~sex+age+logbili+protimegrp1+protimegrp2+stage3+stage4,
data=d)
# compare fits in real and simulated pbc data
cbind(coef(F1),coef(sF1))
cbind(coef(F2),coef(sF2))
cbind(coef(G),coef(sG))
cbind(coef(glm(protimegrp1~age+sex+logbili,data=pbc,family="binomial")),
coef(glm(protimegrp1~age+sex+logbili,data=d,family="binomial")))
cbind(coef(lm(logbili~age+sex,data=pbc)),coef(lm(logbili~age+sex,data=d)))
```

--------------------------------

### Load Melanoma dataset and required libraries

Source: https://github.com/tagteam/riskregression/blob/master/simulation/synthesize.html

Loads the riskRegression, survival, and lava packages, then loads the Melanoma dataset and selects the relevant variables. The comment notes that all variables in the dataset should be included in the model for synthesize to work as intended.

```R
library(riskRegression)
#> riskRegression version 2021.08.27
library(survival)
library(lava)
data("Melanoma")
Melanoma <- subset(Melanoma, select = c("time","status","thick","sex","age","invasion"))
knitr::kable(head(Melanoma))
```

--------------------------------

### Bootstrap cross-validation with bootcv and IPA

Source: https://github.com/tagteam/riskregression/blob/master/simulation/k-fold-CV.org

Run bootstrap cross-validation (bootcv) on the two fitted models with 100 bootstrap samples, requesting IPA summary and Brier metric. Note that IPA values may be negative.

```R
X1 <- Score(list("Exclusive ERG"=lrfit.ex,"Inclusive ERG"=lrfit.inc),data=astest,
	      formula=Y1~1,summary="ipa",se.fit=0L,metrics="brier",contrasts=FALSE,
	      split.method = "bootcv", B=100)
```

--------------------------------

### Binary outcome example

Source: https://github.com/tagteam/riskregression/blob/master/man/plotRisk.Rd

Fits two logistic regression models on a binary outcome and plots their predicted risks using plotRisk.

```R
library(prodlim)
## uncensored
set.seed(10)
learndat = sampleData(40,outcome="binary")
testdat = sampleData(40,outcome="binary")
lr1 = glm(Y~X1+X2+X7+X9,data=learndat,family="binomial")
lr2 = glm(Y~X3+X5+X6,data=learndat,family="binomial")
xb=Score(list("LR(X1+X2+X7+X9)"=lr1,"LR(X3+X5+X6)"=lr2),formula=Y~1,
         data=testdat,summary="risks",null.model=0L)
plotRisk(xb)
```

--------------------------------

### riskRegression.options

Source: https://github.com/tagteam/riskregression/blob/master/man/riskRegression.options.Rd

Get and set global options for the riskRegression package. Only used by the ate function. The function accepts arguments for method.predictRisk and method.predictRiskIID.

```APIDOC
## riskRegression.options

### Description
Output and set global options for the `riskRegression` package. Only used by the `ate` function.

### Usage
```
riskRegression.options(...)
```

### Parameters
#### Arguments
- **...** - For now limited to `method.predictRisk` and `mehtod.predictRiskIID`.

### Request Example
```
options <- riskRegression.options()

## add new method.predictRiskIID
riskRegression.options(method.predictRiskIID = c(options$method.predictRiskIID,"xx"))

riskRegression.options()
```
```

--------------------------------

### Generate sample data and fit working models

Source: https://github.com/tagteam/riskregression/blob/master/man/IPWbox.Rd

Creates a binary-outcome dataset of 250 observations and fits a glm for the event model and a logistic glm for the treatment model.

```R
#### generate data ####
n <- 250
set.seed(2)
dt <- sampleData(n, outcome="binary")
dt[, id := paste0("id",1:.N)]
dt[, X2 := as.numeric(X2)]

#### working models ####
m.event <- glm(formula = Y ~ X1+X2+X3, data=dt, family = "binomial")
m.treatment <- glm(X3~X1+X2+X5+X8, data=dt,family=binomial(link="logit"))
```

--------------------------------

### rowMultiply_cpp example: scale by inverse column means

Source: https://github.com/tagteam/riskregression/blob/master/man/rowMultiply_cpp.Rd

Uses rowMultiply_cpp() to multiply each row by the inverse of the column means of x. The output is not shown.

```r
rowMultiply_cpp(x, 1/colMeans(x) )
```

--------------------------------

### saveSynth(object, file = "")

Source: https://github.com/tagteam/riskregression/blob/master/man/saveSynth.Rd

Exports a synth object to a file or returns a string representation using dput.

```APIDOC
## saveSynth(object, file = "")

### Description
Function for exporting objects of type `synth` via `dput`.

### Usage
```r
saveSynth(object, file = "")
```

### Arguments
- **object** (synth) - Required - An object of type `synth`.
- **file** (character) - Optional - File to print to. Default is `""`.

### Value
Either a string or nothing if printed to a file.

### Examples
```r
# See the documentation for the `synthesize` function.
```

### See Also
`lvm`
```

--------------------------------

### Simulate data and compare linear regression parameters

Source: https://github.com/tagteam/riskregression/blob/master/simulation/synthesize.html

Simulates 10,000 observations from the linear model and compares the coefficients from the original and simulated data using lm and knitr::kable.

```R
set.seed(15)
d <- sim(m.cars,10000)
fit <- lm(dist ~ speed, data = cars)
fit.s <- lm(dist ~ speed, data = d)

res <- as.data.frame(cbind(coef(fit),coef(fit.s)))
colnames(res) <- c("Parameters of the model from original data", "Parameters of the model from simulated data")
knitr::kable(res)
```

--------------------------------

### rowMultiply_cpp example: compare with sweep

Source: https://github.com/tagteam/riskregression/blob/master/man/rowMultiply_cpp.Rd

Creates a 6x5 matrix of ones and compares sweep() with rowMultiply_cpp() using the same scale vector 1:5. The output is not shown.

```r
x <- matrix(1,6,5)
sweep(x, MARGIN = 2, FUN = "*", STATS = 1:5)
rowMultiply_cpp(x, 1:5 )
```

--------------------------------

### Compare exponential approximation with product limit

Source: https://github.com/tagteam/riskregression/blob/master/man/predict.CauseSpecificCox.Rd

Compares the absolute risk estimates obtained with the exponential approximation (product.limit = FALSE) against the product-limit estimates. The range of differences is shown.

```R
range(predict(fit.AE, product.limit = FALSE)$absRisk - ePL.AE$absRisk)
```
Tokens:
Raw