Python3 CNN中卷积和池化的实现--限制为二维输入

 # -*- coding: utf-8 -*-
 """
 Created on Wed Jan 31 14:10:03 2018

 @author: markli
 """
 import numpy as np;

 def ReLU(x):
     return max(0,x);

 class CovolutionLayer:
     """
     卷积层包含卷积和汇合两步操作
     """
     def __init__(self,filters,padding,pooling,action_fun=ReLU):
         """
         filters 包含 filter_size filter_num filter_stride
         filter_size 过滤器(卷积核)大小 [行,列]
         filter_num  过滤器(卷积核)的个数
         filter_stride 卷积步长
         padding 填充的大小 填充0值
         pooling 包含 pooling_size pooling_stride pooling_classic
         pooling_size 池化时的大小 [行,列] 池化矩阵为方阵
         pooling_stride 池化时的步长 一般情况下大小等于pooling_size
         pooling_classic 汇合类型 类型包括 最大值汇合 max, 平均值汇合 average
         action_fun 卷积操作的激活函数
         """
         self.f_size = (filters[0],filters[1]);
         self.f_num = filters[2];
         self.f_stride = filters[3];
         self.padding = padding;
         self.p_size = (pooling[0],pooling[1]);
         self.p_stride = pooling[2]
         self.p_classic = pooling[3];
         self.action_fun = action_fun;

         self.weights = [];
         for i in range(self.f_num):
             weight = np.random.randn(self.f_size[0],self.f_size[1]);
             self.weights.append(weight);

         self.biase = np.random.randn(self.f_num);

     def Convolution(self,X):
         """
         X 为二维数组
         """
         #获得初始X的形状
         n,m = X.shape;
         #填充
         if(self.padding != 0):
             ones = np.zeros((n+2*self.padding,m+2*self.padding));
             ones[self.padding:self.padding+n,self.padding:self.padding+m] = X;
             X = ones;

         #获得填充后X的形状
         n,m = X.shape;

         #求得卷积操作降维后的层的大小
         t = int((n-self.f_size[0])/ self.f_stride) + 1; #行数
         l = int((m-self.f_size[1]) / self.f_stride) + 1; #列数

         #求得池化后降维的大小
         t_p = int((t-self.p_size[0]) / self.p_stride) + 1; #池化层的行数
         l_p = int((l-self.p_size[1]) / self.p_stride) + 1; #池化层的列数

         self.convs = [];
         self.pools = []
         for k in range(self.f_num):
             conv = np.ones((t,l));
             pool = np.ones((t_p,l_p));
             row = 0;
             #卷积
             for i in range(l):
                 col = 0;
                 for j in range(t):
                     temp = X[row:row+self.f_size[0],col:col+self.f_size[1]];
                     z = np.sum(np.multiply(self.weights[k],temp)) + self.biase[k];
                     a = self.action_fun(z);
                     conv[i][j] = a;
                     col = col + self.f_stride;

                 row = row + self.f_stride;

             self.convs.append(conv);

             #池化
             row = 0;
             for i in range(t_p):
                 col = 0;
                 for j in range(l_p):
                     temp = conv[row:row+self.p_size[0],col:col+self.p_size[1]];
                     if(self.p_classic == "average"):
                         pool[i][j] = np.sum(temp) / (self.p_size[0] * self.p_size[1]);
                     else:
                         pool[i][j] = np.max(temp);

                     col = col + self.p_stride;

                 row = row + self.p_stride;

             self.pools.append(pool);

 X = np.array([[18,54,51,239,244,188],
               [55,121,75,78,95,88],
               [35,24,104,113,109,221],
               [3,154,104,235,25,130],
               [15,253,225,159,78,233],
               [68,85,180,214,215,0]]);

 #X 归一化处理
 X = (X - np.sum(X)/36) / np.max(X);
 #print(X.shape)

 con = CovolutionLayer([3,3,2,1],1,[2,2,2,"max"],);
 con.Convolution(X);
 print(con.pools);

目前只能实现二维的操作，三维的实现还没想好如何存储。卷积神经网络的存储和计算是真的很复杂，过段时间想好了在实现。