卷积神经网络简介

$$卷积神经网络简介$$

Numpy 方式实现卷积层

import numpy as np
"""
TensorFlow有两种数据格式NHWC和NCHW，默认的数据格式是NHWC，可以通过参数data_format指定数据格式。
这个参数规定了 input Tensor 和 output Tensor 的排列方式。
设置为 “NHWC” 时，排列顺序为 [batch, height, width, channels]
设置为 “NCHW” 时，排列顺序为 [batch, channels, height, width]
"""

def conv_numpy(x, w, b, pad,strides):
    out = None
    
    N, H, W, C = x.shape
    F,  HH, WW, C = w.shape
  
    X = np.pad(x, ((0, 0),(pad, pad), (pad, pad), (0, 0) ), 'constant')

    Hn = 1 + int((H + 2 * pad - HH) / strides[0])
    Wn = 1 + int((W + 2 * pad - WW) / strides[1])
    
    out = np.zeros((N, Hn, Wn, F))
    
    for n in range(N):
        for m in range(F):
            for i in range(Hn):
                for j in range(Wn):
                    data = X[n, i * strides[0]:i * strides[0] + HH, j * strides[1]:j * strides[1] + WW, :].reshape(1, -1)
                    filt = w[m].reshape(-1, 1)
                    out[n, i, j, m] = data.dot(filt) + b[m]

    return out

inputs_ = np.random.random((10,28,28,3))

w = np.random.random((6,3,3,3))
b = np.random.random((6,))

inputs_ = inputs_.astype(np.float32)
w = w.astype(np.float32)
b = b.astype(np.float32)

a= conv_numpy(inputs_,w = w, b=b, pad=1,strides=(1,1) )

a.shape

tf.keras.layers.Conv2D(filters=6,kernel_size=(3,3))(inputs_).shape

tf版本实现卷积层

import tensorflow as tf

def corr2d(x, w, b, pad, stride):
    N, H, W, C = tf.shape(x)
    F, HH, WW, C = tf.shape(w)

    x = tf.pad(x, ((0, 0),(pad, pad), (pad, pad), (0, 0) ), 'constant')
    Hn = 1 + int((H + 2 * pad - HH) / stride[0])
    Wn = 1 + int((W + 2 * pad - WW) / stride[1])
    Y = tf.Variable(tf.zeros((N, Hn, Wn, F),dtype=tf.float32))

    for m in range(F):
        for i in range(Hn):
            for j in range(Wn):
                data = x[:, i * stride[0]:i * 1 + HH, j * stride[1]:j * 1 + WW, :]
                filt = w[m,:,:,:]
                Y[:, i, j, m].assign(tf.reduce_sum(tf.multiply(data,filt),axis=(1,2,3))+b[m])

    return Y

x = tf.constant(inputs_)
w_tf = tf.constant(w)
b_tf = tf.constant(b)

x = tf.dtypes.cast(x,dtype=tf.float32)
b_tf = tf.dtypes.cast(w_tf,dtype=tf.float32)
b_tf = tf.dtypes.cast(b_tf,dtype=tf.float32)

corr2d(x,w,b,1,(1,1))

class Conv2D(tf.keras.layers.Layer):
    def __init__(self,filters=None,kernel_size=(3,3),stride=(1,1),pad = 0, **kwargs):
        self.filters = filters
        self.kernel_size = kernel_size
        self.stride = stride
        self.pad = 0 
        
        super(Conv2D,self).__init__(**kwargs)


    def build(self, input_shape):
        self.w = self.add_weight(name='w',
                                shape=(self.filters,input_shape[-1],self.kernel_size[0],self.kernel_size[1]),
                                initializer=tf.random_normal_initializer())
        self.b = self.add_weight(name='b',
                                shape=(self.filters,),
                                initializer=tf.random_normal_initializer())
        
        super(Conv2D,self).build(input_shape)
        
    def call(self, inputs):
        return self.corr2d(inputs, self.w, self.b,self.pad,self.stride)
    

    @staticmethod
    def corr2d(x, w, b, pad, stride):
        N, H, W, C = tf.shape(x)
        F, HH, WW, C = tf.shape(w)
        
        Hn = 1 + int((H + pad - HH) / stride[0])
        Wn = 1 + int((W + pad - WW) / stride[1])
        Y = tf.Variable(tf.zeros((N, Hn, Wn, F),dtype=tf.float32))

        for m in range(F):
            for i in range(Hn):
                for j in range(Wn):
                    data = x[:, i * 1:i * 1 + HH, j * 1:j * 1 + WW, :]
                    filt = w[m,:,:,:]
                    Y[:, i, j, m].assign(tf.reduce_sum(tf.multiply(data,filt),axis=(1,2,3))+b[m])

        return Y

