Fix:CONFIG

Author: abilng

config/CNN/data_spec.json

@@ -6,7 +6,6 @@
 		"random" : true,
 		"random_seed" : 123,
 		"dim_shuffle" : [0,3,2,1],
-		"batch_size": 256,
 		"keep_flatten" : false,
 		"reader_type" : "NP"
 	},
@@ -18,7 +17,6 @@
 		"random" : true,
 		"random_seed" : 123,
 		"dim_shuffle" : [0,3,2,1],
-		"batch_size": 256,
 		"keep_flatten" : false,
 		"reader_type" : "NP"
 	},
@@ -30,7 +28,6 @@
 		"random" : true,
 		"random_seed" : 123,
 		"dim_shuffle" : [0,3,2,1],
-		"batch_size": 256,
 		"keep_flatten" : false,
 		"reader_type" : "NP"
 	}

config/CNN1/data_spec.json

@@ -7,7 +7,6 @@
 		"random_seed" : 123,
 		"input_shape" : [1,10,5],
 		"dim_shuffle" : [0,1,2,3],
-		"batch_size": 8,
 		"keep_flatten" : false,
 		"reader_type" : "T1"
 	},
@@ -20,7 +19,6 @@
 		"random_seed" : 123,
 		"input_shape" : [1,10,5],
 		"dim_shuffle" : [0,1,2,3],
-		"batch_size": 8,
 		"keep_flatten" : false,
 		"reader_type" : "T1"
 	},
@@ -33,7 +31,6 @@
 		"random_seed" : 123,
 		"input_shape" : [1,10,5],
 		"dim_shuffle" : [0,1,2,3],
-		"batch_size": 8,
 		"keep_flatten" : false,
 		"reader_type" : "T1"
 	}

config/DBN/data_spec.json

@@ -5,8 +5,6 @@
 		"partition" : 200,
 		"random" : true,
 		"random_seed" : 123,
-		"dim_shuffle" : [0,3,2,1],
-		"batch_size": 256,
 		"keep_flatten" : true,
 		"reader_type" : "NP"
 	},
@@ -17,8 +15,6 @@
 		"partition" : 200,
 		"random" : true,
 		"random_seed" : 123,
-		"dim_shuffle" : [0,3,2,1],
-		"batch_size": 256,
 		"keep_flatten" : true,
 		"reader_type" : "NP"
 	},
@@ -29,8 +25,6 @@
 		"partition" : 200,
 		"random" : true,
 		"random_seed" : 123,
-		"dim_shuffle" : [0,3,2,1],
-		"batch_size": 256,
 		"keep_flatten" : true,
 		"reader_type" : "NP"
 	}

config/SDA/data_spec.json

@@ -5,8 +5,6 @@
 		"partition" : 200,
 		"random" : true,
 		"random_seed" : 123,
-		"dim_shuffle" : [0,3,2,1],
-		"batch_size": 256,
 		"keep_flatten" : true,
 		"reader_type" : "NP"
 	},
@@ -17,8 +15,6 @@
 		"partition" : 200,
 		"random" : true,
 		"random_seed" : 123,
-		"dim_shuffle" : [0,3,2,1],
-		"batch_size": 256,
 		"keep_flatten" : true,
 		"reader_type" : "NP"
 	},
@@ -29,8 +25,6 @@
 		"partition" : 200,
 		"random" : true,
 		"random_seed" : 123,
-		"dim_shuffle" : [0,3,2,1],
-		"batch_size": 256,
 		"keep_flatten" : true,
 		"reader_type" : "NP"
 	}

io_modules/__init__.py

@@ -1,5 +1,5 @@
 
-def setLogger(level="INFO",stderr=True,logFile='python-dnn.log',name=None):
+def setLogger(stderr=True,logFile='python-dnn.log',name=None):
 	import logging,sys
 
 	#get Logger
@@ -19,16 +19,7 @@ def setLogger(level="INFO",stderr=True,logFile='python-dnn.log',name=None):
 		file_handler = logging.FileHandler(logFile)
 		file_handler.setFormatter(formatter)
 		logger.addHandler(file_handler)
