🤖 machine learning

Archimedean Copula Inference via Taylor-Mode AD

This paper introduces \textsc{acopula}, a JAX-native framework that enables exact, efficient inference for arbitrary nested Archimedean copulas with per-variable censoring and neural generators by leveraging Taylor-mode automatic differentiation to replace hand-derived formulas with a single differentiable computation.

Original authors: Cambridge Yang, Dongdong Li

Published 2026-05-25

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Cambridge Yang, Dongdong Li

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to understand how different things in a complex system are connected. Maybe you are looking at a patient's health, where their blood pressure, heart rate, and sugar levels might rise and fall together. Or perhaps you are watching the stock market, where tech stocks and energy stocks often move in sync during a crash.

In statistics, there is a special tool called a Copula that acts like a "glue." It doesn't care about the individual behaviors of the variables (like how high the blood pressure goes); it only cares about how they stick together.

However, real-world data is messy.

It's hierarchical: Some things are more closely related than others. For example, blood pressure and heart rate might be tightly linked, while both are loosely linked to sugar levels. This is like a family tree.
It's incomplete: In a hospital, a patient might leave before their test results come back. In finance, a stock might stop trading. This is called "censoring." You know the event happened after a certain time, but you don't know exactly when.
It's hard to calculate: To figure out the best "glue" (the mathematical model) for this messy, hierarchical, incomplete data, you have to do incredibly complex math. Existing tools are like old calculators: they can only handle two variables at a time, or they get stuck if the data is too messy or the family tree is too deep.

The Problem: The "Hand-Derived" Bottleneck

The authors of this paper point out that current software is stuck in the past. To handle these complex connections, mathematicians have to manually derive specific formulas for every single type of relationship they want to study.

If you want to study a new type of relationship, you have to do the math by hand.
If you have 50 variables (like 50 different lab tests), the math becomes so heavy that computers crash or take forever.
If some data is missing (censored), the math gets even harder, and most tools can't do it at all for large groups.

The Solution: ACOPULA (The "Universal Translator")

The authors present a new tool called ACOPULA. Think of it as a universal translator that can instantly understand any type of relationship, no matter how complex the family tree or how much data is missing.

Here is how it works, using a simple analogy:

1. The "Taylor-Mode" Magic (The Infinite Zoom Lens)
Imagine you are trying to understand a curve. Usually, you might look at the slope (first derivative) to see which way it's going. But to understand the shape of the curve perfectly, you need to know how the slope itself is changing, and how that is changing, and so on.
ACOPULA uses a technique called Taylor-Mode Automatic Differentiation. Instead of looking at the curve one step at a time, it takes a "snapshot" of the entire curve's shape all at once. It generates a list of numbers (coefficients) that describe the curve perfectly, like a high-resolution 3D scan.

2. The "Polynomial Powering" Trick (The Lego Builder)
The hardest part of the math involves calculating something called "Bell Polynomials." In the old days, statisticians had to look up these values in giant, pre-written tables (like a dictionary) for specific types of relationships. If you wanted a new type of relationship, the dictionary didn't have an entry, and you were stuck.

ACOPULA throws away the dictionary. Instead, it treats the math like Lego blocks.

It takes the "snapshot" of the curve (the Taylor coefficients).
It multiplies these blocks together (polynomial powering) in a very smart, fast way.
This automatically builds the complex "Bell Polynomials" needed for the answer.
The Result: You don't need to hand-write the math anymore. You just tell the computer, "Here is the shape of the relationship," and ACOPULA builds the rest automatically.

3. Handling the "Missing Pieces" (Censoring)
Because ACOPULA builds the math dynamically, it can easily ignore the missing pieces. If a patient leaves the hospital early, the tool simply skips that variable in its calculation without breaking the whole model. It can handle thousands of different "missing piece" patterns instantly.

What They Actually Achieved

The paper doesn't just talk about theory; they built the tool and tested it on real, massive datasets:

