python二維矩陣卷積自定義

㈠ 怎樣用python構建一個卷積神經網路

用keras框架較為方便

首先安裝anaconda，然後腔升瞎通過pip安裝keras

㈡ 怎樣用python構建一個卷積神經網路模型

上周末利用python簡單實現了一個卷積神經網路，只包含一個卷積層和一個maxpooling層，pooling層後面的多層神經網路採用了softmax形式的輸出。實驗輸入仍然採用MNIST圖像使用10個feature map時，卷積和pooling的結果分別如下所示。

部分源碼如下：

[python]view plain

• #coding=utf-8

• '''''

• Createdon2014年11月30日

• @author:Wangliaofan

• '''

• importnumpy

• importstruct

• importmatplotlib.pyplotasplt

• importmath

• importrandom

• import

• #test

• defsigmoid(inX):

• if1.0+numpy.exp(-inX)==0.0:

• return999999999.999999999

• return1.0/(1.0+numpy.exp(-inX))

• defdifsigmoid(inX):

• returnsigmoid(inX)*(1.0-sigmoid(inX))

• deftangenth(inX):

• return(1.0*math.exp(inX)-1.0*math.exp(-inX))/(1.0*math.exp(inX)+1.0*math.exp(-inX))

• defcnn_conv(in_image,filter_map,B,type_func='sigmoid'):

• #in_image[num,featuremap,row,col]=>in_image[Irow,Icol]

• #featuresmap[kfilter,row,col]

• #type_func['sigmoid','tangenth']

• #out_feature[kfilter,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)#[kfilter,row,col]

• ifshape_filter[1]>shape_image[0]orshape_filter[2]>shape_image[1]:

• raiseException

• 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)

• fork_idxinrange(0,k):

• #rotate180tocalculateconv

• c_filter=numpy.rot90(filter_map[k_idx,:,:],2)

• forr_idxinrange(0,m):

• forc_idxinrange(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)

• iftype_func=='sigmoid':

• out_feature[k_idx,r_idx,c_idx]=sigmoid(sum_temp+B[k_idx])

• eliftype_func=='tangenth':

• out_feature[k_idx,r_idx,c_idx]=tangenth(sum_temp+B[k_idx])

• else:

• raiseException

• returnout_feature

• defcnn_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))

• fork_idxinrange(0,k):

• forr_idxinrange(0,out_row):

• forc_idxinrange(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)

• #printmax_index

• #printmax_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

• returnout_pooling,max_index_Matirx

• defpoolwithfunc(in_pooling,W,B,type_func='sigmoid'):

• k,row,col=numpy.shape(in_pooling)

• out_pooling=numpy.zeros((k,row,col))

• fork_idxinrange(0,k):

• forr_idxinrange(0,row):

• forc_idxinrange(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])

• returnout_pooling

• #out_featureistheoutputofconv

• defbackErrorfromPoolToConv(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)

• ifk1!=k2:

• raiseException

• foridx_kinrange(0,k1):

• foridx_rowinrange(0,row):

• foridx_colinrange(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])

• returnerror_conv

• defbackErrorfromConvToInput(theta,inputImage):

• k1,row,col=numpy.shape(theta)

• #print"theta",k1,row,col

• i_row,i_col=numpy.shape(inputImage)

• ifrow>i_roworcol>i_col:

• raiseException

• filter_row=i_row-row+1

• filter_col=i_col-col+1

• detaW=numpy.zeros((k1,filter_row,filter_col))

• #thesamewithconvvalidinmatlab

• fork_idxinrange(0,k1):

• foridx_rowinrange(0,filter_row):

• foridx_colinrange(0,filter_col):

• subInputMatrix=inputImage[idx_row:idx_row+row,idx_col:idx_col+col]

• #print"subInputMatrix",numpy.shape(subInputMatrix)

• #rotatetheta180

• #printnumpy.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))

• fork_idxinrange(0,k1):

• detaB[k_idx]=numpy.sum(theta[k_idx,:,:])

• returndetaW,detaB

• defloadMNISTimage(absFilePathandName,datanum=60000):

• images=open(absFilePathandName,'rb')

• buf=images.read()

• index=0

• magic,numImages,numRows,numColumns=struct.unpack_from('>IIII',buf,index)

• printmagic,numImages,numRows,numColumns

• index+=struct.calcsize('>IIII')

• ifmagic!=2051:

• raiseException

• 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)

• returnnextmatrix,numImages

• defloadMNISTlabels(absFilePathandName,datanum=60000):

• labels=open(absFilePathandName,'rb')

• buf=labels.read()

• index=0

• magic,numLabels=struct.unpack_from('>II',buf,index)

• printmagic,numLabels

• index+=struct.calcsize('>II')

• ifmagic!=2049:

• raiseException

• datablock=">"+str(datanum)+"B"

• #nextmatrix=struct.unpack_from('>60000B',buf,index)

• nextmatrix=struct.unpack_from(datablock,buf,index)

• nextmatrix=numpy.array(nextmatrix)

• returnnextmatrix,numLabels

• defsimpleCNN(numofFilter,filter_size,pooling_size=2,maxIter=1000,imageNum=500):

• decayRate=0.01

• MNISTimage,num1=loadMNISTimage("F:\train-images-idx3-ubyte",imageNum)

• printnum1

• 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:\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

• whilecIter<maxIter:

• 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)

• #printnumpy.shape(MLP_input)

• DetaW,DetaB,temperror=MLP.backwardPropogation(MLP_input,ImageNum)

• ifcIter%50==0:

• printcIter,"Temperror:",temperror

• #printnumpy.shape(MLP.Theta[MLP.Nl-2])

• #printnumpy.shape(MLP.Ztemp[0])

