# -*- 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);