딥러닝 Hidden Layer 개수 정해보기: Deep Learning With Only Numpy(패키지 없이 코딩하기)

안녕하세요!

https://shiningyouandme.tistory.com/50

Neural Network Gradient Descent With Only Numpy(패키지 없이 코딩하기)

위의 글처럼 패키지 없이 Deep Learning Neural Network Gradient Descent 구현해보았습니다.

이번엔, 딥러닝의 Hidden Layer 개수에 따른 Loss에 영향을 알아보도록 하겠습니다.

딥러닝의 Hidden Layer개수가 많을 수록 Loss가 적어질까요? 정답은 NO! 

Hidden Layer의 개수가 많아질수록 Vanishing Gradient Problem(기울기 소실 문제)이 생기기 때문입니다.(자세한 내용은 다음에 작성하겠습니다.)

그렇다면 Hidden Layer수는 어느정도가 적정할까요? 

가장 심플한 방법은 Hidden Layer의 수를 구해볼려면 Layer개수에 따른 Loss값을 구해보면 됩니다..! ㅎㅎ

아래는 이전 글에서 작성한 코드입니다. 

https://shiningyouandme.tistory.com/50

Neural Network Gradient Descent With Only Numpy(패키지 없이 코딩하기)

# Import Library
import numpy as np
from numpy import loadtxt
import matplotlib.pyplot as plt

## DATA SET 
train = loadtxt('./training.txt')
train = np.random.permutation(train)
training_data = train[:,0:2]
test_data = train[:,-1]
label = np.zeros((1000,2))
for i in range(1000):
 if test_data[i]== 1.:
 label[i,1]=1
 if test_data[i]== 0.:
 label[i,0]=1

## Activate Fuction Sigmoid 
def sigmoid(x):
 return 1 / (1+np.exp(-x))
 
 ## Basic Deep Learning Network
class BasicDeepLearning:
 
 def __init__(self, input_nodes, hidden_nodes, output_nodes, learning_rate):
 
 self.input_nodes = input_nodes
 self.hidden_nodes = hidden_nodes
 self.output_nodes = output_nodes
 
 # hidden layer weight init 
 self.W2 = np.random.random((self.input_nodes, self.hidden_nodes))
 
 # output layer weight init 
 self.W3 = np.random.random((self.hidden_nodes, self.output_nodes))
 
 # output layer 
 self.Z3 = np.zeros([1,output_nodes])
 self.A3 = np.zeros([1,output_nodes])
 
 # hidden layer
 self.Z2 = np.zeros([1,hidden_nodes])
 self.A2 = np.zeros([1,hidden_nodes])
 
 # input layer 
 self.Z1 = np.zeros([1,input_nodes]) 
 self.A1 = np.zeros([1,input_nodes]) 
 
 # learning rate
 self.learning_rate = learning_rate
 
 ## Feed Forward 
 def feed_forward(self): 
 # input layer
 self.Z1 = self.input_data
 self.A1 = self.input_data
 # hidden layer 
 self.Z2 = self.A1.dot( self.W2)
 self.A2 = sigmoid(self.Z2)
 # output layser
 self.Z3 = self.A2.dot(self.W3)
 self.A3 = sigmoid(self.Z3)
 
 return self.A3
 
 
 ## loss 
 def loss(self):
 
 loss = ((self.A3 - self.target_data)**2)
 loss = np.mean(loss)
 
 return loss
 
 ## Train(Backwoard, Weight Update)
 def train(self, input_data, target_data): 
 
 self.target_data = target_data 
 self.input_data = input_data
 
 #feedforward
 self.feed_forward()
 
 # stage1 (output → hidden weight update) 
 loss_3 = (self.A3 - self.target_data) * self.A3 * (1- self.A3)
 self.W3 = self.W3 - self.learning_rate * np.dot(self.A2.T, loss_3) 
 
 # stage2 (hidden → input weight update)
 loss_2 = np.dot(loss_3, self.W3.T) * self.A2 * (1-self.A2) 
 self.W2 = self.W2 - self.learning_rate * np.dot(self.A1.T, loss_2)

 

아래 코드는 for문을 돌면서 Hidden Layer의 개수에 따른 Loss를 구하는 코드입니다.

## hidden layer를 다르게 하여 loss를 구해보기
end_loss=[]
for i in range(2,17):
 ## Parameter Settinga
 input_nodes = 2
 hidden_nodes = i
 output_nodes = 1
 learning_rate = 0.01
 epochs = 1000
 ## Training for optimization 
 bdl = BasicDeepLearning(input_nodes, hidden_nodes, output_nodes, learning_rate)
 loss = []
 for j in range(epochs):
 bdl.train( training_data, label)
 loss.append(bdl.loss())
 end_loss.append(loss[-1])
 print("→ hidden layer: ", i ,", end of loss: ", loss[-1])

Hidden Layer별 Loss를 시각해봅니다.

x = np.arange(2,17)
y = end_loss
plt.style.use("seaborn")
plt.xticks(x)
plt.scatter(x, y)
plt.ylabel('End of Loss')
plt.xlabel("Number of Hidden layer")
plt.show()

제가 구현한 딥러닝 네크워크에서는 Hidden Layer개수가 9개였을때, 가장 작은 Loss값이 나온다는 걸 알 수 있습니다.

따라서 Hidden Layer수는 9개로 지정합니다.

 

많은 도움이 되셨길 바랍니다.

감사합니다:)