def kernel_sigmoid_modular(train_fname=traindat, test_fname=testdat, size_cache=10, gamma=1.2, coef0=1.3):
from modshogun import RealFeatures, SigmoidKernel, CSVFile
feats_train = RealFeatures(CSVFile(train_fname))
feats_test = RealFeatures(CSVFile(test_fname))
kernel = SigmoidKernel(feats_train, feats_train, size_cache, gamma, coef0)
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 BuildModel(self, data, labels, options):
k = re.search("-k ([^\s]+)", options)
c = re.search("-c (\d+)", options)
g = re.search("-g (\d+)", options)
self.C = 1.0 if not c else float(c.group(1))
self.gamma = 0.0 if not g else float(g.group(1))
if not k or k.group(1) == "gaussian":
self.kernel = GaussianKernel(data, data, 1)
elif k.group(1) == "polynomial":
d = re.search('-D (\d+)', options)
d = 1 if not d else int(d.group(1))
self.kernel = PolyKernel(data, data, d, True)
elif k.group(1) == "linear":
self.kernel = LinearKernel(data, data)
elif k.group(1) == "hyptan":
self.kernel = SigmoidKernel(data, data, 2, 1.0, 1.0)
else:
self.kernel = GaussianKernel(data, data, 1)
# Create and train the classifier.
svm = LibSvm(self.C, self.kernel, labels)
svm.train()
return svm
def RunKPCAShogun():
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.
if "new_dimensionality" in options:
d = int(options.pop("new_dimensionality"))
if (d > data.shape[1]):
Log.Fatal("New dimensionality (" + str(d) + ") cannot be greater "
+ "than existing dimensionality (" + str(data.shape[1]) + ")!")
return -1
else:
d = data.shape[1]
# Get the kernel type and make sure it is valid.
if "kernel" in options:
kernel = str(options.pop("kernel"))
else:
Log.Fatal("Choose kernel type, valid choices are 'linear'," +
" 'hyptan', 'polynomial' and 'gaussian'.")
return -1
if "degree" in options:
degree = int(options.pop("degree"))
if len(options) > 0:
Log.Fatal("Unknown parameters: " + str(options))
raise Exception("unknown parameters")
if kernel == "polynomial":
kernel = PolyKernel(dataFeat, dataFeat, degree, True)
elif kernel == "gaussian":
kernel = GaussianKernel(dataFeat, dataFeat, 2.0)
elif kernel == "linear":
kernel = LinearKernel(dataFeat, dataFeat)
elif kernel == "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'.")
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:
return -1
return totalTimer.ElapsedTime()
def evaluate4svm(labels, feats, params={'c': 1, 'kernal': 'gauss'}, Nsplit=2):
"""
Run Cross-validation to evaluate the SVM.
Parameters
----------
labels: 2d array
Data set labels.
feats: array
Data set feats.
params: dictionary
Search scope parameters.
Nsplit: int, default = 2
The n for n-fold cross validation.
"""
c = params.get('c')
if params.get('kernal' == 'gauss'):
kernal = GaussianKernel()
kernal.set_width(80)
elif params.get('kernal' == 'sigmoid'):
kernal = SigmoidKernel()
else:
kernal = LinearKernel()
split = CrossValidationSplitting(labels, Nsplit)
split.build_subsets()
accuracy = np.zeros(Nsplit)
time_test = np.zeros(accuracy.shape)
for i in range(Nsplit):
idx_train = split.generate_subset_inverse(i)
idx_test = split.generate_subset_indices(i)
feats.add_subset(idx_train)
labels.add_subset(idx_train)
print c, kernal, labels
svm = GMNPSVM(c, kernal, labels)
_ = svm.train(feats)
out = svm.apply(feats_test)
evaluator = MulticlassAccuracy()
accuracy[i] = evaluator.evaluate(out, labels_test)
feats.remove_subset()
labels.remove_subset()
feats.add_subset(idx_test)
labels.add_subset(idx_test)
t_start = time.clock()
time_test[i] = (time.clock() - t_start) / labels.get_num_labels()
feats.remove_subset()
labels.remove_subset()
return accuracy
def kernel_sigmoid_modular(train_fname=traindat,
test_fname=testdat,
size_cache=10,
gamma=1.2,
coef0=1.3):
from modshogun import RealFeatures, SigmoidKernel, CSVFile
feats_train = RealFeatures(CSVFile(train_fname))
feats_test = RealFeatures(CSVFile(test_fname))
kernel = SigmoidKernel(feats_train, feats_train, size_cache, gamma, coef0)
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 BuildModel(self, data, labels, options):
if "kernel" in options:
k = str(options.pop("kernel"))
else:
Log.Fatal("Required parameter 'kernel' not specified!")
raise Exception("missing parameter")
if "c" in options:
self.C = float(options.pop("c"))
if "gamma" in options:
self.gamma = float(options.pop("gamma"))
if k == "gaussian":
self.kernel = GaussianKernel(data, data, 1)
elif k == "polynomial":
if "degree" in options:
d = int(options.pop("degree"))
else:
d = 1
self.kernel = PolyKernel(data, data, d, True)
elif k == "linear":
self.kernel = LinearKernel(data, data)
elif k == "hyptan":
self.kernel = SigmoidKernel(data, data, 2, 1.0, 1.0)
else:
self.kernel = GaussianKernel(data, data, 1)
if len(options) > 0:
Log.Fatal("Unknown parameters: " + str(options))
raise Exception("unknown parameters")
# Create and train the classifier.
svm = LibSvm(self.C, self.kernel, labels)
svm.train()
return svm
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