def test_kmp_precomputed_dictionary():
n_samples = mult_dense.shape[0]
cv = ShuffleSplit(n_samples,
n_iterations=1,
test_fraction=0.2,
random_state=0)
train, test = list(cv)[0]
X_train, y_train = mult_dense[train], mult_target[train]
X_test, y_test = mult_dense[test], mult_target[test]
components = select_components(X_train, y_train,
n_components=0.3,
random_state=0)
K_train = pairwise_kernels(X_train, components)
kmp = KMPClassifier(metric="precomputed")
kmp.fit(K_train, y_train)
y_pred = kmp.predict(K_train)
acc = np.mean(y_pred == y_train)
assert_true(acc >= 0.75)
K_test = pairwise_kernels(X_test, components)
y_pred = kmp.predict(K_test)
acc = np.mean(y_pred == y_test)
assert_true(acc >= 0.63)
def pairwise_persistence_diagram_kernels(X, Y=None, kernel="sliced_wasserstein", **kwargs):
"""
This function computes the kernel matrix between two lists of persistence diagrams given as numpy arrays of shape (nx2).
Parameters:
X (list of n numpy arrays of shape (numx2)): first list of persistence diagrams.
Y (list of m numpy arrays of shape (numx2)): second list of persistence diagrams (optional). If None, pairwise kernel values are computed from the first list only.
kernel: kernel to use. It can be either a string ("sliced_wasserstein", "persistence_scale_space", "persistence_weighted_gaussian", "persistence_fisher") or a function taking two numpy arrays of shape (nx2) and (mx2) as inputs. If it is a function, make sure that it is symmetric.
**kwargs: optional keyword parameters. Any further parameters are passed directly to the kernel function. See the docs of the various kernel classes in this module.
Returns:
numpy array of shape (nxm): kernel matrix.
"""
XX = np.reshape(np.arange(len(X)), [-1,1])
YY = None if Y is None else np.reshape(np.arange(len(Y)), [-1,1])
if kernel == "sliced_wasserstein":
return np.exp(-pairwise_persistence_diagram_distances(X, Y, metric="sliced_wasserstein", num_directions=kwargs["num_directions"]) / kwargs["bandwidth"])
elif kernel == "persistence_fisher":
return np.exp(-pairwise_persistence_diagram_distances(X, Y, metric="persistence_fisher", kernel_approx=kwargs["kernel_approx"], bandwidth=kwargs["bandwidth"]) / kwargs["bandwidth_fisher"])
elif kernel == "persistence_scale_space":
return pairwise_kernels(XX, YY, metric=_sklearn_wrapper(_persistence_scale_space_kernel, X, Y, **kwargs))
elif kernel == "persistence_weighted_gaussian":
return pairwise_kernels(XX, YY, metric=_sklearn_wrapper(_persistence_weighted_gaussian_kernel, X, Y, **kwargs))
else:
return pairwise_kernels(XX, YY, metric=_sklearn_wrapper(metric, **kwargs))
def eval(self, X):
"""Evaluate the kernel density estimation
Parameters
----------
X : array_like
array of points at which to evaluate the KDE. Shape is
(n_points, n_dim), where n_dim matches the dimension of
the training points.
Returns
-------
dens : ndarray
array of shape (n_points,) giving the density at each point.
The density will be normalized for metric='gaussian' or
metric='tophat', and will be unnormalized otherwise.
"""
X = np.atleast_2d(X)
if X.ndim != 2:
raise ValueError('X must be two-dimensional')
if X.shape[1] != self.X_.shape[1]:
raise ValueError('dimensions of X do not match training dimension')
if self.metric == 'gaussian':
# wrangle gaussian into scikit-learn's 'rbf' kernel
gamma = 0.5 / self.h / self.h
D = pairwise_kernels(X, self.X_, metric='rbf', gamma=gamma)
D /= np.sqrt(2 * np.pi * self.h ** (2 * X.shape[1]))
dens = D.sum(1)
elif self.metric == 'tophat':
# use Ball Tree to efficiently count neighbors
bt = BallTree(self.X_)
counts = bt.query_radius(X, self.h,
count_only=True)
dens = counts / n_volume(self.h, X.shape[1])
elif self.metric == 'exponential':
D = pairwise_distances(X, self.X_)
dens = np.exp(-abs(D) / self.h)
dens = dens.sum(1)
dens /= n_volume(self.h, X.shape[1]) * special.gamma(X.shape[1])
elif self.metric == 'quadratic':
D = pairwise_distances(X, self.X_)
dens = (1 - (D / self.h) ** 2)
dens[D > self.h] = 0
dens = dens.sum(1)
dens /= 2. * n_volume(self.h, X.shape[1]) / (X.shape[1] + 2)
else:
D = pairwise_kernels(X, self.X_, metric=self.metric, **self.kwargs)
dens = D.sum(1)
return dens
def eval(self, X):
"""Evaluate the kernel density estimation
Parameters
----------
X : array_like
array of points at which to evaluate the KDE. Shape is
(n_points, n_dim), where n_dim matches the dimension of
the training points.
Returns
-------
dens : ndarray
array of shape (n_points,) giving the density at each point.
The density will be normalized for metric='gaussian' or
metric='tophat', and will be unnormalized otherwise.
"""
X = np.atleast_2d(X)
if X.ndim != 2:
raise ValueError('X must be two-dimensional')
if X.shape[1] != self.X_.shape[1]:
raise ValueError('dimensions of X do not match training dimension')
if self.metric == 'gaussian':
# wrangle gaussian into scikit-learn's 'rbf' kernel
gamma = 0.5 / self.h / self.h
D = pairwise_kernels(X, self.X_, metric='rbf', gamma=gamma)
D /= np.sqrt(2 * np.pi * self.h ** (2 * X.shape[1]))
dens = D.sum(1)
elif self.metric == 'tophat':
# use Ball Tree to efficiently count neighbors
bt = BallTree(self.X_)
counts = bt.query_radius(X, self.h,
count_only=True)
dens = counts / n_volume(self.h, X.shape[1])
elif self.metric == 'exponential':
D = pairwise_distances(X, self.X_)
dens = np.exp(-abs(D) / self.h)
dens = dens.sum(1)
dens /= n_volume(self.h, X.shape[1]) * special.gamma(X.shape[1])
elif self.metric == 'quadratic':
D = pairwise_distances(X, self.X_)
dens = (1 - (D / self.h) ** 2)
dens[D > self.h] = 0
dens = dens.sum(1)
dens /= 2. * n_volume(self.h, X.shape[1]) / (X.shape[1] + 2)
else:
D = pairwise_kernels(X, self.X_, metric=self.metric, **self.kwargs)
dens = D.sum(1)
return dens
def kernel_two_sample_test(X, Y, kernel_function='rbf', iterations=10000,
verbose=False, random_state=None, **kwargs):
"""Compute MMD^2_u, its null distribution and the p-value of the
kernel two-sample test.
Note that extra parameters captured by **kwargs will be passed to
pairwise_kernels() as kernel parameters. E.g. if
kernel_two_sample_test(..., kernel_function='rbf', gamma=0.1),
then this will result in getting the kernel through
kernel_function(metric='rbf', gamma=0.1).
"""
m = len(X)
n = len(Y)
XY = np.vstack([X, Y])
K = pairwise_kernels(XY, metric=kernel_function, **kwargs)
mmd2u = MMD2u(K, m, n)
if verbose:
print("MMD^2_u = %s" % mmd2u)
print("Computing the null distribution.")
mmd2u_null = compute_null_distribution(K, m, n, iterations,
verbose=verbose,
random_state=random_state)
p_value = max(1.0/iterations, (mmd2u_null > mmd2u).sum() /
float(iterations))
if verbose:
print("p-value ~= %s \t (resolution : %s)" % (p_value, 1.0/iterations))
return mmd2u, mmd2u_null, p_value
def kernelTwoSampleTest(X,
Y,
kernel_function='rbf',
iterations=10000,
verbose=False,
**kwargs):
"""Compute MMD^2_u, its null distribution and the p-value of the
kernel two-sample test.
Note that extra parameters captured by **kwargs will be passed to
pairwise_kernels() as kernel parameters. E.g. if
kernel_two_sample_test(..., kernel_function='rbf', gamma=0.1),
then this will result in getting the kernel through
kernel_function(metric='rbf', gamma=0.1).
"""
m = len(X)
n = len(Y)
X = X.numpy()
X = X.reshape(X.shape[0], -1)
Y = Y.numpy()
Y = Y.reshape(Y.shape[0], -1)
XY = np.vstack([X, Y])
# calculate the kernel matrix given elements of both domains
K = pairwise_kernels(XY, metric=kernel_function, **kwargs)
mmd2u = MMD2u(K, m, n)
if verbose:
print("MMD^2_u = %s" % mmd2u)
print("Computing the null distribution.")
return mmd2u
def _get_kernel(self, view, X, Y=None):
params = {
"gamma": self.gamma[view],
}
return pairwise_kernels(
X, Y, metric=self.kernel[view], filter_params=True, **params
)
def compute_rbf_kernel_matrix(X):
"""Compute the RBF kernel matrix with sigma2 as the median pairwise
distance.
"""
sigma2 = np.median(pairwise_distances(X, metric='euclidean'))**2
K = pairwise_kernels(X, X, metric='rbf', gamma=1.0 / sigma2, n_jobs=-1)
return K
def extract(self, A, k, W=None, H=None):
""" Run a NMF algorithm
Parameters
----------
A : numpy.array or scipy.sparse matrix, shape (m,n)
m : Number of features
n : Number of samples
k : int - target lower rank
Returns
-------
(W, H, rec)
W : Obtained factor matrix, shape (m,k)
H : Obtained coefficient matrix, shape (n,k)
"""
if W is None and H is None:
W = np.random.rand(A.shape[0], k)
H = np.random.rand(A.shape[1], k)
elif W is None:
Sol, info = nnls.nnlsm_blockpivot(H, A.T)
W = Sol.T
elif H is None:
Sol, info = nnls.nnlsm_blockpivot(W.T, A)
H = Sol.T
H_hat = np.random.rand(A.shape[1], k)
S = metrics.pairwise_kernels(A.T)
norm_A = mu.norm_fro(A)
for i in range(1, self.max_iter + 1):
(W, H, H_hat) = self.iter_solver(A, S, W, H, H_hat, self.alpha,
self.beta)
rel_error = mu.norm_fro_err(A, W, H, norm_A) / norm_A
return W, H, H_hat
def extract(self, A, k, max_iter=100, lambda_reg=0.1, alpha_reg=0.1):
""" Run a NMF algorithm
Parameters
----------
A : numpy.array or scipy.sparse matrix, shape (m,n)
m : Number of features
n : Number of samples
k : int - target lower rank
lambda_reg : Regularization constant for GRNMF
alpha : L1 regularization constant for H matrix
Returns
-------
(W, H, rec)
W : Obtained factor matrix, shape (m,k)
H : Obtained coefficient matrix, shape (n,k)
"""
W = np.random.rand(A.shape[0], k)
H = np.random.rand(A.shape[1], k)
S = metrics.pairwise_kernels(A.T)
# normalize the distance matrix between 0 to 1
S = S - np.min(S) / (np.max(S) - np.min(S))
D = np.sum(S, axis=1)
norm_A = mu.norm_fro(A)
for i in range(1, max_iter + 1):
(W, H) = self.iter_solver(A, S, D, W, H, lambda_reg, alpha_reg)
rel_error = mu.norm_fro_err(A, W, H, norm_A) / norm_A
return W, H
def compute_rbf_kernel_matrix(X):
"""Compute the RBF kernel matrix with sigma2 as the median pairwise
distance.
"""
sigma2 = np.median(pairwise_distances(X, metric='euclidean'))**2
K = pairwise_kernels(X, X, metric='rbf', gamma=1.0/sigma2, n_jobs=-1)
return K
def __generate_kernel(self):
t0 = timer()
if self._n_neighbors is not None:
self.__calc_epsilon()
k_init = np.exp(-self._dist**2 / self._epsilon)
else:
k_init = pairwise_kernels(self._data,
metric='rbf',
gamma=1 / self._epsilon,
n_jobs=self._n_jobs)
# k_init = k_init - np.eye(k_init.shape[0]) # prohibits self-transitions
d_init = np.sum(k_init, 1)
d_init_alpha = d_init**(-self._alpha)
d_init_alpha_mat = d_init_alpha.reshape(-1, 1) * d_init_alpha
self._kernel_alpha = k_init / d_init_alpha_mat
if np.allclose(self._kernel_alpha, self._kernel_alpha.T):
pass
else:
self._kernel_alpha = (self._kernel_alpha +
self._kernel_alpha.T) / 2
self._d_alpha = np.sum(self._kernel_alpha, 1)
t1 = timer()
t10 = round(t1 - t0, 3)
print('time elapsed for the computation of the kernel: {}'.format(t10))
def compute_mmd2u(X, Y):
m = len(X)
n = len(Y)
XY = np.vstack([X, Y])
sigma2 = np.median(pairwise_distances(X, Y, metric='euclidean'))**2
K = pairwise_kernels(XY, metric='rbf', gamma=1./sigma2)
return MMD2u(K, m, n)
def compute_metric_mmd2(X, Y):
m = len(X)
n = len(Y)
sigma2 = np.median(pairwise_distances(X, Y, metric='euclidean'))**2
XY = np.vstack([X, Y])
K = pairwise_kernels(XY, metric='rbf', gamma=1.0 / sigma2)
mmd2u = MMD2u(K, m, n, False)
return mmd2u
def score(self,x):
n=len(x)
Phi=pairwise_kernels(x,self.xce,metric="rbf",gamma=1./(2*self.sigma**2))
Phi1=tile(Phi.sum(0),(n,1))
tmp1=Phi1.T.dot(Phi)/(n**2)
tmp2=Phi.sum(0)/(n)
score=self.alpha.dot(tmp1).dot(self.alpha)-self.alpha.dot(tmp2)
return -score
def test_degenerate(self):
# simple cosine similarity (we always return normalized vectors)
sims1 = pairwise_kernels(self.query, self.index, metric='linear')
# degenerate soft cosine should be equal to cosine
sims2 = soft_cosine_similarities(
self.query, self.index, np.identity(len(self.vocab)))
self.assertTrue(np.allclose(sims1, sims2))
def predict(self, X):
'''
Returns +1 if the sample is predicted to be novel, -1 otherwise.
'''
ks = metrics.pairwise_kernels(X=self.X_train, Y=X, metric=self.metric)
scores = score(self.projection, self.target_points, ks)
prediction = np.array([1 if sc > self.threshold else -1 for sc in scores])
return prediction
def fit(self, X, y, sample_weight=None):
kernel_mat = metrics.pairwise_kernels(X, metric=self.metric)
proj, target_points = learn(kernel_mat, y)
self.projection = proj
self.target_points = target_points
self.X_train = X
return self
def fit(self, X, y, sample_weight=None):
kernel_mat = metrics.pairwise_kernels(X, metric=self.metric)
proj, target_points = learn(kernel_mat, y)
self.projection = proj
self.target_points = target_points
self.X_train = X
return self
def witness_function(X, Y, grid, kernel_function='rbf', **kwargs):
"""
This function computes the witness function. For the definition of the witness function see page 729
in the "A Kernel Two-Sample Test" by Gretton et al. (2012)
:param X: numpy-array
Data, of size MxD [M is the number of data points, D is the features dimension]
:param Y: numpy-array
Data, of size NxD [N is the number of data points, D is the features dimension]
:param gird: numpy-array
Defines a grid for which the witness function is computed. It has the size PxD
where P is the number of grid points, D is the features dimension
:param kernel_function: string
defines the kernel function, only used for the MMD.
For the list of implemented kernel please consult with https://scikit-learn.org/stable/modules/generated/sklearn.metrics.pairwise.kernel_metrics.html#sklearn.metrics.pairwise.kernel_metrics
:param kwargs:
extra parameters, these are passed to `pairwise_kernels()` as kernel parameters.
E.g., if `kernel_two_sample_test(..., kernel_function='rbf', gamma=0.1)`
:return: numpy-array
witness function
"""
if X.shape[1] != Y.shape[1]:
raise ValueError(
"Incompatible dimension for X and Y matrices. X and Y should have the same feature dimension,"
": X.shape[1] == %i while Y.shape[1] == %i." %
(X.shape[1], Y.shape[1]))
if X.shape[1] != grid.shape[1]:
raise ValueError(
"Incompatible dimension for data and grid matrices. data and grid should have the same feature dimension,"
": data.shape[1] == %i while grid.shape[1] == %i." %
(X.shape[1], grid.shape[1]))
# data and grid size
m = len(X)
n = len(Y)
# compute pairwise kernels
K_xg = pairwise_kernels(X, grid, metric=kernel_function, **kwargs)
K_yg = pairwise_kernels(Y, grid, metric=kernel_function, **kwargs)
return (np.sum(K_xg, axis=0) / m) - (np.sum(K_yg, axis=0) / n)
def predict(self, X, prob=False):
X = copy.deepcopy(X)
K_ts_matrix = pairwise_kernels(X,
self.X,
metric=self.kernel,
gamma=self.gamma)
output = np.dot(K_ts_matrix, self.alpha)
if prob is True:
return output
return output.argmax(axis=1)
def predict(self, X):
'''
Returns +1 if the sample is predicted to be novel, -1 otherwise.
'''
ks = metrics.pairwise_kernels(X=self.X_train, Y=X, metric=self.metric)
scores = score(self.projection, self.target_points, ks)
prediction = np.array(
[1 if sc > self.threshold else -1 for sc in scores])
return prediction
def example():
import numpy as np
from sklearn.metrics import pairwise_distances
from sklearn.metrics import pairwise_kernels
X = np.array([[2, 3], [3, 5], [5, 8]])
Y = np.array([[1, 0], [2, 1]])
print(pairwise_distances(X, Y, metric='manhattan'))
print(pairwise_distances(X, metric='manhattan'))
print(pairwise_kernels(X, Y, metric='linear'))
def transform(self, X):
"""Apply the feature map to X."""
X = check_array(X)
embedded = pairwise_kernels(X,
self.components_,
metric=self.kernel,
gamma=self.gamma)
return np.dot(embedded, self.normalization_.T)
def get_cosine_sim(self, s, p, o, body):
scores = []
claim = s + p + o
lsen = tokenize.sent_tokenize(body)
vec = CountVectorizer(analyzer='word')
vec.fit(lsen)
scores = pairwise_kernels(vec.transform([claim]),
vec.transform(lsen),
metric='cosine')
scores = scores[0].tolist()
return max(scores)
def test_statistics(X, Y, model='MMD', kernel_function='rbf', **kwargs):
"""
This function performs a test statistics and return a test value. This implementation can perform
the Kolmogorov-Smirnov test (for one-dimensional data only), Kullback-Leibler divergence and MMD.
:param X: numpy-array
Data, of size MxD [M is the number of data points, D is the features dimension]
:param Y: numpy-array
Data, of size NxD [N is the number of data points, D is the features dimension]
:param model: string
defines the basis model to perform two sample test ['KS', 'KL', 'MMD']
:param kernel_function: string
defines the kernel function, only used for the MMD.
For the list of implemented kernel please consult with https://scikit-learn.org/stable/modules/generated/sklearn.metrics.pairwise.kernel_metrics.html#sklearn.metrics.pairwise.kernel_metrics
:param kwargs:
extra parameters, these are passed to `pairwise_kernels()` as kernel parameters or `KL_divergence_estimator()`
as the number of k. E.g., if `kernel_two_sample_test(..., kernel_function='rbf', gamma=0.1)`
:return: float
the test value
"""
if model not in ['KS', 'KL', 'MMD']:
raise ValueError(
"The Model '%s' is not implemented, try 'KS', 'KL', or 'MMD'." %
model)
if X.shape[1] != Y.shape[1]:
raise ValueError(
"Incompatible dimension for X and Y matrices. X and Y should have the same feature dimension,"
": X.shape[1] == %i while Y.shape[1] == %i." %
(X.shape[1], Y.shape[1]))
if model == 'KS' and X.shape[1] > 1:
raise ValueError("The KS test can handle only one dimensional data,"
": X.shape[1] == %i and Y.shape[1] == %i." %
(X.shape[1], Y.shape[1]))
m = len(X)
n = len(Y)
# compute the test statistics according to the input model
if model == 'MMD':
XY = np.vstack([X, Y])
K = pairwise_kernels(XY, metric=kernel_function, **kwargs)
test_value = MMD2u_estimator(K, m, n)
elif model == 'KS':
test_value, _ = stats.ks_2samp(X.T[0], Y.T[0])
elif model == 'KL':
test_value = KL_divergence_estimator(X, Y, **kwargs)
return test_value
def predict(self, X):
X = np.asarray(X)
if X.ndim != 2:
raise ValueError('X must be two-dimensional')
if X.shape[1] != self.X.shape[1]:
raise ValueError('dimensions of X do not match training dimension')
if self.kernel == 'gaussian':
# wrangle gaussian into scikit-learn's 'rbf' kernel
h = np.asarray(self.h)
gamma = 0.5 / h / h
K = pairwise_kernels(X, self.X, metric='rbf', gamma=gamma)
else:
K = pairwise_kernels(X, self.X, metric=self.kernel, **self.kwargs)
K /= self.dy**2
return (K * self.y).sum(1) / K.sum(1)
def predict(self, X):
X = np.asarray(X)
if X.ndim != 2:
raise ValueError('X must be two-dimensional')
if X.shape[1] != self.X.shape[1]:
raise ValueError('dimensions of X do not match training dimension')
if self.kernel == 'gaussian':
# wrangle gaussian into scikit-learn's 'rbf' kernel
h = np.asarray(self.h)
gamma = 0.5 / h / h
K = pairwise_kernels(X, self.X, metric='rbf', gamma=gamma)
else:
K = pairwise_kernels(X, self.X, metric=self.kernel, **self.kwargs)
K /= self.dy ** 2
return (K * self.y).sum(1) / K.sum(1)
def transform(self, X):
"""Project the points in X onto the fisher directions.
Parameters
----------
X : {array-like} of shape (n_samples, n_features) to be
projected onto the fisher directions.
"""
check_is_fitted(self)
return pairwise_kernels(
X, self.X_, metric=self.kernel, **self.kwds
) @ self.weights_
def _get_kernel(self, view, X, Y=None):
if callable(self.kernel[view]):
params = self.kernel_params[view] or {}
else:
params = {
"gamma": self.gamma[view],
"degree": self.degree[view],
"coef0": self.coef0[view],
}
return pairwise_kernels(
X, Y, metric=self.kernel[view], filter_params=True, **params
)
def fit(self, X):
A = self.__adjacent_mat(X, self.n_neighbors)
if self.kernel == 'linear':
K = pairwise_kernels(X, metric='linear')
elif self.kernel == 'polynomial':
K = pairwise_kernels(X, metric='polynomial', gamma=0.05, degree=3)
elif self.kernel == 'sigmoid':
K = pairwise_kernels(X, metric='sigmoid', gamma=0.5)
elif self.kernel == 'rbf':
K = pairwise_kernels(X, metric='rbf', gamma=self.gamma)
else:
raise Exception('Invalid kernel')
I = np.eye(X.shape[0])
T = np.dot(np.transpose(A), K)
inv = np.linalg.inv(np.dot(T, K) + self.regu_coef * I)
C = np.dot(inv, T)
Coef = self.thrC(C, self.ro)
y_pre, C_final = self.post_proC(Coef, self.n_clusters, 8, 18)
if self.save_affinity:
np.savez('./gcsc-kernel-affinity.npz', C=C_final, C1=0.5 * (np.abs(C) + np.abs(C.T)))
return y_pre
def fit(self, X, y):
self.X = X
self.y = y
if y.shape.__len__() != 2:
self.classes_ = np.unique(y)
self.n_classes_ = self.classes_.__len__()
self.y = self.one2array(y, self.n_classes_)
else:
self.classes_ = np.arange(y.shape[1])
self.n_classes_ = self.classes_.__len__()
K_tr_matrix = pairwise_kernels(X, X, metric=self.kernel)
self.alpha = np.dot(
np.linalg.inv(np.eye(X.shape[0]) / self.C + K_tr_matrix), self.y)
def __init__(self, X, y, theta_0, theta_1):
self.X = X
self.size, self.dim = self.X.shape
y = y
ε = 1e-2
self.theta_0 = theta_0
self.theta_1 = theta_1
self.c = np.sqrt(theta_1**2 + ε)
length_scale = 1.0 / (np.sqrt(2) * self.c)
self.kernel = RBF(length_scale=length_scale)
K = theta_0**2 * pairwise_kernels(X, metric=self.kernel)
self.z = np.linalg.solve(K, y)
def predict(self, X):
'''
Returns +1 if the sample is predicted to be novel, -1 otherwise.
The threshold is selected between 0 and the minimum distance between
two target points.
'''
ks = metrics.pairwise_kernels(X=self.X_train, Y=X, metric=self.metric)
scores = score(self.projection, self.target_points, ks)
# min_dist = self._get_pairwise_min_dist()
prediction = np.array([1 if sc > self.threshold else -1 for sc in scores])
return scores
def predict_kernel(self, X):
n_test = X.shape[0]
distance_matrix = 2 - 2 * pairwise_kernels(
X, self.X, metric='rbf', gamma=10)
mean_vector = np.zeros(
(n_test, self.n_classes_, X.shape[1])) # [n_X, n_class, n_feature]
for c in range(self.n_classes_):
c_index = np.nonzero(self.y == self.classes_[c])
dis_c = distance_matrix[:, c_index[0]]
X_c = self.X[c_index]
sorted_index = dis_c.argsort()
nearest_neighbor_c = X_c[sorted_index][:, :self.n_neighbor, :]
mean_vector[:, c, :] = nearest_neighbor_c.mean(axis=1)
results = np.zeros(n_test)
for i in range(n_test):
dis = 2 - 2 * pairwise_kernels(X[i].reshape(1, X.shape[1]),
mean_vector[i, :, :],
metric='rbf',
gamma=1).flatten()
results[i] = self.classes_[np.argmin(dis)]
return results
def predict(self, X):
'''
Returns +1 if the sample is predicted to be novel, -1 otherwise.
The threshold is selected between 0 and the minimum distance between
two target points.
'''
ks = metrics.pairwise_kernels(X=self.X_train, Y=X, metric=self.metric)
scores = score(self.projection, self.target_points, ks)
# min_dist = self._get_pairwise_min_dist()
prediction = np.array(
[1 if sc > self.threshold else -1 for sc in scores])
return scores
def fit(self, X, y):
"""
Fit the NearestCentroid model according to the given training data.
Parameters
----------
X : {array-like, sparse matrix} of shape (n_samples, n_features)
Training vector, where n_samples is the number of samples and
n_features is the number of features.
y : array, shape = [n_samples]
Target values (integers)
"""
X, y = check_X_y(X, y)
self.classes_ = unique_labels(y)
if self.n_components > self.classes_.size - 1:
warnings.warn(
"n_components > classes_.size - 1."
"Only the first classes_.size - 1 components will be valid."
)
self.X_ = X
self.y_ = y
y_onehot = OneHotEncoder().fit_transform(
self.y_[:, np.newaxis])
K = pairwise_kernels(
X, X, metric=self.kernel, **self.kwds)
m_classes = y_onehot.T @ K / y_onehot.T.sum(1)
indices = (y_onehot @ np.arange(self.classes_.size)).astype('i')
N = K @ (K - m_classes[indices])
# Add value to diagonal for rank robustness
N += eye(self.y_.size) * self.robustness_offset
m_classes_centered = m_classes - K.mean(1)
M = m_classes_centered.T @ m_classes_centered
# Find weights
w, self.weights_ = eigsh(M, self.n_components, N, which='LM')
# Compute centers
centroids_ = m_classes @ self.weights_
# Train nearest centroid classifier
self.clf_ = NearestCentroid().fit(centroids_, self.classes_)
return self
def fit(self, X, y):
# Validate input.
X, y = check_X_y(X, y, accept_sparse=None, dtype='numeric')
# Normalize input.
self.n_, self.d_ = X.shape
X, y = self._normalize_X_y(X, y)
self.gamma_ = kernel_radius_to_gamma(self.kernel_radius, self.n_,
self.d_,
self.kernel_value_at_radius)
# Train model.
self.K_ = pairwise_kernels(X,
metric='rbf',
gamma=self.gamma_,
n_jobs=-1)
return self
def SVM_single_modality(data_b6, data_btbr, modality='Structural'):
"""
"""
print 'Analyzing %s data' %(modality)
vectors = np.vstack((data_b6, data_btbr))
y = np.hstack((np.zeros(len(data_b6)), np.ones(len(data_btbr))))
sigma2 = np.median(pairwise_distances(vectors, metric='euclidean'))**2
k_matrix = pairwise_kernels(vectors, metric='rbf', gamma=1.0/sigma2)
clf = SVC(kernel='precomputed')
cv_scores = cross_val_score(clf, k_matrix, y, cv=StratifiedKFold(y, n_folds=len(y)/2))
print 'Mean accuracy: %s, std: %s' %(np.mean(cv_scores), np.std(cv_scores))
print 'All folds scores: %s' %(cv_scores)
print ''
def fit(self,x):
n=len(x)
if self.xce is None:
self.b=min(100,n)
self.xce=x[permutation(n)][:self.b]
else:
self.b=len(self.xce)
Phi=pairwise_kernels(x,self.xce,metric="rbf",gamma=1./(2*self.sigma**2))
Phi1=tile(Phi.sum(0),(n,1))
tmp1=Phi1.T.dot(Phi)/(n**2)
tmp2=Phi.sum(0)/(n)
self.alpha=pinv(tmp1 + self.lam*identity(self.b)).dot(tmp2)
ppred1=maximum(Phi.dot(self.alpha),0.)
ypred=ppred1>=0.5
self.label=ypred
return self
def main():
r"""Plot figure: Different outcomes of a Gaussian kernel approximation."""
T = 25 # Number of curves
cm_subsection = np.linspace(0, 1, T + 1)
colors = [matplotlib.cm.rainbow(x) for x in cm_subsection]
d = 1 # Dimension of the input
N = 250 # Number of points per curves
# Generate N data in (-1, 1) and exact Gram matrix
np.random.seed(0)
X = np.linspace(-1, 1, N).reshape((N, d))
K = pairwise_kernels(X, metric='rbf', gamma=1. / (2. * .1 ** 2))
# A Matrix for the decomposable kernel. Link the outputs to some mean value
c = np.random.randn(N, 2)
A = .5 * np.eye(2) + .5 * np.ones((2, 2))
plt.close()
plt.rc('text', usetex=True)
plt.rc('font', family='serif')
f, axes = plt.subplots(2, 2, figsize=(12, 8), sharex=True, sharey=True)
# For each curve with different D
for k, D in enumerate(np.logspace(0, 4, T)):
D = int(D)
np.random.seed(0)
w = np.random.randn(d, D) / .1
phiX = phi(X, w, D)
Kt = np.dot(phiX, phiX.T)
# Generate outputs with the exact Gram matrix
pred = np.dot(np.dot(Kt, c), A)
axes[0, 0].plot(X, pred[:, 0], c=colors[k], lw=.5, linestyle='-')
axes[0, 0].set_ylabel(r'$y_1$')
axes[0, 1].plot(X, pred[:, 1], c=colors[k], lw=.5, linestyle='-')
axes[0, 1].set_ylabel(r'$y_2$')
# Generate outputs with the a realization of the random Gram matrix
w = np.random.randn(d, D) / .1
phiX = phi(X, w, D)
Kt = np.dot(phiX, phiX.T)
pred = np.dot(np.dot(Kt, c), A)
axes[1, 0].plot(X, pred[:, 0], c=colors[k], lw=.5, linestyle='-')
axes[1, 0].set_xlabel(r'$x$')
axes[1, 0].set_ylabel(r'$y_1$')
axes[1, 1].plot(X, pred[:, 1], c=colors[k], lw=.5, linestyle='-')
axes[1, 1].set_xlabel(r'$x$')
axes[1, 1].set_ylabel(r'$y_2$')
axes[0, 0].plot(X, np.dot(np.dot(K, c), A)[:, 0], c='k', lw=.5, label='K')
axes[0, 1].plot(X, np.dot(np.dot(K, c), A)[:, 1], c='k', lw=.5, label='K')
axes[1, 0].plot(X, np.dot(np.dot(K, c), A)[:, 0], c='k', lw=.5, label='K')
axes[1, 1].plot(X, np.dot(np.dot(K, c), A)[:, 1], c='k', lw=.5, label='K')
axes[0, 0].set_title(r'$\widetilde{K}u \approx Ku$, realization 1', x=1.1)
axes[1, 0].set_title(r'$\widetilde{K}u \approx Ku$, realization 2', x=1.1)
for xx in axes.ravel():
xx.legend(loc=4)
createColorbar(1, D, f, axes)
plt.savefig('not_Mercer.pgf', bbox_inches='tight')
print "X_train", X_train.shape
print "X_test", X_test.shape
# PCA view
print "Computing PCA..."
pca = RandomizedPCA(n_components=300)
X_train_pca = pca.fit_transform(X_train)
X_test_pca = pca.transform(X_test)
components_pca = select_components(X_train_pca, y_train,
n_components=opts.n_components,
class_distrib="balanced")
print "Computing kernels (PCA view)..."
K_pca_train = pairwise_kernels(X_train_pca, components_pca, metric="rbf",
gamma=0.1)
K_pca_test = pairwise_kernels(X_test_pca, components_pca, metric="rbf",
gamma=0.1)
# Regular view
components = select_components(X_train, y_train,
n_components=opts.n_components,
class_distrib="balanced")
print "Computing kernels (regular view)..."
K_train = pairwise_kernels(X_train, components, metric="rbf", gamma=0.1)
K_test = pairwise_kernels(X_test, components, metric="rbf", gamma=0.1)
# Combined views
n_components = components.shape[0]
n = n_components / 2
def predict(self,x):
Phi=pairwise_kernels(x,self.xce,metric="rbf",gamma=1./(2*self.sigma**2))
ppred1=maximum(Phi.dot(self.alpha),0.)
#ppred1=exp(-Phi.dot(self.alpha))
ypred=ppred1>=0.5
return ypred
def _summarize(data, vocabulary, labels_column, num_cluster):
# Basic stats
print("Number of songs per cluster")
counter = Counter(labels_column)
print(counter)
print()
prob_Ct, prob_Tc, prob_T = compute_probs(data, num_cluster, labels_column, counter)
all_tags = range(len(prob_T))
print("Top tags per cluster")
for clust in xrange(num_cluster):
print(clust, "tags with max_freq_in_cluster")
songs_in_cluster = np.where(labels_column == clust)[0]
for tag in top_10_frequency(data[songs_in_cluster]):
print("\t", vocabulary[tag])
print()
print(clust, "tags with max_prob_p(c|t)")
sort_func = lambda to_sort: prob_Ct[to_sort][clust]
for tag in sorted(all_tags, key=sort_func, reverse=True)[:10]:
print("\t", vocabulary[tag])
print()
print()
print("Term entropies for each cluster")
term_entropies = []
for clust in xrange(num_cluster):
h = entropy.entropy(prob_Tc[clust])
term_entropies.append(h)
print(clust, h)
print()
# Number of shared tags between clusters
X = np.zeros((num_cluster, len(all_tags)))
for clust in xrange(num_cluster):
for tag in all_tags:
X[clust][tag] = prob_Tc[clust][tag]
distances = pairwise_kernels(X)
for i in xrange(num_cluster):
distances[i, i] = 0
plt.imshow(distances, cmap="bone_r", interpolation="nearest")
ax = plt.gca()
plt.xticks(np.arange(0, num_cluster))
plt.yticks(np.arange(0, num_cluster))
plt.colorbar()
plt.title("Confusion Matrix for Cluster Similarities")
plt.ylabel("ClusterID")
plt.xlabel("ClusterID")
for i in xrange(num_cluster):
ax.annotate("%.3f" % term_entropies[i], xy=(i, i), horizontalalignment="center", verticalalignment="center")
plt.show()
print("Mean difference")
to_corr_1 = []
to_corr_2 = []
for clust in xrange(num_cluster):
to_corr_1.append(term_entropies[clust])
to_corr_2.append(np.mean(distances[clust]))
print(clust, term_entropies[clust], np.mean(distances[clust]))
from scipy.stats import pearsonr
print("R2 ", pearsonr(to_corr_1, to_corr_2))
proportion_train=0.75,
random_state=random_state)
except KeyError:
raise ValueError("Wrong dataset name!")
print "X_train", X_train.shape
print "X_test", X_test.shape
class_distrib = "random" if opts.regression else "balanced"
components = select_components(X_train, y_train,
n_components=opts.n_components,
class_distrib=class_distrib)
print "Computing linear kernels..."
linear_train = pairwise_kernels(X_train, components, metric="linear")
linear_test = pairwise_kernels(X_test, components, metric="linear")
print "Computing rbf kernels..."
rbf_train = pairwise_kernels(X_train, components, metric="rbf",
gamma=opts.gamma)
rbf_test = pairwise_kernels(X_test, components, metric="rbf",
gamma=opts.gamma)
print "Computing polynomial kernels..."
poly_train = pairwise_kernels(X_train, components, metric="poly",
degree=opts.degree)
poly_test = pairwise_kernels(X_test, components, metric="poly",
degree=opts.degree)
n_components = components.shape[0]
def setData(self, X):
self.X_ = X
self.gram_ = metrics.pairwise_kernels(self.X_, metric = 'rbf',
gamma = self.gamma_)
def MMD_single_modality(data_b6, data_btbr, modality='Structural',
iterations=100000, plot=True):
"""
Process the data with the following approach: Embedding +
RBF_kernel + KTST
Parameters:
-----------
Return:
----------
MMD distance, null_distribution, p-value
"""
print 'Analyzing %s data' %(modality)
#Concatenating the data
vectors = np.vstack((data_b6, data_btbr))
n_b6 = len(data_b6)
n_btbr = len(data_btbr)
sigma2 = np.median(pairwise_distances(vectors, metric='euclidean'))**2
k_matrix = pairwise_kernels(vectors, metric='rbf', gamma=1.0/sigma2)
if plot:
plot_similarity_matrix(k_matrix)
#Computing the MMD
mmd2u = MMD2u(k_matrix, n_b6, n_btbr)
print("MMD^2_u = %s" % mmd2u)
#Computing the null-distribution
#Null distribution only on B6 mice
# sigma2_b6 = np.median(pairwise_distances(vectors_cl1, metric='euclidean'))**2
# k_matrix_b6 = pairwise_kernels(vectors_cl1, metric='rbf', gamma=1.0/sigma2_b6)
# mmd2u_null = compute_null_distribution(k_matrix_b6, 5, 5, iterations, seed=123, verbose=False)
mmd2u_null = compute_null_distribution(k_matrix, n_b6, n_btbr, iterations,
seed=123, verbose=False)
print np.max(mmd2u_null)
#Computing the p-value
p_value = max(1.0/iterations, (mmd2u_null > mmd2u).sum() / float(iterations))
print("p-value ~= %s \t (resolution : %s)" % (p_value, 1.0/iterations))
print 'Number of stds from MMD^2_u to mean value of null distribution: %s' % ((mmd2u - np.mean(mmd2u_null))/np.std(mmd2u_null))
if plot:
fig = plt.figure()
ax = fig.add_subplot(111)
prob, bins, patches = plt.hist(mmd2u_null, bins=50, normed=True)
ax.plot(mmd2u, prob.max()/30, 'w*', markersize=15,
markeredgecolor='k', markeredgewidth=2,
label="$%s MMD^2_u = %s$" % (modality, mmd2u))
# func_p_value = max(1.0/iterations, (functional_mmd[1] > functional_mmd[0]).sum() / float(iterations))
ax.annotate('p-value: %s' %(p_value),
xy=(float(mmd2u), prob.max()/9.), xycoords='data',
xytext=(-105, 30), textcoords='offset points',
bbox=dict(boxstyle="round", fc="1."),
arrowprops=dict(arrowstyle="->",
connectionstyle="angle,angleA=0,angleB=90,rad=10"),
)
plt.xlabel('$MMD^2_u$')
plt.ylabel('$p(MMD^2_u)$')
plt.legend(numpoints=1)
# plt.title('%s_DATA: $p$-value=%s' %(modality, p_value))
print ''
