轉載自吳恩達老師深度學習練習notebook

Initialization

Welcome to the first assignment of “Improving Deep Neural Networks”.

Training your neural network requires specifying an initial value of the weights. A well chosen initialization method will help learning.

If you completed the previous course of this specialization, you probably followed our instructions for weight initialization, and it has worked out so far. But how do you choose the initialization for a new neural network? In this notebook, you will see how different initializations lead to different results.

A well chosen initialization can:

Speed up the convergence of gradient descent
Increase the odds of gradient descent converging to a lower training (and generalization) error

To get started, run the following cell to load the packages and the planar dataset you will try to classify.

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

%matplotlib inline
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()

png

You would like a classifier to separate the blue dots from the red dots.

1 - Neural Network model

You will use a 3-layer neural network (already implemented for you). Here are the initialization methods you will experiment with:

Zeros initialization – setting initialization = "zeros" in the input argument.
Random initialization – setting initialization = "random" in the input argument. This initializes the weights to large random values.
He initialization – setting initialization = "he" in the input argument. This initializes the weights to random values scaled according to a paper by He et al., 2015.

Instructions: Please quickly read over the code below, and run it. In the next part you will implement the three initialization methods that this model() calls.

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

2 - Zero initialization

There are two types of parameters to initialize in a neural network:

the weight matrices $(W^{[1]}, W^{[2]}, W^{[3]}, ..., W^{[L-1]}, W^{[L]})$
the bias vectors $(b^{[1]}, b^{[2]}, b^{[3]}, ..., b^{[L-1]}, b^{[L]})$

Exercise: Implement the following function to initialize all parameters to zeros. You’ll see later that this does not work well since it fails to “break symmetry”, but lets try it anyway and see what happens. Use np.zeros((…,…)) with the correct shapes.

# 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

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"]))

W1 = [[0. 0. 0.]
 [0. 0. 0.]]
b1 = [[0.]
 [0.]]
W2 = [[0. 0.]]
b2 = [[0.]]

Expected Output:

W1	[[ 0. 0. 0.] [ 0. 0. 0.]]
b1	[[ 0.] [ 0.]]
W2	[[ 0. 0.]]
b2	[[ 0.]]

Run the following code to train your model on 15,000 iterations using zeros initialization.

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)

Cost after iteration 0: 0.6931471805599453
Cost after iteration 1000: 0.6931471805599453
Cost after iteration 2000: 0.6931471805599453
Cost after iteration 3000: 0.6931471805599453
Cost after iteration 4000: 0.6931471805599453
Cost after iteration 5000: 0.6931471805599453
Cost after iteration 6000: 0.6931471805599453
Cost after iteration 7000: 0.6931471805599453
Cost after iteration 8000: 0.6931471805599453
Cost after iteration 9000: 0.6931471805599453
Cost after iteration 10000: 0.6931471805599455
Cost after iteration 11000: 0.6931471805599453
Cost after iteration 12000: 0.6931471805599453
Cost after iteration 13000: 0.6931471805599453
Cost after iteration 14000: 0.6931471805599453

png

On the train set:
Accuracy: 0.5
On the test set:
Accuracy: 0.5

The performance is really bad, and the cost does not really decrease, and the algorithm performs no better than random guessing. Why? Lets look at the details of the predictions and the decision boundary:

print ("predictions_train = " + str(predictions_train))
print ("predictions_test = " + str(predictions_test))

predictions_train = [[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0]]
predictions_test = [[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]]

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, np.squeeze(train_Y))

png

The model is predicting 0 for every example.

In general, initializing all the weights to zero results in the network failing to break symmetry. This means that every neuron in each layer will learn the same thing, and you might as well be training a neural network with $n^{[l]}=1$ for every layer, and the network is no more powerful than a linear classifier such as logistic regression.

**What you should remember**: - The weights $W^{[l]}$ should be initialized randomly to break symmetry. - It is however okay to initialize the biases $b^{[l]}$ to zeros. Symmetry is still broken so long as $W^{[l]}$ is initialized randomly.

3 - Random initialization

To break symmetry, lets intialize the weights randomly. Following random initialization, each neuron can then proceed to learn a different function of its inputs. In this exercise, you will see what happens if the weights are intialized randomly, but to very large values.

Exercise: Implement the following function to initialize your weights to large random values (scaled by *10) and your biases to zeros. Use np.random.randn(..,..) * 10 for weights and np.zeros((.., ..)) for biases. We are using a fixed np.random.seed(..) to make sure your “random” weights match ours, so don’t worry if running several times your code gives you always the same initial values for the 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['W' + str(l)] = np.random.randn(layers_dims[l], layers_dims[l-1]) 
        parameters['b' + str(l)] = np.zeros((layers_dims[l], 1))
        ### END CODE HERE ###

    return parameters

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"]))

