Struct DifferentiallyPrivateOptimizer 

pub struct DifferentiallyPrivateOptimizer<O, A, D>
where
    A: Float + ScalarOperand + Debug + Send + Sync,
    D: Dimension,
    O: Optimizer<A, D>,
{ /* private fields */ }

Differentially private optimizer wrapper

Implementations

impl<O, A, D> DifferentiallyPrivateOptimizer<O, A, D>

where A: Float + AddAssign + SubAssign + Send + Sync + ScalarOperand + Debug, D: Dimension, O: Optimizer<A, D>,

pub fn new(baseoptimizer: O, config: DifferentialPrivacyConfig) -> Result<Self>

Create a new differentially private optimizer.

The configuration is validated up front, and the accountant named by config.accounting_method is constructed (an unimplemented method is an error, never a silent substitution).

pub fn dp_step_per_example( &mut self, params: &Array<A, D>, per_example_gradients: &[Array<A, D>], ) -> Result<Array<A, D>>

Perform a differentially private step from per-example gradients.

This is the entry point that delivers the standard DP-SGD guarantee:

1. every per-example gradient is clipped to the current L2 threshold C, bounding one example’s influence on the sum by C;
2. the clipped gradients are summed;
3. N(0, sigma^2 C^2) noise is added to the sum (adding it after the division would silently reduce the effective sigma by the batch size);
4. the noisy sum is divided by the batch size.

Adjacency: add/remove-one-example, for which the L2 sensitivity of the clipped sum is exactly C.

The privacy budget is enforced before the noisy gradient is released: if composing this step would push epsilon past target_epsilon, the call returns OptimError::PrivacyBudgetExhausted and nothing is released.

pub fn dp_step_presummed( &mut self, params: &Array<A, D>, summed_clipped_gradients: &Array<A, D>, batch_size: usize, ) -> Result<Array<A, D>>

Perform a differentially private step from a pre-clipped sum of per-example gradients.

The caller asserts that summed_clipped_gradients is the sum of batch_size per-example gradients, each already clipped to DifferentialPrivacyConfig::l2_norm_clip. Noise N(0, sigma^2 C^2) is added to the sum, which is then divided by batch_size.

Use this when per-example gradients are produced by an external framework and materialising them all is impractical.

pub fn dp_step( &mut self, params: &Array<A, D>, gradients: &mut Array<A, D>, ) -> Result<Array<A, D>>

Perform a step that clips the already aggregated gradient.

This does not provide per-example differential privacy

Clipping a batch-mean (or batch-sum) gradient bounds the influence of the whole batch, not of any single example, so the standard DP-SGD analysis – and the epsilon this optimizer reports – does not apply under example-level adjacency. One outlier example can still move the aggregate arbitrarily far inside the clipping ball.

The entry point is retained for batch-level adjacency (neighbouring datasets differing in an entire batch) and for reproducing legacy behaviour. Because subsampling amplification does not apply under that adjacency, the step is accounted with sampling probability q = 1, which is strictly more conservative than the per-example path.

It returns an error unless DifferentialPrivacyConfig::acknowledge_aggregate_clipping is set, so nobody gets this behaviour by accident. Prefer Self::dp_step_per_example.

pub fn consumed_epsilon(&self) -> Result<f64>

Epsilon consumed so far.

Errors from the accountant are propagated rather than swallowed: an accounting failure must never be reported as “zero spent”, which would let training continue with no budget enforcement at all.

pub fn has_privacy_budget(&self) -> Result<bool>

Whether at least one more step fits inside the epsilon budget.

pub fn get_privacy_budget(&self) -> Result<PrivacyBudget>

Current privacy budget status.

Returns an error if the accountant cannot produce a number – failing closed instead of reporting a fabricated zero spend.

pub fn accounting_segments(&self) -> &[AccountingSegment]

Immutable view of the accountant’s segment ledger.

pub fn config(&self) -> &DifferentialPrivacyConfig

The configuration in force.

pub fn get_clipping_threshold(&self) -> f64

Current clipping threshold (adaptive if enabled).

pub fn get_clipping_stats(&self) -> ClippingStats

Gradient clipping statistics.

pub fn get_audit_trail(&self) -> &[PrivacyEvent]

Privacy audit trail.

pub fn validate_privacy(&self) -> Result<PrivacyValidation>

Validate privacy guarantees against the configured budget.