close_btn
조회 수 45 추천 수 0 댓글 0
?

단축키

Prev이전 문서

Next다음 문서

+ - Up Down Comment Print Files
?

단축키

Prev이전 문서

Next다음 문서

+ - Up Down Comment Print Files


ToBig's_11th_W06_Advanced_NN

Assignment 01

 

1. (He 초기화를 사용하여 무작위로 선택한 값이라면) 모든 가중치를 같은 값으로 초기화해도 괜찮을까요?

모든 가중치를 같은 값으로 초기화하면 마지막 layer의 가중치만 갱신되므로 multi layer로 설계한 의미를 잃게 되기 때문에 모든 가중치를 같은 값으로 초기화하는 것은 좋지 않다.

softmaxcross entropy loss function을 사용할 때를 생각해보자. 모든 가중치를 같은 값으로 초기화하면 forward propagation의 첫 번째 layer에서부터 모든 Node가 같은 값을 갖게 되며, softmax의 결과로 모든 label에 대해 같은 확률을 출력한다. 하지만 back propagation에서 정답 label에 해당하는 softmax node의 입력단의 역전파 값(softmax 직전의 hidden layer의 가중치에 대한 gradient)만 다른 값을 가지기 때문에 softmax 직전의 hidden layer는 학습 label에 따라 각기 다른 가중치가 학습된다. 하지만 이후의 역전파는 해당 hidden layer의 가중치를 모두 포함하므로 모두 동일한 가중치가 학습된다.

이렇게 되면 하나의 softmax 직전의 하나의 hidden layer만 가지고 학습하는 것과 같은 결과를 초래하므로 multi layer로 설계한 의미가 없게 된다.

 

2. ReLU는 왜 좋은가요? ReLU보다 ELU가 나은 점은?

기존 sigmoid 함수에서 발생하는 vanishing or exploding gradient 문제를 해결하였고, 함수의 미분이 간단하여 기존 sigmoidtanh 대비 학습 수렴 속도가 빠르다.

ReLUELU보다 나은 점 : 입력 값이 음수일 때에도 gradient가 사라지지 않는다.

 

3. ELU, LeakyReLU, ReLU, tanh, sigmoid, softmax 각각을 어떤 경우에 쓰는지?

- sigmoid : Logistic function이라고도 불리며 Binary Classifier 또는 Activation function으로 쓰인다. 깊은 신경망에서 gradient vanishing 문제가 발생하고, 역전파된 gradient의 방향에 제약이 있어 학습이 더딘 단점이 있다.

- softmax : sigmoid를 이진 분류에서 다항 분류로 일반화한 함수로 주로 model의 말단부에서 Classifier로 쓰인다.

- tanh : sigmoid function의 가중치 학습시 역전파된 gradient의 방향에 제약이 가해져 학습속도가 늦거나 수렴이 어렵게 되는 문제를 해결한 함수. 그러나 sigmoid함수와 마찬가지로 입력 값이 지나치게 크거나 작은 경우 gradient0에 수렴하는 단점(gradient vanishing)이 있다.

- ReLU : 기존의 sigmoid, tanh에서 입력 값이 지나치게 크거나 작을 때 gradient0에 수렴하는 문제를 개선한 함수. 입력 값이 0보다 작으면 gradient0으로 만들기 때문에 필요한 정보에 집중해 계산이 빠르다는 장점이 있다. 하지만 동시에 정보 손실이 발생한다(dying ReLU).

- LeakyReLU : ReLU를 보완하기 위한 변형 중 하나. 입력 값이 음수일 때 gradient0.01이라는 점을 제외하고 ReLU와 동일.

- ELU : ReLU를 보완하기 위한 변형 중 하나. 하지만 exp()ReLU, LeakyReLU와는 달리 exp()를 계산해야 하는 비용이 든다.

 

4. Momentum Optimizer를 사용할 때 Momentum parameter1에 매우 가깝게 하면(ex 0.99999) 어떤 일이 일어나는가?

최초의 gradient descent 방향을 거의 그대로 유지하게 된다.

 

5. Dropout이 훈련 속도를 느리게 만드는가? predict(test set 예측)도 느리게 만드는가?

