Diagnostics for Semiparametric Accelerated Failure Time Models with R Package afttest

This paper introduces the R package `afttest`, which provides computationally efficient martingale-residual-based diagnostic tools, including a new influence-function linear approximation method, for assessing the goodness-of-fit of semiparametric accelerated failure time models.

The Gist

Imagine you are a doctor trying to predict how long a patient will live after a diagnosis. You have a powerful tool called a Survival Model that takes various clues (like age, blood test results, and symptoms) and tries to draw a straight line to predict the outcome.

But here's the problem: What if your straight line is actually crooked? Or what if the clues you are using don't actually relate to the outcome the way you think they do? If you use a broken tool, your predictions will be wrong, and your medical advice could be dangerous.

This paper introduces a new, super-fast quality control kit called afttest (available in the R programming language) that helps statisticians check if their survival models are working correctly.

Here is a breakdown of the paper using simple analogies:

1. The Problem: The "Broken Compass"

In the world of survival analysis, there are two main ways to predict time-to-event (like death or machine failure):

• The Cox Model: This is like a compass that tells you the direction of the wind (risk) but doesn't tell you exactly how far you will travel. It's very popular but has strict rules.
• The AFT Model (Accelerated Failure Time): This is like a GPS that tells you exactly how long the trip will take. It's often easier to understand because it says, "This treatment speeds up the trip by 20%," rather than "This treatment increases the risk by 20%."

The Issue: While the AFT model is great, checking if it's "working" (diagnostics) has been like trying to fix a car engine with a hammer. The old methods to check the model were incredibly slow and computationally heavy. They required the computer to solve complex math puzzles over and over again, thousands of times, just to see if the model was valid. It was like asking a chef to bake a whole new cake every time they wanted to taste a single crumb to check if the recipe was right.

2. The Solution: The "Magic Shortcut"

The authors of this paper created a new tool (afttest) that does two things:

1. It checks the model: It runs three specific tests to see if the model is lying to you.
2. It does it instantly: They invented a "mathematical shortcut" (called a linear approximation) that skips the heavy lifting.

The Analogy:
Imagine you want to know if a bridge is safe.

• The Old Way (Standard Bootstrap): You build a full-scale replica of the bridge, load it with weight, see if it breaks, take it down, build another one, load it again, and repeat this 200 times. This takes forever.
• The New Way (Linear Approximation): You use a super-accurate simulation that calculates how the bridge would react to the weight based on its blueprints, without actually building the replica. You get the same answer, but in a fraction of a second.

The paper shows that this "shortcut" is just as accurate as the slow, heavy method but is orders of magnitude faster. For a dataset that used to take 7 minutes to check, the new method takes less than 1 second.

3. The Three Tests in the Kit

The afttest package runs three specific "stress tests" on your model:

• The "Big Picture" Test (Omnibus Test):
  • Analogy: Does the whole car engine sound right?
  • What it does: It checks if the model fits the data generally. If this fails, the whole model is suspect.
• The "Connection" Test (Link Function Test):
  • Analogy: Is the steering wheel connected to the wheels correctly?
  • What it does: It checks if the relationship between your clues (covariates) and the outcome is straight and true, or if it's curved and needs a different shape.
• The "Specific Clue" Test (Functional Form Test):
  • Analogy: Is the speedometer reading accurate for just the speed, or is it confused by the temperature?
  • What it does: It looks at one specific clue (like "bilirubin" levels in blood) to see if it needs to be transformed (e.g., taking the logarithm) to work correctly.

4. The Real-World Demo: The Liver Disease Study

To prove their tool works, the authors tested it on real data from the Mayo Clinic regarding Primary Biliary Cirrhosis (PBC), a liver disease.

• Scenario A (The Broken Model): They first tried a model using raw blood test numbers. The afttest tool immediately flagged it as "broken." The graphs showed the model's predictions wandering far outside the safe zone.
• Scenario B (The Fixed Model): They realized the blood test numbers needed to be "log-transformed" (a mathematical adjustment). They ran the test again with the adjusted numbers.
• The Result: This time, the afttest tool gave a "Green Light." The model's predictions stayed perfectly within the safe zone, confirming that the adjusted model was reliable.

5. Why This Matters

Before this paper, researchers might have given up on the AFT model because checking it was too hard and slow. Or, they might have used a broken model without realizing it because they didn't have the tools to check.

The afttest package is like giving every statistician a high-speed diagnostic scanner. It allows them to:

• Use the more intuitive AFT model with confidence.
• Check their models in seconds instead of hours.
• Visualize exactly where a model is failing using easy-to-read graphs (red lines showing the model vs. grey lines showing the "safe" range).

In summary: This paper introduces a fast, smart, and user-friendly way to ensure that our predictions about time and survival are accurate, preventing us from making decisions based on broken mathematical models.

Technical Summary

Here is a detailed technical summary of the paper "Diagnostics for Semiparametric Accelerated Failure Time Models with R Package afttest."

1. Problem Statement

Survival analysis frequently relies on the Cox proportional hazards (PH) model, which assumes constant hazard ratios over time. However, this assumption is often violated in practice, and the Cox model does not directly estimate the baseline hazard or absolute risk. The semiparametric Accelerated Failure Time (AFT) model offers a robust alternative by modeling the logarithm of failure time directly, providing more interpretable regression parameters without specifying an error distribution.

