ift6266: baseline/conv_mlp/convolutional

comparison baseline/conv_mlp/convolutional_mlp.py @ 253:a491d3600a77

Derniere version du reseau a convolution

author	Jeremy Eustache <jeremy.eustache@voila.fr>
date	Wed, 17 Mar 2010 10:21:57 -0400
parents	168aae8a6419
children	d41fe003fade

comparison

equal deleted inserted replaced

-:7dd43ef66d15
+:a491d3600a77
 import numpy, theano, cPickle, gzip, time
 import theano.tensor as T
 import theano.sandbox.softsign
 import pylearn.datasets.MNIST
 from pylearn.io import filetensor as ft
-from theano.tensor.signal import downsample
+from theano.sandbox import conv, downsample
-from theano.tensor.nnet import conv
+import theano,pylearn.version,ift6266
 class LeNetConvPoolLayer(object):
 def __init__(self, rng, input, filter_shape, image_shape, poolsize=(2,2)):
 """
 # make minibatches of size 20
 batch_size = batch   # sized of the minibatch
 # 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):
 # add to the list of minibatches the minibatch starting at
 # position i, ending at position i+batch_size
 [(train_set_x[i:i+batch_size], train_set_y[i:i+batch_size])]
 #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):
 valid_batches = valid_batches + \
 [(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'
 train_batches, valid_batches, test_batches = load_dataset(dataset,batch_size)
 print 'After load dataset'
 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
 y = T.lvector()  # the labels are presented as 1D vector of [long int] labels
 # filtering reduces the image size to (32-5+1,32-5+1)=(28,28)
 # maxpooling reduces this further to (28/2,28/2) = (14,14)
 # 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):
 	# Construct the second convolutional pooling layer
 	# 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),
+		image_shape=(batch_size,n_kern0,fshape0,fshape0),
-		filter_shape=(n_kern1,n_kern0,filter_shape,filter_shape), poolsize=(2,2))
+		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)
 	test_model = theano.function([x,y], layer2.errors(y))
 	params = layer2.params+ layer1.params + layer0.params
 if(n_layer>3):
-	fshape=(32-filter_shape+1)/2
+	fshape0=(32-filter_shape0+1)/2
-	fshape2=(fshape-filter_shape+1)/2
+	fshape1=(fshape0-filter_shape1+1)/2
-	fshape3=(fshape2-filter_shape+1)/2
 	layer2 = LeNetConvPoolLayer(rng, input=layer1.output,
-		image_shape=(batch_size,n_kern1,fshape2,fshape2),
+		image_shape=(batch_size,n_kern1,fshape1,fshape1),
-		filter_shape=(n_kern2,n_kern1,filter_shape,filter_shape), poolsize=(2,2))
+		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)
 	cost = layer4.negative_log_likelihood(y)
 	params = layer4.params+ layer3.params+ layer2.params+ layer1.params + layer0.params
 elif(n_layer>2):
-	fshape=(32-filter_shape+1)/2
+	fshape0=(32-filter_shape0+1)/2
-	fshape2=(fshape-filter_shape+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).
 	# This will generate a matrix of shape (20,32*4*4) = (20,512)
 	layer2_input = layer1.output.flatten(2)
 	# 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
 	layer3 = LogisticRegression(input=layer2.output, n_in=500, n_out=10)
 if __name__ == '__main__':
 evaluate_lenet5()
 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
 state.test_score = test_score
 state.minutes_trained = minutes_trained

Mercurial > ift6266

comparison baseline/conv_mlp/convolutional_mlp.py @ 253:a491d3600a77