Opake

Opake (/oʊˈpeɪk/, archaic opaque) — Functional DP-SGD and DP-FTRL for PyTorch.

Opake provides composable primitives for differentially private model training in PyTorch: per-example gradient clipping, calibrated noise injection, privacy accounting, and Poisson sampling. Built on torch.func, it uses a functional API with explicit state — no hooks, no subclassing, no hidden mutation.

Work in progress: Opake is research software under active development. Its differential-privacy mechanisms, accounting, and privacy guarantees are still being validated and may change. Do not rely on it for production or compliance-sensitive privacy guarantees without independent validation for your use case.

Documentation

Packages

Install and depend on opake only. The repository is implemented as PEP 420 namespace packages under the shared opake.* namespace:

Import layout

opake.serialization                                       <- opake-base
opake.{types,pytree}                                      <- opake-engine
opake.{random,distributed}                                <- opake-engine
opake.{functional,scheduling,profiling}                   <- opake-engine
opake.optimizers                                          <- opake-optimizers
opake.dpsgd.{clipping,noise,sampling,accounting}          <- opake-dpsgd
opake.dpftrl.{clipping,noise,sampling,accounting}         <- opake-dpftrl
opake.auditing                                            <- opake-auditing
opake.patches.{kernels,torch,transformers,peft}           <- opake-patches
opake.transformers{,.trl}                                 <- opake-transformers
opake.alignment.{sft,dpo,data,metric}                     <- opake-alignment
opake.accounting                                          <- opake-accounting

Installation

Opake is published on PyPI, so a plain install works:

pip install opake

# Or with uv
uv add opake

Releases are mirrored to JetBrains Packages, which also carries .dev wheels built from main:

pip install opake \
  --index-url https://packages.jetbrains.team/pypi/p/fed/python/simple/

# Or with uv
uv add opake \
  --index https://packages.jetbrains.team/pypi/p/fed/python/simple/

Extras:

pip install "opake[auditing]"      # empirical privacy auditing
pip install "opake[dpftrl]"        # correlated-noise DP-FTRL components
pip install "opake[alignment]"     # DP-safe SFT / DPO primitives
pip install "opake[transformers]"  # Hugging Face + patching components
pip install "opake[trl]"           # converters that accept real trl configs
pip install "opake[all]"           # all optional components

Each sub-package is also a separate distribution, so you can install only what you need (see the table above for which distribution provides each import path):

pip install opake-accounting       # PLD privacy accounting (torch-free)
pip install opake-dpsgd            # DP-SGD noise, clipping, sampling
pip install opake-dpftrl           # matrix-factorization noise
pip install "opake-patches[transformers]"  # HF compat + Triton kernels

Patching

Hugging Face and checkpoint patches are applied explicitly through opake.patches:

from opake.patches import apply_model_patches, apply_runtime_patches

apply_runtime_patches()

# ... build / wrap the model, then patch the concrete instance
apply_model_patches(model)

apply_runtime_patches() enables the runtime-side checkpoint, collator, and loss-mapping fixes. apply_model_patches(model) wires compat wrappers and Triton kernels into the specific model instance, including PEFT/LoRA modules.

See the model-patches guide for patching details, model compatibility, and tuning knobs.

Example

A minimal DP-SGD training loop:

import torch
import opake.accounting as acc                # cross-cutting (calibrate, budget)
import opake.dpsgd.accounting as dpsgd_acc    # DP-SGD per-step factories
from opake.dpsgd.clipping import clipped_grad
from opake.dpsgd.noise import gaussian_noise
from opake.random import key

def loss_fn(params, x, y):
    return ((x @ params - y) ** 2).sum()

# Calibrate noise for target privacy budget
result = acc.calibrate(
    acc.epsilon_budget(3.0, delta=1e-5),
    lambda nm: dpsgd_acc.poisson(dpsgd_acc.gaussian(nm), sample_rate=0.01) * 1000,
    param_min=0.1, param_max=10.0,
)
batch_size = 64  # expected batch size for Poisson sampling

# DP-SGD components
grad_fn, clip_state = clipped_grad(
    loss_fn, clipping_norm=1.0, batch_argnums=(1, 2),
    normalize_by=batch_size,
)
noise_fn, noise_state = gaussian_noise(
    noise_multiplier=result.param, key=key(42),
)

# Training loop
params = torch.randn(10, requires_grad=False)
lr = 0.01
for batch_x, batch_y in dataloader:
    grads, clip_state = grad_fn(params, batch_x, batch_y, state=clip_state)
    noisy_grads, noise_state = noise_fn(grads, noise_state)
    params = params - lr * noisy_grads.pytree  # or wire opake.optimizers

Features

• Per-example gradient clipping via torch.func.vmap + torch.func.grad, with fixed, adaptive (Andrew et al. 2021), and AUTO-S (Bu et al. 2023) variants.
• Noise injection: Gaussian and correlated matrix-factorization noise (band-MF, BLT, BSR, BiSR, DP-λCGD), including private second-moment streams for adaptive optimizers.
• Privacy accounting: Rust-based PLD engine with tight composition, multiple privacy metrics (ε-δ, f-DP advantage, error rates), and noise calibration via binary search.
• Sampling: DP-SGD Poisson (plain or capped), DP-FTRL Poisson (identity or banded), balls-in-bins, b-min-separation, and sequential batch samplers.
• Privacy auditing: empirical privacy validation via membership inference.
• Distributed training: DDP-compatible with synchronized noise and gradient aggregation via opake.distributed.
• Hugging Face compatibility: automatic vmap patching for LLaMA, Mistral, Qwen2/3, Phi-3, Gemma/Gemma2, Granite, Cohere/Cohere2, plus fused Triton kernels via opake.patches.

Documentation

• Documentation
• Getting Started
• User Guide
• Tutorials
• API Reference
• Examples

Development

uv sync --group dev --all-packages --extra all
uv run pytest -m "not cuda and not mps and not slow"        # PR-equivalent suite
uv run ruff format packages/                                # Format
uv run ruff check packages/                                 # Lint
uv run --group docs mkdocs build --strict                   # Build docs
cargo test --workspace

See CONTRIBUTING.md for the full development workflow. The development guide includes fork-based setup.

References

• Deep Learning with Differential Privacy (Abadi et al. 2016)
• JAX-Privacy — original inspiration
• Opacus — alternative PyTorch DP library (hook-based design)

License

Apache 2.0. See LICENSE.