--- a/baseline/conv_mlp/convolutional_mlp.py	Tue Mar 16 21:24:41 2010 -0400
+++ b/baseline/conv_mlp/convolutional_mlp.py	Wed Mar 17 10:21:57 2010 -0400
@@ -26,8 +26,8 @@
 import theano.sandbox.softsign
 import pylearn.datasets.MNIST
 from pylearn.io import filetensor as ft
-from theano.tensor.signal import downsample
-from theano.tensor.nnet import conv
+from theano.sandbox import conv, downsample
+import theano,pylearn.version,ift6266
 
 class LeNetConvPoolLayer(object):
 
@@ -214,7 +214,7 @@
 
     # Dealing with the training set
     # get the list of training images (x) and their labels (y)
-    (train_set_x, train_set_y) = (d[:4000,:],labels[:4000])
+    (train_set_x, train_set_y) = (d[:200000,:],labels[:200000])
     # initialize the list of training minibatches with empty list
     train_batches = []
     for i in xrange(0, len(train_set_x), batch_size):
@@ -229,7 +229,7 @@
     #print train_batches[500]
 
     # Dealing with the validation set
-    (valid_set_x, valid_set_y) = (d[4000:5000,:],labels[4000:5000])
+    (valid_set_x, valid_set_y) = (d[200000:270000,:],labels[200000:270000])
     # initialize the list of validation minibatches 
     valid_batches = []
     for i in xrange(0, len(valid_set_x), batch_size):
@@ -237,17 +237,18 @@
                [(valid_set_x[i:i+batch_size], valid_set_y[i:i+batch_size])]
 
     # Dealing with the testing set
-    (test_set_x, test_set_y) = (d[5000:6000,:],labels[5000:6000])
+    (test_set_x, test_set_y) = (d[270000:340000,:],labels[270000:340000])
     # initialize the list of testing minibatches 
     test_batches = []
     for i in xrange(0, len(test_set_x), batch_size):
         test_batches = test_batches + \
               [(test_set_x[i:i+batch_size], test_set_y[i:i+batch_size])]
 
+
     return train_batches, valid_batches, test_batches
 
 
-def evaluate_lenet5(learning_rate=0.1, n_iter=1, batch_size=20, n_kern0=20,n_kern1=50,filter_shape=5,n_layer=3, dataset='mnist.pkl.gz'):
+def evaluate_lenet5(learning_rate=0.1, n_iter=200, batch_size=20, n_kern0=20, n_kern1=50, n_layer=3, filter_shape0=5, filter_shape1=5, dataset='mnist.pkl.gz'):
     rng = numpy.random.RandomState(23455)
 
     print 'Before load dataset'
@@ -256,6 +257,16 @@
 
     ishape = (32,32)     # this is the size of NIST images
     n_kern2=80
+    n_kern3=100
+    if n_layer==4:
+      filter_shape1=3
+      filter_shape2=3
+    if n_layer==5:
+      filter_shape0=4
+      filter_shape1=2
+      filter_shape2=2
+      filter_shape3=2
+
 
     # allocate symbolic variables for the data
     x = T.matrix('x')  # rasterized images
@@ -276,7 +287,7 @@
     # 4D output tensor is thus of shape (20,20,14,14)
     layer0 = LeNetConvPoolLayer(rng, input=layer0_input,
             image_shape=(batch_size,1,32,32), 
-            filter_shape=(n_kern0,1,filter_shape,filter_shape), poolsize=(2,2))
+            filter_shape=(n_kern0,1,filter_shape0,filter_shape0), poolsize=(2,2))
 
     if(n_layer>2):
 
@@ -284,17 +295,17 @@
 	# filtering reduces the image size to (14-5+1,14-5+1)=(10,10)
 	# maxpooling reduces this further to (10/2,10/2) = (5,5)
 	# 4D output tensor is thus of shape (20,50,5,5)
-	fshape=(32-filter_shape+1)/2
+	fshape0=(32-filter_shape0+1)/2
 	layer1 = LeNetConvPoolLayer(rng, input=layer0.output,
-		image_shape=(batch_size,n_kern0,fshape,fshape), 
-		filter_shape=(n_kern1,n_kern0,filter_shape,filter_shape), poolsize=(2,2))
+		image_shape=(batch_size,n_kern0,fshape0,fshape0), 
+		filter_shape=(n_kern1,n_kern0,filter_shape1,filter_shape1), poolsize=(2,2))
 
     else:
 
-	fshape=(32-filter_shape+1)/2
+	fshape0=(32-filter_shape0+1)/2
 	layer1_input = layer0.output.flatten(2)
 		# construct a fully-connected sigmoidal layer