conv2 = Conv2D(filters=6,kernel_size=(3,3),stride=(1,1),pad = 0)

conv2(x)

x = tf.random.uniform((10,3,3,3))
w = tf.random.uniform((1,3,3,3))

tf.reduce_sum(tf.multiply(x,w),axis=(1,2,3))

help(tf.multiply)

x = tf.random.uniform((10,28,28,3))
w = tf.random.uniform((6,3,3,3))
b = tf.random.uniform((6,))
x = tf.dtypes.cast(x,tf.float32)
N, H, W, C = tf.shape(x)
F, HH, WW,C = tf.shape(w)


Hn = 1 + int((H + 2 * 0 - HH) / 1)
Wn = 1 + int((W + 2 * 0 - WW) / 1)
Y = tf.Variable(tf.zeros((N, Hn, Wn, F)))

for n in range(N):
    for m in range(F):
        for i in range(Hn):
            for j in range(Wn):
                data = x[n, i * 1:i * 1 + HH, j * 1:j * 1 + WW, :]
                
                print(data.shape)
                filt = w[n]
                print(tf.matmul(data,filt).shape)
                Y[n, i, j, m].assign(tf.cast(tf.matmul(data,filt) ,dtype=tf.float32))

a = Conv2D()

tf

corr2d(x,w,b)

X = tf.constant([[0,1,2], [3,4,5], [6,7,8]])
K = tf.constant([[0,1], [2,3]])
a(X)

池化层

import tensorflow as tf
import numpy as np

def max_pool_forward_naive(x, pool_size=(2,2),strides=(1,1)):

    N, H, W, C = x.shape
    h_p, w_p = pool_size
    h_s, w_s = strides
    
    
    Hn = 1 + int((H - h_p) / h_s)
    Wn = 1 + int((W - w_p) / w_s)
    out = np.zeros((N, Hn, Wn, C))
    for i in range(Hn):
        for j in range(Wn):
            out[:, i, j, :] = np.max(x[:, i*h_s:i*h_s+h_p, j*w_s:j*w_s+w_p, :], axis=(1,2))
    return out

x = np.random.random((10,26,26,6))

numpy_pool_res = max_pool_forward_naive(x,pool_size=(2,2),strides=(1,1))

numpy_pool_res.shape

x =tf.constant(x,dtype=tf.float32)

def pool2d(X, pool_size=(2,2),strides=(1,1)):
    N, H, W, C = tf.shape(X)
    p_h, p_w = pool_size
    s_h, s_w = strides
    Y = tf.zeros((N, (H - p_h + 1)//s_h, (W - p_w +1)//s_w, C))
    Y = tf.Variable(Y)

    for i in tf.range(tf.shape(Y)[1]):
        for j in tf.range(tf.shape(Y)[2]):
            Y[:,i,j,:].assign(tf.math.reduce_max(X[:,i*s_h:i*s_h+p_h, j*s_w:j*s_w+p_w,:],axis=(1,2),keepdims=False))
    return Y

tf_pool_res = pool2d(x,pool_size=(2,2),strides=(2,2))

tf_pool_res.shape

tf_pool_res

numpy_pool_res

max_pool_2d = tf.keras.layers.MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='valid')

max_pool_2d(x)