def predict(self, new_X):
self.results = []
n = new_X.shape[0]
for j in range(n):
X = new_X[j]
self.results += [
np.sum([(self.a[i] - self.a_[i]) * kernel_f(X,
self.X[i],
kernel=self.kernel,
coef0=self.coef0,
degree=self.degree,
gamma=self.gamma)
for i in range(n)]) + self.b
]
return self.results
def fit(self, X, y):
self.X = X
self.y = y
n = self.X.shape[0] #numper of instances
#variable for dual optimization problem
alpha = cvx.Variable(n)
alpha_ = cvx.Variable(n)
one_vec = np.ones(n)
#object function and constraints of all types of loss fuction
if self.loss == 'huber':
self.constraints = []
self.svr_obj = cvx.Maximize(
-.5 * cvx.quad_form(
alpha - alpha_,
kernel_matrix(self.X,
kernel=self.kernel,
coef0=self.coef0,
degree=self.degree,
gamma=self.gamma)) - self.epsilon * one_vec *
(alpha + alpha_) + self.y * (alpha - alpha_) - self.sigma /
(2 * self.C) * one_vec *
(cvx.power(alpha, 2) + cvx.power(alpha_, 2)))
self.constraints += [
cvx.sum_entries(one_vec * alpha - one_vec * alpha_) == 0
]
for i in range(n):
self.constraints += [alpha[i] >= 0, alpha_[i] >= 0]
svr = cvx.Problem(self.svr_obj, self.constraints)
svr.solve()
#alpha & alpha_
self.a = np.array(alpha.value).flatten()
self.a_ = np.array(alpha_.value).flatten()
#compute b
idx = np.where((np.array(alpha.value).ravel() < self.C - 1E-10) *
(np.array(alpha.value).ravel() > 1E-10))[0][0]
self.b = -self.epsilon + self.y[idx] - np.sum(
[(alpha.value[i] - alpha_.value[i]) *
kernel_f(self.X[idx],
self.X[i],
kernel=self.kernel,
coef0=self.coef0,
degree=self.degree,
gamma=self.gamma) for i in range(n)])
elif self.loss == 'laplacian': # epsilon = 0 of epsilon-insensitive
self.constraints = []
self.svr_obj = cvx.Maximize(-.5 * cvx.quad_form(
alpha - alpha_,
kernel_matrix(self.X,
kernel=self.kernel,
coef0=self.coef0,
degree=self.degree,
gamma=self.gamma)) + self.y * (alpha - alpha_))
self.constraints += [
cvx.sum_entries(one_vec * alpha - one_vec * alpha_) == 0
]
for i in range(n):
self.constraints += [
alpha[i] >= 0, alpha_[i] >= 0, alpha[i] <= self.C,
alpha_[i] <= self.C
]
svr = cvx.Problem(self.svr_obj, self.constraints)
svr.solve()
#alpha & alpha_
self.a = np.array(alpha.value).flatten()
self.a_ = np.array(alpha_.value).flatten()
#compute b
idx = np.where((np.array(alpha.value).ravel() < self.C - 1E-10) *
(np.array(alpha.value).ravel() > 1E-10))[0][0]
self.b = -self.epsilon + self.y[idx] - np.sum(
[(alpha.value[i] - alpha_.value[i]) *
kernel_f(self.X[idx],
self.X[i],
kernel=self.kernel,
coef0=self.coef0,
degree=self.degree,
gamma=self.gamma) for i in range(n)])
elif self.loss == 'gaussian': # sigma = 1 of huber
self.constraints = []
self.svr_obj = cvx.Maximize(
-.5 * cvx.quad_form(
alpha - alpha_,
kernel_matrix(self.X,
kernel=self.kernel,
coef0=self.coef0,
degree=self.degree,
gamma=self.gamma)) - self.epsilon * one_vec *
(alpha + alpha_) + self.y * (alpha - alpha_) - 1. /
(2 * self.C) * one_vec *
(cvx.power(alpha, 2) + cvx.power(alpha_, 2)))
self.constraints += [
cvx.sum_entries(one_vec * alpha - one_vec * alpha_) == 0
]
for i in range(n):
self.constraints += [alpha[i] >= 0, alpha_[i] >= 0]
svr = cvx.Problem(self.svr_obj, self.constraints)
svr.solve()
#alpha & alpha_
self.a = np.array(alpha.value).flatten()
self.a_ = np.array(alpha_.value).flatten()
#compute b
idx = np.where((np.array(alpha.value).ravel() < self.C - 1E-10) *
(np.array(alpha.value).ravel() > 1E-10))[0][0]
self.b = -self.epsilon + self.y[idx] - np.sum(
[(alpha.value[i] - alpha_.value[i]) *
kernel_f(self.X[idx],
self.X[i],
kernel=self.kernel,
coef0=self.coef0,
degree=self.degree,
gamma=self.gamma) for i in range(n)])
elif self.loss == 'polynomial':
self.constraints = []
self.svr_obj = cvx.Maximize(
-.5 * cvx.quad_form(
alpha - alpha_,
kernel_matrix(self.X,
kernel=self.kernel,
coef0=self.coef0,
degree=self.degree,
gamma=self.gamma)) + self.y *
(alpha - alpha_) - (self.p - 1) /
(self.p * self.C**(self.p - 1)) * one_vec *
(cvx.power(alpha, self.p /
(self.p - 1)) + cvx.power(alpha_, self.p /
(self.p - 1))))
self.constraints += [
cvx.sum_entries(one_vec * alpha - one_vec * alpha_) == 0
]
for i in range(n):
self.constraints += [alpha[i] >= 0, alpha_[i] >= 0]
svr = cvx.Problem(self.svr_obj, self.constraints)
svr.solve()
#alpha & alpha_
self.a = np.array(alpha.value).flatten()
self.a_ = np.array(alpha_.value).flatten()
#compute b
idx = np.where((np.array(alpha.value).ravel() < self.C - 1E-10) *
(np.array(alpha.value).ravel() > 1E-10))[0][0]
self.b = -self.epsilon + self.y[idx] - np.sum(
[(alpha.value[i] - alpha_.value[i]) *
kernel_f(self.X[idx],
self.X[i],
kernel=self.kernel,
coef0=self.coef0,
degree=self.degree,
gamma=self.gamma) for i in range(n)])
elif self.loss == 'piecewise_polynomial':
self.constraints = []
self.svr_obj = cvx.Maximize(
-.5 * cvx.quad_form(
alpha - alpha_,
kernel_matrix(self.X,
kernel=self.kernel,
coef0=self.coef0,
degree=self.degree,
gamma=self.gamma)) + self.y *
(alpha - alpha_) - (self.p - 1) * self.sigma /
(self.p * self.C**(self.p - 1)) * one_vec *
(cvx.power(alpha, self.p /
(self.p - 1)) + cvx.power(alpha_, self.p /
(self.p - 1))))
self.constraints += [
cvx.sum_entries(one_vec * alpha - one_vec * alpha_) == 0
]
for i in range(n):
self.constraints += [alpha[i] >= 0, alpha_[i] >= 0]
svr = cvx.Problem(self.svr_obj, self.constraints)
svr.solve()
#alpha & alpha_
self.a = np.array(alpha.value).flatten()
self.a_ = np.array(alpha_.value).flatten()
#compute b
idx = np.where((np.array(alpha.value).ravel() < self.C - 1E-10) *
(np.array(alpha.value).ravel() > 1E-10))[0][0]
self.b = -self.epsilon + self.y[idx] - np.sum(
[(alpha.value[i] - alpha_.value[i]) *
kernel_f(self.X[idx],
self.X[i],
kernel=self.kernel,
coef0=self.coef0,
degree=self.degree,
gamma=self.gamma) for i in range(n)])
else:
self.constraints = []
self.svr_obj = cvx.Maximize(-.5 * cvx.quad_form(
alpha - alpha_,
kernel_matrix(self.X,
kernel=self.kernel,
coef0=self.coef0,
degree=self.degree,
gamma=self.gamma)) - self.epsilon * one_vec *
(alpha + alpha_) + self.y *
(alpha - alpha_))
self.constraints += [
cvx.sum_entries(one_vec * alpha - one_vec * alpha_) == 0
]
for i in range(n):
self.constraints += [
alpha[i] >= 0, alpha_[i] >= 0, alpha[i] <= self.C,
alpha_[i] <= self.C
]
svr = cvx.Problem(self.svr_obj, self.constraints)
svr.solve()
#alpha & alpha_
self.a = np.array(alpha.value).flatten()
self.a_ = np.array(alpha_.value).flatten()
#compute b
idx = np.where((np.array(alpha.value).ravel() < self.C - 1E-10) *
(np.array(alpha.value).ravel() > 1E-10))[0][0]
self.b = -self.epsilon + self.y[idx] - np.sum(
[(alpha.value[i] - alpha_.value[i]) *
kernel_f(self.X[idx],
self.X[i],
kernel=self.kernel,
coef0=self.coef0,
degree=self.degree,
gamma=self.gamma) for i in range(n)])