-	layer1 = SigmoidalLayer(rng, input=layer1_input,n_in=n_kern0*fshape*fshape, n_out=500)
+	layer1 = SigmoidalLayer(rng, input=layer1_input,n_in=n_kern0*fshape0*fshape0, n_out=500)
 
 	layer2 = LogisticRegression(input=layer1.output, n_in=500, n_out=10)
 	cost = layer2.negative_log_likelihood(y)
@@ -304,17 +315,46 @@
 
     if(n_layer>3):
 
-	fshape=(32-filter_shape+1)/2
-	fshape2=(fshape-filter_shape+1)/2
-	fshape3=(fshape2-filter_shape+1)/2
+	fshape0=(32-filter_shape0+1)/2
+	fshape1=(fshape0-filter_shape1+1)/2
 	layer2 = LeNetConvPoolLayer(rng, input=layer1.output,
-		image_shape=(batch_size,n_kern1,fshape2,fshape2), 
-		filter_shape=(n_kern2,n_kern1,filter_shape,filter_shape), poolsize=(2,2))
+		image_shape=(batch_size,n_kern1,fshape1,fshape1), 
+		filter_shape=(n_kern2,n_kern1,filter_shape2,filter_shape2), poolsize=(2,2))
+
+    if(n_layer>4):
+
+
+	fshape0=(32-filter_shape0+1)/2
+	fshape1=(fshape0-filter_shape1+1)/2
+	fshape2=(fshape1-filter_shape2+1)/2
+	fshape3=(fshape2-filter_shape3+1)/2
+	layer3 = LeNetConvPoolLayer(rng, input=layer2.output,
+		image_shape=(batch_size,n_kern2,fshape2,fshape2), 
+		filter_shape=(n_kern3,n_kern2,filter_shape3,filter_shape3), poolsize=(2,2))
+
+	layer4_input = layer3.output.flatten(2)
 
+	layer4 = SigmoidalLayer(rng, input=layer4_input, 
+					n_in=n_kern3*fshape3*fshape3, n_out=500)
+
+  
+	layer5 = LogisticRegression(input=layer4.output, n_in=500, n_out=10)
+
+	cost = layer5.negative_log_likelihood(y)
+
+	test_model = theano.function([x,y], layer5.errors(y))
+
+	params = layer5.params+ layer4.params+ layer3.params+ layer2.params+ layer1.params + layer0.params
+
+    elif(n_layer>3):
+
+	fshape0=(32-filter_shape0+1)/2
+	fshape1=(fshape0-filter_shape1+1)/2
+	fshape2=(fshape1-filter_shape2+1)/2
 	layer3_input = layer2.output.flatten(2)
 
 	layer3 = SigmoidalLayer(rng, input=layer3_input, 
-					n_in=n_kern2*fshape3*fshape3, n_out=500)
+					n_in=n_kern2*fshape2*fshape2, n_out=500)
 
   
 	layer4 = LogisticRegression(input=layer3.output, n_in=500, n_out=10)
@@ -328,8 +368,8 @@
  
     elif(n_layer>2):
 
-	fshape=(32-filter_shape+1)/2
-	fshape2=(fshape-filter_shape+1)/2
+	fshape0=(32-filter_shape0+1)/2
+	fshape1=(fshape0-filter_shape1+1)/2
 
 	# the SigmoidalLayer being fully-connected, it operates on 2D matrices of
 	# shape (batch_size,num_pixels) (i.e matrix of rasterized images).
@@ -338,7 +378,7 @@
 
 	# construct a fully-connected sigmoidal layer
 	layer2 = SigmoidalLayer(rng, input=layer2_input, 
-					n_in=n_kern1*fshape2*fshape2, n_out=500)
+					n_in=n_kern1*fshape1*fshape1, n_out=500)
 
   
 	# classify the values of the fully-connected sigmoidal layer
@@ -462,7 +502,7 @@
 
 def experiment(state, channel):
     print 'start experiment'
-    (best_validation_loss, test_score, minutes_trained, iter) = evaluate_lenet5(state.learning_rate, state.n_iter, state.batch_size, state.n_kern0, state.n_kern1, state.filter_shape, state.n_layer)
+    (best_validation_loss, test_score, minutes_trained, iter) = evaluate_lenet5(state.learning_rate, state.n_iter, state.batch_size, state.n_kern0, state.n_kern1, state.n_layer, state.filter_shape0, state.filter_shape1)
     print 'end experiment'
     
     state.best_validation_loss = best_validation_loss