def _LSSVMtrain(X, Y, kernel_dict, regulator):
m = Y.shape[0]
# Kernel
if kernel_dict['type'] == 'RBF':
K = Kernel.RBF(m, kernel_dict['gamma'])
K.calculate(X)
elif kernel_dict['type'] == 'LINEAR':
K = Kernel.LINEAR(m)
K.calculate(X)
elif kernel_dict['type'] == 'POLY':
K = Kernel.POLY(m, kernel_dict['c'], kernel_dict['d'])
K.calculate(X)
elif kernel_dict['type'] == 'TANH':
K = Kernel.TANH(m, kernel_dict['c'], kernel_dict['d'])
K.calculate(X)
elif kernel_dict['type'] == 'TL1':
K = Kernel.TL1(m, kernel_dict['rho'])
K.calculate(X)
H = np.multiply(np.dot(np.matrix(Y).T, np.matrix(Y)), K.kernelMat)
M_BR = H + np.eye(m) / regulator
#Concatenate
L_L = np.concatenate((np.matrix(0), np.matrix(Y).T), axis=0)
L_R = np.concatenate((np.matrix(Y), M_BR), axis=0)
L = np.concatenate((L_L, L_R), axis=1)
R = np.ones(m + 1)
R[0] = 0
#solve
b_a = LA.solve(L, R)
b = b_a[0]
alpha = b_a[1:]
#return
return (alpha, b, K)
def _KSVMtrain(X, Y, kernel_dict):
m = Y.shape[0]
if kernel_dict['type'] == 'RBF':
K = Kernel.RBF(m, kernel_dict['gamma'])
K.calculate(X)
elif kernel_dict['type'] == 'LINEAR':
K = Kernel.LINEAR(m)
K.calculate(X)
elif kernel_dict['type'] == 'POLY':
K = Kernel.POLY(m)
K.calculate(X)
elif kernel_dict['type'] == 'TANH':
K = Kernel.TANH(m, kernel_dict['c'], kernel_dict['d'])
K.calculate(X)
elif kernel_dict['type'] == 'TL1':
K = Kernel.TL1(m, kernel_dict['rho'])
K.calculate(X)
p1, p2 = trans_mat(K.kernelMat)
K.kernelMat = np.dot((p1 - p2), K.kernelMat)
#根据SVM求出alpha,b ？？？
svm = Algorithms.SVM(X, Y, kernel_dict)
#更新alpha
alpha = np.dot((p1 - p2), svm.alphas)
b = svm.b
return (alpha, b, K)
def fit(self, X, Y):
# print('Kernel:', kernel_dict)
train_data = np.append(X, Y.reshape(len(Y), 1), axis=1)
if self.databalance == 'LowSampling':
data_maj = train_data[Y == 1] # 将多数
data_min = train_data[Y != 1]
index = np.random.randint(len(data_maj), size=len(data_min))
lower_data_maj = data_maj[list(index)]
train_data = np.append(lower_data_maj, data_min, axis=0)
X = train_data[:, :-1]
Y = train_data[:, -1]
self.Y = Y
elif self.databalance == 'UpSampling':
X, Y = SVMSMOTE(random_state=42).fit_sample(train_data[:, :-1],\
np.asarray(train_data[:, -1]))
self.Y = Y
else:
X = X
Y = Y
self.Y = Y
m = Y.shape[0]
# Kernel
if self.kernel_dict['type'] == 'RBF':
K = Kernel.RBF(m, self.kernel_dict['sigma'])
elif self.kernel_dict['type'] == 'LINEAR':
K = Kernel.LINEAR(m)
elif self.kernel_dict['type'] == 'POLY':
K = Kernel.POLY(m, self.kernel_dict['d'])
K.calculate(X)
tmp1 = np.hstack((np.ones((1, 2 * m)), [[0]]))
M_BR = K.kernelMat + np.eye(m) / (self.C * self.m_value)
tmp2 = np.hstack((M_BR, K.kernelMat, np.ones((m, 1))))
M_BL = K.kernelMat + np.eye(m) / (self.C * (1 - self.m_value))
tmp3 = np.hstack((K.kernelMat, M_BL, np.ones((m, 1))))
L = np.vstack((tmp1, tmp2, tmp3))
R = np.ones(2 * m + 1)
R[0] = 0
R[m + 1:] = -1
# solve
solution = LA.solve(L, R)
b = solution[-1]
alpha = solution[:m]
beta = solution[m:2 * m]
print('b', b)
# self.gamma = gamma
self.beta = beta
self.alpha = alpha
self.b = b
self.K = K
self.kernelMat = K.kernelMat
def fit(self, X, Y):
# print('Kernel:', self.kernel_dict)
train_data = np.append(X, Y.reshape(len(Y), 1), axis=1)
if self.databalance == 'LowSampling':
data_maj = train_data[Y == 1] # 将多数
data_min = train_data[Y != 1]
index = np.random.randint(len(data_maj), size=len(data_min))
lower_data_maj = data_maj[list(index)]
train_data = np.append(lower_data_maj, data_min, axis=0)
X = train_data[:, :-1]
Y = train_data[:, -1]
self.Y = Y
elif self.databalance == 'UpSampling':
X, Y = SVMSMOTE(random_state=42).fit_sample(train_data[:, :-1],\
np.asarray(train_data[:, -1]))
self.Y = Y
else:
X = X
Y = Y
self.Y = Y
m = len(Y)
# Kernel
if self.kernel_dict['type'] == 'RBF':
K = Kernel.RBF(m, self.kernel_dict['sigma'])
K.calculate(X)
elif self.kernel_dict['type'] == 'LINEAR':
K = Kernel.LINEAR(m)
K.calculate(X)
elif self.kernel_dict['type'] == 'POLY':
K = Kernel.POLY(m, self.kernel_dict['d'])
K.calculate(X)
H = np.multiply(np.dot(np.matrix(Y).T, np.matrix(Y)), K.kernelMat)
M_BR = H + np.eye(m) / (self.C)
# Concatenate
L_L = np.concatenate((np.matrix(0), np.matrix(Y).T), axis=0)
L_R = np.concatenate((np.matrix(Y), M_BR), axis=0)
L = np.concatenate((L_L, L_R), axis=1)
R = np.ones(m + 1)
R[0] = 0
# solve
b_a = LA.solve(L, R)
b = b_a[0]
alpha = b_a[1:]
e = alpha / self.C
self.alpha = alpha
self.b = b
self.K = K
self.kernelMat = K.kernelMat
return self.alpha, self.b, e
def train(self, C=[0.01, 1, 10, 100], tol=1e-3):
m = self.Y.shape[0]
A = [0] * 10
B = [0] * 10
indices = numpy.random.permutation(
self.X.shape[0]) # shape[0]表示第0轴的长度，通常是训练数据的数量
rand_data_x = self.X[indices]
rand_data_y = self.Y[indices] # data_y就是标记（label）
l = int(len(indices) / 10)
for i in range(9):
A[i] = rand_data_x[i * l:i * l + l]
B[i] = rand_data_y[i * l:i * l + l]
A[9] = rand_data_x[9 * l:]
B[9] = rand_data_y[9 * l:]
# '''
# X_num=self.X.shape[0]
# train_index=range(X_num)
# test_size=int(X_num*0.1)+1
# for i in range(9):
# test_index=[]
# for j in range(test_size):
# randomIndex=int(numpy.random.uniform(0,len(train_index)))
# test_index.append(train_index[randomIndex])
# #del train_index[randomIndex]
# A[i]=self.X[test_index,:]
# B[i]=self.Y[test_index,:]
# A[9]=self.X.ix_[train_index]
# B[9]=self.Y.ix_[train_index]
# '''
acc_best = 0
C_best = None
avg_acc = 0
# gamma_best = None
for CVal in C:
# for gammaVal in gamma:
# avg_acc = 0
for i in range(10):
X_test = A[i]
Y_test = B[i]
# X_train = None
# Y_train = None
#model= SMO.SMO_Model(X_train, Y_train, CVal, kernel,gammaVal, tol=1e-3, eps=1e-3)
#output_model=SMO.SMO(model)
#根据output_model的参数信息计算对应decision_function----->推得accuracy
#acc = _evaulate(output_model)
X_train = numpy.concatenate([
A[(i + 1) % 10], A[(i + 2) % 10], A[(i + 3) % 10],
A[(i + 4) % 10], A[(i + 5) % 10], A[(i + 6) % 10],
A[(i + 7) % 10], A[(i + 8) % 10], A[(i + 9) % 10]
],
axis=0)
Y_train = numpy.concatenate([
B[(i + 1) % 10], B[(i + 2) % 10], B[(i + 3) % 10],
B[(i + 4) % 10], B[(i + 5) % 10], B[(i + 6) % 10],
B[(i + 7) % 10], B[(i + 8) % 10], B[(i + 9) % 10]
],
axis=0)
# SMO.GG = gammaVal
# calculate Kernel Matrix then pass it to SMO.
if self.IK:
if self.kernel_dict['type'] == 'TANH':
K = Kernel.TANH(X_train.shape[0],
self.kernel_dict['c'],
self.kernel_dict['d'])
K.calculate(X_train)
elif self.kernel_dict['type'] == 'TL1':
K = Kernel.TL1(X_train.shape[0],
self.kernel_dict['rho'])
K.calculate(X_train)
p1, p2 = trans_mat(K.kernelMat)
K.kernelMat = np.dot((p1 - p2), K.kernelMat)
if self.kernel_dict['type'] == 'RBF':
K = Kernel.RBF(X_train.shape[0], self.kernel_dict['gamma'])
K.calculate(X_train)
elif self.kernel_dict['type'] == 'LINEAR':
K = Kernel.LINEAR(X_train.shape[0])
K.calculate(X_train)
elif self.kernel_dict['type'] == 'POLY':
K = Kernel.POLY(X_train.shape[0], self.kernel_dict['c'],
self.kernel_dict['d'])
K.calculate(X_train)
elif self.kernel_dict['type'] == 'TANH':
K = Kernel.TANH(X_train.shape[0], self.kernel_dict['c'],
self.kernel_dict['d'])
K.calculate(X_train)
elif self.kernel_dict['type'] == 'TL1':
K = Kernel.TL1(X_train.shape[0], self.kernel_dict['rho'])
K.calculate(X_train)
model = SMO.SMO_Model(X_train,
Y_train,
CVal,
K,
tol=1e-3,
eps=1e-3)
output_model = SMO.SMO(model)
#IK
if self.IK:
output_model.alphas = np.dot((p1 - p2),
output_model.alphas)
acc = SMO._evaluate(output_model, X_test, Y_test)
avg_acc = avg_acc + acc / 10
if avg_acc > acc_best:
acc_best = avg_acc
#更新C gamma
C_best = CVal
# gamma_best =gammaVal
# self.gamma = gamma_best
#最后一遍train
# SMO.GG = gamma_best
#!K
if self.IK:
if self.kernel_dict['type'] == 'TANH':
K = Kernel.TANH(self.X.shape[0], self.kernel_dict['c'],
self.kernel_dict['d'])
K.calculate(self.X)
elif self.kernel_dict['type'] == 'TL1':
K = Kernel.TL1(self.X.shape[0], self.kernel_dict['rho'])
K.calculate(self.X)
p1, p2 = trans_mat(K.kernelMat)
K.kernelMat = np.dot((p1 - p2), K.kernelMat)
if self.kernel_dict['type'] == 'RBF':
K = Kernel.RBF(self.X.shape[0], self.kernel_dict['gamma'])
K.calculate(self.X)
elif self.kernel_dict['type'] == 'LINEAR':
K = Kernel.LINEAR(self.X.shape[0])
K.calculate(self.X)
elif self.kernel_dict['type'] == 'POLY':
K = Kernel.POLY(self.X.shape[0], self.kernel_dict['c'],
self.kernel_dict['d'])
K.calculate(self.X)
elif self.kernel_dict['type'] == 'TANH':
K = Kernel.TANH(self.X.shape[0], self.kernel_dict['c'],
self.kernel_dict['d'])
K.calculate(self.X)
elif self.kernel_dict['type'] == 'TL1':
K = Kernel.TL1(self.X.shape[0], self.kernel_dict['rho'])
K.calculate(self.X)
SVM_model = SMO.SMO(
SMO.SMO_Model(self.X, self.Y, C_best, K, tol=1e-3, eps=1e-3))
# 参数传递给最后生成的SVM类
if self.IK:
SVM_model.alphas = np.dot((p1 - p2), SVM_model.alphas)
self.X = SVM_model.X
self.Y = SVM_model.y
self.kernel_dict = SVM_model.kernel
self.alphas = SVM_model.alphas
self.b = SVM_model.b
# C_best = C
# gamma_best =gamma
# (w,b) = SMO(X_train,Y_train,C_best,gamma_best,kernal,tol=1e-3)
# self.w = w
# self.b = b
return None
def fit(self, X, Y):
# print('Kernel:', kernel_dict)
train_data = np.append(X,Y.reshape(len(Y),1),axis=1)
if self.databalance =='LowSampling':
data_maj = train_data[Y == 1] # 将多数
data_min = train_data[Y != 1]
index = np.random.randint(len(data_maj), size=len(data_min))
lower_data_maj = data_maj[list(index)]
train_data = np.append(lower_data_maj,data_min,axis=0)
X = train_data[:,:-1]
Y = train_data[:,-1]
self.Y = Y
elif self.databalance =='UpSampling':
X, Y = SVMSMOTE(random_state=42).fit_sample(train_data[:, :-1],\
np.asarray(train_data[:, -1]))
self.Y = Y
else:
X = X
Y = Y
self.Y = Y
m = Y.shape[0]
# Kernel
if self.kernel_dict['type'] == 'RBF':
K = Kernel.RBF(m, self.kernel_dict['sigma'])
K.calculate(X)
elif self.kernel_dict['type'] == 'LINEAR':
K = Kernel.LINEAR(m)
K.calculate(X)
elif self.kernel_dict['type'] == 'POLY':
K = Kernel.POLY(m, self.kernel_dict['d'])
K.calculate(X)
P = cvxopt.matrix(np.outer(Y, Y) * K.kernelMat)
q = cvxopt.matrix(np.ones(m) * -1)
A = cvxopt.matrix(Y, (1, m))
A = matrix(A, (1, m), 'd')
b = cvxopt.matrix(0.0)
tmp1 = np.diag(np.ones(m) * -1)
tmp2 = np.identity(m)
G = cvxopt.matrix(np.vstack((tmp1, tmp2)))
tmp1 = np.zeros(m)
tmp2 = np.ones(m) * self.m_value * self.C
h = cvxopt.matrix(np.hstack((tmp1, tmp2)))
# solve QP problem
solution = cvxopt.solvers.qp(P, q, G, h, A, b)
# Lagrange multipliers
alpha = np.ravel(solution['x'])
for i in range(m):
sv = np.logical_and(alpha < self.m_value, alpha > 1e-5)
alpha_sv = alpha[sv]
X_sv = X[sv]
Y_sv = Y[sv]
b = 0
sum_y = sum(Y)
A = np.multiply(alpha, Y)
b = (sum_y - np.sum(K.kernelMat * A.reshape(len(A),1)))/len(alpha)
self.alpha = alpha
self.alpha_sv = alpha_sv
self.X_sv = X_sv
self.Y_sv = Y_sv
self.b = b
self.K = K
self.kernelMat = K.kernelMat
def fit(self, X, Y):
# print('Kernel:', kernel_dict)
train_data = np.append(X,Y.reshape(len(Y),1),axis=1)
if self.databalance =='LowSampling':
data_maj = train_data[Y == 1] # 将多数
data_min = train_data[Y != 1]
index = np.random.randint(len(data_maj), size=len(data_min))
lower_data_maj = data_maj[list(index)]
train_data = np.append(lower_data_maj,data_min,axis=0)
X = train_data[:,:-1]
Y = train_data[:,-1]
self.Y = Y
elif self.databalance =='UpSampling':
X, Y = SVMSMOTE(random_state=42).fit_sample(train_data[:, :-1],\
np.asarray(train_data[:, -1]))
self.Y = Y
else:
X = X
Y = Y
self.Y = Y
m = Y.shape[0]
# Kernel
if self.kernel_dict['type'] == 'RBF':
K = Kernel.RBF(m, self.kernel_dict['sigma'])
elif self.kernel_dict['type'] == 'LINEAR':
K = Kernel.LINEAR(m)
elif self.kernel_dict['type'] == 'POLY':
K = Kernel.POLY(m, self.kernel_dict['d'])
K.calculate(X)
kernel = np.zeros((2*m, 2*m))
kernel[:m,:m] = K.kernelMat
P = cvxopt.matrix(kernel)
q = cvxopt.matrix(np.hstack((np.ones(m)*-1,np.ones(m)*-2)))
A = cvxopt.matrix(np.hstack((np.ones(m),np.zeros(m))))
A = matrix(A, (1, 2*m), 'd')
b = cvxopt.matrix(0.0)
tmp1 = np.hstack((np.identity(m),np.identity(m)))
tmp2 = np.hstack((np.diag(np.ones(m) * -1),np.diag(np.ones(m) * -1)))
tmp3 = np.hstack((np.zeros((m,m)),np.identity(m)))
tmp4 = np.hstack((np.zeros((m,m)),np.diag(np.ones(m) * -1)))
G = cvxopt.matrix(np.vstack((tmp1, tmp2, tmp3, tmp4)))
tmp1 = np.zeros(m)
tmp2 = np.ones(m) * self.m_value * self.C
tmp3 = np.ones(m) * (1-self.m_value) * self.C
h = cvxopt.matrix(np.hstack((tmp2, tmp1,tmp3,tmp1)))
# solve QP problem
solution = cvxopt.solvers.qp(P, q, G, h, A, b)
sol = np.ravel(solution['x'])
gamma = sol[:m]
beta = sol[m:]
alpha = gamma + beta
w_phi = np.multiply(np.sum(K.kernelMat,axis=1),gamma)
b = 0
b = np.sum(Y-w_phi)/len(Y)
print('b',b)
self.gamma = gamma
self.beta = beta
self.alpha = alpha
self.b = b
self.K = K
self.kernelMat = K.kernelMat
