base_wdk = WeightedDegreeStringKernel(feat, feat, 1)
normalizer = MultitaskKernelNormalizer(task_vector)
#wdk.set_task_vector(task_vector) #, task_vector)
for i in xrange(2):
for j in xrange(2):
if i == j:
normalizer.set_task_similarity(i, j, 4.0)
else:
normalizer.set_task_similarity(i, j, 1.0)
base_wdk.set_normalizer(normalizer)
print base_wdk.get_kernel_matrix()
print "--->", base_wdk.get_normalizer().get_name()
wdk = WeightedDegreeStringKernel(feat, feat, 1)
normalizer = IdentityKernelNormalizer()
wdk.set_normalizer(normalizer)
##################################################################
# external modification
##################################################################
km = wdk.get_kernel_matrix()
normalizer = MultitaskKernelNormalizer(task_vector)
#wdk.set_task_vector(task_vector) #, task_vector)
for i in xrange(2):
for j in xrange(2):
if i==j:
normalizer.set_task_similarity(i,j, 4.0)
else:
normalizer.set_task_similarity(i,j, 1.0)
base_wdk.set_normalizer(normalizer)
print base_wdk.get_kernel_matrix()
print "--->",base_wdk.get_normalizer().get_name()
wdk = WeightedDegreeStringKernel(feat, feat, 1)
normalizer = IdentityKernelNormalizer()
wdk.set_normalizer(normalizer)
##################################################################
# external modification
##################################################################
km = wdk.get_kernel_matrix()
def solver_mtk_shogun(C, all_xt, all_lt, task_indicator, M, L, eps,
target_obj):
"""
implementation using multitask kernel
"""
xt = numpy.array(all_xt)
lt = numpy.array(all_lt)
tt = numpy.array(task_indicator, dtype=numpy.int32)
tsm = numpy.array(M)
print "task_sim:", tsm
num_tasks = L.shape[0]
# sanity checks
assert len(xt) == len(lt) == len(tt)
assert M.shape == L.shape
assert num_tasks == len(set(tt))
# set up shogun objects
if type(xt[0]) == numpy.string_:
feat = StringCharFeatures(DNA)
xt = [str(a) for a in xt]
feat.set_features(xt)
base_kernel = WeightedDegreeStringKernel(feat, feat, 8)
else:
feat = RealFeatures(xt.T)
base_kernel = LinearKernel(feat, feat)
lab = Labels(lt)
# set up normalizer
normalizer = MultitaskKernelNormalizer(tt.tolist())
for i in xrange(num_tasks):
for j in xrange(num_tasks):
normalizer.set_task_similarity(i, j, M[i, j])
print "num of unique tasks: ", normalizer.get_num_unique_tasks(
task_indicator)
# set up kernel
base_kernel.set_cache_size(2000)
base_kernel.set_normalizer(normalizer)
base_kernel.init_normalizer()
# set up svm
svm = SVMLight() #LibSVM()
svm.set_epsilon(eps)
#print "reducing num threads to one"
#svm.parallel.set_num_threads(1)
#print "using one thread"
# how often do we like to compute objective etc
svm.set_record_interval(0)
svm.set_target_objective(target_obj)
svm.set_linadd_enabled(False)
svm.set_batch_computation_enabled(False)
svm.io.set_loglevel(MSG_DEBUG)
#SET THREADS TO 1
svm.set_C(C, C)
svm.set_bias_enabled(False)
# prepare for training
svm.set_labels(lab)
svm.set_kernel(base_kernel)
# train svm
svm.train()
train_times = svm.get_training_times()
objectives = [-obj for obj in svm.get_dual_objectives()]
if False:
# get model parameters
sv_idx = svm.get_support_vectors()
sparse_alphas = svm.get_alphas()
assert len(sv_idx) == len(sparse_alphas)
# compute dense alpha (remove label)
alphas = numpy.zeros(len(xt))
for id_sparse, id_dense in enumerate(sv_idx):
alphas[id_dense] = sparse_alphas[id_sparse] * lt[id_dense]
# print alphas
W = alphas_to_w(alphas, xt, lt, task_indicator, M)
primal_obj = compute_primal_objective(
W.reshape(W.shape[0] * W.shape[1]), C, all_xt, all_lt,
task_indicator, L)
objectives.append(primal_obj)
train_times.append(train_times[-1] + 100)
return objectives, train_times
