吳恩達第四課第一週編程作業

本次作業目的

構建一個簡單的卷積網絡

下載地址

鏈接：https://pan.baidu.com/s/1h6gy7kDwzUOHDssnEw7lVQ 
提取碼：nctg 

代碼

原生代碼

import numpy as np
import h5py
import matplotlib.pyplot as plt
plt.rcParams['figure.figsize'] = (5.0, 4.0)
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'
np.random.seed(1)      #指定隨機種子
#邊界填充
def zero_pad(X,pad):
    X_paded=np.pad(X,
                   ((0,0),#樣本數量不增加
                   (pad,pad),#圖像高度增加2*pad
                   (pad,pad),#圖像寬度增加2*pad
                    (0,0)),#圖像信道不增加
                   'constant',constant_values=0)
    return X_paded
#單步卷積
def conv_single_step(a_slice_prev,W,b):
    """
    :param a_slice_prev: 像素矩陣的一個切片大小，同過濾器
    """
    s=np.multiply(a_slice_prev,W)+b
    Z=np.sum(s)
    return Z
#卷積的前向傳播
def conv_forward(A_prev, W, b, hparameters):
    """
    :param A_prev: 上一層激活輸出矩陣（樣本數量，上一層高度，上一層寬度，上一層過濾器數量）
    :param W:權重矩陣（過濾器大小，過濾器大小，上一層過濾器數量，這一層過濾器數量）
    :param b:偏置矩陣（1,1,1,這一層過濾器數量）
    :param hparameters:步長和填充數量等超參數
    """
    (m,n_H_prev,n_W_prev,n_C_prev)=A_prev.shape
    (f,f,n_C_prev,n_C)=W.shape
    stride=hparameters['stride']
    pad=hparameters['pad']
    #進行卷積後的圖像大小
    n_H=int((n_H_prev-f+2*pad)/stride)+1
    n_W=int((n_W_prev-f+2*pad)/stride)+1
    #初始化Z
    Z=np.zeros((m,n_H,n_W,n_C))
    #填充
    A_prev_pad=zero_pad(A_prev,pad)
    for i in range(m):
        a_prev_pad=A_prev_pad[i]#第i個填充後的矩陣
        for h in range(n_H):
            for w in range(n_W):
                for c in range(n_C):
                    vert_start=h*stride
                    vert_end=vert_start+f
                    horiz_start=w*stride
                    horiz_end=horiz_start+f#定位過濾器
                    a_slice_prev=a_prev_pad[vert_start:vert_end,horiz_start:horiz_end,:]
                    Z[i,h,w,c]=conv_single_step(a_slice_prev,W[:,:,:,c],b[0,0,0,c])
    assert (Z.shape==(m,n_H,n_W,n_C))
    cache=(A_prev,W,b,hparameters)
    return Z,cache
#卷積的反向傳播
def conv_backward(dZ,cache):
    (A_prev, W, b, hparameters)=cache
    (m,n_H_prev,n_W_prev,n_C_prev)=A_prev.shape
    (m,n_H,n_W,n_C)=dZ.shape
    (f,f,n_C_prev,n_C)=W.shape
    stride=hparameters['stride']
    pad=hparameters['pad']
    #初始化
    dA_prev=np.zeros((m,n_H_prev,n_W_prev,n_C_prev))
    dW=np.zeros((f,f,n_C_prev,n_C))
    db=np.zeros((1,1,1,n_C))
    A_prev_pad=zero_pad(A_prev,pad)
    dA_prev_pad=zero_pad(dA_prev,pad)
    for i in range(m):
        a_prev_pad=A_prev_pad[i]
        da_prev_pad=dA_prev_pad[i]
        for h in range(n_H):
            for w in range(n_W):
                for c in range(n_C):
                    vert_start = h
                    vert_end=vert_start+f
                    horiz_start = w
                    horiz_end=horiz_start+f
                    a_slice=a_prev_pad[vert_start:vert_end,horiz_start:horiz_end,:]
                    da_prev_pad[vert_start:vert_end,horiz_start:horiz_end,:]+=W[:,:,:,c]*dZ[i,h,w,c]
                    dW[:,:,:,c]+=a_slice*dZ[i,h,w,c]
                    db[:,:,:,c]+=dZ[i,h,w,c]
        dA_prev[i,:,:,:]=da_prev_pad[pad:-pad,pad:-pad,:]
    assert (dA_prev.shape==(m,n_H_prev,n_W_prev,n_C_prev))
    return (dA_prev,dW,db)