-
-	# Set the level which determines what you see
-	if level == "INFO":
-		logger.setLevel(logging.INFO)
-	elif level == "DEBUG":
-		logger.setLevel(logging.DEBUG)
-	elif level == "ERROR":
-		logger.setLevel(logging.ERROR)		
-	else:
-		logger.setLevel(logging.WARNING)
+		
 
 def create_folder_structure_if_not_exists(filepath):
 	import logging,os,errno

io_modules/file_reader.py

@@ -6,13 +6,13 @@
 import logging
 logger = logging.getLogger(__name__)
 
-def read_dataset(options,pad_zeros=False):
+def read_dataset(options,batch_size,pad_zeros=False):
 	filepath =   options['base_path'] + os.sep + options['filename'];
 	logger.info("%s dataset will be initialized to reader to %s",
 				options['reader_type'],filepath);
 	logger.debug("options : %s" % str(options))	
 
-	file_reader = FileReader.get_instance(filepath,options)
+	file_reader = FileReader.get_instance(filepath,batch_size,options)
 	file_header = file_reader.read_file_info()
 
 	shared_xy = file_reader.create_shared(pad_zeros)
@@ -39,16 +39,16 @@ class FileReader(object):
 	num_pad_frames = 0;
 
 	@staticmethod
-	def get_instance(filepath,options):
+	def get_instance(filepath,batch_size,options):
 		file_reader = None;
 		if options['reader_type']=='NP':
-			file_reader = NPFileReader(filepath,options);
+			file_reader = NPFileReader(filepath,batch_size,options);
 		elif options['reader_type']=='TD':
-			file_reader = TDFileReader(filepath,options);
+			file_reader = TDFileReader(filepath,batch_size,options);
 		elif options['reader_type']=='T1':
-			file_reader = T1FileReader(filepath,options);
+			file_reader = T1FileReader(filepath,batch_size,options);
 		elif options['reader_type']=='T2':
-			file_reader = T2FileReader(filepath,options);
+			file_reader = T2FileReader(filepath,batch_size,options);
 		else:
 			logger.critical('\'%s\'  reader_type is not defined...'\
 						%options['reader_type'])
@@ -125,9 +125,10 @@ def initialize_read(self):
 
 class TDFileReader(FileReader):
 	''' Reads the data stored in as Simple Text File'''
-	def __init__(self,path,options):
+	def __init__(self,path,batch_size,options):
 		self.filepath = path;
-		self.options=options;
+		self.options = options;
+		self.batch_size = batch_size
 		self.lbl = options['label'];
 		self.filehandle = open(self.filepath,'rb')
 
@@ -141,7 +142,7 @@ def read_file_info(self):
 		#self.frames_remaining = long(self.header[1])
 		# partitions specifies approximate amount data to be loaded one operation
 		self.frames_per_partition= self.options['partition'] *1000*1000/ (self.feat_dim * 4)
-		batch_residual = self.frames_per_partition% self.options['batch_size']
+		batch_residual = self.frames_per_partition% self.batch_size
 		self.frames_per_partition = self.frames_per_partition - batch_residual
 		return self.header
 
@@ -191,9 +192,10 @@ def read_next_partition_data(self,already_read=0,pad_zeros=False):
 
 class T2FileReader(FileReader):
 	''' Reads the data stored in as Simple Text File With Two level header structure'''
-	def __init__(self,path,options):
+	def __init__(self,path,batch_size,options):
 		self.filepath = path;
 		self.options=options;
+		self.batch_size=batch_size
 		self.filehandle = open(self.filepath,'rb')
 
 	def read_file_info(self):
@@ -213,7 +215,7 @@ def read_file_info(self):
 		self.header['featdim'] = self.feat_dim
 		self.header['classes'] = self.classes
 
-		batch_size = self.options['batch_size']
+		batch_size = self.batch_size
 
 		# partitions specifies approximate amount data to be loaded one operation
 		self.frames_per_partition = self.options['partition'] *1000*1000/ (self.feat_dim * 4)
@@ -276,6 +278,7 @@ def read_next_partition_data(self,already_read=0,pad_zeros=False):
 			self.partition_num = self.partition_num + 1
 
 			if not self.options['keep_flatten'] :	#reshape the vector if needed
