Automatic point selection with semi-log regression

With semi-log regression, the typical method used to automatically select concentrations for inclusion in the half-life estimate is to:

1. Omit all concentrations that are missing.
2. Omit all concentrations that are below the LLOQ.
3. Estimate the half-life for each set of points from the first concentration measure after T_max to the third measure before T_last.
4. Select the best half-life with the following criteria, in order:
   1. The adjusted r-squared must be within a tolerance factor (typically 0.0001) of the largest adjusted r-squared. Setting the r.squared.factor option selects on the unadjusted r-squared instead; see the “Half-Life Calculation” vignette.
   2. The \(\lambda_z\) value (slope for the half-life line) must be positive; in other words, the half-life slope must be decreasing.
   3. If multiple choices of points fit the above criteria, choose the one with the most concentration measurements included.

For comparison with PKNCA, note that Phoenix WinNonlin switches the order for selection of 4.1 and 4.2 above. So, if the best adjusted r-squared is for an increasing slope but there is another adjusted r-squared with a decreasing slope, Phoenix will report the half-life.

Automatic point selection with Tobit regression

With Tobit regression, the method is generally similar to the semi-log regression with two changes. The first change is that concentrations below the LLOQ are retained in the estimate as left-censored values. The second change is that the adjusted r-squared is not possible to calculate when including points below the LLOQ, so the residual standard deviation of the Tobit fit is minimized instead. Neither adj.r.squared.factor nor r.squared.factor applies to hl_method = "tobit".

The selection method below results in effectively the same estimates for half-life when all points are above the LLOQ and improved estimates for half-life when some points are below the LLOQ. Future research may investigate optimization of this method.

The steps for Tobit regression are:

1. Omit all concentrations that are missing.
2. Estimate the half-life for each candidate set of points. Each candidate set starts at one of the concentration measures after T_max and extends through the last measurement. Concentrations below the LLOQ anywhere within the set are retained and treated as left-censored, and a set is only fit if it includes at least min.hl.points concentrations above the LLOQ (concentrations below the LLOQ do not count toward the minimum). Each fit is estimated by maximum likelihood with stats::optim(); the tobit_optim_control option passes control parameters to the optimizer.
3. Select the best half-life with the following criteria, in order:
   1. Sets of points where the \(\lambda_z\) value (slope for the half-life line) is not positive are removed from consideration; in other words, the half-life slope must be decreasing.
   2. Among the remaining sets, select the set minimizing tobit_residual * n_points ^ tobit_n_points_penalty, where tobit_residual is the residual standard deviation of the Tobit fit on the log-concentration scale and n_points is the number of points in the set. The tobit_n_points_penalty option (default 0) sets the penalty on the number of points; with the default of 0, the set with the smallest Tobit residual is selected.
   3. If more than one set ties on the selection criterion, select the set with the most points included.

Example 1: All observations above the LLOQ

When no observations are below the LLOQ, Tobit and log-linear regression produce essentially the same answer.

conc_no_blq <- c(10, 5, 2.5, 1.25, 0.625)
time_points  <- c(0,  1, 2,   3,    4)
lloq         <- 0.1   # well below all observations

hl_loglinear <- pk.calc.half.life(
  conc = conc_no_blq,
  time = time_points,
  allow.tmax.in.half.life = TRUE
)

hl_tobit <- pk.calc.half.life(
  conc = conc_no_blq,
  time = time_points,
  lloq = lloq,
  hl_method = "tobit",
  allow.tmax.in.half.life = TRUE
)
#> Warning: Tobit half-life optimization did not converge (code 10)

cat("Log-linear half-life:", round(hl_loglinear$half.life, 3), "\n")
#> Log-linear half-life: 1
cat("Tobit half-life:     ", round(hl_tobit$half.life, 3),    "\n")
#> Tobit half-life:      1

Note the columns that are returned:

# Log-linear returns r-squared and related diagnostics
names(hl_loglinear)
#>  [1] "lambda.z"            "r.squared"           "adj.r.squared"      
#>  [4] "lambda.z.corrxy"     "lambda.z.time.first" "lambda.z.time.last" 
#>  [7] "lambda.z.n.points"   "clast.pred"          "half.life"          
#> [10] "span.ratio"          "tmax"                "tlast"

# Tobit returns tobit_residual and BLQ point counts instead
names(hl_tobit)
#>  [1] "lambda.z"              "lambda.z.time.first"   "lambda.z.time.last"   
#>  [4] "lambda.z.n.points"     "lambda.z.n.points_blq" "clast.pred"           
#>  [7] "half.life"             "span.ratio"            "tobit_residual"       
#> [10] "adj_tobit_residual"    "tmax"                  "tlast"

Example 2: BLQ observations before T_last

When some observations are below the LLOQ, the log-linear method drops them entirely. Tobit regression treats them as left-censored, which can provide a better estimate.

lloq <- 1.0
conc_true  <- c(10, 5, 2.5, 1.25, 0.5, 0.2)
time_points <- c(0,  1, 2,   3,    4,   5)
# Observations below the LLOQ are reported as zero
conc_obs <- ifelse(conc_true < lloq, 0, conc_true)

cat("Observed concentrations:", conc_obs, "\n")
#> Observed concentrations: 10 5 2.5 1.25 0 0
cat("LLOQ:", lloq, "\n")
#> LLOQ: 1
cat("Number of BLQ observations:", sum(conc_obs < lloq), "\n")
#> Number of BLQ observations: 2

hl_loglinear <- pk.calc.half.life(
  conc = conc_obs,
  time = time_points,
  allow.tmax.in.half.life = TRUE
)

hl_tobit <- pk.calc.half.life(
  conc = conc_obs,
  time = time_points,
  lloq = lloq,
  hl_method = "tobit",
  allow.tmax.in.half.life = TRUE
)

cat("\nLog-linear (drops BLQ):\n")
#> 
#> Log-linear (drops BLQ):
cat("  Half-life:      ", round(hl_loglinear$half.life, 3), "\n")
#>   Half-life:       1
cat("  Points used:    ", hl_loglinear$lambda.z.n.points, "\n")
#>   Points used:     4

cat("\nTobit (includes BLQ as censored):\n")
#> 
#> Tobit (includes BLQ as censored):
cat("  Half-life:      ", round(hl_tobit$half.life, 3), "\n")
#>   Half-life:       1
cat("  Total points:   ", hl_tobit$lambda.z.n.points, "\n")
#>   Total points:    6
cat("  BLQ points:     ", hl_tobit$lambda.z.n.points_blq, "\n")
#>   BLQ points:      2
cat("  Tobit residual: ", round(hl_tobit$tobit_residual, 4), "\n")
#>   Tobit residual:  0