#池化的前向傳播
def pool_forward(A_prev,hparaneters,mode='max'):
    (m,n_H_prev,n_W_prev,n_C_prev)=A_prev.shape
    f=hparaneters['f']
    stride=hparaneters['stride']
    n_H=int((n_H_prev-f)/stride)+1
    n_W=int((n_W_prev-f)/stride)+1
    n_C=n_C_prev
    A=np.zeros((m,n_H,n_W,n_C))
    for i in range(m):
        for h in range(n_H):
            for w in range(n_W):
                for c in range(n_C):
                    vert_start=h*stride
                    vert_end=vert_start+f
                    horiz_start=w*stride
                    horiz_end=horiz_start+f
                    a_slice_prev=A_prev[i,vert_start:vert_end,horiz_start:horiz_end,c]

                    if mode=='max':
                        A[i,h,w,c]=np.max(a_slice_prev)
                    if mode=='average':
                        A[i,h,w,c]=np.mean(a_slice_prev)
    assert (A.shape==(m,n_H,n_W,n_C))
    cache=(A_prev,hparaneters)
    return A,cache
#最大池化層反向傳播
def create_mask_from_window(x):
    mask=x==np.max(x)
    return mask
#均值池化層反向傳播
def distribute_value(dZ,shape):
    #獲取矩陣大小
    (n_H,n_W)=shape
    average=dZ/(n_H*n_W)
    a=np.ones(shape)*average
    return a
#池化層反向傳播
def pool_backward(dA,cache,mode = "max"):
    (A_prev, hparaneters)=cache
    f=hparaneters['f']
    stride=hparaneters['stride']
    # 獲取A_prev和dA的基本信息
    (m,n_H_prev,n_W_prev,n_C_prev)=A_prev.shape
    (m,n_H,n_W,n_C)=dA.shape
    dA_prev=np.zeros_like(A_prev)
    for i in range(m):
        a_prev=A_prev[i]
        for h in range(n_H):
            for w in range(n_W):
                for c in range(n_C):
                    vert_start = h
                    vert_end=vert_start+f
                    horiz_start = w
                    horiz_end=horiz_start+f
                    if mode=='max':
                        a_prev_slice=a_prev[vert_start:vert_end,horiz_start:horiz_end,c]
                        #創建掩碼
                        mask=create_mask_from_window(a_prev_slice)
                        dA_prev[i,vert_start:vert_end,horiz_start:horiz_end,c]+=np.multiply(mask,dA[i,h,w,c])
                    elif mode=='average':
                        da=dA[i,h,w,c]
                        shape=(f,f)
                        dA_prev[i,vert_start:vert_end,horiz_start:horiz_end,c]+=distribute_value(da,shape)
    assert (dA_prev.shape==(A_prev.shape))
    return dA_prev

TensorFlow實現

import math
import numpy as np
import h5py
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import tensorflow as tf
from tensorflow.python.framework import ops
import cnn_utils
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
np.random.seed(1)


X_train_orig , Y_train_orig , X_test_orig , Y_test_orig , classes = cnn_utils.load_dataset()#加載數據集
#一列爲一個樣本
X_train_flatten=X_train_orig.reshape(X_train_orig.shape[0],-1).T
X_test_flatten=X_test_orig.reshape(X_test_orig.shape[0],-1).T
#歸一化
X_train=X_train_flatten/255
X_test=X_test_flatten/255
#獲得獨熱矩陣
Y_train=cnn_utils.convert_to_one_hot(Y_train_orig,6)
Y_test=cnn_utils.convert_to_one_hot(Y_test_orig,6)
#創建palceholder
def create_placeholders(n_H0,n_W0,n_C0,n_y):
    """
    :return:X:輸入數據的佔位符
            Y：標籤的佔位符
    """
    X=tf.placeholder(tf.float32,[None,n_H0,n_W0,n_C0])
    Y=tf.placeholder(tf.float32,[None,n_y])
    return X,Y
