Putting cnn file model in single file.......... Feature exporting done

Author: sudhargk

data/TFILE/val.dat

@@ -1,5 +1,5 @@
 50 2
-val_c1.dat
-val_c2.dat
+c1/val_c1.dat
+c2/val_c2.dat
 
 

io_modules/file_reader.py

@@ -6,13 +6,13 @@
 import logging
 logger = logging.getLogger(__name__)
 
-def read_dataset(options,batch_size,pad_zeros=False):
+def read_dataset(options,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,batch_size,options)
+	file_reader = FileReader.get_instance(filepath,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,batch_size,options):
+	def get_instance(filepath,options):
 		file_reader = None;
 		if options['reader_type']=='NP':
-			file_reader = NPFileReader(filepath,batch_size,options);
+			file_reader = NPFileReader(filepath,options);
 		elif options['reader_type']=='TD':
-			file_reader = TDFileReader(filepath,batch_size,options);
+			file_reader = TDFileReader(filepath,options);
 		elif options['reader_type']=='T1':
-			file_reader = T1FileReader(filepath,batch_size,options);
+			file_reader = T1FileReader(filepath,options);
 		elif options['reader_type']=='T2':
-			file_reader = T2FileReader(filepath,batch_size,options);
+			file_reader = T2FileReader(filepath,options);
 		else:
 			logger.critical('\'%s\'  reader_type is not defined...'\
 						%options['reader_type'])
@@ -125,10 +125,10 @@ def initialize_read(self):
 
 class TDFileReader(FileReader):
 	''' Reads the data stored in as Simple Text File'''
-	def __init__(self,path,batch_size,options):
+	def __init__(self,path,options):
 		self.filepath = path;
 		self.options = options;
-		self.batch_size = batch_size
+		self.batch_size = options['batch_size']
 		self.lbl = options['label'];
 		self.filehandle = open(self.filepath,'rb')
 
@@ -192,10 +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,batch_size,options):
+	def __init__(self,path,options):
 		self.filepath = path;
 		self.options=options;
-		self.batch_size=batch_size
+		self.batch_size = options['batch_size']
 		self.filehandle = open(self.filepath,'rb')
 
 	def read_file_info(self):
@@ -300,10 +300,10 @@ 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,batch_size,options):
+	def __init__(self,path,options):
 		self.filepath = path;
-		self.batch_size = batch_size
 		self.options=options;
+		self.batch_size = options['batch_size']
 		self.filehandle = open(self.filepath,'rb')
 
 	def read_file_info(self):
@@ -334,7 +334,7 @@ def read_file_info(self):
 			child_options['label']= i;
 			child_options['keep_flatten'] = True
 			data_file = child_options['base_path'] + os.sep + child_options['filename']
-			self.filehandles.append(TDFileReader(data_file,self.batch_size,child_options));
+			self.filehandles.append(TDFileReader(data_file,child_options));
 			self.filehandles[-1].read_file_info();
 
 		if self.frames_per_partition < self.classes:
@@ -393,10 +393,10 @@ 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,batch_size,options):
+	def __init__(self,path,options):
 		self.filepath = path;
-		self.batch_size = batch_size
 		self.options=options;
+		self.batch_size = options['batch_size']
 		self.filehandle = open(self.filepath,'rb')
 
 	def read_file_info(self):

io_modules/file_writer.py

@@ -71,6 +71,7 @@ def write_data(self,vector_array,labels):
 			flatten_vector = vector.flatten();
 			if self.feat_dim!=len(flatten_vector):
 				logger.critical('Feature dimension mentioned in header and vector length are mismatching');
+				exit(0)
 			else:
 				data['d']=flatten_vector; data['l']=label;
 				data.tofile(self.filehandle); 
@@ -97,7 +98,8 @@ def write_data(self,vector_array,labels):
 		for vector,label in zip(vector_array,labels):
 			flatten_vector = vector.flatten();
 			if self.feat_dim!=len(flatten_vector):
