卷积神经网络（三）：卷积神经网络CNN的简单实现（部分Python源码）

转载自：

卷积神经网络（三）：卷积神经网络CNN的简单实现（部分Python源码） - xuanyuansen的专栏 - 博客频道 - CSDN.NET
http://blog.csdn.net/xuanyuansen/article/details/41924377

上周末利用python简单实现了一个卷积神经网络，只包含一个卷积层和一个maxpooling层，pooling层后面的多层神经网络采用了softmax形式的输出。实验输入仍然采用MNIST图像使用10个feature map时，卷积和pooling的结果分别如下所示。

部分源码如下：

 #coding=utf-8
 '''''
 Created on 2014年11月30日
 @author: Wangliaofan
 '''
 import numpy
 import struct
 import matplotlib.pyplot as plt
 import math
 import random
 import copy
 #test
 from BasicMultilayerNeuralNetwork import BMNN2


 def sigmoid(inX):
     if 1.0+numpy.exp(-inX)== 0.0:
         return 999999999.999999999
     return 1.0/(1.0+numpy.exp(-inX))
 def difsigmoid(inX):
     return sigmoid(inX)*(1.0-sigmoid(inX))
 def tangenth(inX):
     return (1.0*math.exp(inX)-1.0*math.exp(-inX))/(1.0*math.exp(inX)+1.0*math.exp(-inX))

 def cnn_conv(in_image, filter_map,B,type_func='sigmoid'):
     #in_image[num,feature map,row,col]=>in_image[Irow,Icol]
     #features map[k filter,row,col]
     #type_func['sigmoid','tangenth']
     #out_feature[k filter,Irow-row+1,Icol-col+1]
     shape_image=numpy.shape(in_image)#[row,col]
     #print "shape_image",shape_image
     shape_filter=numpy.shape(filter_map)#[k filter,row,col]
     if shape_filter[1]>shape_image[0] or shape_filter[2]>shape_image[1]:
         raise Exception
     shape_out=(shape_filter[0],shape_image[0]-shape_filter[1]+1,shape_image[1]-shape_filter[2]+1)
     out_feature=numpy.zeros(shape_out)
     k,m,n=numpy.shape(out_feature)
     for k_idx in range(0,k):
         #rotate 180 to calculate conv
         c_filter=numpy.rot90(filter_map[k_idx,:,:], 2)
         for r_idx in range(0,m):
             for c_idx in range(0,n):
                 #conv_temp=numpy.zeros((shape_filter[1],shape_filter[2]))
                 conv_temp=numpy.dot(in_image[r_idx:r_idx+shape_filter[1],c_idx:c_idx+shape_filter[2]],c_filter)
                 sum_temp=numpy.sum(conv_temp)
                 if type_func=='sigmoid':
                     out_feature[k_idx,r_idx,c_idx]=sigmoid(sum_temp+B[k_idx])
                 elif type_func=='tangenth':
                     out_feature[k_idx,r_idx,c_idx]=tangenth(sum_temp+B[k_idx])
                 else:
                     raise Exception
     return out_feature

 def cnn_maxpooling(out_feature,pooling_size=2,type_pooling="max"):
     k,row,col=numpy.shape(out_feature)
     max_index_Matirx=numpy.zeros((k,row,col))
     out_row=int(numpy.floor(row/pooling_size))
     out_col=int(numpy.floor(col/pooling_size))
     out_pooling=numpy.zeros((k,out_row,out_col))
     for k_idx in range(0,k):
         for r_idx in range(0,out_row):
             for c_idx in range(0,out_col):
                 temp_matrix=out_feature[k_idx,pooling_size*r_idx:pooling_size*r_idx+pooling_size,pooling_size*c_idx:pooling_size*c_idx+pooling_size]
                 out_pooling[k_idx,r_idx,c_idx]=numpy.amax(temp_matrix)
                 max_index=numpy.argmax(temp_matrix)
                 #print max_index
                 #print max_index/pooling_size,max_index%pooling_size
                 max_index_Matirx[k_idx,pooling_size*r_idx+max_index/pooling_size,pooling_size*c_idx+max_index%pooling_size]=1
     return out_pooling,max_index_Matirx

 def poolwithfunc(in_pooling,W,B,type_func='sigmoid'):
     k,row,col=numpy.shape(in_pooling)
     out_pooling=numpy.zeros((k,row,col))
     for k_idx in range(0,k):
         for r_idx in range(0,row):
             for c_idx in range(0,col):
                 out_pooling[k_idx,r_idx,c_idx]=sigmoid(W[k_idx]*in_pooling[k_idx,r_idx,c_idx]+B[k_idx])
     return out_pooling
 #out_feature is the out put of conv
 def backErrorfromPoolToConv(theta,max_index_Matirx,out_feature,pooling_size=2):
     k1,row,col=numpy.shape(out_feature)
     error_conv=numpy.zeros((k1,row,col))
     k2,theta_row,theta_col=numpy.shape(theta)
     if k1!=k2:
         raise Exception
     for idx_k in range(0,k1):
         for idx_row in range( 0, row):
             for idx_col in range( 0, col):
                 error_conv[idx_k,idx_row,idx_col]=\
                     max_index_Matirx[idx_k,idx_row,idx_col]*\
                     float(theta[idx_k,idx_row/pooling_size,idx_col/pooling_size])*\
                     difsigmoid(out_feature[idx_k,idx_row,idx_col])
     return error_conv

 def backErrorfromConvToInput(theta,inputImage):
     k1,row,col=numpy.shape(theta)
     #print "theta",k1,row,col
     i_row,i_col=numpy.shape(inputImage)
     if row>i_row or col> i_col:
         raise Exception
     filter_row=i_row-row+1
     filter_col=i_col-col+1
     detaW=numpy.zeros((k1,filter_row,filter_col))
     #the same with conv valid in matlab
     for k_idx in range(0,k1):
         for idx_row in range(0,filter_row):
             for idx_col in range(0,filter_col):
                 subInputMatrix=inputImage[idx_row:idx_row+row,idx_col:idx_col+col]
                 #print "subInputMatrix",numpy.shape(subInputMatrix)
                 #rotate theta 180
                 #print numpy.shape(theta)
                 theta_rotate=numpy.rot90(theta[k_idx,:,:], 2)
                 #print "theta_rotate",theta_rotate
                 dotMatrix=numpy.dot(subInputMatrix,theta_rotate)
                 detaW[k_idx,idx_row,idx_col]=numpy.sum(dotMatrix)
     detaB=numpy.zeros((k1,1))
     for k_idx in range(0,k1):
         detaB[k_idx]=numpy.sum(theta[k_idx,:,:])
     return detaW,detaB

 def loadMNISTimage(absFilePathandName,datanum=60000):
     images=open(absFilePathandName,'rb')
     buf=images.read()
     index=0
     magic, numImages , numRows , numColumns = struct.unpack_from('>IIII' , buf , index)
     print magic, numImages , numRows , numColumns
     index += struct.calcsize('>IIII')
     if magic != 2051:
         raise Exception
     datasize=int(784*datanum)
     datablock=">"+str(datasize)+"B"
     #nextmatrix=struct.unpack_from('>47040000B' ,buf, index)
     nextmatrix=struct.unpack_from(datablock ,buf, index)
     nextmatrix=numpy.array(nextmatrix)/255.0
     #nextmatrix=nextmatrix.reshape(numImages,numRows,numColumns)
     #nextmatrix=nextmatrix.reshape(datanum,1,numRows*numColumns)
     nextmatrix=nextmatrix.reshape(datanum,1,numRows,numColumns)
     return nextmatrix, numImages

 def loadMNISTlabels(absFilePathandName,datanum=60000):
     labels=open(absFilePathandName,'rb')
     buf=labels.read()
     index=0
     magic, numLabels  = struct.unpack_from('>II' , buf , index)
     print magic, numLabels
     index += struct.calcsize('>II')
     if magic != 2049:
         raise Exception

     datablock=">"+str(datanum)+"B"
     #nextmatrix=struct.unpack_from('>60000B' ,buf, index)
     nextmatrix=struct.unpack_from(datablock ,buf, index)
     nextmatrix=numpy.array(nextmatrix)
     return nextmatrix, numLabels

 def simpleCNN(numofFilter,filter_size,pooling_size=2,maxIter=1000,imageNum=500):
     decayRate=0.01
     MNISTimage,num1=loadMNISTimage("F:\Machine Learning\UFLDL\data\common\\train-images-idx3-ubyte",imageNum)
     print num1
     row,col=numpy.shape(MNISTimage[0,0,:,:])
     out_Di=numofFilter*((row-filter_size+1)/pooling_size)*((col-filter_size+1)/pooling_size)
     MLP=BMNN2.MuiltilayerANN(1,[128],out_Di,10,maxIter)
     MLP.setTrainDataNum(imageNum)
     MLP.loadtrainlabel("F:\Machine Learning\UFLDL\data\common\\train-labels-idx1-ubyte")
     MLP.initialweights()
     #MLP.printWeightMatrix()
     rng = numpy.random.RandomState(23455)
     W_shp = (numofFilter, filter_size, filter_size)
     W_bound = numpy.sqrt(numofFilter * filter_size * filter_size)
     W_k=rng.uniform(low=-1.0 / W_bound,high=1.0 / W_bound,size=W_shp)
     B_shp = (numofFilter,)
     B= numpy.asarray(rng.uniform(low=-.5, high=.5, size=B_shp))
     cIter=0
     while cIter
         cIter += 1
         ImageNum=random.randint(0,imageNum-1)
         conv_out_map=cnn_conv(MNISTimage[ImageNum,0,:,:], W_k, B,"sigmoid")
         out_pooling,max_index_Matrix=cnn_maxpooling(conv_out_map,2,"max")
         pool_shape = numpy.shape(out_pooling)
         MLP_input=out_pooling.reshape(1,1,out_Di)
         #print numpy.shape(MLP_input)
         DetaW,DetaB,temperror=MLP.backwardPropogation(MLP_input,ImageNum)
         if cIter%50 ==0 :
             print cIter,"Temp error: ",temperror
         #print numpy.shape(MLP.Theta[MLP.Nl-2])
         #print numpy.shape(MLP.Ztemp[0])
         #print numpy.shape(MLP.weightMatrix[0])
         theta_pool=MLP.Theta[MLP.Nl-2]*MLP.weightMatrix[0].transpose()
         #print numpy.shape(theta_pool)
         #print "theta_pool",theta_pool
         temp=numpy.zeros((1,1,out_Di))
         temp[0,:,:]=theta_pool
         back_theta_pool=temp.reshape(pool_shape)
         #print "back_theta_pool",numpy.shape(back_theta_pool)
         #print "back_theta_pool",back_theta_pool
         error_conv=backErrorfromPoolToConv(back_theta_pool,max_index_Matrix,conv_out_map,2)
         #print "error_conv",numpy.shape(error_conv)
         #print error_conv
         conv_DetaW,conv_DetaB=backErrorfromConvToInput(error_conv,MNISTimage[ImageNum,0,:,:])
         #print "W_k",W_k
         #print "conv_DetaW",conv_DetaW
         #print "conv_DetaB",conv_DetaB
         temp=W_k- decayRate*conv_DetaW
         W_k=copy.deepcopy(temp)
         #print "W_k",W_k
         temp = B - decayRate*conv_DetaB
         B=copy.deepcopy(B)
         #print "B",B
         MLP.updatePara(DetaW, DetaB, 1)
     return W_k,B,MLP
 def getTrainAccuracy(numofFilter,filter_size,pooling_size,ImageNum,W_k,B,MLP):
     MNISTimage,num1=loadMNISTimage("F:\Machine Learning\UFLDL\data\common\\train-images-idx3-ubyte",ImageNum)
     MLP.setTrainDataNum(ImageNum)
     MLP.loadtrainlabel("F:\Machine Learning\UFLDL\data\common\\train-labels-idx1-ubyte")
     #MNISTlabel,num2=loadMNISTimage("F:\Machine Learning\UFLDL\data\common\\train-images-idx3-ubyte",ImageNum)
     row,col=numpy.shape(MNISTimage[0,0,:,:])
     iteration=0
     out_Di=numofFilter*((row-filter_size+1)/pooling_size)*((col-filter_size+1)/pooling_size)
     accuracycount=0
     while iteration
         conv_out_map=cnn_conv(MNISTimage[iteration,0,:,:], W_k, B,"sigmoid")
         out_pooling,max_index_Matrix=cnn_maxpooling(conv_out_map,2,"max")
         #pool_shape = numpy.shape(out_pooling)
         MLP_input=out_pooling.reshape(1,1,out_Di)
         Atemp,Ztemp,errorsum=MLP.forwardPropogation(MLP_input,iteration)
         TrainPredict=Atemp[MLP.Nl-2]
         #print TrainPredict
         Plist=TrainPredict.tolist()
         LabelPredict=Plist[0].index(max(Plist[0]))
         #print "LabelPredict",LabelPredict
         #print "trainLabel",MLP.trainlabel[iteration]
         if int(LabelPredict) == int(MLP.trainlabel[iteration]):
             accuracycount += 1
         iteration += 1
         if iteration%50 ==0 :
             print iteration
     print "accuracy:", float(accuracycount)/float(ImageNum)
     return  float(accuracycount)/float(ImageNum)

 if __name__ == '__main__':
     MNISTimage,num1=loadMNISTimage("F:\Machine Learning\UFLDL\data\common\\train-images-idx3-ubyte",1)
     MNISTlabel,num2=loadMNISTlabels("F:\Machine Learning\UFLDL\data\common\\train-labels-idx1-ubyte",1)
     fig1 = plt.figure("convolution")
     k=10
     filter_size=5
     rng = numpy.random.RandomState(23455)
     w_shp = (k, filter_size, filter_size)
     w_bound = numpy.sqrt(k * filter_size * filter_size)
     w_k=rng.uniform(low=-1.0 / w_bound,high=1.0 / w_bound,size=w_shp)
     B_shp = (k,)
     B= numpy.asarray(rng.uniform(low=-.5, high=.5, size=B_shp))
     #print B
     out_map=cnn_conv(MNISTimage[0,0,:,:], w_k, B,"sigmoid")
     for idx in range(0,10):
         plotwindow = fig1.add_subplot(2,5,idx+1)
         plt.imshow(out_map[idx,:,:], cmap='gray')
     #plt.show()
     fig2 = plt.figure("max-pooling")
     out_pooling,max_index=cnn_maxpooling(out_map)
     for idx in range(0,10):
         plotwindow = fig2.add_subplot(2,5,idx+1)
         plt.imshow(out_pooling[idx,:,:], cmap='gray')

     W_pool_shp = (k,)
     W_pool= numpy.asarray(rng.uniform(low=-1, high=1, size=W_pool_shp))
     B_pool_shp = (k,)
     B_pool= numpy.asarray(rng.uniform(low=-.5, high=.5, size=B_pool_shp))
     fig3 = plt.figure("pooling")
     pooling=poolwithfunc(out_pooling, W_pool, B_pool)
     for idx in range(0,10):
         plotwindow = fig3.add_subplot(2,5,idx+1)
         plt.imshow(pooling[idx,:,:], cmap='gray')
     #plt.show()

     W_k,B,MLP=simpleCNN(5,5,2,2000,10000)
     #MLP.printWeightMatrix()
     accu=getTrainAccuracy(5,5,2,4000,W_k,B,MLP)
     print accu
     pass