docs: def svm_predict(y, x, m, options=""):
  	"""
  	svm_predict(y, x, m [, options]) -> (p_labels, p_acc, p_vals)
  
  	y: a list/tuple/ndarray of l true labels (type must be int/double).
  	   It is used for calculating the accuracy. Use [] if true labels are
  	   unavailable.
  
  	x: 1. a list/tuple of l training instances. Feature vector of
  	      each training instance is a list/tuple or dictionary.
  
  	   2. an l * n numpy ndarray or scipy spmatrix (n: number of features).
  
  	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.
  	    -q : quiet mode (no outputs).
  
  	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.
  	"""
  
  	def info(s):
  		print(s)
  
  	if scipy and isinstance(x, scipy.ndarray):
  		x = scipy.ascontiguousarray(x) # enforce row-major
  	elif sparse and isinstance(x, sparse.spmatrix):
  		x = x.tocsr()
  	elif not isinstance(x, (list, tuple)):
  		raise TypeError("type of x: {0} is not supported!".format(type(x)))
  
  	if (not isinstance(y, (list, tuple))) and (not (scipy and isinstance(y, scipy.ndarray))):
  		raise TypeError("type of y: {0} is not supported!".format(type(y)))
  
  	predict_probability = 0
  	argv = options.split()
  	i = 0
  	while i < len(argv):
  		if argv[i] == '-b':
  			i += 1
  			predict_probability = int(argv[i])
  		elif argv[i] == '-q':
  			info = print_null
  		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 scipy and isinstance(x, sparse.spmatrix):
  		nr_instance = x.shape[0]
  	else:
  		nr_instance = len(x)
  
  	if predict_probability:
  		if not is_prob_model:
  			raise ValueError("Model does not support probabiliy estimates")
  
  		if svm_type in [NU_SVR, EPSILON_SVR]:
  			info("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 i in range(nr_instance):
  			if scipy and isinstance(x, sparse.spmatrix):
  				indslice = slice(x.indptr[i], x.indptr[i+1])
  				xi, idx = gen_svm_nodearray((x.indices[indslice], x.data[indslice]), isKernel=(m.param.kernel_type == PRECOMPUTED))
  			else:
  				xi, idx = gen_svm_nodearray(x[i], isKernel=(m.param.kernel_type == PRECOMPUTED))
  			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:
  			info("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 i in range(nr_instance):
  			if scipy and isinstance(x, sparse.spmatrix):
  				indslice = slice(x.indptr[i], x.indptr[i+1])
  				xi, idx = gen_svm_nodearray((x.indices[indslice], x.data[indslice]), isKernel=(m.param.kernel_type == PRECOMPUTED))
  			else:
  				xi, idx = gen_svm_nodearray(x[i], isKernel=(m.param.kernel_type == PRECOMPUTED))
  			label = libsvm.svm_predict_values(m, xi, dec_values)
  			if(nr_class == 1):
  				values = [1]
  			else:
  				values = dec_values[:nr_classifier]
  			pred_labels += [label]
  			pred_values += [values]
  
  	if len(y) == 0:
  		y = [0] * nr_instance
  	ACC, MSE, SCC = evaluations(y, pred_labels)
  
  	if svm_type in [EPSILON_SVR, NU_SVR]:
  		info("Mean squared error = %g (regression)" % MSE)
  		info("Squared correlation coefficient = %g (regression)" % SCC)
  	else:
  		info("Accuracy = %g%% (%d/%d) (classification)" % (ACC, int(round(nr_instance*ACC/100)), nr_instance))
  
  	return pred_labels, (ACC, MSE, SCC), pred_values