深度学习 —— 卷积神经网路 CNN

classLeNetConvPoolLayer(object):
"""PoolLayerofaconvolutionalnetwork"""

def__init__(self,rng,input,filter_shape,image_shape,poolsize=(2,2)):
"""
AllocateaLeNetConvPoolLayerwithsharedvariableinternalparameters.

:typerng:numpy.random.RandomState
:paramrng:arandomnumbergeneratorusedtoinitializeweights

:typeinput:theano.tensor.dtensor4
:paraminput:symbolicimagetensor,ofshapeimage_shape

:typefilter_shape:tupleorlistoflength4
:paramfilter_shape:(numberoffilters,numinputfeaturemaps,
filterheight,filterwidth)

:typeimage_shape:tupleorlistoflength4
:paramimage_shape:(batchsize,numinputfeaturemaps,
imageheight,imagewidth)

:typepoolsize:tupleorlistoflength2
:parampoolsize:thedownsampling(pooling)factor(#rows,#cols)
"""

assertimage_shape[1]==filter_shape[1]
self.input=input

#thereare"numinputfeaturemaps*filterheight*filterwidth"
#inputstoeachhiddenunit
fan_in=numpy.prod(filter_shape[1:])
#eachunitinthelowerlayerreceivesagradientfrom:
#"numoutputfeaturemaps*filterheight*filterwidth"/
#poolingsize
fan_out=(filter_shape[0]*numpy.prod(filter_shape[2:])//
numpy.prod(poolsize))
#initializeweightswithrandomweights
W_bound=numpy.sqrt(6./(fan_in+fan_out))
self.W=theano.shared(
numpy.asarray(
rng.uniform(low=-W_bound,high=W_bound,size=filter_shape),
dtype=theano.config.floatX
),
borrow=True
)

#thebiasisa1Dtensor--onebiasperoutputfeaturemap
b_values=numpy.zeros((filter_shape[0],),dtype=theano.config.floatX)
self.b=theano.shared(value=b_values,borrow=True)

#convolveinputfeaturemapswithfilters
conv_out=conv2d(
input=input,
filters=self.W,
filter_shape=filter_shape,
input_shape=image_shape
)

#pooleachfeaturemapindividually,usingmaxpooling
pooled_out=pool.pool_2d(
input=conv_out,
ds=poolsize,
ignore_border=True
)

#addthebiasterm.Sincethebiasisavector(1Darray),wefirst
#reshapeittoatensorofshape(1,n_filters,1,1).Eachbiaswill
#thusbebroadcastedacrossmini-batchesandfeaturemap
#width&height
self.output=T.tanh(pooled_out+self.b.dimshuffle('x',0,'x','x'))

#storeparametersofthislayer
self.params=[self.W,self.b]

#keeptrackofmodelinput
self.input=input

x=T.matrix('x')#thedataispresentedasrasterizedimages
y=T.ivector('y')#thelabelsarepresentedas1Dvectorof
#[int]labels

######################
#BUILDACTUALMODEL#
######################
print('...buildingthemodel')

#Reshapematrixofrasterizedimagesofshape(batch_size,28*28)
#toa4Dtensor,compatiblewithourLeNetConvPoolLayer
#(28,28)isthesizeofMNISTimages.
layer0_input=x.reshape((batch_size,1,28,28))

#Constructthefirstconvolutionalpoolinglayer:
#filteringreducestheimagesizeto(28-5+1,28-5+1)=(24,24)
#maxpoolingreducesthisfurtherto(24/2,24/2)=(12,12)
#4Doutputtensoristhusofshape(batch_size,nkerns[0],12,12)
layer0=LeNetConvPoolLayer(
rng,
input=layer0_input,
image_shape=(batch_size,1,28,28),
filter_shape=(nkerns[0],1,5,5),
poolsize=(2,2)
)

#Constructthesecondconvolutionalpoolinglayer
#filteringreducestheimagesizeto(12-5+1,12-5+1)=(8,8)
#maxpoolingreducesthisfurtherto(8/2,8/2)=(4,4)
#4Doutputtensoristhusofshape(batch_size,nkerns[1],4,4)
layer1=LeNetConvPoolLayer(
rng,
input=layer0.output,
image_shape=(batch_size,nkerns[0],12,12),
filter_shape=(nkerns[1],nkerns[0],5,5),
poolsize=(2,2)
)

#theHiddenLayerbeingfully-connected,itoperateson2Dmatricesof
#shape(batch_size,num_pixels)(i.ematrixofrasterizedimages).
#Thiswillgenerateamatrixofshape(batch_size,nkerns[1]*4*4),
#or(500,50*4*4)=(500,800)withthedefaultvalues.
layer2_input=layer1.output.flatten(2)

#constructafully-connectedsigmoidallayer
layer2=HiddenLayer(
rng,
input=layer2_input,
n_in=nkerns[1]*4*4,
n_out=500,
activation=T.tanh
)

#classifythevaluesofthefully-connectedsigmoidallayer
layer3=LogisticRegression(input=layer2.output,n_in=500,n_out=10)

#thecostweminimizeduringtrainingistheNLLofthemodel
cost=layer3.negative_log_likelihood(y)

#createafunctiontocomputethemistakesthataremadebythemodel
test_model=theano.function(
[index],
layer3.errors(y),
givens={
x:test_set_x[index*batch_size:(index+1)*batch_size],
y:test_set_y[index*batch_size:(index+1)*batch_size]
}
)

validate_model=theano.function(
[index],
layer3.errors(y),
givens={
x:valid_set_x[index*batch_size:(index+1)*batch_size],
y:valid_set_y[index*batch_size:(index+1)*batch_size]
}
)

#createalistofallmodelparameterstobefitbygradientdescent
params=layer3.params+layer2.params+layer1.params+layer0.params

#createalistofgradientsforallmodelparameters
grads=T.grad(cost,params)

#train_modelisafunctionthatupdatesthemodelparametersby
#SGDSincethismodelhasmanyparameters,itwouldbetediousto
#manuallycreateanupdateruleforeachmodelparameter.Wethus
#createtheupdateslistbyautomaticallyloopingoverall
#(params[i],grads[i])pairs.
updates=[
(param_i,param_i-learning_rate*grad_i)
forparam_i,grad_iinzip(params,grads)
]

train_model=theano.function(
[index],
cost,
updates=updates,
givens={
x:train_set_x[index*batch_size:(index+1)*batch_size],
y:train_set_y[index*batch_size:(index+1)*batch_size]
}
)

pythoncode/convolutional_mlp.py

Optimizationcomplete.
Bestvalidationscoreof0.910000%obtainedatiteration17800,withtest
performance0.920000%
Thecodeforfileconvolutional_mlp.pyranfor380.28m

Optimizationcomplete.
Bestvalidationscoreof0.910000%obtainedatiteration15500,withtest
performance0.930000%
Thecodeforfileconvolutional_mlp.pyranfor46.76m

Optimizationcomplete.
Bestvalidationscoreof0.910000%obtainedatiteration16400,withtest
performance0.930000%
Thecodeforfileconvolutional_mlp.pyranfor32.52m