eluka 0.1.0

data/ext/libsvm/python/svm.py

@@ -0,0 +1,259 @@
+#!/usr/bin/env python
+
+from ctypes import *
+from ctypes.util import find_library
+import sys
+
+# For unix the prefix 'lib' is not considered.
+if find_library('svm'):
+	libsvm = CDLL(find_library('svm'))
+elif find_library('libsvm'):
+	libsvm = CDLL(find_library('libsvm'))
+else:
+	if sys.platform == 'win32':
+		libsvm = CDLL('../windows/libsvm.dll')
+	else:
+		libsvm = CDLL('../libsvm.so.2')
+
+# Construct constants
+SVM_TYPE = ['C_SVC', 'NU_SVC', 'ONE_CLASS', 'EPSILON_SVR', 'NU_SVR' ]
+KERNEL_TYPE = ['LINEAR', 'POLY', 'RBF', 'SIGMOID', 'PRECOMPUTED']
+for i, s in enumerate(SVM_TYPE): exec("%s = %d" % (s , i))
+for i, s in enumerate(KERNEL_TYPE): exec("%s = %d" % (s , i))
+
+PRINT_STRING_FUN = CFUNCTYPE(None, c_char_p)
+def print_null(s): 
+	return 
+
+def genFields(names, types): 
+	return list(zip(names, types))
+
+def fillprototype(f, restype, argtypes): 
+	f.restype = restype
+	f.argtypes = argtypes
+
+class svm_node(Structure):
+	_names = ["index", "value"]
+	_types = [c_int, c_double]
+	_fields_ = genFields(_names, _types)
+
+def gen_svm_nodearray(xi, feature_max=None, issparse=None):
+	if isinstance(xi, dict):
+		index_range = xi.keys()
+	elif isinstance(xi, (list, tuple)):
+		index_range = range(len(xi))
+	else:
+		raise TypeError('xi should be a dictionary, list or tuple')
+
+	if feature_max:
+		assert(isinstance(feature_max, int))
+		index_range = filter(lambda j: j <= feature_max, index_range)
+	if issparse: 
+		index_range = filter(lambda j:xi[j] != 0, index_range)
+
+	index_range = sorted(index_range)
+	ret = (svm_node * (len(index_range)+1))()
+	ret[-1].index = -1
+	for idx, j in enumerate(index_range):
+		ret[idx].index = j
+		ret[idx].value = xi[j]
+	max_idx = 0
+	if index_range: 
+		max_idx = index_range[-1]
+	return ret, max_idx
+
+class svm_problem(Structure):
+	_names = ["l", "y", "x"]
+	_types = [c_int, POINTER(c_double), POINTER(POINTER(svm_node))]
+	_fields_ = genFields(_names, _types)
+
+	def __init__(self, y, x):
+		if len(y) != len(x):
+			raise ValueError("len(y) != len(x)")
+		self.l = l = len(y)
+
+		max_idx = 0
+		x_space = self.x_space = []
+		for i, xi in enumerate(x):
+			tmp_xi, tmp_idx = gen_svm_nodearray(xi)
+			x_space += [tmp_xi]
+			max_idx = max(max_idx, tmp_idx)
+		self.n = max_idx
+
+		self.y = (c_double * l)()
+		for i, yi in enumerate(y): self.y[i] = yi
+
+		self.x = (POINTER(svm_node) * l)() 
+		for i, xi in enumerate(self.x_space): self.x[i] = xi
+
+class svm_parameter(Structure):
+	_names = ["svm_type", "kernel_type", "degree", "gamma", "coef0",
+			"cache_size", "eps", "C", "nr_weight", "weight_label", "weight", 
+			"nu", "p", "shrinking", "probability"]
+	_types = [c_int, c_int, c_int, c_double, c_double, 
+			c_double, c_double, c_double, c_int, POINTER(c_int), POINTER(c_double),
+			c_double, c_double, c_int, c_int]
+	_fields_ = genFields(_names, _types)
+
+	def __init__(self, options = None):
+		if options == None:
+			options = ''
+		self.parse_options(options)
+
+	def show(self):
+		attrs = svm_parameter._names + self.__dict__.keys()
+		values = map(lambda attr: getattr(self, attr), attrs) 
+		for attr, val in zip(attrs, values):
+			print(' %s: %s' % (attr, val))
+
+	def set_to_default_values(self):
+		self.svm_type = C_SVC;
+		self.kernel_type = RBF
+		self.degree = 3
+		self.gamma = 0
+		self.coef0 = 0
+		self.nu = 0.5
+		self.cache_size = 100
+		self.C = 1
+		self.eps = 0.001
+		self.p = 0.1
+		self.shrinking = 1
+		self.probability = 0
+		self.nr_weight = 0
+		self.weight_label = (c_int*0)()
+		self.weight = (c_double*0)()
+		self.cross_validation = False
+		self.nr_fold = 0
+		self.print_func = None
+
+	def parse_options(self, options):
+		argv = options.split()
+		self.set_to_default_values()
+		self.print_func = cast(None, PRINT_STRING_FUN)
+		weight_label = []
+		weight = []
+
+		i = 0
+		while i < len(argv):
+			if argv[i] == "-s":
+				i = i + 1
+				self.svm_type = int(argv[i])
+			elif argv[i] == "-t":
+				i = i + 1
+				self.kernel_type = int(argv[i])
+			elif argv[i] == "-d":
+				i = i + 1
+				self.degree = int(argv[i])
+			elif argv[i] == "-g":
+				i = i + 1
+				self.gamma = float(argv[i])
+			elif argv[i] == "-r":
+				i = i + 1
+				self.coef0 = float(argv[i])
+			elif argv[i] == "-n":
+				i = i + 1
+				self.nu = float(argv[i])
+			elif argv[i] == "-m":
+				i = i + 1
+				self.cache_size = float(argv[i])
+			elif argv[i] == "-c":
+				i = i + 1
+				self.C = float(argv[i])
+			elif argv[i] == "-e":
+				i = i + 1
+				self.eps = float(argv[i])
+			elif argv[i] == "-p":
+				i = i + 1
+				self.p = float(argv[i])
+			elif argv[i] == "-h":
+				i = i + 1
+				self.shrinking = int(argv[i])
+			elif argv[i] == "-b":
+				i = i + 1
+				self.probability = int(argv[i])
+			elif argv[i] == "-q":
+				self.print_func = PRINT_STRING_FUN(print_null)
+			elif argv[i] == "-v":
+				i = i + 1
+				self.cross_validation = 1
+				self.nr_fold = int(argv[i])
+				if self.nr_fold < 2:
+					raise ValueError("n-fold cross validation: n must >= 2")
+			elif argv[i].startswith("-w"):
+				i = i + 1
+				self.nr_weight += 1
+				nr_weight = self.nr_weight
+				weight_label += [int(argv[i-1][2:])]
+				weight += [float(argv[i])]
+			else:
+				raise ValueError("Wrong options")
+			i += 1
+
+		libsvm.svm_set_print_string_function(self.print_func)
+		self.weight_label = (c_int*self.nr_weight)()
+		self.weight = (c_double*self.nr_weight)()
+		for i in range(self.nr_weight): 
+			self.weight[i] = weight[i]
+			self.weight_label[i] = weight_label[i]
+
+class svm_model(Structure):
+	def __init__(self):
+		self.__createfrom__ = 'python'
+
+	def __del__(self):
+		# free memory created by C to avoid memory leak
+		if hasattr(self, '__createfrom__') and self.__createfrom__ == 'C':
+			libsvm.svm_free_and_destroy_model(pointer(self))
+
+	def get_svm_type(self):
+		return libsvm.svm_get_svm_type(self)
+
+	def get_nr_class(self):
+		return libsvm.svm_get_nr_class(self)
+
+	def get_svr_probability(self):
+		return libsvm.svm_get_svr_probability(self)
+
+	def get_labels(self):
+		nr_class = self.get_nr_class()
+		labels = (c_int * nr_class)()
+		libsvm.svm_get_labels(self, labels)
+		return labels[:nr_class]
+
+	def is_probability_model(self):
+		return (libsvm.svm_check_probability_model(self) == 1)
+
+def toPyModel(model_ptr):
+	"""
+	toPyModel(model_ptr) -> svm_model
+
+	Convert a ctypes POINTER(svm_model) to a Python svm_model
+	"""
+	if bool(model_ptr) == False:
+		raise ValueError("Null pointer")
+	m = model_ptr.contents
+	m.__createfrom__ = 'C'
+	return m
+
+fillprototype(libsvm.svm_train, POINTER(svm_model), [POINTER(svm_problem), POINTER(svm_parameter)])
+fillprototype(libsvm.svm_cross_validation, None, [POINTER(svm_problem), POINTER(svm_parameter), c_int, POINTER(c_double)])
+
+fillprototype(libsvm.svm_save_model, c_int, [c_char_p, POINTER(svm_model)])
+fillprototype(libsvm.svm_load_model, POINTER(svm_model), [c_char_p])
+
+fillprototype(libsvm.svm_get_svm_type, c_int, [POINTER(svm_model)])
+fillprototype(libsvm.svm_get_nr_class, c_int, [POINTER(svm_model)])
+fillprototype(libsvm.svm_get_labels, None, [POINTER(svm_model), POINTER(c_int)])
+fillprototype(libsvm.svm_get_svr_probability, c_double, [POINTER(svm_model)])
+
+fillprototype(libsvm.svm_predict_values, c_double, [POINTER(svm_model), POINTER(svm_node), POINTER(c_double)])
+fillprototype(libsvm.svm_predict, c_double, [POINTER(svm_model), POINTER(svm_node)])
+fillprototype(libsvm.svm_predict_probability, c_double, [POINTER(svm_model), POINTER(svm_node), POINTER(c_double)])
+
+fillprototype(libsvm.svm_free_model_content, None, [POINTER(svm_model)])
+fillprototype(libsvm.svm_free_and_destroy_model, None, [POINTER(POINTER(svm_model))])
+fillprototype(libsvm.svm_destroy_param, None, [POINTER(svm_parameter)])
+
+fillprototype(libsvm.svm_check_parameter, c_char_p, [POINTER(svm_problem), POINTER(svm_parameter)])
+fillprototype(libsvm.svm_check_probability_model, c_int, [POINTER(svm_model)])
+fillprototype(libsvm.svm_set_print_string_function, None, [PRINT_STRING_FUN])

