docs: def svm_train(arg1, arg2=None, arg3=None):
  	"""
  	svm_train(y, x [, options]) -> model | ACC | MSE
  
  	y: a list/tuple/ndarray of l true labels (type must be int/double).
  
  	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).
  
  	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		(multi-class classification)
  	        1 -- nu-SVC		(multi-class classification)
  	        2 -- one-class SVM
  	        3 -- epsilon-SVR	(regression)
  	        4 -- nu-SVR		(regression)
  	    -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)) or (scipy and isinstance(arg1, scipy.ndarray)):
  		assert isinstance(arg2, (list, tuple)) or (scipy and isinstance(arg2, (scipy.ndarray, sparse.spmatrix)))
  		y, x, options = arg1, arg2, arg3
  		param = svm_parameter(options)
  		prob = svm_problem(y, x, isKernel=(param.kernel_type == PRECOMPUTED))
  	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 i in range(prob.l):
  			xi = prob.x[i]
  			idx, val = xi[0].index, xi[0].value
  			if idx != 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