W1 = [[ 17.88628473   4.36509851   0.96497468]
 [-18.63492703  -2.77388203  -3.54758979]]
b1 = [[0.]
 [0.]]
W2 = [[-0.82741481 -6.27000677]]
b2 = [[0.]]

Expected Output:

W1	[[ 17.88628473 4.36509851 0.96497468] [-18.63492703 -2.77388203 -3.54758979]]
b1	[[ 0.] [ 0.]]
W2	[[-0.82741481 -6.27000677]]
b2	[[ 0.]]

Run the following code to train your model on 15,000 iterations using random initialization.

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)

Cost after iteration 0: inf


D:\My document\Interest Learning\Data Mining\Python\jupyter-notebook\00_DeepLearning\2_Improving Deep Neural Networks\week1_initialization_Regularization_Gradientchecking\week1_01_initialization\init_utils.py:145: RuntimeWarning: divide by zero encountered in log
  logprobs = np.multiply(-np.log(a3),Y) + np.multiply(-np.log(1 - a3), 1 - Y)
D:\My document\Interest Learning\Data Mining\Python\jupyter-notebook\00_DeepLearning\2_Improving Deep Neural Networks\week1_initialization_Regularization_Gradientchecking\week1_01_initialization\init_utils.py:145: RuntimeWarning: invalid value encountered in multiply
  logprobs = np.multiply(-np.log(a3),Y) + np.multiply(-np.log(1 - a3), 1 - Y)


Cost after iteration 1000: 0.6250982793959966
Cost after iteration 2000: 0.5981216596703697
Cost after iteration 3000: 0.5638417572298645
Cost after iteration 4000: 0.5501703049199763
Cost after iteration 5000: 0.5444632909664456
Cost after iteration 6000: 0.5374513807000807
Cost after iteration 7000: 0.4764042074074983
Cost after iteration 8000: 0.39781492295092263
Cost after iteration 9000: 0.3934764028765484
Cost after iteration 10000: 0.3920295461882659
Cost after iteration 11000: 0.38924598135108
Cost after iteration 12000: 0.3861547485712325
Cost after iteration 13000: 0.384984728909703
Cost after iteration 14000: 0.3827828308349524

png

On the train set:
Accuracy: 0.83
On the test set:
Accuracy: 0.86

If you see “inf” as the cost after the iteration 0, this is because of numerical roundoff; a more numerically sophisticated implementation would fix this. But this isn’t worth worrying about for our purposes.

Anyway, it looks like you have broken symmetry, and this gives better results. than before. The model is no longer outputting all 0s.

print (predictions_train)
print (predictions_test)

[[1 0 1 1 0 0 1 1 1 1 1 0 1 0 0 1 0 1 1 0 0 0 1 0 1 1 1 1 1 1 0 1 1 0 0 1
  1 1 1 1 1 1 1 0 1 1 1 1 0 1 0 1 1 1 1 0 0 1 1 1 1 0 1 1 0 1 0 1 1 1 1 0
  0 0 0 0 1 0 1 0 1 1 1 0 0 1 1 1 1 1 1 0 0 1 1 1 0 1 1 0 1 0 1 1 0 1 1 0
  1 0 1 1 0 0 1 0 0 1 1 0 1 1 1 0 1 0 0 1 0 1 1 1 1 1 1 1 0 1 1 0 0 1 1 0
  0 0 1 0 1 0 1 0 1 1 1 0 0 1 1 1 1 0 1 1 0 1 0 1 1 0 1 0 1 1 1 1 0 1 1 1
  1 0 1 0 1 0 1 1 1 1 0 1 1 0 1 1 0 1 1 0 1 0 1 1 1 0 1 1 1 0 1 0 1 0 0 1
  0 1 1 0 1 1 0 1 1 0 1 1 1 0 1 1 1 1 0 1 0 0 1 1 0 1 1 1 0 0 0 1 1 0 1 1
  1 1 0 1 1 0 1 1 1 0 0 1 0 0 0 1 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 1 1 1
  1 1 1 1 0 0 0 1 1 1 1 0]]
[[1 1 1 1 0 1 0 1 1 0 1 1 1 0 0 0 0 1 0 1 0 0 1 0 1 0 1 1 1 1 1 0 0 0 0 1
  0 1 1 0 0 1 1 1 1 1 0 1 1 1 0 1 0 1 1 0 1 0 1 0 1 1 1 1 1 1 1 1 1 0 1 0
  1 1 1 1 1 0 1 0 0 1 0 0 0 1 1 0 1 1 0 0 0 1 1 0 1 1 0 0]]

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, np.squeeze(train_Y))

png

Observations:

