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)