python batch normalization_使用Python实现Batch normalization和卷积层

昨天TX代码面试让手撸IOU,BN和CONV，当时一听真的是有点懵，其实IOU倒还好点，比较简单，但是BN,CONV实现就有点难了，当时也只是实现了BN的前向，卷积也只是写了一个一维卷积的公式而已。s今天趁有空顺便实现了一下IOU和BN的前向和反向。

IOU实现

iou的原理比较简单这里不予介绍。具体代码实现如下：

1

2

3

4

5

6

7

8

9

10def IoU(boxA,boxB):#x1,y1,x2,y2

xA=max(boxA[0],boxB[0])

yA=max(boxA[1],boxB[1])

xB=min(boxA[2],boxB[2])

yB=min(boxA[3],boxB[3])

interArea=max(0,xB-xA+1)*max(0,yB-yA+1)

boxAArea=(boxA[2]-boxA[0]+1)*(boxA[3]-boxA[1]+1)

boxBArea=(boxB[2]-boxB[0]+1)*(boxB[3]-boxB[1]+1)

iou=interArea/(boxAArea+boxBArea-interArea)

return iou

用C++实现和上面是一样的，如下：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18struct Rect

{

int x;int y;

int width;int height;

};

int IoU(Rect Box1, Rect Box2)

{

int XA = max(Box1.x, Box2.x);

int YA = max(Box1.y, Box2.y);

int XB = min(Box1.x + Box1.width, Box2.x + Box2.width);

int YB = min(Box1.y + Box1.height, Box2.y + Box2.height);

int interArea = max(0, XB - XA)*max(0, YB - YA);

int box1Area = Box1.width*Box1.height;

int box2Area = Box2.width*Box2.height;

int iou = float(interArea) / (box1Area + box2Area - interArea);

return iou;

}

使用Python实现BN

BN的前向操作只需要实现下面这些公式就行

对于反向传播的话，我们需要对x,r,β进行求导获得其梯度，然后进行反向传播。下面是原文给出的求导公式，原文给出的公式省略了一些中间步骤，下面我自己也推导了一下，如下图所示。

具体实现如下：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35import numpy as np

def bn_forward(x,gamma,beta,eps=1e-5):#eps: 除以方差时为了防止方差太小而导致数值计算不稳定

#计算均值

sample_mean = np.mean(x, axis=0)

#计算方差

sample_var = np.var(x, axis=0)

#归一化

out_ = (x - sample_mean) / np.sqrt(sample_var + eps)

#缩放平移

out=gamma*out_+beta

#缓存中间变量用于反向传播计算

cache=(x,out_,gamma,beta,sample_mean,sample_var,eps)

return out,cache

def bn_backward(dout,cache):

N,D = dout.shape

x,out_,gamma,beta,sample_mean,sample_var,eps=cache

dbeta=np.sum(dout,axis=0)

dgamma=np.sum(out_*dout,axis=0)

dxhat=gamma*dout

dvar=np.sum(dxhat*out_,axis=0)*(-1/2.)*(1./sample_var+eps)

dmean=np.sum(dxhat,axis=0)/np.sqrt(sample_var + eps) + dvar*(-2)*sample_mean

dx=dxhat/np.sqrt(sample_var + eps) + dvar*2*(x-sample_mean)/N + dmean/N

return dx,dgamma,dbeta

使用Python实现卷积层

这道题我当时很懵，因为之前从来都没有去手动实现过，只是知道原理。因此面试的时候直接就放弃了。亡羊补牢，为时未晚，秋招才刚开始，为避免后续再出现这样的面试，还是自己手动实现以下比较好。原理都懂，就不写了，来点公式对于实现卷积会比较合适。

卷积层前向传播

卷积层的前向激活过程，我们首先忽略激活层。认为f(x)=x，那么纯卷积层的前向激活公式如下：

n是输入的个数，比如输入100张图片，n＝100.

C是input channel，比如输入的图片是RGB三通道的，C＝3.