The cost starts very high. This is because with large random-valued weights, the last activation (sigmoid) outputs results that are very close to 0 or 1 for some examples, and when it gets that example wrong it incurs a very high loss for that example. Indeed, when $\log(a^{[3]}) = \log(0)$ , the loss goes to infinity.
Poor initialization can lead to vanishing/exploding gradients, which also slows down the optimization algorithm.
If you train this network longer you will see better results, but initializing with overly large random numbers slows down the optimization.

**In summary**: - Initializing weights to very large random values does not work well. - Hopefully intializing with small random values does better. The important question is: how small should be these random values be? Lets find out in the next part!

4 - He initialization

Finally, try “He Initialization”; this is named for the first author of He et al., 2015. (If you have heard of “Xavier initialization”, this is similar except Xavier initialization uses a scaling factor for the weights $W^{[l]}$ of sqrt(1./layers_dims[l-1]) where He initialization would use sqrt(2./layers_dims[l-1]).)

Exercise: Implement the following function to initialize your parameters with He initialization.

Hint: This function is similar to the previous initialize_parameters_random(...). The only difference is that instead of multiplying np.random.randn(..,..) by 10, you will multiply it by $\sqrt{\frac{2}{\text{dimension of the previous layer}}}$ , which is what He initialization recommends for layers with a ReLU activation.

# 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]) * np.sqrt(2/layers_dims[l - 1])
        parameters['b' + str(l)] = np.zeros((layers_dims[l], 1))
        ### END CODE HERE ###
        
    return parameters

parameters = initialize_parameters_he([3, 2, 1])
print
              
           
              
              
            
            相關推薦
			   
            
            
            
 

    

    
    吳恩達深度學習2.1練習_Improving Deep Neural Networks_initialization
       
  
  
 轉載自吳恩達老師深度學習練習notebook 
 Initialization 
 Welcome to the first assignment of “Improving Deep Neural Networks”. 
 Training your neural network requ 

  
 

    

    
    吳恩達深度學習2.1練習_Improving Deep Neural Networks(Initialization_Regularization_Gradientchecking)
       
  
  
 版權宣告：本文為博主原創文章，未經博主允許不得轉載。 https://blog.csdn.net/weixin_42432468 
 學習心得： 1、每週的視訊課程看一到兩遍 2、做筆記 
 3、做每週的作業練習，這個裡面的含金量非常高。先根據notebook過一遍，掌握後一定要自己敲一遍， 

  
 

    

    
    吳恩達深度學習2.3練習_Improving Deep Neural Networks_Tensorflow
       
  
  
 轉載自吳恩達老師深度學習練習notebook 
 TensorFlow Tutorial 
 Welcome to this week’s programming assignment. Until now, you’ve always used numpy to build neural  

  
 

    

    
    吳恩達深度學習2.1筆記_Improving Deep Neural Networks_深度學習的實踐層面
       
  
  
 版權宣告：本文為博主原創文章，未經博主允許不得轉載。 https://blog.csdn.net/weixin_42432468 
 學習心得： 1、每週的視訊課程看一到兩遍 2、做筆記 
 3、做每週的作業練習，這個裡面的含金量非常高。先根據notebook過一遍，掌握後一定要自己敲一遍， 

  
 

    

    
    吳恩達深度學習2.3筆記_Improving Deep Neural Networks_超引數除錯 和 Batch Norm
       
  
  
 版權宣告：本文為博主原創文章，未經博主允許不得轉載。 https://blog.csdn.net/weixin_42432468 
 學習心得： 1、每週的視訊課程看一到兩遍 2、做筆記 
 3、做每週的作業練習，這個裡面的含金量非常高。先根據notebook過一遍，掌握後一定要自己敲一遍， 

  
 

    

    
    吳恩達深度學習4.1練習_Convolutional Neural Networks_Convolution_model_Application_2
       
  
  
 版權宣告：本文為博主原創文章，未經博主允許不得轉載。 https://blog.csdn.net/weixin_42432468 
 學習心得： 1、每週的視訊課程看一到兩遍 2、做筆記 
 3、做每週的作業練習，這個裡面的含金量非常高。先根據notebook過一遍，掌握後一定要自己敲一遍， 

  
 

    

    
    吳恩達深度學習4.1練習_Convolutional Neural Networks_Convolution_model_StepByStep_1
       
  
  
 轉載自吳恩達老師深度學習練習notebook 
 Convolutional Neural Networks: Step by Step 
 Welcome to Course 4’s first assignment! In this assignment, you will implem 

  
 

    

    
    吳恩達深度學習2.2練習_Improving Deep Neural Networks_Optimization
       
  
  
 版權宣告：本文為博主原創文章，未經博主允許不得轉載。 https://blog.csdn.net/weixin_42432468 
 學習心得： 1、每週的視訊課程看一到兩遍 2、做筆記 
 3、做每週的作業練習，這個裡面的含金量非常高。先根據notebook過一遍，掌握後一定要自己敲一遍， 

  
 

    

    
    吳恩達深度學習2-Week2課後作業3-優化演算法
       
 
 
 一、deeplearning-assignment 
 到目前為止，在之前的練習中我們一直使用梯度下降來更新引數並最小化成本函式。在本次作業中，將學習更先進的優化方法，它在加快學習速度的同時，甚至可以獲得更好的最終值。一個好的優化演算法可以讓你幾個小時內就獲得一個結果，而不是等待幾天。 
 1. 

  
 

    

    
    吳恩達深度學習2-Week1課後作業3-梯度檢測
       
 
 
 一、deeplearning-assignment 
 神經網路的反向傳播很複雜，在某些時候需要對反向傳播演算法進行驗證，以證明確實有效，這時我們引入了“梯度檢測”。 
 反向傳播需要計算梯度 , 其中θ表示模型的引數。J是使用前向傳播和損失函式計算的。因為前向傳播實現相對簡單, 所以 

  
 

    

    
    吳恩達深度學習總結(1)
       
  
  
 
 
  DeaplearningAI01.weak2
  
   forward
   backward
  
 
  
 本週主要介紹了神經網路中forward和backward的一般實現和向量實現。一般實現較為簡單，向量實現中存在一些疑點 
     
      
       
  

  
 

    

    
    吳恩達深度學習2-Week3課後作業-Tensorflow
       
 
 
 一、deeplearning-assignment 
 到目前為止，我們一直使用numpy來建立神經網路。這次作業將深入學習框架，可以更容易地建立神經網路。 
 TensorFlow，PaddlePaddle，Torch，Caffe，Keras等機器學習框架可以顯著地加速機器學習開發。這些框架有 

  
 

    

    
    吳恩達深度學習2-Week1課後作業2-正則化
      
                一、deeplearning-assignment

