def kernel_fisher_modular(
fm_train_dna=traindat,
fm_test_dna=testdat,
label_train_dna=label_traindat,
N=1,
M=4,
pseudo=1e-1,
order=1,
gap=0,
reverse=False,
kargs=[1, False, True],
):
from shogun.Features import StringCharFeatures, StringWordFeatures, FKFeatures, DNA
from shogun.Kernel import PolyKernel
from shogun.Distribution import HMM, BW_NORMAL # , MSG_DEBUG
# train HMM for positive class
charfeat = StringCharFeatures(fm_hmm_pos, DNA)
# charfeat.io.set_loglevel(MSG_DEBUG)
hmm_pos_train = StringWordFeatures(charfeat.get_alphabet())
hmm_pos_train.obtain_from_char(charfeat, order - 1, order, gap, reverse)
pos = HMM(hmm_pos_train, N, M, pseudo)
pos.baum_welch_viterbi_train(BW_NORMAL)
# train HMM for negative class
charfeat = StringCharFeatures(fm_hmm_neg, DNA)
hmm_neg_train = StringWordFeatures(charfeat.get_alphabet())
hmm_neg_train.obtain_from_char(charfeat, order - 1, order, gap, reverse)
neg = HMM(hmm_neg_train, N, M, pseudo)
neg.baum_welch_viterbi_train(BW_NORMAL)
# Kernel training data
charfeat = StringCharFeatures(fm_train_dna, DNA)
wordfeats_train = StringWordFeatures(charfeat.get_alphabet())
wordfeats_train.obtain_from_char(charfeat, order - 1, order, gap, reverse)
# Kernel testing data
charfeat = StringCharFeatures(fm_test_dna, DNA)
wordfeats_test = StringWordFeatures(charfeat.get_alphabet())
wordfeats_test.obtain_from_char(charfeat, order - 1, order, gap, reverse)
# get kernel on training data
pos.set_observations(wordfeats_train)
neg.set_observations(wordfeats_train)
feats_train = FKFeatures(10, pos, neg)
feats_train.set_opt_a(-1) # estimate prior
kernel = PolyKernel(feats_train, feats_train, *kargs)
km_train = kernel.get_kernel_matrix()
# get kernel on testing data
pos_clone = HMM(pos)
neg_clone = HMM(neg)
pos_clone.set_observations(wordfeats_test)
neg_clone.set_observations(wordfeats_test)
feats_test = FKFeatures(10, pos_clone, neg_clone)
feats_test.set_a(feats_train.get_a()) # use prior from training data
kernel.init(feats_train, feats_test)
km_test = kernel.get_kernel_matrix()
return km_train, km_test, kernel
def kernel_top_modular(
fm_train_dna=traindat,
fm_test_dna=testdat,
label_train_dna=label_traindat,
pseudo=1e-1,
order=1,
gap=0,
reverse=False,
kargs=[1, False, True],
):
from shogun.Features import StringCharFeatures, StringWordFeatures, TOPFeatures, DNA
from shogun.Kernel import PolyKernel
from shogun.Distribution import HMM, BW_NORMAL
N = 1 # toy HMM with 1 state
M = 4 # 4 observations -> DNA
# train HMM for positive class
charfeat = StringCharFeatures(fm_hmm_pos, DNA)
hmm_pos_train = StringWordFeatures(charfeat.get_alphabet())
hmm_pos_train.obtain_from_char(charfeat, order - 1, order, gap, reverse)
pos = HMM(hmm_pos_train, N, M, pseudo)
pos.baum_welch_viterbi_train(BW_NORMAL)
# train HMM for negative class
charfeat = StringCharFeatures(fm_hmm_neg, DNA)
hmm_neg_train = StringWordFeatures(charfeat.get_alphabet())
hmm_neg_train.obtain_from_char(charfeat, order - 1, order, gap, reverse)
neg = HMM(hmm_neg_train, N, M, pseudo)
neg.baum_welch_viterbi_train(BW_NORMAL)
# Kernel training data
charfeat = StringCharFeatures(fm_train_dna, DNA)
wordfeats_train = StringWordFeatures(charfeat.get_alphabet())
wordfeats_train.obtain_from_char(charfeat, order - 1, order, gap, reverse)
# Kernel testing data
charfeat = StringCharFeatures(fm_test_dna, DNA)
wordfeats_test = StringWordFeatures(charfeat.get_alphabet())
wordfeats_test.obtain_from_char(charfeat, order - 1, order, gap, reverse)
# get kernel on training data
pos.set_observations(wordfeats_train)
neg.set_observations(wordfeats_train)
feats_train = TOPFeatures(10, pos, neg, False, False)
kernel = PolyKernel(feats_train, feats_train, *kargs)
km_train = kernel.get_kernel_matrix()
# get kernel on testing data
pos_clone = HMM(pos)
neg_clone = HMM(neg)
pos_clone.set_observations(wordfeats_test)
neg_clone.set_observations(wordfeats_test)
feats_test = TOPFeatures(10, pos_clone, neg_clone, False, False)
kernel.init(feats_train, feats_test)
km_test = kernel.get_kernel_matrix()
return km_train, km_test, kernel
def fisher (): print "Fisher Kernel" from shogun.Features import StringCharFeatures, StringWordFeatures, FKFeatures, DNA from shogun.Kernel import PolyKernel from shogun.Distribution import HMM, BW_NORMAL N=1 # toy HMM with 1 state M=4 # 4 observations -> DNA pseudo=1e-1 order=1 gap=0 reverse=False kargs=[1, False, True] # train HMM for positive class charfeat=StringCharFeatures(fm_hmm_pos, DNA) hmm_pos_train=StringWordFeatures(charfeat.get_alphabet()) hmm_pos_train.obtain_from_char(charfeat, order-1, order, gap, reverse) pos=HMM(hmm_pos_train, N, M, pseudo) pos.baum_welch_viterbi_train(BW_NORMAL) # train HMM for negative class charfeat=StringCharFeatures(fm_hmm_neg, DNA) hmm_neg_train=StringWordFeatures(charfeat.get_alphabet()) hmm_neg_train.obtain_from_char(charfeat, order-1, order, gap, reverse) neg=HMM(hmm_neg_train, N, M, pseudo) neg.baum_welch_viterbi_train(BW_NORMAL) # Kernel training data charfeat=StringCharFeatures(fm_train_dna, DNA) wordfeats_train=StringWordFeatures(charfeat.get_alphabet()) wordfeats_train.obtain_from_char(charfeat, order-1, order, gap, reverse) # Kernel testing data charfeat=StringCharFeatures(fm_test_dna, DNA) wordfeats_test=StringWordFeatures(charfeat.get_alphabet()) wordfeats_test.obtain_from_char(charfeat, order-1, order, gap, reverse) # get kernel on training data pos.set_observations(wordfeats_train) neg.set_observations(wordfeats_train) feats_train=FKFeatures(10, pos, neg) feats_train.set_opt_a(-1) #estimate prior kernel=PolyKernel(feats_train, feats_train, *kargs) km_train=kernel.get_kernel_matrix() # get kernel on testing data pos_clone=HMM(pos) neg_clone=HMM(neg) pos_clone.set_observations(wordfeats_test) neg_clone.set_observations(wordfeats_test) feats_test=FKFeatures(10, pos_clone, neg_clone) feats_test.set_a(feats_train.get_a()) #use prior from training data kernel.init(feats_train, feats_test) km_test=kernel.get_kernel_matrix()
def kernel_poly_modular (fm_train_real=traindat,fm_test_real=testdat,degree=4,inhomogene=False, use_normalization=True): from shogun.Features import RealFeatures from shogun.Kernel import PolyKernel feats_train=RealFeatures(fm_train_real) feats_test=RealFeatures(fm_test_real) kernel=PolyKernel( feats_train, feats_train, degree, inhomogene, use_normalization) km_train=kernel.get_kernel_matrix() kernel.init(feats_train, feats_test) km_test=kernel.get_kernel_matrix() return km_train,km_test,kernel
def RunKPCAShogun(q):
totalTimer = Timer()
try:
# Load input dataset.
Log.Info("Loading dataset", self.verbose)
data = np.genfromtxt(self.dataset, delimiter=',')
dataFeat = RealFeatures(data.T)
with totalTimer:
# Get the new dimensionality, if it is necessary.
dimension = re.search('-d (\d+)', options)
if not dimension:
d = data.shape[1]
else:
d = int(dimension.group(1))
if (d > data.shape[1]):
Log.Fatal("New dimensionality (" + str(d) + ") cannot be greater "
+ "than existing dimensionality (" + str(data.shape[1]) + ")!")
q.put(-1)
return -1
# Get the kernel type and make sure it is valid.
kernel = re.search("-k ([^\s]+)", options)
if not kernel:
Log.Fatal("Choose kernel type, valid choices are 'linear'," +
" 'hyptan', 'polynomial' and 'gaussian'.")
q.put(-1)
return -1
elif kernel.group(1) == "polynomial":
degree = re.search('-D (\d+)', options)
degree = 1 if not degree else int(degree.group(1))
kernel = PolyKernel(dataFeat, dataFeat, degree, True)
elif kernel.group(1) == "gaussian":
kernel = GaussianKernel(dataFeat, dataFeat, 2.0)
elif kernel.group(1) == "linear":
kernel = LinearKernel(dataFeat, dataFeat)
elif kernel.group(1) == "hyptan":
kernel = SigmoidKernel(dataFeat, dataFeat, 2, 1.0, 1.0)
else:
Log.Fatal("Invalid kernel type (" + kernel.group(1) + "); valid "
+ "choices are 'linear', 'hyptan', 'polynomial' and 'gaussian'.")
q.put(-1)
return -1
# Perform Kernel Principal Components Analysis.
model = KernelPCA(kernel)
model.set_target_dim(d)
model.init(dataFeat)
model.apply_to_feature_matrix(dataFeat)
except Exception as e:
q.put(-1)
return -1
time = totalTimer.ElapsedTime()
q.put(time)
return time
def create_param_tree():
from shogun.ModelSelection import ModelSelectionParameters, R_EXP, R_LINEAR
from shogun.ModelSelection import ParameterCombination
from shogun.Kernel import GaussianKernel, PolyKernel
root=ModelSelectionParameters()
tau=ModelSelectionParameters("tau")
root.append_child(tau)
# also R_LINEAR/R_LOG is available as type
min=-1
max=1
type=R_EXP
step=1.5
base=2
tau.build_values(min, max, type, step, base)
# gaussian kernel with width
gaussian_kernel=GaussianKernel()
# print all parameter available for modelselection
# Dont worry if yours is not included but, write to the mailing list
gaussian_kernel.print_modsel_params()
param_gaussian_kernel=ModelSelectionParameters("kernel", gaussian_kernel)
gaussian_kernel_width=ModelSelectionParameters("width");
gaussian_kernel_width.build_values(5.0, 8.0, R_EXP, 1.0, 2.0)
param_gaussian_kernel.append_child(gaussian_kernel_width)
root.append_child(param_gaussian_kernel)
# polynomial kernel with degree
poly_kernel=PolyKernel()
# print all parameter available for modelselection
# Dont worry if yours is not included but, write to the mailing list
poly_kernel.print_modsel_params()
param_poly_kernel=ModelSelectionParameters("kernel", poly_kernel)
root.append_child(param_poly_kernel)
# note that integers are used here
param_poly_kernel_degree=ModelSelectionParameters("degree")
param_poly_kernel_degree.build_values(1, 2, R_LINEAR)
param_poly_kernel.append_child(param_poly_kernel_degree)
return root
def create_param_tree():
from shogun.ModelSelection import ModelSelectionParameters, R_EXP, R_LINEAR
from shogun.ModelSelection import ParameterCombination
from shogun.Kernel import GaussianKernel, PolyKernel
root = ModelSelectionParameters()
tau = ModelSelectionParameters("tau")
root.append_child(tau)
# also R_LINEAR/R_LOG is available as type
min = -1
max = 1
type = R_EXP
step = 1.5
base = 2
tau.build_values(min, max, type, step, base)
# gaussian kernel with width
gaussian_kernel = GaussianKernel()
# print all parameter available for modelselection
# Dont worry if yours is not included but, write to the mailing list
gaussian_kernel.print_modsel_params()
param_gaussian_kernel = ModelSelectionParameters("kernel", gaussian_kernel)
gaussian_kernel_width = ModelSelectionParameters("width")
gaussian_kernel_width.build_values(5.0, 8.0, R_EXP, 1.0, 2.0)
param_gaussian_kernel.append_child(gaussian_kernel_width)
root.append_child(param_gaussian_kernel)
# polynomial kernel with degree
poly_kernel = PolyKernel()
# print all parameter available for modelselection
# Dont worry if yours is not included but, write to the mailing list
poly_kernel.print_modsel_params()
param_poly_kernel = ModelSelectionParameters("kernel", poly_kernel)
root.append_child(param_poly_kernel)
# note that integers are used here
param_poly_kernel_degree = ModelSelectionParameters("degree")
param_poly_kernel_degree.build_values(1, 2, R_LINEAR)
param_poly_kernel.append_child(param_poly_kernel_degree)
return root
def poly (): print 'Poly' from shogun.Features import RealFeatures from shogun.Kernel import PolyKernel feats_train=RealFeatures(fm_train_real) feats_test=RealFeatures(fm_test_real) degree=4 inhomogene=False use_normalization=True kernel=PolyKernel( feats_train, feats_train, degree, inhomogene, use_normalization) km_train=kernel.get_kernel_matrix() kernel.init(feats_train, feats_test) km_test=kernel.get_kernel_matrix()
def create_kernel(kname, features, kparam=None):
if kname == 'gauss':
kernel = GaussianKernel(features, features, kparam)
elif kname == 'linear':
kernel = LinearKernel(features, features)
elif kname == 'poly':
kernel = PolyKernel(features, features, kparam, True, False)
return kernel
def create_kernel(kname, kparam, feats_train):
"""Call the corresponding constructor for the kernel"""
if kname == 'gauss':
kernel = GaussianKernel(feats_train, feats_train, kparam['width'])
elif kname == 'linear':
kernel = LinearKernel(feats_train, feats_train)
kernel.set_normalizer(AvgDiagKernelNormalizer(kparam['scale']))
elif kname == 'poly':
kernel = PolyKernel(feats_train, feats_train, kparam['degree'],
kparam['inhomogene'], kparam['normal'])
elif kname == 'wd':
kernel = WeightedDegreePositionStringKernel(feats_train, feats_train,
kparam['degree'])
kernel.set_normalizer(
AvgDiagKernelNormalizer(float(kparam['seqlength'])))
kernel.set_shifts(kparam['shift'] *
numpy.ones(kparam['seqlength'], dtype=numpy.int32))
#kernel=WeightedDegreeStringKernel(feats_train, feats_train, kparam['degree'])
elif kname == 'spec':
kernel = CommUlongStringKernel(feats_train, feats_train)
elif kname == 'cumspec':
kernel = WeightedCommWordStringKernel(feats_train, feats_train)
kernel.set_weights(numpy.ones(kparam['degree']))
elif kname == 'spec2':
kernel = CombinedKernel()
k0 = CommWordStringKernel(feats_train['f0'], feats_train['f0'])
k0.io.disable_progress()
kernel.append_kernel(k0)
k1 = CommWordStringKernel(feats_train['f1'], feats_train['f1'])
k1.io.disable_progress()
kernel.append_kernel(k1)
elif kname == 'cumspec2':
kernel = CombinedKernel()
k0 = WeightedCommWordStringKernel(feats_train['f0'], feats_train['f0'])
k0.set_weights(numpy.ones(kparam['degree']))
k0.io.disable_progress()
kernel.append_kernel(k0)
k1 = WeightedCommWordStringKernel(feats_train['f1'], feats_train['f1'])
k1.set_weights(numpy.ones(kparam['degree']))
k1.io.disable_progress()
kernel.append_kernel(k1)
elif kname == 'localalign':
kernel = LocalAlignmentStringKernel(feats_train, feats_train)
elif kname == 'localimprove':
kernel = LocalityImprovedStringKernel(feats_train, feats_train, kparam['length'],\
kparam['indeg'], kparam['outdeg'])
else:
print 'Unknown kernel %s' % kname
kernel.set_cache_size(32)
return kernel
def create_kernel(examples, param):
"""
kernel factory
@param examples: list/array of examples
@type examples: list
@param param: parameter object
@type param: Parameter
@return subclass of shogun Kernel object
@rtype: Kernel
"""
# first create feature object of correct type
feat = create_features(examples, param)
kernel = None
if param.kernel == "WeightedDegreeStringKernel":
kernel = WeightedDegreeStringKernel(feat, feat, param.wdk_degree)
kernel.set_cache_size(200)
elif param.kernel == "LinearKernel":
kernel = LinearKernel(feat, feat)
elif param.kernel == "PolyKernel":
kernel = PolyKernel(feat, feat, 1, False)
elif param.kernel == "GaussianKernel":
kernel = GaussianKernel(feat, feat, param.sigma)
elif param.kernel == "WeightedDegreeRBFKernel":
size_cache = 200
nof_properties = 20
sigma = param.base_similarity
kernel = WeightedDegreeRBFKernel(feat, feat, sigma, param.wdk_degree,
nof_properties, size_cache)
elif param.kernel == "Promoter":
kernel = create_promoter_kernel(examples, param.flags)
else:
raise Exception, "Unknown kernel type."
if hasattr(param, "flags") and param.flags.has_key("cache_size"):
kernel.set_cache_size(param.flags["cache_size"])
if param.flags.has_key("debug"):
kernel.io.set_loglevel(shogun.Kernel.MSG_DEBUG)
return kernel
def kernel_fisher_modular(fm_train_dna=traindat,
fm_test_dna=testdat,
label_train_dna=label_traindat,
N=1,
M=4,
pseudo=1e-1,
order=1,
gap=0,
reverse=False,
kargs=[1, False, True]):
from shogun.Features import StringCharFeatures, StringWordFeatures, FKFeatures, DNA
from shogun.Kernel import PolyKernel
from shogun.Distribution import HMM, BW_NORMAL #, MSG_DEBUG
# train HMM for positive class
charfeat = StringCharFeatures(fm_hmm_pos, DNA)
#charfeat.io.set_loglevel(MSG_DEBUG)
hmm_pos_train = StringWordFeatures(charfeat.get_alphabet())
hmm_pos_train.obtain_from_char(charfeat, order - 1, order, gap, reverse)
pos = HMM(hmm_pos_train, N, M, pseudo)
pos.baum_welch_viterbi_train(BW_NORMAL)
# train HMM for negative class
charfeat = StringCharFeatures(fm_hmm_neg, DNA)
hmm_neg_train = StringWordFeatures(charfeat.get_alphabet())
hmm_neg_train.obtain_from_char(charfeat, order - 1, order, gap, reverse)
neg = HMM(hmm_neg_train, N, M, pseudo)
neg.baum_welch_viterbi_train(BW_NORMAL)
# Kernel training data
charfeat = StringCharFeatures(fm_train_dna, DNA)
wordfeats_train = StringWordFeatures(charfeat.get_alphabet())
wordfeats_train.obtain_from_char(charfeat, order - 1, order, gap, reverse)
# Kernel testing data
charfeat = StringCharFeatures(fm_test_dna, DNA)
wordfeats_test = StringWordFeatures(charfeat.get_alphabet())
wordfeats_test.obtain_from_char(charfeat, order - 1, order, gap, reverse)
# get kernel on training data
pos.set_observations(wordfeats_train)
neg.set_observations(wordfeats_train)
feats_train = FKFeatures(10, pos, neg)
feats_train.set_opt_a(-1) #estimate prior
kernel = PolyKernel(feats_train, feats_train, *kargs)
km_train = kernel.get_kernel_matrix()
# get kernel on testing data
pos_clone = HMM(pos)
neg_clone = HMM(neg)
pos_clone.set_observations(wordfeats_test)
neg_clone.set_observations(wordfeats_test)
feats_test = FKFeatures(10, pos_clone, neg_clone)
feats_test.set_a(feats_train.get_a()) #use prior from training data
kernel.init(feats_train, feats_test)
km_test = kernel.get_kernel_matrix()
return km_train, km_test, kernel
def mkl_multiclass_modular(fm_train_real, fm_test_real, label_train_multiclass,
width, C, epsilon, num_threads, mkl_epsilon,
mkl_norm):
from shogun.Features import CombinedFeatures, RealFeatures, Labels
from shogun.Kernel import CombinedKernel, GaussianKernel, LinearKernel, PolyKernel
from shogun.Classifier import MKLMultiClass
kernel = CombinedKernel()
feats_train = CombinedFeatures()
feats_test = CombinedFeatures()
subkfeats_train = RealFeatures(fm_train_real)
subkfeats_test = RealFeatures(fm_test_real)
subkernel = GaussianKernel(10, width)
feats_train.append_feature_obj(subkfeats_train)
feats_test.append_feature_obj(subkfeats_test)
kernel.append_kernel(subkernel)
subkfeats_train = RealFeatures(fm_train_real)
subkfeats_test = RealFeatures(fm_test_real)
subkernel = LinearKernel()
feats_train.append_feature_obj(subkfeats_train)
feats_test.append_feature_obj(subkfeats_test)
kernel.append_kernel(subkernel)
subkfeats_train = RealFeatures(fm_train_real)
subkfeats_test = RealFeatures(fm_test_real)
subkernel = PolyKernel(10, 2)
feats_train.append_feature_obj(subkfeats_train)
feats_test.append_feature_obj(subkfeats_test)
kernel.append_kernel(subkernel)
kernel.init(feats_train, feats_train)
labels = Labels(label_train_multiclass)
mkl = MKLMultiClass(C, kernel, labels)
mkl.set_epsilon(epsilon)
mkl.parallel.set_num_threads(num_threads)
mkl.set_mkl_epsilon(mkl_epsilon)
mkl.set_mkl_norm(mkl_norm)
mkl.train()
kernel.init(feats_train, feats_test)
out = mkl.apply().get_labels()
return out
def kernel_top_modular(fm_train_dna=traindat,
fm_test_dna=testdat,
label_train_dna=label_traindat,
pseudo=1e-1,
order=1,
gap=0,
reverse=False,
kargs=[1, False, True]):
from shogun.Features import StringCharFeatures, StringWordFeatures, TOPFeatures, DNA
from shogun.Kernel import PolyKernel
from shogun.Distribution import HMM, BW_NORMAL
N = 1 # toy HMM with 1 state
M = 4 # 4 observations -> DNA
# train HMM for positive class
charfeat = StringCharFeatures(fm_hmm_pos, DNA)
hmm_pos_train = StringWordFeatures(charfeat.get_alphabet())
hmm_pos_train.obtain_from_char(charfeat, order - 1, order, gap, reverse)
pos = HMM(hmm_pos_train, N, M, pseudo)
pos.baum_welch_viterbi_train(BW_NORMAL)
# train HMM for negative class
charfeat = StringCharFeatures(fm_hmm_neg, DNA)
hmm_neg_train = StringWordFeatures(charfeat.get_alphabet())
hmm_neg_train.obtain_from_char(charfeat, order - 1, order, gap, reverse)
neg = HMM(hmm_neg_train, N, M, pseudo)
neg.baum_welch_viterbi_train(BW_NORMAL)
# Kernel training data
charfeat = StringCharFeatures(fm_train_dna, DNA)
wordfeats_train = StringWordFeatures(charfeat.get_alphabet())
wordfeats_train.obtain_from_char(charfeat, order - 1, order, gap, reverse)
# Kernel testing data
charfeat = StringCharFeatures(fm_test_dna, DNA)
wordfeats_test = StringWordFeatures(charfeat.get_alphabet())
wordfeats_test.obtain_from_char(charfeat, order - 1, order, gap, reverse)
# get kernel on training data
pos.set_observations(wordfeats_train)
neg.set_observations(wordfeats_train)
feats_train = TOPFeatures(10, pos, neg, False, False)
kernel = PolyKernel(feats_train, feats_train, *kargs)
km_train = kernel.get_kernel_matrix()
# get kernel on testing data
pos_clone = HMM(pos)
neg_clone = HMM(neg)
pos_clone.set_observations(wordfeats_test)
neg_clone.set_observations(wordfeats_test)
feats_test = TOPFeatures(10, pos_clone, neg_clone, False, False)
kernel.init(feats_train, feats_test)
km_test = kernel.get_kernel_matrix()
return km_train, km_test, kernel
def kernel_combined_custom_poly_modular(fm_train_real = traindat,fm_test_real = testdat,fm_label_twoclass=label_traindat):
from shogun.Features import CombinedFeatures, RealFeatures, BinaryLabels
from shogun.Kernel import CombinedKernel, PolyKernel, CustomKernel
from shogun.Classifier import LibSVM
kernel = CombinedKernel()
feats_train = CombinedFeatures()
tfeats = RealFeatures(fm_train_real)
tkernel = PolyKernel(10,3)
tkernel.init(tfeats, tfeats)
K = tkernel.get_kernel_matrix()
kernel.append_kernel(CustomKernel(K))
subkfeats_train = RealFeatures(fm_train_real)
feats_train.append_feature_obj(subkfeats_train)
subkernel = PolyKernel(10,2)
kernel.append_kernel(subkernel)
kernel.init(feats_train, feats_train)
labels = BinaryLabels(fm_label_twoclass)
svm = LibSVM(1.0, kernel, labels)
svm.train()
kernel = CombinedKernel()
feats_pred = CombinedFeatures()
pfeats = RealFeatures(fm_test_real)
tkernel = PolyKernel(10,3)
tkernel.init(tfeats, pfeats)
K = tkernel.get_kernel_matrix()
kernel.append_kernel(CustomKernel(K))
subkfeats_test = RealFeatures(fm_test_real)
feats_pred.append_feature_obj(subkfeats_test)
subkernel = PolyKernel(10, 2)
kernel.append_kernel(subkernel)
kernel.init(feats_train, feats_pred)
svm.set_kernel(kernel)
svm.apply()
km_train=kernel.get_kernel_matrix()
return km_train,kernel
def create_empty_kernel(param):
"""
kernel factory
@param param: parameter object
@type param: Parameter
@return subclass of shogun Kernel object
@rtype: Kernel
"""
kernel = None
if param.kernel == "WeightedDegreeStringKernel":
kernel = WeightedDegreeStringKernel(param.wdk_degree)
elif param.kernel == "LinearKernel":
kernel = LinearKernel()
elif param.kernel == "PolyKernel":
kernel = PolyKernel(10, 1, False)
elif param.kernel == "GaussianKernel":
kernel = GaussianKernel(10, param.sigma)
elif param.kernel == "WeightedDegreeRBFKernel":
size_cache = 50
nof_properties = 5 #20
sigma = param.transform
kernel = WeightedDegreeRBFKernel(size_cache, sigma, param.wdk_degree,
nof_properties)
else:
raise Exception, "Unknown kernel type:" + param.kernel
if hasattr(param, "flags") and param.flags.has_key("cache_size"):
kernel.set_cache_size(param.flags["cache_size"])
if param.flags.has_key("debug"):
kernel.io.set_loglevel(shogun.Kernel.MSG_DEBUG)
return kernel
def kernel_poly_modular(fm_train_real=traindat,
fm_test_real=testdat,
degree=4,
inhomogene=False,
use_normalization=True):
from shogun.Features import RealFeatures
from shogun.Kernel import PolyKernel
feats_train = RealFeatures(fm_train_real)
feats_test = RealFeatures(fm_test_real)
kernel = PolyKernel(feats_train, feats_train, degree, inhomogene,
use_normalization)
km_train = kernel.get_kernel_matrix()
kernel.init(feats_train, feats_test)
km_test = kernel.get_kernel_matrix()
return km_train, km_test, kernel
def kernel_sparse_poly_modular (fm_train_real=traindat,fm_test_real=testdat, size_cache=10,degree=3,inhomogene=True ): from shogun.Features import SparseRealFeatures from shogun.Kernel import PolyKernel feats_train=SparseRealFeatures(fm_train_real) feats_test=SparseRealFeatures(fm_test_real) kernel=PolyKernel(feats_train, feats_train, size_cache, degree, inhomogene) km_train=kernel.get_kernel_matrix() kernel.init(feats_train, feats_test) km_test=kernel.get_kernel_matrix() return km_train,km_test,kernel
def mkl_binclass_modular(fm_train_real=traindat, fm_test_real=testdat, fm_label_twoclass=label_traindat):
##################################
# set up and train
# create some poly train/test matrix
tfeats = RealFeatures(fm_train_real)
tkernel = PolyKernel(10, 3)
tkernel.init(tfeats, tfeats)
K_train = tkernel.get_kernel_matrix()
pfeats = RealFeatures(fm_test_real)
tkernel.init(tfeats, pfeats)
K_test = tkernel.get_kernel_matrix()
# create combined train features
feats_train = CombinedFeatures()
feats_train.append_feature_obj(RealFeatures(fm_train_real))
# and corresponding combined kernel
kernel = CombinedKernel()
kernel.append_kernel(CustomKernel(K_train))
kernel.append_kernel(PolyKernel(10, 2))
kernel.init(feats_train, feats_train)
# train mkl
labels = BinaryLabels(fm_label_twoclass)
mkl = MKLClassification()
# which norm to use for MKL
mkl.set_mkl_norm(1) # 2,3
# set cost (neg, pos)
mkl.set_C(1, 1)
# set kernel and labels
mkl.set_kernel(kernel)
mkl.set_labels(labels)
# train
mkl.train()
# w=kernel.get_subkernel_weights()
# kernel.set_subkernel_weights(w)
##################################
# test
# create combined test features
feats_pred = CombinedFeatures()
feats_pred.append_feature_obj(RealFeatures(fm_test_real))
# and corresponding combined kernel
kernel = CombinedKernel()
kernel.append_kernel(CustomKernel(K_test))
kernel.append_kernel(PolyKernel(10, 2))
kernel.init(feats_train, feats_pred)
# and classify
mkl.set_kernel(kernel)
mkl.apply()
return mkl.apply(), kernel
def kernel_combined_custom_poly_modular(fm_train_real = traindat,fm_test_real = testdat,fm_label_twoclass=label_traindat):
from shogun.Features import CombinedFeatures, RealFeatures, BinaryLabels
from shogun.Kernel import CombinedKernel, PolyKernel, CustomKernel
from shogun.Classifier import LibSVM
kernel = CombinedKernel()
feats_train = CombinedFeatures()
tfeats = RealFeatures(fm_train_real)
tkernel = PolyKernel(10,3)
tkernel.init(tfeats, tfeats)
K = tkernel.get_kernel_matrix()
kernel.append_kernel(CustomKernel(K))
subkfeats_train = RealFeatures(fm_train_real)
feats_train.append_feature_obj(subkfeats_train)
subkernel = PolyKernel(10,2)
kernel.append_kernel(subkernel)
kernel.init(feats_train, feats_train)
labels = BinaryLabels(fm_label_twoclass)
svm = LibSVM(1.0, kernel, labels)
svm.train()
kernel = CombinedKernel()
feats_pred = CombinedFeatures()
pfeats = RealFeatures(fm_test_real)
tkernel = PolyKernel(10,3)
tkernel.init(tfeats, pfeats)
K = tkernel.get_kernel_matrix()
kernel.append_kernel(CustomKernel(K))
subkfeats_test = RealFeatures(fm_test_real)
feats_pred.append_feature_obj(subkfeats_test)
subkernel = PolyKernel(10, 2)
kernel.append_kernel(subkernel)
kernel.init(feats_train, feats_pred)
svm.set_kernel(kernel)
svm.apply()
km_train=kernel.get_kernel_matrix()
return km_train,kernel
def mkl_binclass_modular(fm_train_real=traindat,
fm_test_real=testdat,
fm_label_twoclass=label_traindat):
##################################
# set up and train
# create some poly train/test matrix
tfeats = RealFeatures(fm_train_real)
tkernel = PolyKernel(10, 3)
tkernel.init(tfeats, tfeats)
K_train = tkernel.get_kernel_matrix()
pfeats = RealFeatures(fm_test_real)
tkernel.init(tfeats, pfeats)
K_test = tkernel.get_kernel_matrix()
# create combined train features
feats_train = CombinedFeatures()
feats_train.append_feature_obj(RealFeatures(fm_train_real))
# and corresponding combined kernel
kernel = CombinedKernel()
kernel.append_kernel(CustomKernel(K_train))
kernel.append_kernel(PolyKernel(10, 2))
kernel.init(feats_train, feats_train)
# train mkl
labels = BinaryLabels(fm_label_twoclass)
mkl = MKLClassification()
# which norm to use for MKL
mkl.set_mkl_norm(1) #2,3
# set cost (neg, pos)
mkl.set_C(1, 1)
# set kernel and labels
mkl.set_kernel(kernel)
mkl.set_labels(labels)
# train
mkl.train()
#w=kernel.get_subkernel_weights()
#kernel.set_subkernel_weights(w)
##################################
# test
# create combined test features
feats_pred = CombinedFeatures()
feats_pred.append_feature_obj(RealFeatures(fm_test_real))
# and corresponding combined kernel
kernel = CombinedKernel()
kernel.append_kernel(CustomKernel(K_test))
kernel.append_kernel(PolyKernel(10, 2))
kernel.init(feats_train, feats_pred)
# and classify
mkl.set_kernel(kernel)
mkl.apply()
return mkl.apply(), kernel
def RunKPCAShogun(q):
totalTimer = Timer()
try:
# Load input dataset.
Log.Info("Loading dataset", self.verbose)
data = np.genfromtxt(self.dataset, delimiter=',')
dataFeat = RealFeatures(data.T)
with totalTimer:
# Get the new dimensionality, if it is necessary.
dimension = re.search('-d (\d+)', options)
if not dimension:
d = data.shape[1]
else:
d = int(dimension.group(1))
if (d > data.shape[1]):
Log.Fatal("New dimensionality (" + str(d) +
") cannot be greater " +
"than existing dimensionality (" +
str(data.shape[1]) + ")!")
q.put(-1)
return -1
# Get the kernel type and make sure it is valid.
kernel = re.search("-k ([^\s]+)", options)
if not kernel:
Log.Fatal(
"Choose kernel type, valid choices are 'linear'," +
" 'hyptan', 'polynomial' and 'gaussian'.")
q.put(-1)
return -1
elif kernel.group(1) == "polynomial":
degree = re.search('-D (\d+)', options)
degree = 1 if not degree else int(degree.group(1))
kernel = PolyKernel(dataFeat, dataFeat, degree, True)
elif kernel.group(1) == "gaussian":
kernel = GaussianKernel(dataFeat, dataFeat, 2.0)
elif kernel.group(1) == "linear":
kernel = LinearKernel(dataFeat, dataFeat)
elif kernel.group(1) == "hyptan":
kernel = SigmoidKernel(dataFeat, dataFeat, 2, 1.0, 1.0)
else:
Log.Fatal(
"Invalid kernel type (" + kernel.group(1) +
"); valid " +
"choices are 'linear', 'hyptan', 'polynomial' and 'gaussian'."
)
q.put(-1)
return -1
# Perform Kernel Principal Components Analysis.
model = KernelPCA(kernel)
model.set_target_dim(d)
model.init(dataFeat)
model.apply_to_feature_matrix(dataFeat)
except Exception as e:
q.put(-1)
return -1
time = totalTimer.ElapsedTime()
q.put(time)
return time
