def decision_function(self, X):
"""
Compute the distances of X with the ball center
:param X: input samples X
:return: Squared distance between vectors in the feature space and the center hyperball
"""
n = X.shape[0]
K = kernel(X, metric=self.kernel, filter_params=True, gamma=self.gamma, coef0=self.coef0, degree=self.degree)
f = K.diagonal()
K_sv = kernel(X, self.sv, metric=self.kernel, filter_params=True, gamma=self.gamma, coef0=self.coef0, degree=self.degree)
d = f - 2*self.alpha.reshape(1,self.nsv).dot(K_sv.T) + self.b * np.ones(n)
return d
def main():
import synthetics
mv_Xs, y = synthetics.single_blob_dataset()
# kernelize
from sklearn.metrics.pairwise import rbf_kernel as kernel
mv_Xs = [
torch.tensor(kernel(mv_Xs[_])).float() if use_kernel else mv_Xs[_]
for _ in range(len(mv_Xs))
]
mv_Ks = [normalize(Ks) for Ks in mv_Xs]
dims = [Ks.shape[1] for Ks in mv_Ks]
Sw = within_class_vars(mv_Ks, y)
Sb = between_class_vars(mv_Ks, y)
solver = EPSolver(algo='eig')
eigen_vecs = solver.solve(Sw, Sb, argmin=True)
Ws = projections(eigen_vecs, dims)
# transform
mv_Ys = [(Ws[_].t() @ mv_Xs[_].t()).t() for _ in range(len(mv_Xs))]
mv_Ys = group(mv_Ys, y)
mv_Ys = [[Y[:, :2] for Y in Ys] for Ys in mv_Ys]
mv_Ys = [normalize(Ys) for Ys in mv_Ys]
# plot
from torchsl.utils.data_visualizer import DataVisualizer
dv = DataVisualizer()
dv.mv_scatter(group(mv_Ks, y))
dv.mv_scatter(mv_Ys)
dv.show()
def main():
import synthetics
mv_Xs, y = synthetics.single_blob_dataset()
# kernelize
from sklearn.metrics.pairwise import rbf_kernel as kernel
mv_Ks = [
torch.tensor(kernel(mv_Xs[_])).float() if use_kernel else mv_Xs[_]
for _ in range(len(mv_Xs))
]
dims = [Ks.shape[1] for Ks in mv_Ks]
Sw = within_class_vars(mv_Ks, y)
Sb = between_class_vars(mv_Ks, y)
solver = EPSolver()
eigen_vecs = solver.solve(Sw, Sb)
Ws = projections(eigen_vecs, dims)
print('Projection matrices:', [W.shape for W in Ws])
# transform
mv_Ys = [(Ws[_].t() @ mv_Ks[_].t()).t()[:, :2]
for _ in range(len(mv_Ks))]
# plot
from torchsl.utils.data_visualizer import DataVisualizer
dv = DataVisualizer()
dv.mv_scatter(mv_Xs, y)
dv.mv_scatter(mv_Ys, y)
dv.show()
def kdist2(self, X):
n = X.shape[0]
K = kernel(X,
metric=self.kernel,
filter_params=True,
gamma=self.gamma,
coef0=self.coef0,
degree=self.degree)
f = K.diagonal()
K_sv = kernel(X,
self.sv,
metric=self.kernel,
filter_params=True,
gamma=self.gamma,
coef0=self.coef0,
degree=self.degree)
d = f - 2 * self.alpha.reshape(1, self.nsv).dot(
K_sv.T) + self.b * np.ones(n)
return d
def decision_function(self, X):
"""
Compute the distances of X with the ball center
:param X: input samples X
:return: Squared distance between vectors in the feature space and the center hyperball
"""
n = X.shape[0]
K = kernel(X,
metric=self.kernel,
filter_params=True,
gamma=self.gamma,
coef0=self.coef0,
degree=self.degree)
f = K.diagonal()
K_sv = kernel(X,
self.sv,
metric=self.kernel,
filter_params=True,
gamma=self.gamma,
coef0=self.coef0,
degree=self.degree)
d = f - 2 * self.alpha.reshape(1, self.nsv).dot(
K_sv.T) + self.b * np.ones(n)
return d
import synthetics
import torch
if __name__ == '__main__':
precompute_kernel = False
Xs, y = synthetics.dual_blobs_dataset()
# kernelize
from sklearn.metrics.pairwise import rbf_kernel as kernel
Ks = [
torch.tensor(kernel(Xs[_])).float() if precompute_kernel else Xs[_]
for _ in range(len(Xs))
]
model = MvLFDA(n_components=2, kernels='none', ep_algo='eig')
print(model.predicates)
Ys = model.fit_transform(Xs, y)
# plot
from torchsl.utils.data_visualizer import DataVisualizer
dv = DataVisualizer()
dv.mv_scatter(Xs, y)
dv.mv_scatter(Ys, y)
dv.show()
def fit(self, X, y=None):
if self.display:
solvers.options['show_progress'] = True
else:
solvers.options['show_progress'] = False
n = X.shape[0]
# Step 1: Optimizing the SVDD dual problem.....
K = kernel(X,
metric=self.kernel,
n_jobs=1,
filter_params=True,
gamma=self.gamma,
coef0=self.coef0,
degree=self.degree)
q = cvxmatrix(-K.diagonal(), tc='d')
#TODO: make it a separate function call
labeled_indices = np.where(y != 0)[0]
anomaly_indices = np.where(y == 1)[0]
normal_indices = np.where(y == -1)[0]
if (len(labeled_indices)):
c_weighted = self.influence(K, y)
else:
c_weighted = self.C * np.ones(n)
# solver
if self.method is 'qp':
P = cvxmatrix(2 * K, tc='d')
G = cvxmatrix(np.vstack((-np.eye(n), np.eye(n))),
tc='d') # lhs box constraints
c_weighted_eps = np.copy(c_weighted)
c_weighted_eps[normal_indices] -= 2 * self.eps
h = cvxmatrix(np.concatenate((np.zeros(n), c_weighted_eps)),
tc='d') # zeros for >=0, c_weighted for <=c_i
# optimize using cvx solver
Aeq = np.zeros((len(anomaly_indices), n))
beq = np.zeros(len(anomaly_indices))
i = 0
for ind in anomaly_indices:
Aeq[i, ind] = 1
beq[i] = c_weighted[ind]
i += 1
A = cvxmatrix(Aeq, tc='d')
b = cvxmatrix(beq, tc='d')
# optimize using cvx solver
sol = solvers.qp(P,
q,
G,
h,
A,
b,
initvals=cvxmatrix(np.zeros(n), tc='d'))
if self.method is 'smo':
#TODO: apply SMO algorithm
alpha = None
# setup SVC model
alpha = np.asarray(sol['x'])
inx = np.where(alpha > self.eps)[0]
self.sv_inx = inx
self.alpha = alpha[inx]
self.nsv = inx.size
self.sv_ind = np.where((np.ravel(alpha) > self.eps)
& (np.ravel(alpha) < c_weighted - self.eps))[0]
self.bsv_ind = np.where(np.ravel(alpha) >= c_weighted - self.eps)[0]
self.inside_ind = np.where(np.ravel(alpha) < c_weighted - self.eps)[0]
k_inx = K[inx[:, None], inx] # submatrix of K(sv+bsv, sv+bsv)
k_sv = K[self.sv_ind[:, None], self.sv_ind] # submatrix of K(sv,sv)
k_bsv = K[self.bsv_ind[:, None],
self.bsv_ind] # submatrix of K(bsv,bsv)
# 2-norm of center a^2
self.b = self.alpha.reshape(1, self.nsv).dot(k_inx).reshape(
1, self.nsv).dot(self.alpha.reshape(self.nsv, 1))
#including both of SV and BSV (bounded support vectors)
self.sv = X[inx, :]
d = k_sv.diagonal() - 2 * self.alpha.reshape(1, self.nsv).dot(
K[inx[:, None], self.sv_ind]) + self.b * np.ones(self.sv_ind.size)
self.r = d.max()
self.rid = self.sv_ind[np.argmax(d.ravel())]
d_bsv = k_bsv.diagonal() - 2 * self.alpha.reshape(1, self.nsv).dot(K[
inx[:, None], self.bsv_ind]) + self.b * np.ones(self.bsv_ind.size)
self.fval = self.r + self.C * (d_bsv - self.r).sum()
if self.cached: self.K = K
self.y = -1 * np.ones(n)
self.y[self.bsv_ind] = 1
if self.labeling:
#Step 2: Labeling cluster index by using CG
self.predict(X)
self.c_weighted = c_weighted
def fit(self, X, y=None):
if self.display:
solvers.options['show_progress'] = True
else:
solvers.options['show_progress'] = False
n = X.shape[0]
# Step 1: Optimizing the SVDD dual problem.....
K = kernel(X, metric=self.kernel, n_jobs=1,
filter_params=True, gamma=self.gamma,
coef0=self.coef0, degree=self.degree)
q = cvxmatrix(-K.diagonal(), tc='d')
#TODO: make it a separate function call
labeled_indices = np.where(y!=0)[0]
anomaly_indices = np.where(y==1)[0]
normal_indices = np.where(y==-1)[0]
if (len(labeled_indices)):
c_weighted = self.influence(K,y)
else:
c_weighted = self.C*np.ones(n)
# solver
if self.method is 'qp':
P = cvxmatrix(2*K, tc='d')
G = cvxmatrix(np.vstack((-np.eye(n), np.eye(n))), tc='d') # lhs box constraints
c_weighted_eps = np.copy(c_weighted)
c_weighted_eps[normal_indices]-=2*self.eps
h = cvxmatrix(np.concatenate((np.zeros(n), c_weighted_eps)), tc='d') # zeros for >=0, c_weighted for <=c_i
# optimize using cvx solver
Aeq = np.zeros((len(anomaly_indices),n))
beq = np.zeros(len(anomaly_indices))
i=0
for ind in anomaly_indices:
Aeq[i,ind]=1
beq[i]=c_weighted[ind]
i+=1
A = cvxmatrix(Aeq, tc='d')
b = cvxmatrix(beq, tc='d')
# optimize using cvx solver
sol = solvers.qp(P,q,G,h,A,b,initvals=cvxmatrix(np.zeros(n), tc='d'))
if self.method is 'smo':
#TODO: apply SMO algorithm
alpha = None
# setup SVC model
alpha = np.asarray(sol['x'])
inx = np.where(alpha > self.eps)[0]
self.sv_inx = inx
self.alpha = alpha[inx]
self.nsv = inx.size
self.sv_ind = np.where((np.ravel(alpha) > self.eps) & (np.ravel(alpha) < c_weighted-self.eps))[0]
self.bsv_ind= np.where(np.ravel(alpha) >= c_weighted-self.eps)[0]
self.inside_ind = np.where(np.ravel(alpha) < c_weighted-self.eps)[0]
k_inx = K[inx[:,None], inx] # submatrix of K(sv+bsv, sv+bsv)
k_sv = K[self.sv_ind[:,None], self.sv_ind] # submatrix of K(sv,sv)
k_bsv = K[self.bsv_ind[:,None], self.bsv_ind] # submatrix of K(bsv,bsv)
# 2-norm of center a^2
self.b = self.alpha.reshape(1,self.nsv).dot(k_inx).reshape(1,self.nsv).dot(self.alpha.reshape(self.nsv,1))
#including both of SV and BSV (bounded support vectors)
self.sv= X[inx, :]
d = k_sv.diagonal() - 2*self.alpha.reshape(1,self.nsv).dot(K[inx[:,None], self.sv_ind]) + self.b * np.ones(self.sv_ind.size)
self.r = d.max()
self.rid = self.sv_ind[np.argmax(d.ravel())]
d_bsv = k_bsv.diagonal() - 2*self.alpha.reshape(1,self.nsv).dot(K[inx[:,None], self.bsv_ind]) + self.b * np.ones(self.bsv_ind.size)
self.fval = self.r+self.C*(d_bsv - self.r).sum()
if self.cached: self.K = K
self.y = -1*np.ones(n)
self.y[self.bsv_ind] = 1
if self.labeling:
#Step 2: Labeling cluster index by using CG
self.predict(X)
self.c_weighted = c_weighted
def fit(self, X):
if self.display:
solvers.options['show_progress'] = True
else:
solvers.options['show_progress'] = False
n = X.shape[0]
# Step 1: Optimizing the SVDD dual problem.....
K = kernel(X, metric=self.kernel, n_jobs=1, \
filter_params=True, gamma=self.gamma, \
coef0=self.coef0, degree=self.degree)
q = cvxmatrix(-K.diagonal(), tc='d')
if self.method is 'qp':
P = cvxmatrix(2 * K, tc='d')
G = cvxmatrix(np.vstack((-np.eye(n), np.eye(n))),
tc='d') # lhs box constraints
h = cvxmatrix(np.concatenate((np.zeros(n), self.C * np.ones(n))),
tc='d') # rhs box constraints
# optimize using cvx solver
sol = solvers.qp(P,
q,
G,
h,
initvals=cvxmatrix(np.zeros(n), tc='d'))
if self.method is 'smo':
#TODO: apply SMO algorithm
alpha = None
# setup SVC model
alpha = np.asarray(sol['x'])
inx = np.where(alpha > self.eps)[0]
self.sv_inx = inx
self.alpha = alpha[inx]
self.nsv = inx.size
self.sv_ind = np.where((alpha > self.eps)
& (alpha < self.C - self.eps))[0]
self.bsv_ind = np.where(alpha >= self.C - self.eps)[0]
self.inside_ind = np.where(alpha < self.C - self.eps)[0]
k_inx = K[inx[:, None], inx] # submatrix of K(sv+bsv, sv+bsv)
k_sv = K[self.sv_ind[:, None], self.sv_ind] # submatrix of K(sv,sv)
k_bsv = K[self.bsv_ind[:, None],
self.bsv_ind] # submatrix of K(bsv,bsv)
# 2-norm of center a^2
self.b = self.alpha.reshape(1, self.nsv).dot(k_inx).reshape(
1, self.nsv).dot(self.alpha.reshape(self.nsv, 1))
#including both of SV and BSV (bounded support vectors)
self.sv = X[inx, :]
d = k_sv.diagonal() - 2 * self.alpha.reshape(1, self.nsv).dot(
K[inx[:, None], self.sv_ind]) + self.b * np.ones(self.sv_ind.size)
self.r = d.max()
self.rid = self.sv_ind[np.argmax(d.ravel())]
d_bsv = k_bsv.diagonal() - 2 * self.alpha.reshape(1, self.nsv).dot(K[
inx[:, None], self.bsv_ind]) + self.b * np.ones(self.bsv_ind.size)
self.fval = self.r + self.C * (d_bsv - self.r).sum()
self.K = K
self.y = -1 * np.ones(n)
self.y[self.bsv_ind] = 1
if self.labeling:
#Step 2: Labeling cluster index by using CG
self.predict(X)