這一節作業的重點是理解各個正則化方法的原理，以及它們的優缺點，而不是去注重演算法實現的具體末節。

問題陳述：希望你通過一個數據集訓練一個合適的模型，從而幫助推薦法國守門員應該踢球的位置，這樣法國隊的球員可以用頭打。法國過 

  
 

    

    
    吳恩達深度學習4.3練習_Convolutional Neural Networks_Car detection
       
  
  
 轉載自吳恩達老師深度學習課程作業notebook 
 Autonomous driving - Car detection 
 Welcome to your week 3 programming assignment. You will learn about object detecti 

  
 

    

    
    吳恩達深度學習2.2筆記_Improving Deep Neural Networks_優化演算法
       
  
  
 版權宣告：本文為博主原創文章，未經博主允許不得轉載。 https://blog.csdn.net/weixin_42432468 
 學習心得： 1、每週的視訊課程看一到兩遍 2、做筆記 
 3、做每週的作業練習，這個裡面的含金量非常高。先根據notebook過一遍，掌握後一定要自己敲一遍， 

  
 

    

    
    吳恩達深度學習4.4練習_Convolutional Neural Networks_Face Recognition for the Happy House
       
  
  
 轉載自吳恩達老師深度學習課程作業notebook 
 Face Recognition for the Happy House 
 Welcome to the first assignment of week 4! Here you will build a face recognitio 

  
 

    

    
    吳恩達深度學習：1.3樣例用一個隱含層神經網路對資料進行分類
      
							
							
							coding: utf-8



# Planar data classification with one hidden layer



用一個隱含層神經網路對資料進行分類



Welcome to your week 3 programming assi 

  
 

    

    
    吳恩達深度學習筆記1-神經網絡的編程基礎(Basics of Neural Network programming)
      算法   只有一個   ear   最小化   維度   編程基礎   clas   什麽   分類問題   一：二分類(Binary Classification)
　　邏輯回歸是一個用於二分類(binary classification)的算法。在二分類問題中，我們的目標就是習得一個分類器，它以對象的特 

  
 

    

    
    吳恩達深度學習4.2練習_Convolutional Neural Networks_Happy House & Residual Networks
       
  
  
 1、Happy House 
  
  1.1、 Load Dataset 
  
  
  1.2、構建流圖：def HappyModel 
  
  
  1.3、PlaceHolder --> happyModel = HappyModel((64,64,3)) 
  
  
  

  
 

    

    
    吳恩達深度學習4.2練習_Convolutional Neural Networks_Residual Networks
       
  
  
 轉載自吳恩達老師深度學習課程作業notebook 
 Residual Networks 
 Welcome to the second assignment of this week! You will learn how to build very deep convolutional