data/ext/libsvm/python/svmutil.py

@@ -0,0 +1,242 @@
+#!/usr/bin/env python
+
+from svm import *
+
+def svm_read_problem(data_file_name):
+	"""
+	svm_read_problem(data_file_name) -> [y, x]
+
+	Read LIBSVM-format data from data_file_name and return labels y
+	and data instances x.
+	"""
+	prob_y = []
+	prob_x = []
+	for line in open(data_file_name):
+		line = line.split(None, 1)
+		# In case an instance with all zero features
+		if len(line) == 1: line += ['']
+		label, features = line
+		xi = {}
+		for e in features.split():
+			ind, val = e.split(":")
+			xi[int(ind)] = float(val)
+		prob_y += [float(label)]
+		prob_x += [xi]
+	return (prob_y, prob_x)
+
+def svm_load_model(model_file_name):
+	"""
+	svm_load_model(model_file_name) -> model
+	
+	Load a LIBSVM model from model_file_name and return.
+	"""
+	model = libsvm.svm_load_model(model_file_name)
+	if not model: 
+		print("can't open model file %s" % model_file_name)
+		return None
+	model = toPyModel(model)
+	return model
+
+def svm_save_model(model_file_name, model):
+	"""
+	svm_save_model(model_file_name, model) -> None
+
+	Save a LIBSVM model to the file model_file_name.
+	"""
+	libsvm.svm_save_model(model_file_name, model)
+
+def evaluations(ty, pv):
+	"""
+	evaluations(ty, pv) -> (ACC, MSE, SCC)
+
+	Calculate accuracy, mean squared error and squared correlation coefficient
+	using the true values (ty) and predicted values (pv).
+	"""
+	if len(ty) != len(pv):
+		raise ValueError("len(ty) must equal to len(pv)")
+	total_correct = total_error = 0
+	sumv = sumy = sumvv = sumyy = sumvy = 0
+	for v, y in zip(pv, ty):
+		if y == v: 
+			total_correct += 1
+		total_error += (v-y)*(v-y)
+		sumv += v
+		sumy += y
+		sumvv += v*v
+		sumyy += y*y
+		sumvy += v*y 
+	l = len(ty)
+	ACC = 100.0*total_correct/l
+	MSE = total_error/l
+	try:
+		SCC = ((l*sumvy-sumv*sumy)*(l*sumvy-sumv*sumy))/((l*sumvv-sumv*sumv)*(l*sumyy-sumy*sumy))
+	except:
+		SCC = float('nan')
+	return (ACC, MSE, SCC)
+
+def svm_train(arg1, arg2=None, arg3=None):
+	"""
+	svm_train(y, x [, 'options']) -> model | ACC | MSE 
+	svm_train(prob, [, 'options']) -> model | ACC | MSE 
+	svm_train(prob, param) -> model | ACC| MSE 
+
+	Train an SVM model from data (y, x) or an svm_problem prob using
+	'options' or an svm_parameter param. 
+	If '-v' is specified in 'options' (i.e., cross validation)
+	either accuracy (ACC) or mean-squared error (MSE) is returned.
+	'options':
+	    -s svm_type : set type of SVM (default 0)
+	        0 -- C-SVC
+	        1 -- nu-SVC
+	        2 -- one-class SVM
+	        3 -- epsilon-SVR
+	        4 -- nu-SVR
+	    -t kernel_type : set type of kernel function (default 2)
+	        0 -- linear: u'*v
+	        1 -- polynomial: (gamma*u'*v + coef0)^degree
+	        2 -- radial basis function: exp(-gamma*|u-v|^2)
+	        3 -- sigmoid: tanh(gamma*u'*v + coef0)
+	        4 -- precomputed kernel (kernel values in training_set_file)
+	    -d degree : set degree in kernel function (default 3)
+	    -g gamma : set gamma in kernel function (default 1/num_features)
+	    -r coef0 : set coef0 in kernel function (default 0)
+	    -c cost : set the parameter C of C-SVC, epsilon-SVR, and nu-SVR (default 1)
+	    -n nu : set the parameter nu of nu-SVC, one-class SVM, and nu-SVR (default 0.5)
+	    -p epsilon : set the epsilon in loss function of epsilon-SVR (default 0.1)
+	    -m cachesize : set cache memory size in MB (default 100)
+	    -e epsilon : set tolerance of termination criterion (default 0.001)
+	    -h shrinking : whether to use the shrinking heuristics, 0 or 1 (default 1)
+	    -b probability_estimates : whether to train a SVC or SVR model for probability estimates, 0 or 1 (default 0)
+	    -wi weight : set the parameter C of class i to weight*C, for C-SVC (default 1)
+	    -v n: n-fold cross validation mode
+	    -q : quiet mode (no outputs)
+	"""
+	prob, param = None, None
+	if isinstance(arg1, (list, tuple)):
+		assert isinstance(arg2, (list, tuple))
+		y, x, options = arg1, arg2, arg3
+		prob = svm_problem(y, x)
+		param = svm_parameter(options)
+	elif isinstance(arg1, svm_problem):
+		prob = arg1
+		if isinstance(arg2, svm_parameter):
+			param = arg2
+		else:
+			param = svm_parameter(arg2)
+	if prob == None or param == None:
+		raise TypeError("Wrong types for the arguments")
+
+	if param.kernel_type == PRECOMPUTED:
+		for xi in prob.x_space:
+			idx, val = xi[0].index, xi[0].value
+			if xi[0].index != 0:
+				raise ValueError('Wrong input format: first column must be 0:sample_serial_number')
+			if val <= 0 or val > prob.n:
+				raise ValueError('Wrong input format: sample_serial_number out of range')
+
+	if param.gamma == 0 and prob.n > 0: 
+		param.gamma = 1.0 / prob.n
+	libsvm.svm_set_print_string_function(param.print_func)
+	err_msg = libsvm.svm_check_parameter(prob, param)
+	if err_msg:
+		raise ValueError('Error: %s' % err_msg)
+
+	if param.cross_validation:
+		l, nr_fold = prob.l, param.nr_fold
+		target = (c_double * l)()
+		libsvm.svm_cross_validation(prob, param, nr_fold, target)	
+		ACC, MSE, SCC = evaluations(prob.y[:l], target[:l])
+		if param.svm_type in [EPSILON_SVR, NU_SVR]:
+			print("Cross Validation Mean squared error = %g" % MSE)
+			print("Cross Validation Squared correlation coefficient = %g" % SCC)
+			return MSE
+		else:
+			print("Cross Validation Accuracy = %g%%" % ACC)
+			return ACC
+	else:
+		m = libsvm.svm_train(prob, param)
+		m = toPyModel(m)
+
+		# If prob is destroyed, data including SVs pointed by m can remain.
+		m.x_space = prob.x_space
+		return m
+
+def svm_predict(y, x, m, options=""):
+	"""
+	svm_predict(y, x, m [, "options"]) -> (p_labels, p_acc, p_vals)
+
+	Predict data (y, x) with the SVM model m. 
+	"options": 
+	    -b probability_estimates: whether to predict probability estimates, 
+	        0 or 1 (default 0); for one-class SVM only 0 is supported.
+
+	The return tuple contains
+	p_labels: a list of predicted labels
+	p_acc: a tuple including  accuracy (for classification), mean-squared 
+	       error, and squared correlation coefficient (for regression).
+	p_vals: a list of decision values or probability estimates (if '-b 1' 
+	        is specified). If k is the number of classes, for decision values,
+	        each element includes results of predicting k(k-1)/2 binary-class
+	        SVMs. For probabilities, each element contains k values indicating
+	        the probability that the testing instance is in each class.
+	        Note that the order of classes here is the same as 'model.label'
+	        field in the model structure.
+	"""
+	predict_probability = 0
+	argv = options.split()
+	i = 0
+	while i < len(argv):
+		if argv[i] == '-b':
+			i += 1
+			predict_probability = int(argv[i])
+		else:
+			raise ValueError("Wrong options")
+		i+=1
+
+	svm_type = m.get_svm_type()
+	is_prob_model = m.is_probability_model()
+	nr_class = m.get_nr_class()
+	pred_labels = []
+	pred_values = []
+
+	if predict_probability:
+		if not is_prob_model:
+			raise ValueError("Model does not support probabiliy estimates")
+
+		if svm_type in [NU_SVR, EPSILON_SVR]:
+			print("Prob. model for test data: target value = predicted value + z,\n"
+			"z: Laplace distribution e^(-|z|/sigma)/(2sigma),sigma=%g" % m.get_svr_probability());
+			nr_class = 0
+
+		prob_estimates = (c_double * nr_class)()
+		for xi in x:
+			xi, idx = gen_svm_nodearray(xi)
+			label = libsvm.svm_predict_probability(m, xi, prob_estimates)
+			values = prob_estimates[:nr_class]
+			pred_labels += [label]
+			pred_values += [values]
+	else:
+		if is_prob_model:
+			print("Model supports probability estimates, but disabled in predicton.")
+		if svm_type in (ONE_CLASS, EPSILON_SVR, NU_SVC):
+			nr_classifier = 1
+		else:
+			nr_classifier = nr_class*(nr_class-1)//2
+		dec_values = (c_double * nr_classifier)()
+		for xi in x:
+			xi, idx = gen_svm_nodearray(xi)
+			label = libsvm.svm_predict_values(m, xi, dec_values)
+			values = dec_values[:nr_classifier]
+			pred_labels += [label]
+			pred_values += [values]
+
+	ACC, MSE, SCC = evaluations(y, pred_labels)
+	l = len(y)
+	if svm_type in [EPSILON_SVR, NU_SVR]:
+		print("Mean squared error = %g (regression)" % MSE)
+		print("Squared correlation coefficient = %g (regression)" % SCC)
+	else:
+		print("Accuracy = %g%% (%d/%d) (classification)" % (ACC, int(l*ACC/100), l))
+
+	return pred_labels, (ACC, MSE, SCC), pred_values
+