• #printnumpy.shape(MLP.weightMatrix[0])

• theta_pool=MLP.Theta[MLP.Nl-2]*MLP.weightMatrix[0].transpose()

• #printnumpy.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)

• #printerror_conv

• conv_DetaW,conv_DetaB=backErrorfromConvToInput(error_conv,MNISTimage[ImageNum,0,:,:])

• #print"W_k",W_k

• #print"conv_DetaW",conv_DetaW

㈢ 如何使用python表示矩陣

使用python表示矩陣的方法：

使用「import numpy」語句導入numpy包。用numpy包的array函數創建一個二維數組，這個二維數組就表示矩陣

示例代碼如下：

執行結果如下：

㈣ python循環控制函數matrix，使得他可以將輸入的列表轉化為一個行列數自定的矩陣

1、程序運行輸入數據時，第一行為A矩陣的行列數和B矩陣的行列數，接著分別輸入A、B兩個矩陣的值。

㈤ python中怎麼定義二維向量類及其運算

python中怎麼定義二維向量類及其運算如下：
1、向量一維的數組，包括行向量和列向量，和傳統向量定義不同的是定義的默認是行向量。
2、向量的運算，向量和矩陣相加一樣，只有在維數相同的情況下才可以相加，向量相加實質上是對應位置元素的相加。
3、內積運算通過函數實現，一維的向量相乘只能用於行向量相乘，對於二維中的列向量的運行握算，則遵從矩陣的運演算法則。
4、向量的線性組合，向量的線性團帆組合可以在行進行運算，但是塌帶雹更推薦基於列向量中進行運算。

㈥ Python萌新求救！！創建一個二維矩陣~~

def aaa(n):
tmp=[]
for x in range(n):
if x==0 or x==n-1:
tmp.append([1]*n)
else:
tmp.append([1]+[0]*(n-2)+[1])
return tmp
if __name__=='__main__':
import pprint
pprint.pprint(aaa(6))

㈦ 怎樣用python構建一個卷積神經網路

用keras框架較為方便

首先安裝anaconda，然後通過pip安裝keras

㈧ python編程，我建立一個2*2矩陣，然後想其中每個元素都乘上一個實數，於是我在矩陣後加上*2.

安裝numpy，利用numpy數斗仔組：
>>> import numpy
>>> array1 = numpy.array([[1, 2], [3, 4]])
>>> array1
array([[1, 2],
[3, 4]])
>>> array1 * 2.5
array([[ 2.5, 5. ],
[ 7.5, 10. ]])
如果你用的是python的列表豎虛，它的乘法是列表的空纖汪自我復制，[1, 2] * 2就是[1, 2, 1, 2]

㈨ python 矩陣 匹配 求助

在 Python 中，可以使用 NumPy 庫來解決這個問題。
首先，需要將矩陣 A、n1、n2 作為 NumPy 數組讀入內存。例如：
import numpy as np

A = np.array([
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]
])

n1 = np.array([
[1, 2],
[5, 6]
])

n2 = np.array([
[3, 4],
[7, 8]
])

接下來，可以使用 NumPy 的 correlate2d() 函數，將矩陣 A 與 n1 或 n2 進行二維卷積，並查看結果是否為非零值。例如：鏈臘春
result1 = np.correlate2d(A, n1)
result2 = np.correlate2d(A, n2)if np.any(result1): print('n1 在 A 中有對應的位置')else: print('n1 在 A 中沒有對應的位置')if np.any(result2): print('n2 在 A 中有對應的位置')else: print('n2 在 A 中沒有對應的位置')

如果矩陣 A 中包含 n1 或 n2，棚耐則上面的程序會輸出 "n1 在 A 中有對應的位置" 或 "n2 在 A 中有對應的位置"。
下面的程序中，我們使用了 NumPy 的 nonzero() 函數來找到結果矩陣中的非零值的位置，並將這些位置列印出來。
result1 = np.correlate2d(A, n1)
result2 = np.correlate2d(A, n2)

if np.any(result1): print('n1 在 A 中有對應的位置：') print(np.nonzero(result1))
else: print('n1 在 A 中沒有對應的位置')

if np.any(result2): print('n2 在 A 中有對應的位局凳置：') print(np.nonzero(result2))
else: print('n2 在 A 中沒有對應的位置')

運行上面的程序，如果 A、n1、n2 的值為上面的值，則會輸出如下內容：
n1 在 A 中有對應的位置：
(array([0]), array([0]))
n2 在 A 中沒有對應的位置

這表示，n1 在矩陣 A 的第 (0, 0) 位置有對應的位置，而 n2 在矩陣 A 中沒有對應的位置。
希望這些信息能幫助你理解並實現演算法。

㈩ 矩陣卷積的運算

最近在看圖像處理，卷積運算這一塊也查了很多，但是感覺都寫的太復雜，我這里簡單的寫一下卷積到底是一個什麼計算過程。
假設有一個卷積核h，就一般為3*3的矩陣：
有一個待處理矩陣x：
h*x的計算過程分為三步
第一步，將卷積核翻轉180°，也就是成為了
第二步，將卷積核h的中心對准x的第一個元素，然後對應元素相乘後相加，沒有元素的地方補0。
這樣結果Y中的第一個元素值Y11=1*0+2*0+1*0+0*0+0*1+0*2+-1*0+-2*5+-1*6=-16
第三步每個元素都像這樣計算出來就可以得到一個輸出矩陣，就是卷積結果
像這樣計算，其他過程略了。
最後結果
注意：
我這里是用0補全原矩陣的，但我們不一定選擇0。在Opencv的cvFilter2D函數中，就沒有使用0來補全矩陣，而是用了邊緣拷貝的方式，下一篇我會介紹Opencv的CvFilter2D函數卷積運算過程。