S是stride，stride为1，逐行扫描。stride为2，隔一行扫描一次

XP是填0后的输入。若不填0，则XP＝X.

F是filter number，系数的高和宽分别是HH，WW。Ho和Wo是输出的高，宽。

根据上面的公式可以写出卷积层前向传播的一个朴素的实现，在实现过程中，可以暂时不考虑for循环有多少层，后面可以优化。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41def conv_forward_naive(x,w,b,conv_param):

"""

Input:

- x: Input data of shape (N, C, H, W)

- w: Filter weights of shape (F, C, HH, WW)

- b: Biases, of shape (F,)

- conv_param: A dictionary with the following keys:

- 'stride': The number of pixels between adjacent receptive fields in the

horizontal and vertical directions.

- 'pad': The number of pixels that will be used to zero-pad the input.

Returns a tuple of:

- out: Output data, of shape (N, F, H', W') where H' and W' are given by

H' = 1 + (H + 2 * pad - HH) / stride

W' = 1 + (W + 2 * pad - WW) / stride

- cache: (x, w, b, conv_param)

"""

out = None

N, C, H, W=x.shape

F, _, HH, WW=w.shape

S,P = conv_param['stride'],conv_param['pad']

Ho =int( 1 + (H + 2 * P - HH) / S)

Wo = int(1 + (W + 2 * P - WW) / S)

out=np.zeros((N,F,Ho,Wo))

x_pad=np.zeros((N,C,H+2*P,W+2*P))

x_pad[:,:,P:P+H,P:P+W]=x

for i in range(Ho):

for j in range(Wo):

x_pad_mask=x_pad[:,:,i*S:i*S+HH,j*S:j*S+WW]

for f in range(F):

out[:,f,i,j]=np.sum(x_pad_mask*w[f,:,:,:],axis=(1,2,3))#逐通道相加

out = out + (b)[None, :, None, None]

cache=(x,w,b,conv_param)

return out,cache

前向传播还算是比较容易理解，实现起来不是特别难。

卷积层反向传播

反向传播求导很简单，和BN求导难度相比差远了，只是计算起来比较复杂，搞得有点懵。假设卷积层后反传的就是loss对于该层输出的梯度。那么，

代码实现如下：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39def conv_backward_naive(dout,cache):

"""

Inputs:

- dout: Upstream derivatives.

- cache: A tuple of (x, w, b, conv_param) as in conv_forward_naive

Outputs:

- dx: Gradient with respect to x

- dw: Gradient with respect to w

- db: Gradient with respect to b

"""

dx, dw, db = None, None, None

N, F, H1, W1 = dout.shape

x, w, b, conv_param = cache

N, C, H, W = x.shape

HH = w.shape[2]

WW = w.shape[3]

S = conv_param['stride']

P = conv_param['pad']

dx, dw, db=np.zeros_like(x),np.zeros_like(w),np.zeros_like(b)

x_pad=np.zeros((N,C,H+2*P,W+2*P))

x_pad[:,:,P:P+H,P:P+W]=x

dx_pad=np.zeros_like(x_pad)

db=np.sum(dout,axis=(0,2,3))

for i in range(H1):

for j in range(W1):

x_pad_mask=x_pad[:,:,i*S:i*S+HH,j*S:j*S+WW]

for f in range(F):

dw[f,:,:,:]+=np.sum(x_pad_mask * (dout[:, f, i, j])[:, None, None, None], axis=0)

for n in range(N): #compute dx_pad

dx_pad[n, :,i*S:i*S+HH,j*S:j*S+WW] += np.sum((w[:, :, :, :] *(dout[n, :, i, j])[:,None ,None, None]), axis=0)

dx = dx_pad[:, :, P:P+H, P:P+W]

return dx, dw, db

最后

上面关于卷积层的实现主要参考了cs231n大作业，实现卷积只是大作业的一部分，这个大作业还包括实现max pooling，dropout等等，具体可以看这里。