1.3 Deep Neural Networks

깊은 신경망은 앞서 정리한 얕은 신경망과 유사하다.

layer를 \(L\)개로 확장하면 된다.

 

 

 

1 ~ 1-\(L\) layer는 임의의 activation function(\(g^{[1]}, ..., g^{[L-1]}\))을 사용하고

\(L\) layer의 activation function(\(g^{[L]}\))는 Sigmoid일 때,

Forward Propagation과 Backward Propagation은 다음과 같다.

 

 

 

---

 

L-layer Neural Network에서 최적의 parameter(W, b)와 cost를 구하는 로직은 다음과 같다.

 

def L_layer_model(X, Y, layers_dims, learning_rate = 0.0075, num_iterations = 3000, print_cost=False):
    np.random.seed(1)
    costs = [] 
    # 1. Parameters initialization
	parameters = initialize_parameters_deep(layers_dims)
    for i in range(0, num_iterations):
        # 2. Forward propagation: [LINEAR -> RELU]*(L-1) -> LINEAR -> SIGMOID
        AL, caches = L_model_forward(X, parameters)
        # 3. Compute cost
        cost = compute_cost(AL, Y)
        # 4. Backward propagation
        grads = L_model_backward(AL, Y, caches)
        # 5. Update parameters
        parameters = update_parameters(parameters, grads, learning_rate)
        # Print the cost every 100 iterations
        if print_cost and i % 100 == 0 or i == num_iterations - 1:
            print("Cost after iteration {}: {}".format(i, np.squeeze(cost)))
        if i % 100 == 0 or i == num_iterations:
            costs.append(cost)
    return parameters, costs

 

1. Parameters initialization

2. Forward propagation

3. Backward propagation

4. Compute cost

5. Update parameters

 

1은 최초의 parameter \(W, b\) 값을 초기화한다.

2~5는 cost를 구하고, parameter를 업데이트하는 것을 반복한다.

 

 

---

 

L-layer Neural Network를 구성하는 각 단계를 살펴보자.

(1 ~ L-1 layer는 ReLU, L layer는 Sigmoid를 사용하는 L-layer Neural Network이다.)

 

 

 

 

1. Parameters Initialization

def initialize_parameters_deep(layer_dims):
    parameters = {}
    L = len(layer_dims) # number of layers
    for l in range(1, L):
        parameters['W' + str(l)] = np.random.randn(layer_dims[l], layer_dims[l-1]) * 0.01
        parameters['b' + str(l)] = np.zeros((layer_dims[l], 1))       
    return parameters

 

\(W\)는 random 값을 가지도록 초기화해야한다.

 

 

2. Forward Propagation

def linear_forward(A, W, b):
    Z = np.dot(W, A) + b
    cache = (A, W, b)
    return Z, cache
    
def linear_activation_forward(A_prev, W, b, activation):
    if activation == "sigmoid":
        Z, linear_cache = linear_forward(A_prev, W, b)
        A, activation_cache = sigmoid(Z)        
    elif activation == "relu":
        Z, linear_cache = linear_forward(A_prev, W, b)
        A, activation_cache = relu(Z)        
    cache = (linear_cache, activation_cache)
    return A, cache
    
def L_model_forward(X, parameters):
    caches = []
    A = X
    L = len(parameters) // 2 # number of layers
    for l in range(1, L):
        A_prev = A 
        A, cache = linear_activation_forward(A_prev, parameters['W' + str(l)], parameters['b' + str(l)], "relu")
        caches.append(cache)          
    AL, cache = linear_activation_forward(A, parameters['W' + str(L)], parameters['b' + str(L)], "sigmoid")
    caches.append(cache)       
    return AL, caches

 

1 ~ L layer 순서로 계산하여 AL(\(=\hat{Y}\))를 구한다. 

1 ~ L-1 layer는 ReLU, L layer는 Sigmoid를 사용한다.

 

각 layer를 계산할 때, layer에 해당하는 cache를 기록한다.

cache는 linear cache (A, W, b), activation cache Z로 구성된다.

이후 back propagation에서 linear cache는 dA_prev, dW, db를 계산에, activation cache는 dZ를 계산에 사용될 것이다.

 

caches = [((A1, W1, b1), Z1), ((A2, W2, b2), Z2), ..., ((AL, WL, bL), ZL)]

 

 

3. Compute Cost

def compute_cost(AL, Y):
    m = Y.shape[1]
    logprobs = np.multiply(np.log(AL),Y) + np.multiply(np.log(1-AL),1-Y)
    cost = - 1/m * np.sum(logprobs)     
    return cost

 

Cost function으로 Cross-Entropy를 사용하였다.

 

 

4. Backward Propagation

def linear_backward(dZ, cache):
    A_prev, W, b = cache
    m = A_prev.shape[1]
    dW = 1/m * np.dot(dZ, A_prev.T)
    db = 1/m * np.sum(dZ, axis=1, keepdims=True)
    dA_prev = np.dot(W.T, dZ)
    return dA_prev, dW, db
    
def linear_activation_backward(dA, cache, activation):
    linear_cache, activation_cache = cache
    if activation == "relu":
        dZ =  relu_backward(dA, activation_cache)
        dA_prev, dW, db =  linear_backward(dZ, linear_cache)        
    elif activation == "sigmoid":
        dZ =  sigmoid_backward(dA, activation_cache)
        dA_prev, dW, db =  linear_backward(dZ, linear_cache)       
    return dA_prev, dW, db
    
def L_model_backward(AL, Y, caches):
    grads = {}
    L = len(caches) # number of layers
    m = AL.shape[1]
    Y = Y.reshape(AL.shape)
    dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL))
    # Lth layer (SIGMOID -> LINEAR) gradients.
    current_cache = caches[L-1]
    dA_prev_temp, dW_temp, db_temp = linear_activation_backward(dAL, current_cache, "sigmoid")
    grads["dA" + str(L-1)] = dA_prev_temp
    grads["dW" + str(L)] = dW_temp
    grads["db" + str(L)] = db_temp    
    # Loop from l=L-2 to l=0
    for l in reversed(range(L-1)):
        # lth layer: (RELU -> LINEAR) gradients.
        current_cache = caches[l]
        dA_prev_temp, dW_temp, db_temp = linear_activation_backward(dA_prev_temp, current_cache, "relu")
        grads["dA" + str(l)] = dA_prev_temp
        grads["dW" + str(l + 1)] = dW_temp
        grads["db" + str(l + 1)] = db_temp     
    return grads

 

L  ~ 1 layer 순서로 계산하여 각 layer에서의 dW, db를 구한다.

L layer는 Sigmoid를, L-1 ~ 1 layer는 ReLU를 사용한다.

 

forward propagation에서 계산한 cache를 입력받아   

activation cache로 dZ를 계산하고, dZ와 linear cache로 dA_prev, dW, db를 계산한다.

각 layer를 계산할 때, layer에 해당하는 grad(dW, db)를 기록한다.

 

 

5. Update parameters

def update_parameters(params, grads, learning_rate):
    parameters = params.copy()
    L = len(parameters) // 2 # number of layers
    for l in range(L):
        parameters["W" + str(l+1)] = parameters["W" + str(l+1)] - learning_rate * grads['dW'+ str(l+1)]
        parameters["b" + str(l+1)] = parameters["b" + str(l+1)] - learning_rate * grads['db'+ str(l+1)]        
    return parameters

 

경사하강법(Gradient Descent)을 사용하여 patameter W, b를 업데이트한다. 

 

 

---

 

• https://www.coursera.org/learn/neural-networks-deep-learning/home/week/4