ift6266: baseline/mlp/ratio_classes/mlp_nist

comparison baseline/mlp/ratio_classes/mlp_nist_ratio.py @ 443:89a49dae6cf3

merge

author	Xavier Glorot <glorotxa@iro.umontreal.ca>
date	Mon, 03 May 2010 18:38:58 -0400
parents	d8129a09ffb1
children

comparison

equal deleted inserted replaced

-:d5b2b6397a5a
+:89a49dae6cf3
 to do lr first, then add regularization)
 """
 __docformat__ = 'restructedtext en'
-import ift6266
+import setup_batches
-from scripts import setup_batches
 import pdb
 import numpy
 import theano
 import theano.tensor as T
 sigmoid function  while the top layer is a softamx layer.
 """
-def __init__(self, input, n_in, n_hidden, n_out,learning_rate):
+def __init__(self, input, n_in, n_hidden, n_out,learning_rate, test_subclass):
 """Initialize the parameters for the multilayer perceptron
 :param input: symbolic variable that describes the input of the
 architecture (one minibatch)
 # symbolic expression computing the values of the top layer
 self.p_y_given_x= T.nnet.softmax(T.dot(self.hidden, self.W2)+self.b2)
 # compute prediction as class whose probability is maximal in
 # symbolic form
-self.y_pred = T.argmax( self.p_y_given_x, axis =1)
+#self.y_pred = T.argmax( self.p_y_given_x, axis =1)
-self.y_pred_num = T.argmax( self.p_y_given_x[0:9], axis =1)
+#self.y_pred_num = T.argmax( self.p_y_given_x[0:9], axis =1)
+	self.test_subclass = test_subclass
+	#if (self.test_subclass == "u"):
+	#  self.y_pred = T.argmax( self.p_y_given_x[10:35], axis =1) + 10
+#elif (self.test_subclass == "l"):
+	#  self.y_pred = T.argmax( self.p_y_given_x[35:], axis =1) + 35
+#elif (self.test_subclass == "d"):
+	#  self.y_pred = T.argmax( self.p_y_given_x[0:9], axis =1)
+#else:
+	self.y_pred = T.argmax( self.p_y_given_x, axis =1)
 # L1 norm ; one regularization option is to enforce L1 norm to
 # be small
 self.L1     = abs(self.W1).sum() + abs(self.W2).sum()
 # square of L2 norm ; one regularization option is to enforce
 L1_reg = 0.00,\
 L2_reg = 0.0001,\
 nb_max_exemples=1000000,\
 batch_size=20,\
 nb_hidden = 500,\
-nb_targets = 62,\
+nb_targets = 26,\
 			tau=1e6,\
-			main_class="d",\
+			main_class="l",\
 			start_ratio=1,\
 			end_ratio=1):
 configuration = [learning_rate,nb_max_exemples,nb_hidden,adaptive_lr]
 print 'finished parsing the data'
 # construct the logistic regression class
 classifier = MLP( input=x.reshape((batch_size,32*32)),\
 n_in=32*32,\
 n_hidden=nb_hidden,\
-n_out=nb_targets,
+n_out=nb_targets,\
-learning_rate=learning_rate)
+learning_rate=learning_rate,\
+			test_subclass=main_class)
 # the cost we minimize during training is the negative log likelihood of
 n_iter = nb_max_exemples/batch_size  # nb of max times we are allowed to run through all exemples
 n_iter = n_iter/n_minibatches + 1 #round up
 n_iter=max(1,n_iter) # run at least once on short debug call
 time_n=0 #in unit of exemples
+if (main_class == "u"):
+class_offset = 10
+elif (main_class == "l"):
+class_offset = 36
+else:
+class_offset = 0
 if verbose == True:
 print 'looping at most %d times through the data set' %n_iter
 for iter in xrange(n_iter* n_minibatches):
 	    classifier.lr.value = tau*initial_lr/(tau+time_n)
 # get the minibatches corresponding to `iter` modulo
 # `len(train_batches)`
 x,y = train_batches[ minibatch_index ]
+	y = y - class_offset
 # convert to float
 x_float = x/255.0
 cost_ij = train_model(x_float,y)
 if (iter+1) % validation_frequency == 0:
 # compute zero-one loss on validation set
 this_validation_loss = 0.
 for x,y in validation_batches:
 # sum up the errors for each minibatch
+		y = y - class_offset
 x_float = x/255.0
 this_validation_loss += test_model(x_float,y)
 # get the average by dividing with the number of minibatches
 this_validation_loss /= len(validation_batches)
 #save the validation loss
 #get the training error rate
 this_train_loss=0
 for x,y in train_batches:
 # sum up the errors for each minibatch
+		y = y - class_offset
 x_float = x/255.0
 this_train_loss += test_model(x_float,y)
 # get the average by dividing with the number of minibatches
 this_train_loss /= len(train_batches)
 #save the validation loss
 # so we continue exploring
 patience=nb_max_exemples/batch_size
 # test it on the test set
 test_score = 0.
 for x,y in test_batches:
+		    y = y - class_offset
 x_float=x/255.0
 test_score += test_model(x_float,y)
 test_score /= len(test_batches)
 if verbose == True:
 print(('     epoch %i, minibatch %i/%i, test error of best '
 test_score = 0.
 #cap the patience so we are allowed one more validation error
 #calculation before aborting
 patience = iter+validation_frequency+1
 for x,y in test_batches:
+		    y = y - class_offset
 x_float=x/255.0
 test_score += test_model(x_float,y)
 test_score /= len(test_batches)
 if verbose == True:
 print ' validation error is going up, possibly stopping soon'
 if __name__ == '__main__':
 mlp_full_nist(True)
 def jobman_mlp_full_nist(state,channel):
 (train_error,validation_error,test_error,nb_exemples,time)=mlp_full_nist(learning_rate=state.learning_rate,\
-nb_max_exemples=state.nb_max_exemples,\
 nb_hidden=state.nb_hidden,\
-adaptive_lr=state.adaptive_lr,\
+main_class=state.main_class,\
-								tau=state.tau,\
+								start_ratio=state.ratio,\
-								main_class=state.main_class,\
+								end_ratio=state.ratio)
-								start_ratio=state.start_ratio,\
-								end_ratio=state.end_ratio)
 state.train_error=train_error
 state.validation_error=validation_error
 state.test_error=test_error
 state.nb_exemples=nb_exemples
 state.time=time

Mercurial > ift6266

comparison baseline/mlp/ratio_classes/mlp_nist_ratio.py @ 443:89a49dae6cf3