def nanvar(array, epsilon=1.0, bounds=None, axis=None, dtype=None, keepdims=False, accountant=None, **unused_args):
r"""
Compute the differentially private variance along the specified axis, ignoring NaNs.
Returns the variance of the array elements, a measure of the spread of a distribution, with differential privacy.
The variance is computer for the flattened array by default, otherwise over the specified axis. Noise is added
using :class:`.LaplaceBoundedDomain` to satisfy differential privacy, where sensitivity is calculated using
`bounds`. Users are advised to consult the documentation of :obj:`numpy.var` for further details, as the behaviour
of `var` closely follows its Numpy variant.
For all-NaN slices, NaN is returned and a `RuntimeWarning` is raised.
Parameters
----------
array : array_like
Array containing numbers whose variance is desired. If `array` is not an array, a conversion is attempted.
epsilon : float, default: 1.0
Privacy parameter :math:`\epsilon`.
bounds : tuple, optional
Bounds of the values of the array, of the form (min, max).
axis : int or tuple of ints, optional
Axis or axes along which the variance is computed. The default is to compute the variance of the flattened
array.
If this is a tuple of ints, a variance is performed over multiple axes, instead of a single axis or all the axes
as before.
dtype : data-type, optional
Type to use in computing the variance. For arrays of integer type the default is `float32`; for arrays of float
types it is the same as the array type.
keepdims : bool, default: False
If this is set to True, the axes which are reduced are left in the result as dimensions with size one. With
this option, the result will broadcast correctly against the input array.
accountant : BudgetAccountant, optional
Accountant to keep track of privacy budget.
Returns
-------
variance : ndarray, see dtype parameter above
If ``out=None``, returns a new array containing the variance; otherwise, a reference to the output array is
returned.
See Also
--------
std , mean, var
"""
warn_unused_args(unused_args)
return _var(array, epsilon=epsilon, bounds=bounds, axis=axis, dtype=dtype, keepdims=keepdims, accountant=accountant,
nan=True)
def std(array, epsilon=1.0, bounds=None, axis=None, dtype=None, keepdims=False, accountant=None, **unused_args):
r"""
Compute the standard deviation along the specified axis.
Returns the standard deviation of the array elements, a measure of the spread of a distribution, with differential
privacy. The standard deviation is computed for the flattened array by default, otherwise over the specified axis.
Noise is added using :class:`.LaplaceBoundedDomain` to satisfy differential privacy, where sensitivity is
calculated using `bounds`. Users are advised to consult the documentation of :obj:`numpy.std` for further details,
as the behaviour of `std` closely follows its Numpy variant.
Parameters
----------
array : array_like
Calculate the standard deviation of these values.
epsilon : float, default: 1.0
Privacy parameter :math:`\epsilon`.
bounds : tuple, optional
Bounds of the values of the array, of the form (min, max).
axis : int or tuple of ints, optional
Axis or axes along which the standard deviation is computed. The default is to compute the standard deviation
of the flattened array.
If this is a tuple of ints, a standard deviation is performed over multiple axes, instead of a single axis or
all the axes as before.
dtype : dtype, optional
Type to use in computing the standard deviation. For arrays of integer type the default is float64, for arrays
of float types it is the same as the array type.
keepdims : bool, default: False
If this is set to True, the axes which are reduced are left in the result as dimensions with size one. With
this option, the result will broadcast correctly against the input array.
accountant : BudgetAccountant, optional
Accountant to keep track of privacy budget.
Returns
-------
standard_deviation : ndarray, see dtype parameter above.
Return a new array containing the standard deviation.
See Also
--------
var, mean, nanstd
"""
warn_unused_args(unused_args)
return _std(array, epsilon=epsilon, bounds=bounds, axis=axis, dtype=dtype, keepdims=keepdims,
accountant=accountant, nan=False)
def nansum(array, epsilon=1.0, bounds=None, accountant=None, axis=None, dtype=None, keepdims=False, **unused_args):
r"""Sum of array elements over a given axis with differential privacy, ignoring NaNs.
Parameters
----------
array : array_like
Elements to sum.
epsilon : float, default: 1.0
Privacy parameter :math:`\epsilon`.
bounds : tuple, optional
Bounds of the values of the array, of the form (min, max).
accountant : BudgetAccountant, optional
Accountant to keep track of privacy budget.
axis : None or int or tuple of ints, optional
Axis or axes along which a sum is performed. The default, axis=None, will sum all of the elements of the input
array. If axis is negative it counts from the last to the first axis.
If axis is a tuple of ints, a sum is performed on all of the axes specified in the tuple instead of a single
axis or all the axes as before.
dtype : dtype, optional
The type of the returned array and of the accumulator in which the elements are summed. The dtype of `array` is
used by default unless `array` has an integer dtype of less precision than the default platform integer. In
that case, if `array` is signed then the platform integer is used while if `array` is unsigned then an unsigned
integer of the same precision as the platform integer is used.
keepdims : bool, default: False
If this is set to True, the axes which are reduced are left in the result as dimensions with size one. With
this option, the result will broadcast correctly against the input array.
Returns
-------
sum_along_axis : ndarray
An array with the same shape as `array`, with the specified axis removed. If `array` is a 0-d array, or if
`axis` is None, a scalar is returned. If an output array is specified, a reference to `out` is returned.
See Also
--------
ndarray.sum : Equivalent non-private method.
mean, sum
"""
warn_unused_args(unused_args)
return _sum(array, epsilon=epsilon, bounds=bounds, accountant=accountant, axis=axis, dtype=dtype,
keepdims=keepdims, nan=True)
def mean(array, epsilon=1.0, bounds=None, axis=None, dtype=None, keepdims=False, accountant=None, **unused_args):
r"""
Compute the differentially private arithmetic mean along the specified axis.
Returns the average of the array elements with differential privacy. The average is taken over the flattened array
by default, otherwise over the specified axis. Noise is added using :class:`.Laplace` to satisfy differential
privacy, where sensitivity is calculated using `bounds`. Users are advised to consult the documentation of
:obj:`numpy.mean` for further details, as the behaviour of `mean` closely follows its Numpy variant.
Parameters
----------
array : array_like
Array containing numbers whose mean is desired. If `array` is not an array, a conversion is attempted.
epsilon : float, default: 1.0
Privacy parameter :math:`\epsilon`.
bounds : tuple, optional
Bounds of the values of the array, of the form (min, max).
axis : int or tuple of ints, optional
Axis or axes along which the means are computed. The default is to compute the mean of the flattened array.
If this is a tuple of ints, a mean is performed over multiple axes, instead of a single axis or all the axes as
before.
dtype : data-type, optional
Type to use in computing the mean. For integer inputs, the default is `float64`; for floating point inputs, it
is the same as the input dtype.
keepdims : bool, default: False
If this is set to True, the axes which are reduced are left in the result as dimensions with size one. With
this option, the result will broadcast correctly against the input array.
accountant : BudgetAccountant, optional
Accountant to keep track of privacy budget.
Returns
-------
m : ndarray, see dtype parameter above
Returns a new array containing the mean values.
See Also
--------
std, var, nanmean
"""
warn_unused_args(unused_args)
return _mean(array, epsilon=epsilon, bounds=bounds, axis=axis, dtype=dtype, keepdims=keepdims,
accountant=accountant, nan=False)
