안녕하세요, HELLO
오늘은 DeepLearning.AI에서 진행하는 앤드류 응(Andrew Ng) 교수님의 딥러닝 전문화의 첫 번째 과정인 "Neural Networks and Deep Learning"을 정리하려고 합니다. "Neural Networks and Deep Learning"의 강의 목적은 '딥러닝의 기능, 과제 및 결과 이해'를 통해 '머신 러닝을 업무에 적용하고, 기술 수준을 높이고, AI 분야에서 단계를 밟을 수 있는 지식과 기술을 얻을 수 있는 경로'를 배우기 위함이며, 강의는 아래와 같이 구성되어 있습니다.
~ Introduction
~ Basics of Neural Network programming
~ One hidden layer Neural Networks
~ Deep Neural Networks
"Neural Networks and Deep Learning" (Andrew Ng)에서 지금까지 배운 내용을 바탕으로 Logistic Regression을 사용해서 고양이를 인식하는 분류기를 구현하고자 합니다. 추후에 "Neural Networks and Deep Learning"을 듣게 되신다면, 정답 코드가 궁금하신 분들은 참고하시기 바랍니다.
이번 실습을 통해 아래 사항을 구현해볼 수 있습니다.
- Build and train a deep L-layer neural network, and apply it to supervised learning
CHAPTER 1. 'Packages'
CHAPTER 2. 'Load and Process the Dataset'
CHAPTER 3. 'Model Architecture'
CHAPTER 4. 'Two-layer Neural Network'
CHAPTER 5. 'L-layer Neural Network
CHAPTER 6. 'Results Analysis'
CHAPTER 1. 'Packages'
- numpy is the fundamental package for scientific computing with Python.
- matplotlib is a library to plot graphs in Python.
- h5py is a common package to interact with a dataset that is stored on an H5 file.
- PIL and scipy are used here to test your model with your own picture at the end.
- dnn_app_utils provides the functions implemented in the "Building your Deep Neural Network: Step by Step" assignment to this notebook.
- np.random.seed(1) is used to keep all the random function calls consistent. It helps grade your work - so please don't change it!
import time
import numpy as np
import h5py
import matplotlib.pyplot as plt
import scipy
from PIL import Image
from scipy import ndimage
from dnn_app_utils_v3 import *
from public_tests import *
%matplotlib inline
plt.rcParams['figure.figsize'] = (5.0, 4.0) # set default size of plots
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'
%load_ext autoreload
%autoreload 2
np.random.seed(1)
CHAPTER 2. 'Load and Process the Dataset'
lod_dataset 함수를 통해서 traininig set과 test set을 불러오겠습니다. 각 이미지는 (num_px, num_px, 3)으로 3차원 데이터이며, 여기서 '3'은 3 channels (RGB) 이미지를 의미합니다.
# Load dataset
train_x_orig, train_y, test_x_orig, test_y, classes = load_data()
# Example of a picture
index = 10
plt.imshow(train_x_orig[index])
print ("y = " + str(train_y[0,index]) + ". It's a " + classes[train_y[0,index]].decode("utf-8") + " picture.")
training set의 개수 m_train과 test_set의 개수 m_test, 그리고 이미지의 픽셀 수를 확인할 수 있습니다.
# Explore your dataset
m_train = train_x_orig.shape[0]
num_px = train_x_orig.shape[1]
m_test = test_x_orig.shape[0]
print ("Number of training examples: " + str(m_train))
print ("Number of testing examples: " + str(m_test))
print ("Each image is of size: (" + str(num_px) + ", " + str(num_px) + ", 3)")
print ("train_x_orig shape: " + str(train_x_orig.shape))
print ("train_y shape: " + str(train_y.shape))
print ("test_x_orig shape: " + str(test_x_orig.shape))
print ("test_y shape: " + str(test_y.shape))
각 이미지는 3차원의 행렬로 이루어져 있는데, Logistic Regression을 사용하기 위해 입력값을 1차원 벡터로 변환해야 합니다. 이에 따라 (num_px, num_px, 3) 차원을 (num_px * num_px * 3, 1)로 변환해주는 작업이 필요합니다.
만약 (a, b, c, d) 차원의 행렬 X가 있다면, 다음과 같은 방법으로 (b*c*d, a)로 변환할 수 있습니다.
그래서 최종적으로 입력값의 행렬은 (12,288 (equals 64 ×64 × 3), 1) 형태를 이루게 됩니다.
# Reshape the training and test examples
train_x_flatten = train_x_orig.reshape(train_x_orig.shape[0], -1).T # The "-1" makes reshape flatten the remaining dimensions
test_x_flatten = test_x_orig.reshape(test_x_orig.shape[0], -1).T
# Standardize data to have feature values between 0 and 1.
train_x = train_x_flatten/255.
test_x = test_x_flatten/255.
print ("train_x's shape: " + str(train_x.shape))
print ("test_x's shape: " + str(test_x.shape))
# train_x's shape: (12288, 209)
# test_x's shape: (12288, 50)
CHAPTER 3. 'Model Architecture'
□ 3.1. 2-layer Neural Network
실습을 위해 두 가지 다른 모델을 만들어 보겠습니다. 첫 번째는 은닉층이 1개인 2-layer neural network이고, 그리고 은닉층이 (L-1) 개인 L-layer deep neural network입니다. 이후에는 은닉층 개수에 따른 성능 비교를 진행하려고 합니다.
우선, 첫 번째 모델인 '2-layer neural network'의 구성입니다.
- 입력값은 (12288, 1) 크기로 이미지 (64,64,3) 벡터가 병합된 값입니다.
- 입력값 [𝑥0,𝑥1,...,𝑥12287].T에 가중치 행렬 W [1]를 곱합니다. (n [1],12288)
- 그리고 편차 b [1]를 연산하고 relu 함수를 사용하여 다음 벡터를 얻습니다.
- 결과 벡터에 W [2]를 곱하고 절편(편차) b [2]을 추가합니다.
- 마지막으로 결과에 sigmoid를 취합니다. 이때, 0.5보다 크면 고양이(y=1)로 분류합니다.
□ 3.2. L-layer Deep Neural Network
그리고 두 번째 모델인 'L-layer neural network'의 구성입니다.
- 입력값은 (12288, 1) 크기로 이미지 (64,64,3) 벡터가 병합된 값입니다.
- 입력값 [𝑥0,𝑥1,...,𝑥12287].T에 가중치 행렬 W [1]를 곱합니다. (n [1],12288)
- 그리고 편차 b [1]를 연산하고 relu 함수를 사용하여 다음 벡터를 얻습니다.
- 결과 벡터에 W [2]를 곱하고 절편(편차) b [2]을 추가합니다.
- 위 과정을 층(layer) 개수에 따라 여러 번 반복됩니다.
- 마지막으로 최종 선형 단위에 sigmoid를 취합니다. 이때 결괏값이 0.5보다 크면 고양이로 분류(y=1)합니다.
□ 3.3. General Methodology
이를 정리하면 다음과 같은 과정으로 진행됩니다.
- Initialize parameters / Define hyperparameters
- Loop for num_iterations: a. Forward propagation b. Compute cost function c. Backward propagation d. Update parameters (using parameters, and grads from backprop)
- Use trained parameters to predict labels
CHAPTER 4. 'Two-layer Neural Network'
□ two_layer_model
첫 번째 모델인 '2-layer Neural Network'부터 만들어보겠습니다. Linear -> ReLU -> Linear -> Sigmoid의 구조를 갖고 사용되는 함수는 다음과 같습니다.
def initialize_parameters(n_x, n_h, n_y):
...
return parameters
def linear_activation_forward(A_prev, W, b, activation):
...
return A, cache
def compute_cost(AL, Y):
...
return cost
def linear_activation_backward(dA, cache, activation):
...
return dA_prev, dW, db
def update_parameters(parameters, grads, learning_rate):
...
return parameters위 함수는 이전 실습에서 작성해서, 아래 포스팅을 참고해주시기 바랍니다.
2022.02.13 - [분류 전체보기] - week 4_Building your Deep Neural Network Step by Step 실습 (Andrew Ng)
input, hidden, output layer의 크기는 다음과 같이 정리됩니다.
### CONSTANTS DEFINING THE MODEL ####
n_x = 12288 # num_px * num_px * 3
n_h = 7
n_y = 1
layers_dims = (n_x, n_h, n_y)
learning_rate = 0.0075
'2-layer Neural Network' 모델은 아래와 같습니다.
# GRADED FUNCTION: two_layer_model
def two_layer_model(X, Y, layers_dims, learning_rate = 0.0075, num_iterations = 3000, print_cost=False):
"""
Implements a two-layer neural network: LINEAR->RELU->LINEAR->SIGMOID.
Arguments:
X -- input data, of shape (n_x, number of examples)
Y -- true "label" vector (containing 1 if cat, 0 if non-cat), of shape (1, number of examples)
layers_dims -- dimensions of the layers (n_x, n_h, n_y)
num_iterations -- number of iterations of the optimization loop
learning_rate -- learning rate of the gradient descent update rule
print_cost -- If set to True, this will print the cost every 100 iterations
Returns:
parameters -- a dictionary containing W1, W2, b1, and b2
"""
np.random.seed(1)
grads = {}
costs = [] # to keep track of the cost
m = X.shape[1] # number of examples
(n_x, n_h, n_y) = layers_dims
# Initialize parameters dictionary, by calling one of the functions you'd previously implemented
#(≈ 1 line of code)
# parameters = ...
# YOUR CODE STARTS HERE
parameters = initialize_parameters(n_x, n_h, n_y)
# YOUR CODE ENDS HERE
# Get W1, b1, W2 and b2 from the dictionary parameters.
W1 = parameters["W1"]
b1 = parameters["b1"]
W2 = parameters["W2"]
b2 = parameters["b2"]
# Loop (gradient descent)
for i in range(0, num_iterations):
# Forward propagation: LINEAR -> RELU -> LINEAR -> SIGMOID. Inputs: "X, W1, b1, W2, b2". Output: "A1, cache1, A2, cache2".
#(≈ 2 lines of code)
# A1, cache1 = ...
# A2, cache2 = ...
# YOUR CODE STARTS HERE
A1, cache1 = linear_activation_forward(X, W1, b1, activation = 'relu')
A2, cache2 = linear_activation_forward(A1, W2, b2, activation = 'sigmoid')
# YOUR CODE ENDS HERE
# Compute cost
#(≈ 1 line of code)
# cost = ...
# YOUR CODE STARTS HERE
cost = compute_cost(A2, Y)
# YOUR CODE ENDS HERE
# Initializing backward propagation
dA2 = - (np.divide(Y, A2) - np.divide(1 - Y, 1 - A2))
# Backward propagation. Inputs: "dA2, cache2, cache1". Outputs: "dA1, dW2, db2; also dA0 (not used), dW1, db1".
#(≈ 2 lines of code)
# dA1, dW2, db2 = ...
# dA0, dW1, db1 = ...
# YOUR CODE STARTS HERE
dA1, dW2, db2 = linear_activation_backward(dA2, cache2, activation = 'sigmoid')
dA0, dW1, db1 = linear_activation_backward(dA1, cache1, activation = 'relu')
# YOUR CODE ENDS HERE
# Set grads['dWl'] to dW1, grads['db1'] to db1, grads['dW2'] to dW2, grads['db2'] to db2
grads['dW1'] = dW1
grads['db1'] = db1
grads['dW2'] = dW2
grads['db2'] = db2
# Update parameters.
#(approx. 1 line of code)
# parameters = ...
# YOUR CODE STARTS HERE
parameters = update_parameters(parameters, grads, learning_rate)
# YOUR CODE ENDS HERE
# Retrieve W1, b1, W2, b2 from parameters
W1 = parameters["W1"]
b1 = parameters["b1"]
W2 = parameters["W2"]
b2 = parameters["b2"]
# 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
def plot_costs(costs, learning_rate=0.0075):
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per hundreds)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
실습에서 learning_rate는 0.0075, iterations은 3000으로 기본 설정했습니다. 함수는 매 순회마다 순방향 전파(Forward propagation), 비용 함수 Cost 계산, 역방향 전파(Backward propagation), 파라미터 update 과정을 진행하며 학습을 하게 됩니다.
매 순회마다 입력 X, 파라미터 W1, b1, 그리고 activation 함수(ReLU)를 통해 A1을 구하고, 마찬가지로 W2, b2, 그리고 Sigmoid 함수를 통해서 A인 ŷ 를 구합니다. 그리고 A2와 실제 라벨 Y를 가지고 오차 cost를 계산합니다.
이후에 dA2와 Y를 가지고 dA2를 먼저 구하고, dA2와 순방향 전파(Forward propagation)에서 구한 계산 값(caches)들을 가지고 dA1, dW2, db2를 구하고, 첫 번째 layer에서 dA0, dW1, db1을 구합니다. 여기서 dA0은 사용하지 않는 값 (입력 X에 대한 Gradient이기 때문에)입니다.
그리고 이렇게 구한 기울기(gradient)를 가지고 파라미터 W, b를 업데이트하면 한 번 진행(one iteration)됩니다.
two_layer_model 함수를 테스트하면 아래와 같이 나타납니다.
parameters, costs = two_layer_model(train_x, train_y, layers_dims = (n_x, n_h, n_y), num_iterations = 2, print_cost=False)
print("Cost after first iteration: " + str(costs[0]))
two_layer_model_test(two_layer_model)
□ 4.1. Train the model
그리고 two_layer_model을 2,500번 실행해보면, 약 5분 정도 소요되고 아래처럼 결과가 나옵니다.
parameters, costs = two_layer_model(train_x, train_y, layers_dims = (n_x, n_h, n_y), num_iterations = 2500, print_cost=True)
plot_costs(costs, learning_rate)
training set의 정확도는 99%, test set의 정확도는 72%를 달성했습니다.
CHAPTER 5. 'L-layer Neural Network'
이번엔 여러 층(layer)으로 구성된 L-layer Neural network을 구현하겠습니다.
def initialize_parameters(n_x, n_h, n_y):
...
return parameters
def linear_activation_forward(A_prev, W, b, activation):
...
return A, cache
def compute_cost(AL, Y):
...
return cost
def linear_activation_backward(dA, cache, activation):
...
return dA_prev, dW, db
def update_parameters(parameters, grads, learning_rate):
...
return parameters
위 함수는 이전 실습에서 작성해서, 아래 포스팅을 참고해주시기 바랍니다.
2022.02.13 - [분류 전체보기] - week 4_Building your Deep Neural Network Step by Step 실습 (Andrew Ng)
은닉층이 3개인, 4-layer model을 만들어보겠습니다. 각각의 layer 크기는 다음과 같습니다.
### CONSTANTS ###
layers_dims = [12288, 20, 7, 5, 1] # 4-layer model
# GRADED FUNCTION: L_layer_model
def L_layer_model(X, Y, layers_dims, learning_rate = 0.0075, num_iterations = 3000, print_cost=False):
"""
Implements a L-layer neural network: [LINEAR->RELU]*(L-1)->LINEAR->SIGMOID.
Arguments:
X -- data, numpy array of shape (num_px * num_px * 3, number of examples)
Y -- true "label" vector (containing 0 if cat, 1 if non-cat), of shape (1, number of examples)
layers_dims -- list containing the input size and each layer size, of length (number of layers + 1).
learning_rate -- learning rate of the gradient descent update rule
num_iterations -- number of iterations of the optimization loop
print_cost -- if True, it prints the cost every 100 steps
Returns:
parameters -- parameters learnt by the model. They can then be used to predict.
"""
np.random.seed(1)
costs = [] # keep track of cost
# Parameters initialization.
#(≈ 1 line of code)
# parameters = ...
# YOUR CODE STARTS HERE
parameters = initialize_parameters_deep(layers_dims)
# YOUR CODE ENDS HERE
# Loop (gradient descent)
for i in range(0, num_iterations):
# Forward propagation: [LINEAR -> RELU]*(L-1) -> LINEAR -> SIGMOID.
#(≈ 1 line of code)
# AL, caches = ...
# YOUR CODE STARTS HERE
AL, caches = L_model_forward(X, parameters)
# YOUR CODE ENDS HERE
# Compute cost.
#(≈ 1 line of code)
# cost = ...
# YOUR CODE STARTS HERE
cost = compute_cost(AL, Y)
# YOUR CODE ENDS HERE
# Backward propagation.
#(≈ 1 line of code)
# grads = ...
# YOUR CODE STARTS HERE
grads = L_model_backward(AL, Y, caches)
# YOUR CODE ENDS HERE
# Update parameters.
#(≈ 1 line of code)
# parameters = ...
# YOUR CODE STARTS HERE
parameters = update_parameters(parameters, grads, learning_rate)
# YOUR CODE ENDS HERE
# 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
중간 hidden layer에서의 과정이 L-1번 반복되는 것 외에는 2-layer와 거의 동일합니다.
L_layer_model 함수를 테스트하면 아래와 같이 나타납니다.
parameters, costs = L_layer_model(train_x, train_y, layers_dims, num_iterations = 1, print_cost = False)
print("Cost after first iteration: " + str(costs[0]))
L_layer_model_test(L_layer_model)
□ 5.1. Train the model
training set에서 구현한 모델을 학습해보겠습니다.
parameters, costs = L_layer_model(train_x, train_y, layers_dims, num_iterations = 2500, print_cost = True)
training set의 정확도는 98%, test set의 정확도는 80%로 정확도는 8% point 상승했습니다. 은닉층이 1개인 2-layer model에 비해 3개인 4-layer model의 성능이 좋은 것을 확인할 수 있습니다.
CHAPTER 6. 'Results Analysis'
정확도가 80%이기 때문에 잘못 예측하기도 하는데, 잘못 예측된 경우가 아래 사진 같이 있습니다.
이러한 사진들은 다음과 같은 특징을 가집니다.
- 고양이의 자세가 이상한 경우
- 배경과 유사한 색을 가진 고양이
- 보통 고양이의 색이 아니거나 흔한 종이 아닌 경우
- 카메라의 각도의 문제
- 사진의 밝기가 어두운 경우
- 사진의 고양이가 매우 크거나 작은 경우
■ 마무리
"Neural Networks and Deep Learning" (Andrew Ng)에서 지금까지 배운 내용을 바탕으로 Logistic Regression을 사용해서 고양이를 인식하는 분류기를 구현하는 코드에 대해서 정리해봤습니다.
그럼 오늘 하루도 즐거운 나날 되길 기도하겠습니다
좋아요와 댓글 부탁드립니다 :)
감사합니다.
'COURSERA' 카테고리의 다른 글
| [COURSERA] Improving Deep Neural Networks: Hyperparameter Tuning, Regularization and Optimization (Andrew Ng) (0) | 2022.02.14 |
|---|---|
| [COURSERA] Neural Networks and Deep Learning 자격증 취득 (0) | 2022.02.13 |
| week 4_Building your Deep Neural Network Step by Step 실습 (Andrew Ng) (0) | 2022.02.13 |
| week 4_Deep Neural Networks 연습문제 (Andrew Ng) (0) | 2022.02.13 |
| week 4_Deep Neural Networks (Andrew Ng) (0) | 2022.02.13 |
댓글