#初始化
def initialize_parameters():
    tf.set_random_seed(1)
    W1=tf.get_variable('W1',[4,4,3,8],initializer=tf.contrib.layers.xavier_initializer(seed=0))
    W2=tf.get_variable('W2',[2,2,8,16],initializer=tf.contrib.layers.xavier_initializer(seed=0))
    parameters={
        'W1':W1,
        'W2':W2
    }
    return parameters
#前向傳播
def forward_propagation(X,parameters):
    W1=parameters['W1']
    W2=parameters['W2']

    Z1=tf.nn.conv2d(X,W1,[1,1,1,1],padding='SAME')
    A1=tf.nn.relu(Z1)
    P1=tf.nn.max_pool(A1,ksize=[1,8,8,1],strides=[1,8,8,1],padding='SAME')

    Z2=tf.nn.conv2d(P1,W2,[1,1,1,1],padding='SAME')
    A2=tf.nn.relu(Z2)
    P2=tf.nn.max_pool(A2,ksize=[1,4,4,1],strides=[1,4,4,1],padding='SAME')
    #一維化上層輸出
    P=tf.contrib.layers.flatten(P2)
    #全連接層
    Z3=tf.contrib.layers.fully_connected(P,6,activation_fn=None)

    return Z3
#計算成本
def compute_cost(Z3,Y):
    cost=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=Y,logits=Z3))
    return cost
#創建模型
def model(X_train, Y_train, X_test, Y_test, learning_rate=0.009,
         num_epochs=100,minibatch_size=64,print_cost=True,isPlot=True):
    ops.reset_default_graph()
    tf.set_random_seed(1)
    seed=3
    (m,n_H0,n_W0,n_C0)=X_train.shape
    n_y=Y_train.shape[1]
    costs=[]
    X,Y=create_placeholders(n_H0,n_W0,n_C0,n_y)
    parameters=initialize_parameters()
    Z3=forward_propagation(X,parameters)
    cost=compute_cost(Z3,Y)
    optimizer=tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)

    init=tf.global_variables_initializer()
    with tf.Session()as sess:
        sess.run(init)
        for epoch in range(num_epochs):
            minibatch_cost=0
            num_minibatches=int(m/minibatch_size)
            seed+=1
            minibatches=cnn_utils.random_mini_batches(X_train,Y_train,minibatch_size,seed)
            for minibatch in range(minibatches):
                (minibatch_X,minibatch_Y)=minibatch
                _,temp_cost=sess.run([optimizer,cost],feed_dict={X:minibatch_X,Y:minibatch_Y})
                minibatch_cost+=temp_cost/num_minibatches
            if epoch%1==0:
                costs.append(minibatch_cost)
                if print_cost and epoch%5==0:
                    print('第'+str(epoch)+'次迭代，成本爲：'+str(minibatch_cost))
        if isPlot:
            plt.plot(np.squeeze(costs))
            plt.ylabel('cost')
            plt.xlabel('iterations (per tens)')
            plt.title("Learning rate =" + str(learning_rate))
            plt.show()
        corrent_prediction=tf.equal(tf.arg_max(Z3,1),tf.arg_max(Y,1))
        accuracy =tf.reduce_mean(tf.cast(corrent_prediction,'float'))
        print("corrent_prediction accuracy= "+str(accuracy ))
        train_accuracy = accuracy .eval({X: X_train, Y: Y_train})
        test_accuary = accuracy .eval({X: X_test, Y: Y_test})
        print('訓練集準確度：'+str(train_accuracy))
        print('測試集準確度'+str(test_accuary))
        return train_accuracy,test_accuary,parameters
_, _, parameters = model(X_train, Y_train, X_test, Y_test,num_epochs=150)

注：參考網址https://blog.csdn.net/u013733326/article/details/80086090