+				logger.debug('T2 Filereader : Reshape input...')
 				shape = [self.cur_frame_num];
 				shape.extend(self.options['input_shape']);
 				self.feat = self.feat.reshape(shape);
@@ -297,8 +300,9 @@ def read_next_partition_data(self,already_read=0,pad_zeros=False):
 
 class T1FileReader(FileReader):
 	''' Reads the data stored in as Simple Text File With One level header structure'''
-	def __init__(self,path,options):
+	def __init__(self,path,batch_size,options):
 		self.filepath = path;
+		self.batch_size = batch_size
 		self.options=options;
 		self.filehandle = open(self.filepath,'rb')
 
@@ -314,7 +318,7 @@ def read_file_info(self):
 
 		self.header = {};
 		self.header['featdim'] = self.feat_dim
-		batch_size = self.options['batch_size']
+		batch_size = self.batch_size
 
 		logger.debug('T1 Filereader : feat : %d' % self.feat_dim)
 
@@ -370,6 +374,7 @@ def read_next_partition_data(self,already_read=0,pad_zeros=False):
 			self.partition_num = self.partition_num + 1
 
 			if not self.options['keep_flatten'] :	#reshape the vector if needed
+				logger.debug('T1 Filereader : Reshape input...')
 				shape = [self.cur_frame_num];
 				shape.extend(self.options['input_shape']);
 				self.feat = self.feat.reshape(shape);
@@ -388,8 +393,9 @@ def read_next_partition_data(self,already_read=0,pad_zeros=False):
 
 class NPFileReader(FileReader):
 	''' Reads the data stored in as Numpy Array'''
-	def __init__(self,path,options):
+	def __init__(self,path,batch_size,options):
 		self.filepath = path;
+		self.batch_size = batch_size
 		self.options=options;
 		self.filehandle = open(self.filepath,'rb')
 
@@ -400,7 +406,7 @@ def read_file_info(self):
 		logger.debug("NP Filereader : feats : %d"% self.feat_dim);
 		# partitions specifies approximate amount data to be loaded one operation
 		self.frames_per_partition= self.options['partition'] *1000*1000/ (self.feat_dim * 4)
-		batch_residual = self.frames_per_partition% self.options['batch_size']
+		batch_residual = self.frames_per_partition% self.batch_size
 		self.frames_per_partition= self.frames_per_partition- batch_residual
 		self.dtype = numpy.dtype({'names': ['d','l'],'formats': [('>f2',self.feat_dim),'>i2']})
 		return self.header
@@ -417,9 +423,11 @@ def read_next_partition_data(self,already_read=0,pad_zeros=False):
 				for x in xrange(self.num_pad_frames):
 					self.label = numpy.append(self.label,[0]*self.feat_dim) 
 
-			logger.debug('NP Filereader : from file %s, %d partition has %d frames' % (self.filepath,self.partition_num,self.cur_frame_num));
+			logger.debug('NP Filereader : from file %s, %d partition has %d frames',
+				self.filepath,self.partition_num,self.cur_frame_num);
 
 			if not self.options['keep_flatten'] :	#reshape the vector if needed
+				logger.debug('NP Filereader : Reshape input...')
 				shape = [self.cur_frame_num];
 				shape.extend(self.header['input_shape']);
 				self.feat = self.feat.reshape(shape);

run.py

@@ -25,12 +25,15 @@
 from io_modules import setLogger
 
 
-def setLoggerLevel(modelConfig):
+def setLoggerLevel(modelConfig,name=None):
+	logger = logging.getLogger(name)
 	# Set the level which determines what you see
 	try:
 		level = modelConfig['logger_level']
 	except KeyError:
-		level = "INFO"
+		level = "DEBUG"
+
+	logger.info('Changing logger level:%s',level)
 
 	if level == "INFO":
 		logger.setLevel(logging.INFO)

run/__init__.py

