New translations grid.py (Chinese Simplified)

lang/zh/gklearn/gedlib/lib/libsvm.3.22/tools/grid.py

@@ -0,0 +1,500 @@
+#!/usr/bin/env python
+__all__ = ['find_parameters']
+
+import os, sys, traceback, getpass, time, re
+from threading import Thread
+from subprocess import *
+
+if sys.version_info[0] < 3:
+	from Queue import Queue
+else:
+	from queue import Queue
+
+telnet_workers = []
+ssh_workers = []
+nr_local_worker = 1
+
+class GridOption:
+	def __init__(self, dataset_pathname, options):
+		dirname = os.path.dirname(__file__)
+		if sys.platform != 'win32':
+			self.svmtrain_pathname = os.path.join(dirname, '../svm-train')
+			self.gnuplot_pathname = '/usr/bin/gnuplot'
+		else:
+			# example for windows
+			self.svmtrain_pathname = os.path.join(dirname, r'..\windows\svm-train.exe')
+			# svmtrain_pathname = r'c:\Program Files\libsvm\windows\svm-train.exe'
+			self.gnuplot_pathname = r'c:\tmp\gnuplot\binary\pgnuplot.exe'
+		self.fold = 5
+		self.c_begin, self.c_end, self.c_step = -5,  15,  2
+		self.g_begin, self.g_end, self.g_step =  3, -15, -2
+		self.grid_with_c, self.grid_with_g = True, True
+		self.dataset_pathname = dataset_pathname
+		self.dataset_title = os.path.split(dataset_pathname)[1]
+		self.out_pathname = '{0}.out'.format(self.dataset_title)
+		self.png_pathname = '{0}.png'.format(self.dataset_title)
+		self.pass_through_string = ' '
+		self.resume_pathname = None
+		self.parse_options(options)
+
+	def parse_options(self, options):
+		if type(options) == str:
+			options = options.split()
+		i = 0
+		pass_through_options = []
+		
+		while i < len(options):
+			if options[i] == '-log2c':
+				i = i + 1
+				if options[i] == 'null':
+					self.grid_with_c = False
+				else:
+					self.c_begin, self.c_end, self.c_step = map(float,options[i].split(','))
+			elif options[i] == '-log2g':
+				i = i + 1
+				if options[i] == 'null':
+					self.grid_with_g = False
+				else:
+					self.g_begin, self.g_end, self.g_step = map(float,options[i].split(','))
+			elif options[i] == '-v':
+				i = i + 1
+				self.fold = options[i]
+			elif options[i] in ('-c','-g'):
+				raise ValueError('Use -log2c and -log2g.')
+			elif options[i] == '-svmtrain':
+				i = i + 1
+				self.svmtrain_pathname = options[i]
+			elif options[i] == '-gnuplot':
+				i = i + 1
+				if options[i] == 'null':
+					self.gnuplot_pathname = None
+				else:	
+					self.gnuplot_pathname = options[i]
+			elif options[i] == '-out':
+				i = i + 1
+				if options[i] == 'null':
+					self.out_pathname = None
+				else:
+					self.out_pathname = options[i]
+			elif options[i] == '-png':
+				i = i + 1
+				self.png_pathname = options[i]
+			elif options[i] == '-resume':
+				if i == (len(options)-1) or options[i+1].startswith('-'):
+					self.resume_pathname = self.dataset_title + '.out'
+				else:
+					i = i + 1
+					self.resume_pathname = options[i]
+			else:
+				pass_through_options.append(options[i])
+			i = i + 1
+
+		self.pass_through_string = ' '.join(pass_through_options)
+		if not os.path.exists(self.svmtrain_pathname):
+			raise IOError('svm-train executable not found')
+		if not os.path.exists(self.dataset_pathname):
+			raise IOError('dataset not found')
+		if self.resume_pathname and not os.path.exists(self.resume_pathname):
+			raise IOError('file for resumption not found')
+		if not self.grid_with_c and not self.grid_with_g:
+			raise ValueError('-log2c and -log2g should not be null simultaneously')
+		if self.gnuplot_pathname and not os.path.exists(self.gnuplot_pathname):
+			sys.stderr.write('gnuplot executable not found\n')
+			self.gnuplot_pathname = None
+
+def redraw(db,best_param,gnuplot,options,tofile=False):
+	if len(db) == 0: return
+	begin_level = round(max(x[2] for x in db)) - 3
+	step_size = 0.5
+
+	best_log2c,best_log2g,best_rate = best_param
+
+	# if newly obtained c, g, or cv values are the same,
+	# then stop redrawing the contour.
+	if all(x[0] == db[0][0]  for x in db): return
+	if all(x[1] == db[0][1]  for x in db): return
+	if all(x[2] == db[0][2]  for x in db): return
+
+	if tofile:
+		gnuplot.write(b"set term png transparent small linewidth 2 medium enhanced\n")
+		gnuplot.write("set output \"{0}\"\n".format(options.png_pathname.replace('\\','\\\\')).encode())
+		#gnuplot.write(b"set term postscript color solid\n")
+		#gnuplot.write("set output \"{0}.ps\"\n".format(options.dataset_title).encode().encode())
+	elif sys.platform == 'win32':
+		gnuplot.write(b"set term windows\n")
+	else:
+		gnuplot.write( b"set term x11\n")
+	gnuplot.write(b"set xlabel \"log2(C)\"\n")
+	gnuplot.write(b"set ylabel \"log2(gamma)\"\n")
+	gnuplot.write("set xrange [{0}:{1}]\n".format(options.c_begin,options.c_end).encode())
+	gnuplot.write("set yrange [{0}:{1}]\n".format(options.g_begin,options.g_end).encode())
+	gnuplot.write(b"set contour\n")
+	gnuplot.write("set cntrparam levels incremental {0},{1},100\n".format(begin_level,step_size).encode())
+	gnuplot.write(b"unset surface\n")
+	gnuplot.write(b"unset ztics\n")
+	gnuplot.write(b"set view 0,0\n")
+	gnuplot.write("set title \"{0}\"\n".format(options.dataset_title).encode())
+	gnuplot.write(b"unset label\n")
+	gnuplot.write("set label \"Best log2(C) = {0}  log2(gamma) = {1}  accuracy = {2}%\" \
+				  at screen 0.5,0.85 center\n". \
+				  format(best_log2c, best_log2g, best_rate).encode())
+	gnuplot.write("set label \"C = {0}  gamma = {1}\""
+				  " at screen 0.5,0.8 center\n".format(2**best_log2c, 2**best_log2g).encode())
+	gnuplot.write(b"set key at screen 0.9,0.9\n")
+	gnuplot.write(b"splot \"-\" with lines\n")
+	
+	db.sort(key = lambda x:(x[0], -x[1]))
+
+	prevc = db[0][0]
+	for line in db:
+		if prevc != line[0]:
+			gnuplot.write(b"\n")
+			prevc = line[0]
+		gnuplot.write("{0[0]} {0[1]} {0[2]}\n".format(line).encode())
+	gnuplot.write(b"e\n")
+	gnuplot.write(b"\n") # force gnuplot back to prompt when term set failure
+	gnuplot.flush()
+
+
+def calculate_jobs(options):
+	
+	def range_f(begin,end,step):
+		# like range, but works on non-integer too
+		seq = []
+		while True:
+			if step > 0 and begin > end: break
+			if step < 0 and begin < end: break
+			seq.append(begin)
+			begin = begin + step
+		return seq
+	
+	def permute_sequence(seq):
+		n = len(seq)
+		if n <= 1: return seq
+	
+		mid = int(n/2)
+		left = permute_sequence(seq[:mid])
+		right = permute_sequence(seq[mid+1:])
+	
+		ret = [seq[mid]]
+		while left or right:
+			if left: ret.append(left.pop(0))
+			if right: ret.append(right.pop(0))
+			
+		return ret	
+
+	
+	c_seq = permute_sequence(range_f(options.c_begin,options.c_end,options.c_step))
+	g_seq = permute_sequence(range_f(options.g_begin,options.g_end,options.g_step))
+
+	if not options.grid_with_c:
+		c_seq = [None]
+	if not options.grid_with_g:
+		g_seq = [None] 
+	
+	nr_c = float(len(c_seq))
+	nr_g = float(len(g_seq))
+	i, j = 0, 0
+	jobs = []
+
+	while i < nr_c or j < nr_g:
+		if i/nr_c < j/nr_g:
+			# increase C resolution
+			line = []
+			for k in range(0,j):
+				line.append((c_seq[i],g_seq[k]))
+			i = i + 1
+			jobs.append(line)
+		else:
+			# increase g resolution
+			line = []
+			for k in range(0,i):
+				line.append((c_seq[k],g_seq[j]))
+			j = j + 1
+			jobs.append(line)
+
+	resumed_jobs = {}
+	
+	if options.resume_pathname is None:
+		return jobs, resumed_jobs
+
+	for line in open(options.resume_pathname, 'r'):
+		line = line.strip()
+		rst = re.findall(r'rate=([0-9.]+)',line)
+		if not rst: 
+			continue
+		rate = float(rst[0])
+
+		c, g = None, None 
+		rst = re.findall(r'log2c=([0-9.-]+)',line)
+		if rst: 
+			c = float(rst[0])
+		rst = re.findall(r'log2g=([0-9.-]+)',line)
+		if rst: 
+			g = float(rst[0])
+
+		resumed_jobs[(c,g)] = rate
+
+	return jobs, resumed_jobs
+
+	
+class WorkerStopToken:  # used to notify the worker to stop or if a worker is dead
+	pass
+
+class Worker(Thread):
+	def __init__(self,name,job_queue,result_queue,options):
+		Thread.__init__(self)
+		self.name = name
+		self.job_queue = job_queue
+		self.result_queue = result_queue
+		self.options = options
+		
+	def run(self):
+		while True:
+			(cexp,gexp) = self.job_queue.get()
+			if cexp is WorkerStopToken:
+				self.job_queue.put((cexp,gexp))
+				# print('worker {0} stop.'.format(self.name))
+				break
+			try:
+				c, g = None, None
+				if cexp != None:
+					c = 2.0**cexp
+				if gexp != None:
+					g = 2.0**gexp
+				rate = self.run_one(c,g)
+				if rate is None: raise RuntimeError('get no rate')
+			except:
+				# we failed, let others do that and we just quit
+			
+				traceback.print_exception(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])
+				
+				self.job_queue.put((cexp,gexp))
+				sys.stderr.write('worker {0} quit.\n'.format(self.name))
+				break
+			else:
+				self.result_queue.put((self.name,cexp,gexp,rate))
+
+	def get_cmd(self,c,g):
+		options=self.options
+		cmdline = '"' + options.svmtrain_pathname + '"'
+		if options.grid_with_c: 
+			cmdline += ' -c {0} '.format(c)
+		if options.grid_with_g: 
+			cmdline += ' -g {0} '.format(g)
+		cmdline += ' -v {0} {1} {2} '.format\
+			(options.fold,options.pass_through_string,options.dataset_pathname)
+		return cmdline
+		
+class LocalWorker(Worker):
+	def run_one(self,c,g):
+		cmdline = self.get_cmd(c,g)
+		result = Popen(cmdline,shell=True,stdout=PIPE,stderr=PIPE,stdin=PIPE).stdout
+		for line in result.readlines():
+			if str(line).find('Cross') != -1:
+				return float(line.split()[-1][0:-1])
+
+class SSHWorker(Worker):
+	def __init__(self,name,job_queue,result_queue,host,options):
+		Worker.__init__(self,name,job_queue,result_queue,options)
+		self.host = host
+		self.cwd = os.getcwd()
+	def run_one(self,c,g):
+		cmdline = 'ssh -x -t -t {0} "cd {1}; {2}"'.format\
+			(self.host,self.cwd,self.get_cmd(c,g))
+		result = Popen(cmdline,shell=True,stdout=PIPE,stderr=PIPE,stdin=PIPE).stdout
+		for line in result.readlines():
+			if str(line).find('Cross') != -1:
+				return float(line.split()[-1][0:-1])
+
+class TelnetWorker(Worker):
+	def __init__(self,name,job_queue,result_queue,host,username,password,options):
+		Worker.__init__(self,name,job_queue,result_queue,options)
+		self.host = host
+		self.username = username
+		self.password = password		
+	def run(self):
+		import telnetlib
+		self.tn = tn = telnetlib.Telnet(self.host)
+		tn.read_until('login: ')
+		tn.write(self.username + '\n')
+		tn.read_until('Password: ')
+		tn.write(self.password + '\n')
+
+		# XXX: how to know whether login is successful?
+		tn.read_until(self.username)
+		# 
+		print('login ok', self.host)
+		tn.write('cd '+os.getcwd()+'\n')
+		Worker.run(self)
+		tn.write('exit\n')			   
+	def run_one(self,c,g):
+		cmdline = self.get_cmd(c,g)
+		result = self.tn.write(cmdline+'\n')
+		(idx,matchm,output) = self.tn.expect(['Cross.*\n'])
+		for line in output.split('\n'):
+			if str(line).find('Cross') != -1:
+				return float(line.split()[-1][0:-1])
+			
+def find_parameters(dataset_pathname, options=''):
+	
+	def update_param(c,g,rate,best_c,best_g,best_rate,worker,resumed):
+		if (rate > best_rate) or (rate==best_rate and g==best_g and c<best_c):
+			best_rate,best_c,best_g = rate,c,g
+		stdout_str = '[{0}] {1} {2} (best '.format\
+			(worker,' '.join(str(x) for x in [c,g] if x is not None),rate)
+		output_str = ''
+		if c != None:
+			stdout_str += 'c={0}, '.format(2.0**best_c)
+			output_str += 'log2c={0} '.format(c)
+		if g != None:
+			stdout_str += 'g={0}, '.format(2.0**best_g)
+			output_str += 'log2g={0} '.format(g)
+		stdout_str += 'rate={0})'.format(best_rate)
+		print(stdout_str)
+		if options.out_pathname and not resumed:
+			output_str += 'rate={0}\n'.format(rate)
+			result_file.write(output_str)
+			result_file.flush()
+		
+		return best_c,best_g,best_rate
+		
+	options = GridOption(dataset_pathname, options);
+
+	if options.gnuplot_pathname:
+		gnuplot = Popen(options.gnuplot_pathname,stdin = PIPE,stdout=PIPE,stderr=PIPE).stdin
+	else:
+		gnuplot = None
+		
+	# put jobs in queue
+
+	jobs,resumed_jobs = calculate_jobs(options)
+	job_queue = Queue(0)
+	result_queue = Queue(0)
+
+	for (c,g) in resumed_jobs:
+		result_queue.put(('resumed',c,g,resumed_jobs[(c,g)]))
+
+	for line in jobs:
+		for (c,g) in line:
+			if (c,g) not in resumed_jobs:
+				job_queue.put((c,g))
+
+	# hack the queue to become a stack --
+	# this is important when some thread
+	# failed and re-put a job. It we still
+	# use FIFO, the job will be put
+	# into the end of the queue, and the graph
+	# will only be updated in the end
+ 
+	job_queue._put = job_queue.queue.appendleft
+
+	# fire telnet workers
+
+	if telnet_workers:
+		nr_telnet_worker = len(telnet_workers)
+		username = getpass.getuser()
+		password = getpass.getpass()
+		for host in telnet_workers:
+			worker = TelnetWorker(host,job_queue,result_queue,
+					 host,username,password,options)
+			worker.start()
+
+	# fire ssh workers
+
+	if ssh_workers:
+		for host in ssh_workers:
+			worker = SSHWorker(host,job_queue,result_queue,host,options)
+			worker.start()
+
+	# fire local workers
+
+	for i in range(nr_local_worker):
+		worker = LocalWorker('local',job_queue,result_queue,options)
+		worker.start()
+
+	# gather results
+
+	done_jobs = {}
+
+	if options.out_pathname:
+		if options.resume_pathname:
+			result_file = open(options.out_pathname, 'a')
+		else:
+			result_file = open(options.out_pathname, 'w')
+
+
+	db = []
+	best_rate = -1
+	best_c,best_g = None,None  
+
+	for (c,g) in resumed_jobs:
+		rate = resumed_jobs[(c,g)]
+		best_c,best_g,best_rate = update_param(c,g,rate,best_c,best_g,best_rate,'resumed',True)
+
+	for line in jobs:
+		for (c,g) in line:
+			while (c,g) not in done_jobs:
+				(worker,c1,g1,rate1) = result_queue.get()
+				done_jobs[(c1,g1)] = rate1
+				if (c1,g1) not in resumed_jobs:
+					best_c,best_g,best_rate = update_param(c1,g1,rate1,best_c,best_g,best_rate,worker,False)
+			db.append((c,g,done_jobs[(c,g)]))
+		if gnuplot and options.grid_with_c and options.grid_with_g:
+			redraw(db,[best_c, best_g, best_rate],gnuplot,options)
+			redraw(db,[best_c, best_g, best_rate],gnuplot,options,True)
+
+
+	if options.out_pathname:
+		result_file.close()
+	job_queue.put((WorkerStopToken,None))
+	best_param, best_cg  = {}, []
+	if best_c != None:
+		best_param['c'] = 2.0**best_c
+		best_cg += [2.0**best_c]
+	if best_g != None:
+		best_param['g'] = 2.0**best_g
+		best_cg += [2.0**best_g]
+	print('{0} {1}'.format(' '.join(map(str,best_cg)), best_rate))
+
+	return best_rate, best_param
+
+
+if __name__ == '__main__':
+
+	def exit_with_help():
+		print("""\
+Usage: grid.py [grid_options] [svm_options] dataset
+
+grid_options :
+-log2c {begin,end,step | "null"} : set the range of c (default -5,15,2)
+    begin,end,step -- c_range = 2^{begin,...,begin+k*step,...,end}
+    "null"         -- do not grid with c
+-log2g {begin,end,step | "null"} : set the range of g (default 3,-15,-2)
+    begin,end,step -- g_range = 2^{begin,...,begin+k*step,...,end}
+    "null"         -- do not grid with g
+-v n : n-fold cross validation (default 5)
+-svmtrain pathname : set svm executable path and name
+-gnuplot {pathname | "null"} :
+    pathname -- set gnuplot executable path and name
+    "null"   -- do not plot 
+-out {pathname | "null"} : (default dataset.out)
+    pathname -- set output file path and name
+    "null"   -- do not output file
+-png pathname : set graphic output file path and name (default dataset.png)
+-resume [pathname] : resume the grid task using an existing output file (default pathname is dataset.out)
+    This is experimental. Try this option only if some parameters have been checked for the SAME data.
+
+svm_options : additional options for svm-train""")
+		sys.exit(1)
+	
+	if len(sys.argv) < 2:
+		exit_with_help()
+	dataset_pathname = sys.argv[-1]
+	options = sys.argv[1:-1]
+	try:
+		find_parameters(dataset_pathname, options)
+	except (IOError,ValueError) as e:
+		sys.stderr.write(str(e) + '\n')
+		sys.stderr.write('Try "grid.py" for more information.\n')
+		sys.exit(1)