def solve(self, C, xt, lt, task_indicator, M):
"""
solve dual using cvxopt
"""
num_xt = len(xt)
# set up quadratic term
Q = np.zeros((num_xt, num_xt))
# compute quadratic term
for i in xrange(num_xt):
for j in xrange(num_xt):
s = task_indicator[i]
t = task_indicator[j]
Q[i,j] = M[s,t] * lt[i] * lt[j] * np.dot(xt[i], xt[j])
# set up linear term
p = -np.ones(num_xt)
# if we would like to use bias
#b = np.zeros((M,1))
#label_matrix = numpy.zeros((M,N))
# set up QP
p = QP(Q, p, lb=np.zeros(num_xt), ub=C*np.ones(num_xt)) #Aeq=label_matrix, beq=b
p.debug=1
# run solver
r = p.solve('cvxopt_qp', iprint = 0)
# recover result
self.alphas = r.xf
self.dual_obj = self.obj = r.ff
# compute W from alphas
self.W = alphas_to_w(self.alphas, xt, lt, task_indicator, M)
return True
def minimize(self, **kwargs):
""" solve the quadratic problem using OpenOpt
Returns:
obj_value, solution
obj_value -- value of the objective function at the discovered solution
solution -- the solution flux vector (indexed like matrix columns)
"""
qp = QP(self.obj.H, self.obj.f, A=self.Aineq, Aeq=self.Aeq,
b=self.bineq, beq=self.beq, lb=self.lb, ub=self.ub, **kwargs)
qp.debug=1
r = qp.solve(self.solver)
if r.istop <= 0 or r.ff != r.ff: # check halting condition
self.obj_value = 0
self.solution = []
self.istop = r.istop
else:
self.obj_value = r.ff
self.solution = r.xf
self.istop = r.istop
return self.obj_value, self.solution
def _train(self, train_data, param):
"""
training procedure using training examples and labels
@param train_data: Data relevant to SVM training
@type train_data: dict<str, list<instances> >
@param param: Parameters for the training procedure
@type param: ParameterSvm
"""
# fix dimensions
M = len(train_data)
N = 0
for key in train_data.keys():
N += len(train_data[key])
# init containers
examples = []
labels = []
# vector to indicate to which task each example belongs
task_vector = []
task_num = 0
tmp_examples = 0
label_matrix = numpy.zeros((M, N))
# extract training data
for (task_id, instance_set) in train_data.items():
print "train task id:", task_id
#assert(instance_set[0].dataset.organism==task_id)
examples.extend([inst.example for inst in instance_set])
tmp_labels = [inst.label for inst in instance_set]
labels.extend(tmp_labels)
begin_idx = tmp_examples
end_idx = tmp_examples + len(tmp_labels)
# fill matrix row
label_matrix[task_num, begin_idx:end_idx] = tmp_labels
task_vector.extend([task_num] * len(instance_set))
task_num += 1
tmp_examples += len(tmp_labels)
# fetch gammas from parameter object
# TODO: compute gammas outside of this
gammas = numpy.ones((M, M)) + numpy.eye(M)
#gammas = numpy.eye(M)
# create kernel
kernel = shogun_factory.create_kernel(examples, param)
y = numpy.array(labels)
print "computing kernel matrix"
km = kernel.get_kernel_matrix()
km = reweight_kernel_matrix(km, gammas, task_vector)
# "add" labels to Q-matrix
km = numpy.transpose(y.flatten() * (km * y.flatten()).transpose())
print "done computing kernel matrix, calling solver"
f = -numpy.ones(N)
b = numpy.zeros((M, 1))
# set up QP
p = QP(km,
f,
Aeq=label_matrix,
beq=b,
lb=numpy.zeros(N),
ub=param.cost * numpy.ones(N))
p.debug = 1
# run solver
r = p.solve('cvxopt_qp', iprint=0)
print "done with training"
alphas = r.xf
objective = r.ff
print "alphas:", alphas
predictors = {}
for (k, task_id) in enumerate(train_data.keys()):
# pack all relevant information in predictor
predictors[task_id] = (alphas, param, task_vector, k, gammas,
examples, labels)
return predictors
def _train(self, train_data, param):
"""
training procedure using training examples and labels
@param train_data: Data relevant to SVM training
@type train_data: dict<str, list<instances> >
@param param: Parameters for the training procedure
@type param: ParameterSvm
"""
# fix dimensions
M = len(train_data)
N = 0
for key in train_data.keys():
N += len(train_data[key])
# init containers
examples = []
labels = []
# vector to indicate to which task each example belongs
task_vector = []
task_num = 0
tmp_examples = 0
label_matrix = numpy.zeros((M,N))
# extract training data
for (task_id, instance_set) in train_data.items():
print "train task id:", task_id
#assert(instance_set[0].dataset.organism==task_id)
examples.extend([inst.example for inst in instance_set])
tmp_labels = [inst.label for inst in instance_set]
labels.extend(tmp_labels)
begin_idx = tmp_examples
end_idx = tmp_examples + len(tmp_labels)
# fill matrix row
label_matrix[task_num, begin_idx:end_idx] = tmp_labels
task_vector.extend([task_num]*len(instance_set))
task_num += 1
tmp_examples += len(tmp_labels)
# fetch gammas from parameter object
# TODO: compute gammas outside of this
gammas = numpy.ones((M,M)) + numpy.eye(M)
#gammas = numpy.eye(M)
# create kernel
kernel = shogun_factory.create_kernel(examples, param)
y = numpy.array(labels)
print "computing kernel matrix"
km = kernel.get_kernel_matrix()
km = reweight_kernel_matrix(km, gammas, task_vector)
# "add" labels to Q-matrix
km = numpy.transpose(y.flatten() * (km*y.flatten()).transpose())
print "done computing kernel matrix, calling solver"
f = -numpy.ones(N)
b = numpy.zeros((M,1))
# set up QP
p = QP(km, f, Aeq=label_matrix, beq=b, lb=numpy.zeros(N), ub=param.cost*numpy.ones(N))
p.debug=1
# run solver
r = p.solve('cvxopt_qp', iprint = 0)
print "done with training"
alphas = r.xf
objective = r.ff
print "alphas:", alphas
predictors = {}
for (k, task_id) in enumerate(train_data.keys()):
# pack all relevant information in predictor
predictors[task_id] = (alphas, param, task_vector, k, gammas, examples, labels)
return predictors