Despite the existence of well-developed estimation methods for semiparametric AFT models (e.g., rank-based and least-squares estimators), diagnostic tools for model checking remain limited. Existing goodness-of-fit procedures rely on martingale residuals and require approximating the null distribution via multiplier bootstrap. The primary bottleneck is computational: the standard approach requires solving complex estimating equations via numerical optimization for every bootstrap replicate. This makes routine diagnostic analysis computationally prohibitive for moderate-to-large datasets.

2. Methodology

The paper introduces the afttest R package, which implements goodness-of-fit procedures based on cumulative sums of martingale residuals. The core methodological innovation is a computationally efficient resampling strategy based on an asymptotic linear approximation.

A. Theoretical Framework

The diagnostics are based on a multi-parameter stochastic process $W_n(t, z; \hat{\beta}_n)$ constructed from estimated martingale residuals. To assess significance, the null distribution of this process must be approximated.

• Standard Approach (Choi et al., 2024): Uses a perturbed process requiring the re-estimation of parameters ($\hat{\beta}_n^\phi$) for every bootstrap iteration by solving $U_n^\phi(\cdot, \beta) = 0$. This involves iterative optimization.
• Proposed Approach (Linear Approximation): Leverages the influence-function representation of the estimator. The residual process is expanded as $W_n \approx \sum h_i + o_p(1)$, where $h_i$ is the influence function.
  • Instead of re-estimating parameters, the method generates a perturbed process $\tilde{W}_n$ using a closed-form linear combination of the estimated influence functions and random multiplier weights ($\phi_i$):
    $$\tilde{W}_n(t, z; \hat{\beta}_n) = n^{-1/2} \sum_{i=1}^n (\phi_i - 1) \hat{h}_i(t, z; \hat{\beta}_n)$$
  • This bypasses the iterative optimization step entirely while preserving the asymptotic validity of the test statistic.

B. Test Statistics

The package supports three types of goodness-of-fit tests:

1. Omnibus Test: Checks for general departures from the model across time and covariates.
2. Link Function Test: Verifies if the relationship between covariates and log-survival time is correctly specified (testing if the link function $g(\cdot)$ is the identity).
3. Functional Form Test: Checks if individual covariates enter the model linearly.

C. Implementation Details

• Estimators: Supports both rank-based (via aftgee::aftsrr) and least-squares (via aftgee::aftgee) estimators.
• Optimization: Uses the DF-SANE algorithm for fitting and Rcpp/RcppArmadillo for high-performance computing.
• Visualization: Provides plot() methods using ggplot2 to visualize the observed test statistic path against 50 (or more) simulated null paths.

3. Key Contributions

1. Computational Efficiency: The introduction of the asymptotic linear approximation eliminates the need for repeated numerical optimization during bootstrapping.
   • Result: Reduces computation time by orders of magnitude. For example, an omnibus test on a sample size of $n=500$ dropped from ~436 seconds (standard bootstrap) to ~13 seconds (linear approximation).
2. Unified Interface: The afttest package provides a consistent S3 interface that integrates seamlessly with the aftgee package, allowing users to fit models and perform diagnostics in a coherent pipeline.
3. Flexibility: Supports multiple estimation methods (smoothed vs. non-smoothed rank-based, least-squares) and offers both standardized and unstandardized test statistics.
4. Scalability: The method makes routine diagnostic analysis feasible for large datasets where the original bootstrap approach would be intractable.

4. Results

Simulation Study

• Validity: The proposed linear approximation yields Type I error rates and statistical power comparable to the original multiplier bootstrap method.
• Performance: While the original method showed slightly higher power at very small sample sizes ($n=100$), the performance of both methods converged as sample size increased ($n=500$).
• Speed: The linear approximation consistently reduced running time by over 96% across all scenarios, regardless of the estimator type (non-smoothed, induced-smoothed, or least-squares).

Empirical Application (Mayo Clinic PBC Data)

The authors applied the package to the Primary Biliary Cirrhosis (PBC) dataset to evaluate two models:

• Model M1 (Raw bili): The omnibus, link function, and functional form tests for the bilirubin covariate (bili) yielded significant p-values (standardized $p < 0.05$), indicating model misspecification. Diagnostic plots showed the observed path deviating significantly from the null envelope.
• Model M2 (Log-transformed log_bili): After applying a log transformation to the bilirubin variable, all diagnostic tests (omnibus, link, and functional form) yielded non-significant p-values ($p > 0.05$). The observed paths remained well within the null boundaries, confirming that the log-transformed AFT model provided an adequate fit.

5. Significance

The afttest package fills a critical gap in survival analysis software by providing practical, scalable diagnostic tools for semiparametric AFT models. By solving the computational bottleneck associated with residual-based bootstrapping, it enables researchers to:

• Rigorously validate AFT model assumptions (linearity, link function, overall fit) on large-scale datasets.
• Move beyond the restrictive proportional hazards assumption with confidence in model adequacy.
• Visualize model fit using intuitive stochastic process plots similar to those available for Cox models.

The work establishes a foundation for future extensions, including multivariate AFT models and time-varying covariates, ensuring that advanced survival analysis remains computationally tractable as data complexity grows.