Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
def test_no_params(self):
clf = PCA()
X = np.array(
[0.50, 0.75, 1.00, 1.25, 1.50, 1.75, 1.75, 2.00, 2.25, 2.50, 2.75, 3.00, 3.25, 3.50, 4.00, 4.25, 4.50, 4.75,
5.00, 5.50])
X = X[:, np.newaxis]
with self.assertWarns(PrivacyLeakWarning):
clf.fit(X)
def test_no_params(self):
clf = LinearRegression()
X = np.array(
[0.50, 0.75, 1.00, 1.25, 1.50, 1.75, 1.75, 2.00, 2.25, 2.50, 2.75, 3.00, 3.25, 3.50, 4.00, 4.25, 4.50, 4.75,
5.00, 5.50])
y = np.array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1])
X = X[:, np.newaxis]
with self.assertWarns(PrivacyLeakWarning):
clf.fit(X, y)
def test_no_range(self):
x = np.array([1, 2, 3, 4, 5])
y = np.array([5, 7, 1, 5, 9])
with self.assertWarns(PrivacyLeakWarning):
res = histogram2d(x, y, epsilon=1)
self.assertIsNotNone(res)
def test_no_range(self):
a = np.array([1, 2, 3])
with self.assertWarns(PrivacyLeakWarning):
var(a, epsilon=1)
def test_no_range(self):
a = np.array([1, 2, 3])
with self.assertWarns(PrivacyLeakWarning):
res = nanmean(a, epsilon=1)
self.assertIsNotNone(res)
def test_no_range(self):
a = np.array([1, 2, 3])
with self.assertWarns(PrivacyLeakWarning):
res = mean(a, epsilon=1)
self.assertIsNotNone(res)
def test_no_range(self):
a = np.array([1, 2, 3])
with self.assertWarns(PrivacyLeakWarning):
std(a, epsilon=1)
del y
if X.ndim != 2:
raise ValueError(
"Expected 2D array, got array with %d dimensions instead. Reshape your data using array.reshape(-1, 1),"
"or array.reshape(1, -1) if your data contains only one sample." % X.ndim)
n_samples, n_dims = X.shape
iters = self._calc_iters(n_dims, n_samples)
if self.bounds is None:
warnings.warn("Bounds have not been specified and will be calculated on the data provided. This will "
"result in additional privacy leakage. To ensure differential privacy and no additional "
"privacy leakage, specify `bounds` for each dimension.", PrivacyLeakWarning)
self.bounds = list(zip(np.min(X, axis=0), np.max(X, axis=0)))
self.bounds = _check_bounds(self.bounds, n_dims)
centers = self._init_centers(n_dims)
labels = None
distances = None
# Run _update_centers first to ensure consistency of `labels` and `centers`, since convergence unlikely
for _ in range(-1, iters):
if labels is not None:
centers = self._update_centers(X, centers=centers, labels=labels, dims=n_dims, total_iters=iters)
distances, labels = self._distances_labels(X, centers)
self.cluster_centers_ = centers
except TypeError:
temp_axis = (axis,)
else:
temp_axis = tuple(_range(len(a.shape)))
num_datapoints = 1
for i in temp_axis:
num_datapoints *= a.shape[i]
actual_var = np.var(a, axis=axis, dtype=dtype, out=out, ddof=ddof, keepdims=keepdims)
if range is None:
warnings.warn("Range parameter hasn't been specified, so falling back to determining range from the data.\n"
"This will result in additional privacy leakage. To ensure differential privacy with no "
"additional privacy loss, specify `range` for each valued returned by np.mean().",
PrivacyLeakWarning)
ranges = np.maximum(np.max(a, axis=axis) - np.min(a, axis=axis), 1e-5)
elif isinstance(range, Real):
ranges = np.ones_like(actual_var) * range
else:
ranges = np.array(range)
if not (ranges > 0).all():
raise ValueError("Ranges must be specified for each value returned by np.var(), and must be non-negative")
if ranges.shape != actual_var.shape:
raise ValueError("Shape of range must be same as shape of np.var()")
if isinstance(actual_var, np.ndarray):
# Extra np.array() a temporary fix for PyLint bug: https://github.com/PyCQA/pylint/issues/2747
dp_var = np.array(np.zeros_like(actual_var))
iterator = np.nditer(actual_var, flags=['multi_index'])
self : class
"""
if not isinstance(self.C, numbers.Real) or self.C < 0:
raise ValueError("Penalty term must be positive; got (C=%r)" % self.C)
if not isinstance(self.max_iter, numbers.Integral) or self.max_iter < 0:
raise ValueError("Maximum number of iteration must be positive; got (max_iter=%r)" % self.max_iter)
if not isinstance(self.tol, numbers.Real) or self.tol < 0:
raise ValueError("Tolerance for stopping criteria must be positive; got (tol=%r)" % self.tol)
max_norm = np.linalg.norm(X, axis=1).max()
if self.data_norm is None:
warnings.warn("Data norm has not been specified and will be calculated on the data provided. This will "
"result in additional privacy leakage. To ensure differential privacy and no additional "
"privacy leakage, specify `data_norm` at initialisation.", PrivacyLeakWarning)
self.data_norm = max_norm
if max_norm > self.data_norm:
warnings.warn("Differential privacy is only guaranteed for data whose rows have a 2-norm of at most %g. "
"Got %f\n"
"Translate and/or scale the data accordingly to ensure differential privacy is achieved."
% (self.data_norm, max_norm), PrivacyLeakWarning)
solver = _check_solver(self.solver, self.penalty, self.dual)
_dtype = np.float64
X, y = check_X_y(X, y, accept_sparse='csr', dtype=_dtype, order="C", accept_large_sparse=solver != 'liblinear')
check_classification_targets(y)
self.classes_ = np.unique(y)
_, n_features = X.shape