MIMIC-IV (Medical Data): They analyzed 85,000 ICU admissions with 53 different lab tests per patient. Some tests were missing for many patients. ACOPULA successfully found the connections between these tests, even with all the missing data. They also tested it with "Neural" generators (AI-based shapes) to see if it could learn complex patterns, and it worked.
S&P 500 (Stock Market): They modeled 98 different stock sectors. Previous tools couldn't even attempt a model this big. ACOPULA did it in seconds.
Speed: They compared their tool to the best existing software (R's nacLL). At a moderate size (35 variables), ACOPULA was 650 times faster. At larger sizes, the old software crashed, while ACOPULA kept going.
Accuracy: They proved the math is correct by comparing it to known answers and by showing that the tool can perfectly recover "true" parameters from simulated data.

The Bottom Line

ACOPULA is a new engine for understanding how complex things connect. It removes the need for humans to do tedious, error-prone math by hand. It allows researchers to:

Use any type of relationship model (classical or AI-based).
Handle huge amounts of data (dozens or even thousands of variables).
Deal with messy, incomplete data (missing values) without breaking a sweat.

It turns a task that used to be impossible or required a team of mathematicians into something a single researcher can do with a few lines of code.

Technical Summary: ACOPULA – Archimedean Copula Inference via Taylor-Mode AD

Problem Statement

The paper addresses three critical limitations in existing tools for fitting nested Archimedean copulas, a class of models essential for capturing hierarchical dependence in survival analysis, finance, and clinical risk settings:

Per-variable Censoring: Existing tools generally handle only bivariate problems, shared censoring times, or low-dimensional cases ( $d \le 10$ ). They fail to accommodate arbitrary right-censoring masks $\delta \in \{0, 1\}^d$ where different variables in a single observation may be censored independently. This is common in ICU data (e.g., MIMIC-IV) where lab measurements are censored at discharge at different times.
Arbitrary Nesting and Generators: Current implementations (e.g., R's copula package) rely on hand-derived Stirling-number tables for a fixed set of five classical generators and support only two nesting layers. They cannot handle arbitrary tree structures, mixed-family nesting, or user-defined generators (such as neural Archimedean copulas).
Exact Parameter Gradients: Fitting high-dimensional models without exact automatic differentiation forces reliance on derivative-free methods, finite differences, or Monte Carlo approximations (e.g., Simulated Maximum Likelihood Estimation, SMLE). These approaches suffer from poor scaling, bias, or high variance, particularly as dimensionality increases.

The core mathematical obstacle is that the likelihood for a nested copula with censoring requires evaluating a mixed partial derivative of the copula cumulative distribution function (CDF). For a tree of composed generators, this involves computing partial Bell polynomials of high-order derivatives of generator compositions. Existing methods either hard-code these polynomials for specific families or resort to combinatorial enumeration that scales exponentially.

Methodology: ACOPULA

The authors present ACOPULA, a JAX-native framework that resolves these barriers through Taylor-mode Automatic Differentiation (AD) and polynomial powering.

Core Algorithm

The framework computes the nested copula density and its gradients via a bottom-up recursion that replaces hand-derived Bell polynomial tables with a single differentiable computation:

Taylor-Mode AD (Jet Propagation): Instead of nested first-order AD calls (which scale as $O(2^n)$ ), the framework uses Taylor-mode AD to compute the vector of higher-order derivatives (jets) of each generator composition $h = \psi^{-1}_{outer} \circ \psi_{inner}$ in a single forward pass. This yields the coefficients of the Taylor series expansion of the edge composition.
Polynomial Powering for Bell Polynomials: The partial Bell polynomials $B_{n,k}$ $B_{n, k}$ required by the Hofert and Pham [2013] density formula are computed by raising the Taylor coefficient vector to successive powers via truncated convolution.
- Let $p(\epsilon)$ be the exponential generating function of the edge derivatives.
- The coefficient of $\epsilon^n$ in $p(\epsilon)^k$ is proportional to $B_{n,k}$ .
- By iteratively convolving the Taylor vector with itself, the framework recovers all necessary Bell polynomial values without combinatorial enumeration or per-family tables.
Handling Censoring: Censoring is treated as a first-class operation. A censored leaf initializes its contribution vector as $\alpha = [1]$ (the identity for Cauchy products), while an uncensored leaf uses $\alpha = [0, 1]$ . This mechanism automatically reduces the effective dimension of the polynomial powering and Cauchy product steps at every ancestor node, allowing the algorithm to handle arbitrary censoring masks $\delta$ without recompilation.
Numerical Stability: To prevent underflow/overflow in high dimensions (e.g., $d=98$ ), the implementation operates in the log-domain using signed log-sum-exp arithmetic and per-index rescaling. For generator pairs without closed-form inverses, it solves implicit equations using implicit function theorem gradients to avoid catastrophic cancellation.

Complexity

Worst-case: $O(d^3)$ for fixed-depth trees.
Optimized: $O(d^2)$ for $\sqrt{d}$ -decomposed trees (where every non-root subtree has at most $O(\sqrt{d})$ uncensored leaves).
The framework scales quadratically in practice for balanced topologies, reaching dimensions up to $d=8,000$ .

Key Contributions

Family-Agnostic Inference: The framework derives densities and exact gradients automatically for any user-defined generator (classical or neural), removing the need for hand-derived formulas.
Per-Variable Censoring: It supports arbitrary per-observation censoring masks directly in the core recurrence, lifting the bivariate or shared-time restrictions of prior tools.
Scalability: It achieves $O(d^2)$ scaling for balanced trees, validated empirically up to $d=8,000$ , and provides a $\sim 650\times$ speedup over R's nacLL at $d=35$ .
Open-Source Implementation: ACOPULA is released as a JAX package with a simple API for nested-copula density, gradients, and validity diagnostics.
Sampling: As a byproduct, the framework enables practical conditional-distribution sampling (Rosenblatt sampling) for these copulas, previously blocked by the difficulty of computing high-order derivatives.

Experimental Results

The authors validate ACOPULA through extensive simulations and four real-data experiments:

Correctness: Parameter recovery on simulated nested Clayton copulas ( $d \in \{10, 20, 50\}$ ) shows bias $< 2.7\%$ and empirical standard errors matching observed-Fisher SEs. Density values agree with R's nacLL to $< 10^{-14}$ and Mathematica symbolic derivatives up to $d=60$ .
MIMIC-IV ( $d=53$ ): Fitted nested Archimedean copulas on 85,229 ICU admissions with per-variable censoring. Both classical families (Clayton, Frank, Gumbel) and nested neural Archimedean copulas (ACNet, Gen-AC) were successfully fit. Neural generators outperformed classical ones, with ACNet achieving the best held-out negative log-likelihood (NLL) with only 70 parameters.
S&P 500 ( $d=98$ ): Fit an 11-sector hierarchical model on daily returns. This dimension is beyond the reach of R's nacLL (which aborts past $d=40$ ). The nested Gumbel model captured sector-level tail dependence consistent with empirical data.
Retinopathy Study: Demonstrated family-agnostic censored Maximum Likelihood Estimation (MLE) across ten Archimedean families, five of which had no prior censored implementation.
HACSurv Reproduction: The framework exactly reproduced the results of the HACSurv neural copula pipeline on the Framingham dataset, validating the density machinery against an iterative inverse-function-theorem solver.

Significance

The paper claims that ACOPULA unifies nested Archimedean copula inference under a single differentiable pipeline. By replacing restricted, hand-coded slices with arbitrary families, arbitrary nesting depths, and high-dimensional mixed-partial derivatives, it lowers the barrier for practitioners in survival, finance, and reliability to build expressive, interpretable, and censoring-aware dependence models. The work enables exact likelihood inference in regimes where previous tools relied on biased approximations or failed entirely due to dimensionality.