훈련 속도를 1epoch 학습에 걸리는 실제 연산속도로만 본다면 훈련 속도를 빠르게 만든다고 할 수 있다. 반면 훈련 속도를 동일한 성능에 도달(“수렴”)하기까지 반복할 epoch 수로 본다면 훈련 속도를 느리게 만든다고 볼 수 있다. 예를 들면, dropout 비율을 0.5로 한 모델의 경우 dropout을 하지 않은 model 대비 1epoch당 도달하는 성능은 반으로 줄고, 1epoch당 학습에 소요되는 연산시간도 반으로 줄기 때문에, 동일한 성능을 내기위해서 2epoch를 학습하면 되며 이 때 걸리는 시간은 dropout을 하지 않은 model1epoch를 학습한 시간과 같다.

dropout은 모델 훈련 시에만 적용하기 때문에 predict 속도는 하지 않은 모델과 동일하다.

 

6. Adam Optimizer가 좋은 이유?

gradient descent의 속력(RMSProp)과 방향(Momentum)을 모두 고려했기 때문에

 

7. function.py의 파일에 있는 함수들이 무엇인지 정의하고, 그 코드들을 설명하라(주석처리), 또한 그 함수를 저번 주에 구현한 Neural net에 적용시켜 코드로 구현하라


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
def initialize_adam(parameters) :
    """
    Initializes v and s as two python dictionaries with:
                - keys: "dW1", "db1", ..., "dWL", "dbL
                - values: numpy arrays of zeros of the same shape as the corresponding gradients/parameters.
    
    Arguments:
    parameters -- python dictionary containing your parameters.
                    parameters["W" + str(l)] = Wl
                    parameters["b" + str(l)] = bl
    
    Returns: 
    v -- python dictionary that will contain the exponentially weighted average of the gradient.
                    v["dW" + str(l)] = ...
                    v["db" + str(l)] = ...
    s -- python dictionary that will contain the exponentially weighted average of the squared gradient.
                    s["dW" + str(l)] = ...
                    s["db" + str(l)] = ...
    """
    
    L = len(parameters) // 2 # number of layers in the neural networks
    v = {}
    s = {}
    
    # Initialize v, s. Input: "parameters". Outputs: "v, s".
    for l in range(L):
    ### START CODE HERE ### (approx. 4 lines)
        v["dW" + str(l+1)] = np.zeros_like(parameters["W" + str(l+1)])
        v["db" + str(l+1)] = np.zeros_like(parameters["b" + str(l+1)])
        s["dW" + str(l+1)] = np.zeros_like(parameters["W" + str(l+1)])
        s["db" + str(l+1)] = np.zeros_like(parameters["b" + str(l+1)])
    ### END CODE HERE ###
    
    return v, s
# Update Parameters of adam
def function1(parameters, grads, v, s, t, learning_rate = 0.01,
                                beta1 = 0.9, beta2 = 0.999,  epsilon = 1e-8):
    L = len(parameters) // 2
    v_corrected = {}
    s_corrected = {}
    for l in range(L):
        # Update biased first moment estimate (v_t)
        # v_t = beta1 * v_{t-1} + (1-beta1) * g_t
        # cf. g_t = delta_{theta} * J_t(theta_{t-1}) : the gradients w.r.t. stochastic objective at timestep(t)
        v["dW" + str(l+1)] = beta1 * v["dW" + str(l+1)] + (1-beta1) * grads["dW" + str(l+1)]
        v["db" + str(l+1)] = beta1 * v["db" + str(l+1)] + (1-beta1) * grads["db" + str(l+1)]
        # Compute bias-corrected first moment estimate
        # hat{v_t} = m_t / (1-beta1^t)
        v_corrected["dW" + str(l+1)] = v["dW" + str(l+1)]/(1-np.power(beta1,t))
        v_corrected["db" + str(l+1)] = v["db" + str(l+1)]/(1-np.power(beta1,t))
        # Update biased second raw moment estimate (g_t)
        # s_t = beta2 * s_{t-1} + (1-beta2) * (g_t)^2
        s["dW" + str(l+1)] = beta2 * s["dW" + str(l+1)] + (1-beta2) * np.square(grads["dW" + str(l+1)])
        s["db" + str(l+1)] = beta2 * s["db" + str(l+1)] + (1-beta2) * np.square(grads["db" + str(l+1)])
        # Compute bias-corrected second raw moment estimate
        # hat{s_t} = s_t / (1-beta2^t)
        s_corrected["dW" + str(l+1)] = s["dW" + str(l+1)]/(1-np.power(beta2,t))
        s_corrected["db" + str(l+1)] = s["db" + str(l+1)]/(1-np.power(beta2,t))
        # Update parameters
        # theta_t = theta_{t-1} - alpha * hat{m_t) / (sqrt{hat{v_t} + epsilon)
        parameters["W" + str(l+1)] = parameters["W" + str(l+1)] - learning_rate * v_corrected["dW" + str(l+1)]/(np.sqrt(s_corrected["dW" + str(l+1)]) + epsilon)
        parameters["b" + str(l+1)] = parameters["b" + str(l+1)] - learning_rate * v_corrected["db" + str(l+1)]/(np.sqrt(s_corrected["db" + str(l+1)]) + epsilon)
 
    return parameters, v, s
