02改善深层神经网络-Initialization-第一周编程作业1

我会带着你远行 2022-05-11 01:10 200阅读 0赞

分别使用

**全零：parameters\['W' + str(l)\] = np.zeros((layers\_dims\[l\], layers\_dims\[l-1\]))**

**随机：parameters\['W' + str(l)\] = np.random.randn(layers\_dims\[l\], layers\_dims\[l-1\]) \* 10**

**“he”：parameters\['W' + str(l)\] = np.random.randn(layers\_dims\[l\], layers\_dims\[l-1\]) \* (math.sqrt(2./layers\_dims\[l-1\]))**

三种初始化方法对参数W进行初始化，其中参数b始终**parameters\['b' + str(l)\] = np.zeros((layers\_dims\[l\], 1))**，初始化为0。

#coding=utf-8
    import math
    import numpy as np
    import matplotlib.pyplot as plt
    import sklearn
    import sklearn.datasets
    from init_utils import sigmoid, relu, compute_loss, forward_propagation, backward_propagation
    from init_utils import update_parameters, predict, load_dataset, plot_decision_boundary, predict_dec
    
    plt.rcParams['figure.figsize'] = (7.0, 4.0) # set default size of plots
    plt.rcParams['image.interpolation'] = 'nearest'
    plt.rcParams['image.cmap'] = 'gray'
    
    # load image dataset: blue/red dots in circles
    train_X, train_Y, test_X, test_Y = load_dataset()
     
    def model(X, Y, learning_rate = 0.01, num_iterations = 15000, print_cost = True, initialization = "he"):
        """
        Implements a three-layer neural network: LINEAR->RELU->LINEAR->RELU->LINEAR->SIGMOID.
        
        Arguments:
        X -- input data, of shape (2, number of examples)
        Y -- true "label" vector (containing 0 for red dots; 1 for blue dots), of shape (1, number of examples)
        learning_rate -- learning rate for gradient descent 
        num_iterations -- number of iterations to run gradient descent
        print_cost -- if True, print the cost every 1000 iterations
        initialization -- flag to choose which initialization to use ("zeros","random" or "he")
        
        Returns:
        parameters -- parameters learnt by the model
        """
            
        grads = {}
        costs = [] # to keep track of the loss
        m = X.shape[1] # number of examples
        layers_dims = [X.shape[0], 10, 5, 1]
        
        # Initialize parameters dictionary.
        if initialization == "zeros":
            parameters = initialize_parameters_zeros(layers_dims)
        elif initialization == "random":
            parameters = initialize_parameters_random(layers_dims)
        elif initialization == "he":
            parameters = initialize_parameters_he(layers_dims)
    
        # Loop (gradient descent)
    
        for i in range(0, num_iterations):
    
            # Forward propagation: LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID.
            a3, cache = forward_propagation(X, parameters)
            
            # Loss
            cost = compute_loss(a3, Y)
    
            # Backward propagation.
            grads = backward_propagation(X, Y, cache)
            
            # Update parameters.
            parameters = update_parameters(parameters, grads, learning_rate)
            
            # Print the loss every 1000 iterations
            if print_cost and i % 1000 == 0:
                print("Cost after iteration {}: {}".format(i, cost))
                costs.append(cost)
                
        # plot the loss
        plt.plot(costs)
        plt.ylabel('cost')
        plt.xlabel('iterations (per hundreds)')
        plt.title("Learning rate =" + str(learning_rate))
        plt.show()
        
        return parameters
    
        # GRADED FUNCTION: initialize_parameters_zeros 
    
    def initialize_parameters_zeros(layers_dims):
        """
        Arguments:
        layer_dims -- python array (list) containing the size of each layer.
        
        Returns:
        parameters -- python dictionary containing your parameters "W1", "b1", ..., "WL", "bL":
                        W1 -- weight matrix of shape (layers_dims[1], layers_dims[0])
                        b1 -- bias vector of shape (layers_dims[1], 1)
                        ...
                        WL -- weight matrix of shape (layers_dims[L], layers_dims[L-1])
                        bL -- bias vector of shape (layers_dims[L], 1)
        """
        
        parameters = {}
        L = len(layers_dims)            # number of layers in the network
        
        for l in range(1, L):
            ### START CODE HERE ### (≈ 2 lines of code)
            parameters['W' + str(l)] = np.zeros((layers_dims[l], layers_dims[l-1]))
            parameters['b' + str(l)] = np.zeros((layers_dims[l], 1))
            ### END CODE HERE ###
        return parameters  
     
    # GRADED FUNCTION: initialize_parameters_random
    
    def initialize_parameters_random(layers_dims):
        """
        Arguments:
        layer_dims -- python array (list) containing the size of each layer.
        
        Returns:
        parameters -- python dictionary containing your parameters "W1", "b1", ..., "WL", "bL":
                        W1 -- weight matrix of shape (layers_dims[1], layers_dims[0])
                        b1 -- bias vector of shape (layers_dims[1], 1)
                        ...
                        WL -- weight matrix of shape (layers_dims[L], layers_dims[L-1])
                        bL -- bias vector of shape (layers_dims[L], 1)
        """
        
        np.random.seed(3)               # This seed makes sure your "random" numbers will be the as ours
        parameters = {}
        L = len(layers_dims)            # integer representing the number of layers
        
        for l in range(1, L):
            ### START CODE HERE ### (≈ 2 lines of code)
            parameters['W' + str(l)] = np.random.randn(layers_dims[l], layers_dims[l-1]) * 10
            parameters['b' + str(l)] = np.zeros((layers_dims[l], 1))
            ### END CODE HERE ###
    
        return parameters
     
        # GRADED FUNCTION: initialize_parameters_he
    
    def initialize_parameters_he(layers_dims):
        """
        Arguments:
        layer_dims -- python array (list) containing the size of each layer.
        
        Returns:
        parameters -- python dictionary containing your parameters "W1", "b1", ..., "WL", "bL":
                        W1 -- weight matrix of shape (layers_dims[1], layers_dims[0])
                        b1 -- bias vector of shape (layers_dims[1], 1)
                        ...
                        WL -- weight matrix of shape (layers_dims[L], layers_dims[L-1])
                        bL -- bias vector of shape (layers_dims[L], 1)
        """
        
        np.random.seed(3)
        parameters = {}
        L = len(layers_dims) - 1 # integer representing the number of layers
         
        for l in range(1, L + 1):
            ### START CODE HERE ### (≈ 2 lines of code)
            parameters['W' + str(l)] = np.random.randn(layers_dims[l], layers_dims[l-1]) * (math.sqrt(2./layers_dims[l-1])) 
            parameters['b' + str(l)] = np.zeros((layers_dims[l], 1))
            ### END CODE HERE ###
            
        return parameters
         
    if __name__=='__main__':  
        parameters = initialize_parameters_zeros([3,2,1])
        print("W1 = " + str(parameters["W1"]))
        print("b1 = " + str(parameters["b1"]))
        print("W2 = " + str(parameters["W2"]))
        print("b2 = " + str(parameters["b2"]))
       
        parameters = model(train_X, train_Y, initialization = "zeros")
        print ("On the train set:")
        predictions_train = predict(train_X, train_Y, parameters)
        print ("On the test set:")
        predictions_test = predict(test_X, test_Y, parameters)
        
        print ("predictions_train = " + str(predictions_train))
        print ("predictions_test = " + str(predictions_test)) 
    
        plt.title("Model with Zeros initialization")
        axes = plt.gca()
        axes.set_xlim([-1.5,1.5])
        axes.set_ylim([-1.5,1.5])
        plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X, train_Y)
        
        parameters = initialize_parameters_random([3, 2, 1])
        print("W1 = " + str(parameters["W1"]))
        print("b1 = " + str(parameters["b1"]))
        print("W2 = " + str(parameters["W2"]))
        print("b2 = " + str(parameters["b2"]))
    
        parameters = model(train_X, train_Y, initialization = "random")
        print ("On the train set:")
        predictions_train = predict(train_X, train_Y, parameters)
        print ("On the test set:")
        predictions_test = predict(test_X, test_Y, parameters)
    
        print (predictions_train)
        print (predictions_test)
        
        plt.title("Model with large random initialization")
        axes = plt.gca()
        axes.set_xlim([-1.5,1.5])
        axes.set_ylim([-1.5,1.5])
        plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X, train_Y)
        
        parameters = initialize_parameters_he([2, 4, 1])
        print("W1 = " + str(parameters["W1"]))
        print("b1 = " + str(parameters["b1"]))
        print("W2 = " + str(parameters["W2"]))
        print("b2 = " + str(parameters["b2"]))
        
        parameters = model(train_X, train_Y, initialization = "he")
        print ("On the train set:")
        predictions_train = predict(train_X, train_Y, parameters)
        print ("On the test set:")
        predictions_test = predict(test_X, test_Y, parameters)
        
        plt.title("Model with He initialization")
        axes = plt.gca()
        axes.set_xlim([-1.5,1.5])
        axes.set_ylim([-1.5,1.5])
        plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X, train_Y)

