Fix:CNN

Author: abilng

models/__init__.py

@@ -2,7 +2,6 @@
 from collections import OrderedDict
 import theano
 import theano.tensor as T
-import time
 
 class nnet(object):
 	"""Abstract class for all Network Models"""
@@ -133,97 +132,4 @@ def getFeaturesFunction(self):
 		in_x = 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
-
-
-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
-
-
+		return fn

models/cnn.py

@@ -84,46 +84,3 @@ def __init__(self, numpy_rng, theano_rng, batch_size, n_outs,conv_layer_configs,
 
 		self.errors = self.logLayer.errors(self.y)
                 self.output = self.logLayer.prediction();
-
-
-	"Getting CNN Feats Outputs"
-	def build_out_function(self):
-		feat = T.tensor4('feat', dtype=theano.config.floatX)
-		out_da = theano.function([feat], self.conv_layers[-1].output, \
-				updates = None, givens={self.x:feat}, on_unused_input='warn')
-		return out_da
-	
-	"Building fine tuning operation "
-	def build_finetune_functions(self, train_shared_xy, valid_shared_xy, batch_size):
-
-		(train_set_x, train_set_y) = train_shared_xy
-		(valid_set_x, valid_set_y) = valid_shared_xy
-
-		index = T.lscalar('index')  # index to a [mini]batch
-		learning_rate = T.fscalar('learning_rate')
-		momentum = T.fscalar('momentum')
-
-		# compute the gradients with respect to the model parameters
-		gparams = T.grad(self.finetune_cost, self.params)
-
-		# compute list of fine-tuning updates
-        	updates = OrderedDict()
-
-		for dparam, gparam in zip(self.delta_params, gparams):
-			updates[dparam] = momentum * dparam - gparam*learning_rate
-
-		for dparam, param in zip(self.delta_params, self.params):
-			updates[param] = param + updates[dparam]
-		
-		train_fn = theano.function(inputs=[index, theano.Param(learning_rate, default = 0.001),
-				theano.Param(momentum, default = 0.5)],outputs=self.errors, updates=updates,
-				givens={self.x: train_set_x[index * batch_size:(index + 1) * batch_size],
-					self.y: train_set_y[index * batch_size:(index + 1) * batch_size]})
-
-		valid_fn = theano.function(inputs=[index, theano.Param(learning_rate, default = 0.001),
-				theano.Param(momentum, default = 0.5)],outputs=self.errors, updates=updates,
-				givens={self.x: valid_set_x[index * batch_size:(index + 1) * batch_size],
-					self.y: valid_set_y[index * batch_size:(index + 1) * batch_size]})
-
-		return train_fn, valid_fn
-