@@ -0,0 +1,103 @@
+import time,numpy,os
+import logging
+logger = logging.getLogger(__name__)
+
+def testing(nnetModel,test_sets, test_xy, test_x, test_y,batch_size):
+
+	# get the testing function for the model
+	logger.info('Getting the Test function')
+	test_fn = nnetModel.build_test_function((test_x, test_y), batch_size=batch_size)
+
+	logger.info('Starting Testing');
+	
+	test_error  = []
+	test_output = numpy.array([],int);
+	while not test_sets.is_finish():
+		test_sets.make_partition_shared(test_xy)
+		n_test_batches= test_sets.cur_frame_num / batch_size;
+		for i in xrange(n_test_batches):
+			pred, err = test_fn(i)
+			test_error.append(err)
+			test_output=numpy.append(test_output,pred)
+		test_sets.read_next_partition_data()
+		logger.debug("Test Error (upto curr part) = %f",numpy.mean(test_error))
+	test_sets.initialize_read();
+
+	test_loss=numpy.mean(test_error)
+	logger.info('Optimization complete with best Test score of %f %%',test_loss * 100)
+
+	return test_output,test_loss;
+
+def fineTunning(nnetModel,train_sets,train_xy,train_x,train_y,
+		valid_sets,valid_xy,valid_x,valid_y,lrate,momentum,batch_size):
+
+	def valid_score():
+		valid_error = [] 
+		while not valid_sets.is_finish():
+			valid_sets.make_partition_shared(valid_xy)
+			n_valid_batches= valid_sets.cur_frame_num / batch_size;
+			validation_losses = [validate_fn(i) for i in xrange(n_valid_batches)]
+			valid_error.append(validation_losses)
+			valid_sets.read_next_partition_data()
+			logger.debug("Valid Error (upto curr part) = %f",numpy.mean(valid_error))
+		valid_sets.initialize_read();
+		return numpy.mean(valid_error);
+
+	# get the training, validation function for the model
+	logger.info('Getting the finetuning functions')
+	train_fn, validate_fn = nnetModel.build_finetune_functions((train_x, train_y),
+			 (valid_x, valid_y), batch_size=batch_size)
+		
+	best_validation_loss=float('Inf')
+
+	logger.info('Finetunning the model..');	
+	start_time = time.clock()
+
+	while (lrate.get_rate() != 0):
+		train_error = []
+		while not train_sets.is_finish():
+			train_sets.make_partition_shared(train_xy)
+			for batch_index in xrange(train_sets.cur_frame_num / batch_size):  # loop over mini-batches
+				train_error.append(train_fn(index=batch_index,
+					learning_rate = lrate.get_rate(), momentum = momentum))
+				logger.debug('Training batch %d error %f',batch_index, numpy.mean(train_error))
+			train_sets.read_next_partition_data()
+		logger.info('Fine Tunning:epoch %d, training error %f',lrate.epoch, numpy.mean(train_error));
+		train_sets.initialize_read()
+
+		valid_error = valid_score()
+		if valid_error < best_validation_loss:
+			best_validation_loss=valid_error
+		logger.info('Fine Tunning:epoch %d, validation error %f',lrate.epoch, valid_error);
+		lrate.get_next_rate(current_error = 100 * valid_error)
+	
+	end_time = time.clock()
+
+	logger.info('Best validation error %f',best_validation_loss)
+
+	logger.info('The Fine tunning ran for %.2fm' % ((end_time - start_time) / 60.))
+	logger.info('Optimization complete with best validation score of %f %%', best_validation_loss * 100)
+
+	return best_validation_loss
+
+
+def getFeatures(nnetModel,data_spec_testing):
+	out_function = nnetModel.getFeaturesFunction()
+	test_sets, test_xy, test_x, test_y = read_dataset(data_spec_testing)
+	while (not test_sets.is_finish()):
+		data = out_function(test_sets.feat)
+		test_sets.read_next_partition_data()
+		#TODO write data
+
+def createDir(wdir):
+	"""create working dir"""
+	wdir = os.path.abspath(wdir)
+	logger.info("Creating working dir %s ...",wdir)
+	if not os.path.exists(wdir):
+		try:
+			os.makedirs(wdir)
+			logger.info("Creating working dir ... DONE"); 
+		except Exception, e:
+			raise e
+	else:
+		logger.info("Creating working dir  ... Skipping");