运行结果：

（1）全零

![70][]

![70 1][]

（2）随机

![70 2][]

![70 3][]

（3）He

![70 4][]

![70 5][]

![70 6][]

![70 7][]

![70 8][]

Note：

我发现如果随机初始化W：**parameters\['W' + str(l)\] = np.random.randn(layers\_dims\[l\], layers\_dims\[l-1\])**

即不“/10”的话，效果比he还好……准确率达到0.997，而he是0.993……

![70 9][]

![70 10][]

![70 11][]

[70]: /images/20220511/9aaf83f9dbcf4b6a8b0910b8fba24b23.png
[70 1]: /images/20220511/29e310438bb64199a969b17622e4001c.png
[70 2]: /images/20220511/777643335c224bf1a7128addc0496adc.png
[70 3]: /images/20220511/dfa6e006960443b593f7b53492a8f776.png
[70 4]: /images/20220511/764a2398ee8f44148c772869c24da280.png
[70 5]: /images/20220511/6ba04ecfdf7b4579b250990fec700c73.png
[70 6]: /images/20220511/d1c9c41ef9174fd191dc1a45e2a265f1.png
[70 7]: /images/20220511/b7d5cdd2d3ad4569a01769ed0d4c595c.png
[70 8]: /images/20220511/2a5ff59d63e9444393934d4b33cf34e2.png
[70 9]: /images/20220511/773fc7f6acda433d9dc85d8d06860749.png
[70 10]: /images/20220511/a86868222bd5409d917dfe67bfbfb757.png
[70 11]: /images/20220511/0e531c8518f745e7a15c61d2c4d6568f.png