# forward propagation
def function2(X, parameters, keep_prob = 0.5):
    # X : (D, N)
    np.random.seed(1)
    # Assume that the model have 3 Linear Layer
    W1 = parameters["W1"# (H1, D)
    b1 = parameters["b1"# (H1, )
    W2 = parameters["W2"# (H2, H1)
    b2 = parameters["b2"# (H2, )
    W3 = parameters["W3"# (H3, H2)
    b3 = parameters["b3"# (H3, )
    
    # LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID
    Z1 = np.dot(W1, X) + b1 # (H1, N)
    A1 = relu(Z1)
    # Dropout. (At Training time. Not Test time.)
    # D1 is a matrix for drop out. keep_prob : dropout probability
    D1 = np.random.rand(A1.shape[0],A1.shape[1]) # (H1, N)
    D1 = D1 < keep_prob
    A1 = np.multiply(A1,D1)                             
    A1 = A1/keep_prob
    # cf. scaling for expected output : expected output = x
    #     but, output = p*x + (1-p)*0 = p*x. so we scale it back with 1/p
    Z2 = np.dot(W2, A1) + b2 # (H2, N)
    A2 = relu(Z2)
    # Dropout
    D2 = np.random.rand(A2.shape[0],A2.shape[1])                        
    D2 = D2 < keep_prob                               
    A2 = np.multiply(A2,D2)                           
    A2 = A2/keep_prob
    Z3 = np.dot(W3, A2) + b3 # (H3, H2)
    A3 = sigmoid(Z3)
    
    cache = (Z1, D1, A1, W1, b1, Z2, D2, A2, W2, b2, Z3, A3, W3, b3)
    
    return A3, cache
# backward propagation
def function3(X, Y, cache, keep_prob):
    # m means size of X
    m = X.shape[1]
    (Z1, D1, A1, W1, b1, Z2, D2, A2, W2, b2, Z3, A3, W3, b3) = cache
    # dL/dZ3
    dZ3 = A3 - Y
    # dL/dW3 = (dL/dZ3)*(dZ3/dW3)
    dW3 = 1./* np.dot(dZ3, A2.T)
    # dL/db3 = (dL/dZ3)*(dZ3/db3)
    db3 = 1./* np.sum(dZ3, axis=1, keepdims = True)
    # dL/dA2 = (dZ3/dA2)*(dL/dZ3)
    dA2 = np.dot(W3.T, dZ3)
    # update gradient of nodes that wasn't dropped at forward propagation.
    dA2 = np.multiply(dA2,D2)             
    dA2 = dA2/keep_prob              
    # derivation of ReLU
    dZ2 = np.multiply(dA2, np.int64(A2 > 0))
    # dL/dW2 = (dL/dZ2)*(dZ2/dW2)
    dW2 = 1./* np.dot(dZ2, A1.T)
    # dL/db2 = (dL/dZ2)*(dZ2/db2)
    db2 = 1./* np.sum(dZ2, axis=1, keepdims = True)
    # dL/dA1 = (dZ2/dA1)*(dL/dZ2)
    dA1 = np.dot(W2.T, dZ2)
    # update gradient of nodes that wasn't dropped at forward propagation.
    dA1 = np.multiply(dA1,D1)             
    dA1 = dA1/keep_prob             
    # derivation of ReLU
    dZ1 = np.multiply(dA1, np.int64(A1 > 0))
    # dL/dW1 = (dL/dZ1)*(dZ1/dW1)
    dW1 = 1./* np.dot(dZ1, X.T)
    # dL/db1 = (dL/dZ1)*(dZ1/db1)
    db1 = 1./* np.sum(dZ1, axis=1, keepdims = True)
    
    gradients = {"dZ3": dZ3, "dW3": dW3, "db3": db3,"dA2": dA2,
                 "dZ2": dZ2, "dW2": dW2, "db2": db2, "dA1": dA1, 
                 "dZ1": dZ1, "dW1": dW1, "db1": db1}
    
    return gradients
cs


8. function2.py에 있는 함수가 무엇인지 정의하고, return 값에 대해 설명하라.

batch normalization에 대한 코드이다. function1forward propagationbatch normalization 함수를 나타내고, return값의 outbatch-normalized 된 값을, cache는 해당 batch 값 등을 tuple 형태로 반환한다. function2backward propagationbatch-normalization 함수의 parameter 에 대한 역전파값을 계산하는 함수이다. 각각의 미분값을 반환한다.


- 위 서술형 과제에 대해 틀린 서술이 있을 수 있습니다. 지적 및 정정 환영합니다.



Assignment 02





List of Articles
번호 제목 글쓴이 날짜 조회 수
공지 R 소스 공유 게시판 이용 관련 공지사항 1 DataMarket 2014.05.21 34570
149 투빅스 10기&11기 7주차 CNN (Alexnet) - 11기 심은선 file 심은선 2019.03.15 41
148 투빅스 10기&11기 7주차 - NLP - 11기 유기윤 file 유기윤 2019.03.14 51
» 투빅스 10기&11기 6주차 Advanced Neural Network - 11기 김대웅 file 김대웅 2019.03.12 45
146 투빅스 10기&11기 5주차 Neural Network - 11기 김대웅 file 김대웅 2019.03.07 82
145 투빅스 10기&11기 4주차 Algorithm - 10기 정윤호 UNOVATE 2019.03.04 56
144 투빅스 10기&11기 4주차 ML Performance Tuning - 11기 김대웅 김대웅 2019.02.22 92
143 투빅스 10기&11기 4주차 PCA - 11기 임채빈 임채빈 2019.02.22 94
142 투빅스 10기&11기 3주차 Clustering - 11기 한재연 file 한재연 2019.02.16 120
141 투빅스 10기&11기 3주차 Decision Tree - 11기 김유민 file 2019.02.15 111
140 투빅스 10기&11기 3주차 Clustering - 11기 김대웅 file 김대웅 2019.02.15 143
139 투빅스 10기&11기 3주차 Algorithm - 11기 한재연 file 한재연 2019.02.15 99
138 투빅스 10기&11기3주차 앙상블(Kaggle HousePrice) - 11기 이소라 file 소라찌 2019.02.15 119
137 투빅스 10기&11기 2주차 SVM, Naive Bayes, KNN - 11기 유기윤 file 유기윤 2019.02.02 197
136 투빅스 10기&11기 2주차 SVM, Naive Bayes, KNN - 11기 김대웅 file 김대웅 2019.01.31 226
135 투빅스 10기&11기 1주차 Algorithm - 11기 한재연 1 file 한재연 2019.01.31 257
134 투빅스 10기&11기 1주차 Algorithm - 11기 권혜민 file 권혜민 2019.01.31 196
133 투빅스 10&11기 1주차 Linear Regression - 11기 유기윤 file 유기윤 2019.01.24 303
132 투빅스 10&11기 1주차 Regression - 11기 강수민 file 수민 2019.01.24 283
131 투빅스 10&11기 1주차 Logistic Regression - 11기 김대웅 file 김대웅 2019.01.23 271
130 투빅스 9&10기 8주차 CNN - 10기 장유영 장유영 2018.09.20 2021
Board Pagination ‹ Prev 1 2 3 4 5 6 7 ... 8 Next ›
/ 8

나눔글꼴 설치 안내


이 PC에는 나눔글꼴이 설치되어 있지 않습니다.

이 사이트를 나눔글꼴로 보기 위해서는
나눔글꼴을 설치해야 합니다.

설치 취소

Designed by sketchbooks.co.kr / sketchbook5 board skin

Sketchbook5, 스케치북5

Sketchbook5, 스케치북5

Sketchbook5, 스케치북5

Sketchbook5, 스케치북5