-				logger.critical('Feature dimension mentioned in header and vector length are	 mismatching');
+				logger.critical('Feature dimension mentioned in header and vector length are mismatching');
+				exit(0)
 			else:
 				for element in vector:
 					self.filehandle.write('%f ' % element)

io_modules/model_io.py

@@ -15,6 +15,7 @@ def array_2_string(array):
 def string_2_array(string):
 	str_in = StringIO(string)
 	return np.loadtxt(str_in)
+	
 
 def _nnet2file(layers, set_layer_num = -1, filename='nnet.out', activation='sigmoid', start_layer = 0, withfinal=True, 
 		input_factor = 0.0, factor=[0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0]):
@@ -64,47 +65,93 @@ def _file2nnet(layers, set_layer_num = -1, filename='nnet.in', activation='sigmo
 		layers[-1].params[1].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
 	logger.info('Loaded the neural_net model in %s',(filename))
 
-def _cnn2file(conv_layers, filename='nnet.out', activation='sigmoid', withfinal=True, input_factor = 1.0, factor=1.0):
+def _cnn2file(conv_layers,mlp_layers,filename='nnet.out',
+			start_layer = 0,set_layer_num=-1,withfinal=True, input_factor = 1.0, factor=1.0):
+	#Dumping CNN Configuration
 	n_layers = len(conv_layers)
-	nnet_dict = {}
+	cnn_dict = {}
 	for i in xrange(n_layers):
 		conv_layer = conv_layers[i]
 		filter_shape = conv_layer.filter_shape
-		
 		for next_X in xrange(filter_shape[0]):
 			for this_X in xrange(filter_shape[1]):
 				dict_a = 'W ' + str(i) + ' ' + str(next_X) + ' ' + str(this_X) 
 				if i == 0:
-					nnet_dict[dict_a] = array_2_string(input_factor * (conv_layer.W.get_value())[next_X, this_X])
+					cnn_dict[dict_a] = array_2_string(input_factor * (conv_layer.W.get_value())[next_X, this_X])
 				else:
-					nnet_dict[dict_a] = array_2_string(factor * (conv_layer.W.get_value())[next_X, this_X])
+					cnn_dict[dict_a] = array_2_string(factor * (conv_layer.W.get_value())[next_X, this_X])
 
 		dict_a = 'b ' + str(i)
-		nnet_dict[dict_a] = array_2_string(conv_layer.b.get_value())
+		cnn_dict[dict_a] = array_2_string(conv_layer.b.get_value())
+	
+	#Dumping MLP Configuration
+	n_layers = len(mlp_layers)
+	mlp_dict = {}
+	if set_layer_num == -1:
+		set_layer_num = n_layers - 1
+	for i in range(start_layer,set_layer_num):
+	   dict_a = str(i) +' W'
+	   if i == 0:
+		   mlp_dict[dict_a] = array_2_string(input_factor * mlp_layers[i].params[0].get_value())
+	   else:
+		   print mlp_layers[i].params[0]
+		   mlp_dict[dict_a] = array_2_string(factor * mlp_layers[i].params[0].get_value())
+	   dict_a = str(i) + ' b'
+	   mlp_dict[dict_a] = array_2_string(mlp_layers[i].params[1].get_value())
+	
+	if withfinal: 
+		dict_a = 'logreg W'
+		mlp_dict[dict_a] = array_2_string(factor * mlp_layers[-1].params[0].get_value())
+		dict_a = 'logreg b'
+		mlp_dict[dict_a] = array_2_string(mlp_layers[-1].params[1].get_value())
 
+	nnet_dict = {};
+	nnet_dict['cnn'] = cnn_dict;
+	nnet_dict['mlp'] = mlp_dict;
+
 	with open(filename, 'wb') as fp:
 		json.dump(nnet_dict, fp, indent=2, sort_keys = True)
 		fp.flush()
 	logger.info('Dumped the conv_net model in %s',(filename))
 
-def _file2cnn(conv_layers, filename='nnet.in', activation='sigmoid', withfinal=True, factor=1.0):
-	n_layers = len(conv_layers)
+def _file2cnn(conv_layers,mlp_layers, filename='nnet.in',set_layer_num=-1,withfinal=True, factor=1.0):
 	nnet_dict = {}
-
+	
 	with open(filename, 'rb') as fp:
 		nnet_dict = json.load(fp)
+		
+	##Loading CNN Configuration
+	n_layers = len(conv_layers)
+	cnn_dict  = nnet_dict['cnn'];
 	for i in xrange(n_layers):
 		conv_layer = conv_layers[i]
 		filter_shape = conv_layer.filter_shape
 		W_array = conv_layer.W.get_value()
-
+		
 		for next_X in xrange(filter_shape[0]):
 			for this_X in xrange(filter_shape[1]):
 				dict_a = 'W ' + str(i) + ' ' + str(next_X) + ' ' + str(this_X)
-				W_array[next_X, this_X, :, :] = factor * np.asarray(string_2_array(nnet_dict[dict_a]))
-
+				W_array[next_X, this_X, :, :] = factor * np.asarray(string_2_array(cnn_dict[dict_a]))
+				
 		conv_layer.W.set_value(W_array) 
-
 		dict_a = 'b ' + str(i)
-		conv_layer.b.set_value(np.asarray(string_2_array(nnet_dict[dict_a]), dtype=theano.config.floatX))
+		conv_layer.b.set_value(np.asarray(string_2_array(cnn_dict[dict_a]), dtype=theano.config.floatX))
+	
+	##Loading MLP Configuration
+	if not mlp_layers is None:
+		n_layers = len(mlp_layers)
+		mlp_dict  = nnet_dict['mlp'];
+		if set_layer_num == -1:
+			set_layer_num = n_layers - 1
+		for i in xrange(set_layer_num):
+			dict_key = str(i) + ' W'
+			mlp_layers[i].params[0].set_value(factor * np.asarray(string_2_array(mlp_dict[dict_key]), dtype=theano.config.floatX))
+			dict_key = str(i) + ' b' 
+			mlp_layers[i].params[1].set_value(np.asarray(string_2_array(mlp_dict[dict_key]), dtype=theano.config.floatX))
+		if withfinal:
+			dict_key = 'logreg W'
+			mlp_layers[-1].params[0].set_value(np.asarray(string_2_array(mlp_dict[dict_key]), dtype=theano.config.floatX))
+			dict_key = 'logreg b'
+			mlp_layers[-1].params[1].set_value(np.asarray(string_2_array(mlp_dict[dict_key]), dtype=theano.config.floatX))
+
 	logger.info('Loaded the conv_net model in %s',(filename))

models/__init__.py

@@ -19,6 +19,7 @@ def __init__(self):
 		#placeholders
 		self.output = None
 		self.features = None
+		self.features_dim = None
 		self.errors = None
 		self.finetune_cost = None
 
@@ -129,7 +130,7 @@ def getFeaturesFunction(self):
 		A function takes input features 
 		"""
 		#in_x = T.matrix('in_x');
-		in_x = x.type('in_x');
-		fn = theano.function(inputs=[in_x],outputs=[self.features],
+		in_x = self.x.type('in_x');
+		fn = theano.function(inputs=[in_x],outputs=self.features,
 			givens={self.x: in_x},name='features')#,on_unused_input='warn')
-		return fn
+		return fn

models/cnn.py

@@ -77,10 +77,12 @@ def __init__(self, numpy_rng, theano_rng, batch_size, n_outs,conv_layer_configs,
 		self.logLayer = LogisticRegression(input=self.layers[-1].output,n_in=hidden_layers_sizes[-1],n_out=n_outs)
 
 		self.layers.append(self.logLayer)
-	        self.params.extend(self.logLayer.params)
-	        self.delta_params.extend(self.logLayer.delta_params)
+		self.params.extend(self.logLayer.params)
+		self.delta_params.extend(self.logLayer.delta_params)
 
 		self.finetune_cost = self.logLayer.negative_log_likelihood(self.y)
-
 		self.errors = self.logLayer.errors(self.y)
-                self.output = self.logLayer.prediction();
+		self.output = self.logLayer.prediction()
+		
+		self.features = self.conv_layers[-1].output;
+		self.features_dim = self.conv_output_dim;

run/__init__.py

@@ -81,13 +81,11 @@ def valid_score():
 	return best_validation_loss
 
 
-def getFeatures(nnetModel,data_spec_testing):
+def exportFeatures(nnetModel,export_path,data_spec_testing):
+	from io_modules.data_exporter import export_data
+	print nnetModel.features_dim
 	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
+	export_data(data_spec_testing,export_path,out_function,nnetModel.features_dim);
 
 def createDir(wdir):
 	"""create working dir"""

run/run_CNN.py

@@ -27,10 +27,10 @@
 from io_modules.file_reader import read_dataset
 from utils.learn_rates import LearningRate
 from utils.utils import parse_activation
-from io_modules.model_io import _cnn2file,_nnet2file
+from io_modules.model_io import _cnn2file,_file2cnn
 from io_modules import setLogger
 
-from run import fineTunning,testing,createDir
+from run import fineTunning,testing,exportFeatures,createDir
 
 import logging
 logger = logging.getLogger(__name__)
@@ -46,7 +46,7 @@ def runCNN(arg):
 	conv_config,conv_layer_config,mlp_config = load_conv_spec(model_config['nnet_spec'],model_config['batch_size'],
 				model_config['input_shape'])
 
-	data_spec =  load_data_spec(model_config['data_spec']);
+	data_spec =  load_data_spec(model_config['data_spec'],model_config['batch_size']);
 
 
 	numpy_rng = numpy.random.RandomState(89677)
@@ -68,20 +68,19 @@ def runCNN(arg):
 		n_outs=model_config['n_outs'],hidden_layers_sizes=mlp_config['layers'], conv_activation = conv_activation,
 		hidden_activation = hidden_activation,use_fast = conv_config['use_fast'])
 
-	train_sets, train_xy, train_x, train_y = read_dataset(data_spec['training'],model_config['batch_size'])
-	valid_sets, valid_xy, valid_x, valid_y = read_dataset(data_spec['validation'],model_config['batch_size'])
+	train_sets, train_xy, train_x, train_y = read_dataset(data_spec['training'])
+	valid_sets, valid_xy, valid_x, valid_y = read_dataset(data_spec['validation'])
 
 	err=fineTunning(cnn,train_sets,train_xy,train_x,train_y,
-		valid_sets,valid_xy,valid_x,valid_y,lrate,momentum,batch_size);
+				valid_sets,valid_xy,valid_x,valid_y,lrate,momentum,batch_size);
 
-	_cnn2file(cnn.layers[0:cnn.conv_layer_num], filename=model_config['output_file'],activation=conv_config['activation']);
-	_nnet2file(cnn.layers[cnn.conv_layer_num:], filename=model_config['output_file'],activation=mlp_config['activation']);
+	_cnn2file(cnn.layers[0:cnn.conv_layer_num],cnn.layers[cnn.conv_layer_num:], filename=model_config['output_file']);
 
 	####################
 	##	TESTING	 ##
 	####################
 	try:
-		test_sets, test_xy, test_x, test_y = read_dataset(data_spec['testing'],model_config['batch_size']) 
+		test_sets, test_xy, test_x, test_y = read_dataset(data_spec['testing']) 
 	except KeyError:
 		#raise e
 		logger.info("No testing set:Skiping Testing");
@@ -90,7 +89,13 @@ def runCNN(arg):
 
 	pred,err=testing(cnn,test_sets, test_xy, test_x, test_y,batch_size)
 
+	####################
+	##	Export Features ##
+	####################
+	mlp_layers = cnn.layers[cnn.conv_layer_num:]
+	_file2cnn(cnn.conv_layers,mlp_layers, filename=model_config['output_file'])
+
+	exportFeatures(cnn,model_config['export_path'],data_spec['testing'])
 
 if __name__ == '__main__':
-	setLogger(level="DEBUG");
 	runCNN(sys.argv[1])