def _compute_pie(feats, params):
"""Compute a kernel with PluginEstimate.
@param feats kernel features
@param params dict containing various kernel parameters
"""
output = fileop.get_output(category.KERNEL, params)
lab, labels = dataop.get_labels(feats["train"].get_num_vectors())
output["classifier_labels"] = lab
pie = PluginEstimate()
pie.set_labels(labels)
pie.set_features(feats["train"])
pie.train()
kfun = eval("kernel." + params["name"] + "Kernel")
kern = kfun(feats["train"], feats["train"], pie)
output["kernel_matrix_train"] = kern.get_kernel_matrix()
kern.init(feats["train"], feats["test"])
pie.set_features(feats["test"])
output["kernel_matrix_test"] = kern.get_kernel_matrix()
classified = pie.apply().get_labels()
output["classifier_classified"] = classified
fileop.write(category.KERNEL, output)
def _compute_pie(feats, params):
"""Compute a kernel with PluginEstimate.
@param feats kernel features
@param params dict containing various kernel parameters
"""
output = fileop.get_output(category.KERNEL, params)
lab, labels = dataop.get_labels(feats['train'].get_num_vectors())
output['classifier_labels'] = lab
pie = PluginEstimate()
pie.set_labels(labels)
pie.set_features(feats['train'])
pie.train()
kfun = eval('kernel.' + params['name'] + 'Kernel')
kern = kfun(feats['train'], feats['train'], pie)
output['kernel_matrix_train'] = kern.get_kernel_matrix()
kern.init(feats['train'], feats['test'])
pie.set_features(feats['test'])
output['kernel_matrix_test'] = kern.get_kernel_matrix()
classified = pie.classify().get_labels()
output['classifier_classified'] = classified
fileop.write(category.KERNEL, output)
def _run_lda ():
"""Run Linear Discriminant Analysis classifier."""
params={
'name': 'LDA',
'type': 'lda',
'gamma': 0.1,
'num_threads': 1,
'data': dataop.get_clouds(2),
'feature_class': 'simple',
'feature_type': 'Real',
'label_type': 'twoclass',
'accuracy': 1e-7
}
feats=featop.get_features(
params['feature_class'], params['feature_type'], params['data'])
params['labels'], labels=dataop.get_labels(
feats['train'].get_num_vectors(), params['label_type'])
lda=classifier.LDA(params['gamma'], feats['train'], labels)
lda.parallel.set_num_threads(params['num_threads'])
lda.train()
lda.set_features(feats['test'])
params['classified']=lda.classify().get_labels()
output=fileop.get_output(category.CLASSIFIER, params)
fileop.write(category.CLASSIFIER, output)
def _run_perceptron ():
"""Run Perceptron classifier."""
params={
'name': 'Perceptron',
'type': 'perceptron',
'num_threads': 1,
'learn_rate': .1,
'max_iter': 1000,
'data': dataop.get_clouds(2),
'feature_class': 'simple',
'feature_type': 'Real',
'label_type': 'twoclass',
'accuracy': 1e-7
}
feats=featop.get_features(
params['feature_class'], params['feature_type'], params['data'])
num_vec=feats['train'].get_num_vectors()
params['labels'], labels=dataop.get_labels(num_vec, params['label_type'])
perceptron=classifier.Perceptron(feats['train'], labels)
perceptron.parallel.set_num_threads(params['num_threads'])
perceptron.set_learn_rate(params['learn_rate'])
perceptron.set_max_iter(params['max_iter'])
perceptron.train()
params['bias']=perceptron.get_bias()
perceptron.set_features(feats['test'])
params['classified']=perceptron.classify().get_labels()
output=fileop.get_output(category.CLASSIFIER, params)
fileop.write(category.CLASSIFIER, output)
def _compute_pie (feats, params):
"""Compute a kernel with PluginEstimate.
@param feats kernel features
@param params dict containing various kernel parameters
"""
output=fileop.get_output(category.KERNEL, params)
lab, labels=dataop.get_labels(feats['train'].get_num_vectors())
output['classifier_labels']=lab
pie=PluginEstimate()
pie.set_labels(labels)
pie.set_features(feats['train'])
pie.train()
kfun=eval('kernel.'+params['name']+'Kernel')
kern=kfun(feats['train'], feats['train'], pie)
output['kernel_matrix_train']=kern.get_kernel_matrix()
kern.init(feats['train'], feats['test'])
pie.set_features(feats['test'])
output['kernel_matrix_test']=kern.get_kernel_matrix()
classified=pie.classify().get_labels()
output['classifier_classified']=classified
fileop.write(category.KERNEL, output)
def _compute(params, feats, kernel, pout):
"""
Compute a regression and gather result data.
@param params misc parameters for the regression method
@param feats features of the kernel/regression
@param kernel kernel
@param pout previously gathered data from kernel ready to be written to file
"""
kernel.parallel.set_num_threads(params['num_threads'])
kernel.init(feats['train'], feats['train'])
params['labels'], labels = dataop.get_labels(
feats['train'].get_num_vectors())
try:
fun = eval('regression.' + params['name'])
except AttributeError:
return
if params['type'] == 'svm':
regression = fun(params['C'], params['epsilon'], kernel, labels)
regression.set_tube_epsilon(params['tube_epsilon'])
else:
regression = fun(params['tau'], kernel, labels)
regression.parallel.set_num_threads(params['num_threads'])
regression.train()
if params['type'] == 'svm':
params['bias'] = regression.get_bias()
params['alpha_sum'] = 0
for item in regression.get_alphas().tolist():
params['alpha_sum'] += item
params['sv_sum'] = 0
for item in regression.get_support_vectors():
params['sv_sum'] += item
kernel.init(feats['train'], feats['test'])
params['classified'] = regression.classify().get_labels()
output = pout.copy()
output.update(fileop.get_output(category.REGRESSION, params))
fileop.write(category.REGRESSION, output)
def _compute (params, feats, kernel, pout):
"""
Compute a regression and gather result data.
@param params misc parameters for the regression method
@param feats features of the kernel/regression
@param kernel kernel
@param pout previously gathered data from kernel ready to be written to file
"""
kernel.parallel.set_num_threads(params['num_threads'])
kernel.init(feats['train'], feats['train'])
params['labels'], labels=dataop.get_labels(feats['train'].get_num_vectors())
try:
fun=eval('regression.'+params['name'])
except AttributeError:
return
if params['type']=='svm':
regression=fun(params['C'], params['epsilon'], kernel, labels)
regression.set_tube_epsilon(params['tube_epsilon'])
else:
regression=fun(params['tau'], kernel, labels)
regression.parallel.set_num_threads(params['num_threads'])
regression.train()
if params['type']=='svm':
params['bias']=regression.get_bias()
params['alpha_sum']=0
for item in regression.get_alphas().tolist():
params['alpha_sum']+=item
params['sv_sum']=0
for item in regression.get_support_vectors():
params['sv_sum']+=item
kernel.init(feats['train'], feats['test'])
params['classified']=regression.apply().get_labels()
output=pout.copy()
output.update(fileop.get_output(category.REGRESSION, params))
fileop.write(category.REGRESSION, output)
def _loop_svm (svms, params, feats, kernel=None, pout=None):
"""Loop through SVM computations, only slightly differing in parameters.
Loop through SVM computations with little variations in the parameters for
the SVM. Not necessarily used by all SVMs in this generator.
@param svms tuple of SVM names to loop through
@param params parameters to the SVMs
@param feats features to the SVMs
@param kernel kernel for kernel-based SVMs
@param pout previously gathered output data ready to be written to file
"""
for name in svms:
parms={ 'name': name, 'num_threads': 1, 'C': .017, 'epsilon': 1e-5 }
parms['accuracy']=parms['epsilon']*10
parms.update(params)
if params['label_type'] is not None:
parms['labels'], labels=dataop.get_labels(
feats['train'].get_num_vectors(), params['label_type'])
else:
labels=None
_compute_svm(parms, labels, feats, kernel, pout)
parms['C']=.23
_compute_svm(parms, labels, feats, kernel, pout)
parms['C']=1.5
_compute_svm(parms, labels, feats, kernel, pout)
parms['C']=30
_compute_svm(parms, labels, feats, kernel, pout)
if params['type']=='kernel':
_compute_svm(parms, labels, feats, kernel, pout)
parms['num_threads']=16
_compute_svm(parms, labels, feats, kernel, pout)
def _run_knn ():
"""Run K-Nearest-Neighbour classifier.
"""
params={
'name': 'EuclidianDistance',
'data': dataop.get_clouds(2),
'feature_class': 'simple',
'feature_type': 'Real'
}
feats=featop.get_features(
params['feature_class'], params['feature_type'], params['data'])
dfun=eval(params['name'])
distance=dfun(feats['train'], feats['train'])
output=fileop.get_output(category.DISTANCE, params)
params={
'name': 'KNN',
'type': 'knn',
'num_threads': 1,
'k': 3,
'label_type': 'twoclass',
'accuracy': 1e-8
}
params['labels'], labels=dataop.get_labels(
feats['train'].get_num_vectors(), params['label_type'])
knn=classifier.KNN(params['k'], distance, labels)
knn.parallel.set_num_threads(params['num_threads'])
knn.train()
distance.init(feats['train'], feats['test'])
params['classified']=knn.classify().get_labels()
output.update(fileop.get_output(category.CLASSIFIER, params))
fileop.write(category.CLASSIFIER, output)
