TL;DR

The authors test Zama Concrete ML (TFHE) on two real-world XGBoost binary classifiers, measuring conversion time, encrypted inference latency, ciphertext expansion, and prediction agreement with plaintext models, and report that FHE is mature enough for production but adds a ~10^6 latency factor and up to 7x data expansion [Abstract, §III-C, §V].

Problem and motivation

Companies offloading ML training and inference to third-party cloud services must entrust sensitive data (personal, corporate, governmental, health, financial) to providers; encryption today only protects data in transit, not in use [§I]. The paper evaluates whether FHE-based ML is now practical enough to keep data encrypted during cloud inference, addressing GDPR/CCPA compliance concerns [§I]. Threat model: third-party cloud provider that processes data which would otherwise be in plaintext at the server; only the data owner holds the secret key [§I, §II].

Key contributions

FHE setup

ML setup

Datasets

Dataset Task Size (train/test) Modality Notes
Proprietary use-case dataset (Model A) Binary classification Trained on >1M records; evaluated on 3000 records Tabular, 19 features Real-world production use case [§III, §III-C]
Proprietary use-case dataset (Model B) Binary classification Trained on >1M records; evaluated on 3000 records Tabular, 7 features Real-world production use case; FHE/plaintext agreement only 22% [§III-C]

Pipeline diagram

flowchart LR
    subgraph Dev [Developer]
        T[Train XGBoost plaintext] --> Q[Quantize PTQ/QAT]
        Q --> X[Export ONNX]
        X --> CC[Concrete ML compile]
        CC --> SZ[server.zip MLIR]
        CC --> CZ[client.zip specs]
    end
    subgraph Client
        K[Generate keys from specs] --> E[Encrypt features]
    end
    subgraph Server
        L[Load MLIR circuit] --> H[Homomorphic XGBoost eval]
    end
    subgraph ClientDec [Client]
        D[Decrypt result] --> P[Postprocess label]
    end
    SZ -. deploy .-> L
    CZ -. share .-> K
    E -. ciphertext .-> H
    H -. ciphertext .-> D

Pipeline steps (text)

  1. Train an XGBoost binary classifier on plaintext data with scikit-learn / PyTorch-compatible APIs [§II].
  2. Quantize the model (Post-Training Quantization, or Quantization-Aware Training) so weights and activations are integers [§II].
  3. Export to ONNX format via hummingbird-ml [§III-A].
  4. Compile with Concrete ML’s TFHE compiler to MLIR, producing server.zip (compiled circuit, architecture-specific) and client.zip (client.specs.json for key generation and serialized_processing.json for pre/post-processing) [§III-A].
  5. Deploy server.zip to the inference server (AMD EPYC, 96 vCPUs, 192 GiB) and distribute client.zip to the client [§III-B].
  6. Client generates secret + evaluation keys from client.specs.json and ships the evaluation key plus the encrypted input vector to the server [§III-B, §IV-C].
  7. Server runs the homomorphic XGBoost circuit on the ciphertext with the evaluation key [§II, §III-B].
  8. Server returns the encrypted result; client decrypts and de-quantizes to obtain the label [§II, §III-B].

Architecture diagram

flowchart LR
    I([Input: tabular features, Model A: 19, Model B: 7]) --> QI[Quantize input integers]
    QI --> XGB[XGBoost ensemble of boosted trees]
    XGB --> ST[Sequential tensor pipeline via hummingbird-ml]
    ST --> AGG[Aggregate tree outputs]
    AGG --> DQ[De-quantize output]
    DQ --> O([Binary class label])

Note: the paper does not disclose the number of trees, tree depth, or other XGBoost hyperparameters — Not reported. The diagram reflects the conceptual conversion pipeline that hummingbird-ml and Concrete ML produce, where boosted trees are represented as a “sequential pipeline” of tensor operations [§III-A].

Results

The paper reports qualitative ratios rather than raw seconds for individual inference. Key reported numbers [§III-C, §V]:

Metric This paper Baseline Hardware
FHE vs plaintext inference time ratio ~10^6 increase 1x (plaintext) AMD EPYC 3rd-gen, 96 vCPUs, 192 GiB RAM [§III]
Encrypted data size vs plaintext up to 7x larger 1x Same [§III-C, §V]
Evaluation key size (128-bit security) “easily exceed 300 MB” N/A Same [§IV-C]
Prediction agreement plaintext vs FHE (Model A, 19 features) 99% overlap — Same [§III-C]
Prediction agreement plaintext vs FHE (Model B, 7 features) 22% overlap — Same [§III-C]
ONNX conversion + circuit compilation (post-XGBoost switch) “a few dozen seconds” — Same; single-threaded, one vCPU [§III-A]
ONNX conversion (Random Forest first attempt) Aborted — excessively long — Same [§III-A]
Evaluation dataset for latency measurements 3000 records — Same [§III-C]

Single-sample encrypted latency in seconds is Not reported (only the ~10^6 ratio is given without a paired plaintext base time); listed as N/A in the comparison block.

Limitations and assumptions

Code and artifacts

Not released. The paper does not link to a public repository for the evaluation pipeline or the (proprietary) datasets [§III, §V].

Extra diagrams (optional)

Threat model

flowchart LR
    C[Data owner / Client] -- evaluation key + enc(features) --> S[Cloud server / 3rd-party]
    S -- enc(prediction) --> C
    C -.- SK[Holds secret key only]
    S -.- CIRC[Holds compiled FHE circuit only]

The cloud server is treated as untrusted with respect to data confidentiality; it never sees plaintext features or labels, only ciphertexts and the evaluation key [§I, §II, §III-B].

Open questions