앞선 글에서
가벼운 이론에 대한 설명,
그리고 단층 퍼셉트론(SLP)와 다층 퍼셉트론(MLP)에 대한 설명과
원시적인 코드 작성 까지 이야기를 나누었다.
다음으로 코드를 조금 정리할 필요가 있다.
왜냐하면, 프로그래밍 특성상
같은 데이터를 담을 변수를 일일이 선언하는 것은
나중에 코드를 수정할 때 시간을 잡아먹는 원인이 되기도 하며,
버그를 낳을 수 있는 리스크 또한 증가하게 된다.
따라서 특히 가중치(Weight) 부분은 손을 볼 필요가 있다.
코드 최적화
사실 최적화라고 해봤자
그리 대단한 것은 아니다.
단순히 같은 속성을 가지고 있는 데이터들을
하나의 변수로 묶을 뿐이다.
최적화 할 코드는 이전 포스팅에서 다루었던
다층 퍼셉트론의 예제 코드이다.
해당 코드는 아래와 같다.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | inputs = [3, 1, 5.5] weights11 = [0.3, 0.4, -0.7] weights12 = [0.5, -0.33, -0.26] weights13 = [-0.26, -0.57, 0.57] weights14 = [0.7, -0.22, 0.43] weights21 = [0.5, -0.3, -0.2, 0.4] weights22 = [0.33, -0.33, -0.34, 0.2] bias1 = 2 bias2 = 3 h_node = [inputs[0]*weights11[0] + inputs[1]*weights11[1] + inputs[2]*weights11[2] + bias1, inputs[0]*weights12[0] + inputs[1]*weights12[1] + inputs[2]*weights12[2] + bias1, inputs[0]*weights13[0] + inputs[1]*weights13[1] + inputs[2]*weights13[2] + bias1, inputs[0]*weights14[0] + inputs[1]*weights14[1] + inputs[2]*weights14[2] + bias1] outputs = [h_node[0]*weights21[0] + h_node[1]*weights21[1] + h_node[2]*weights21[2] + h_node[3]*weights21[3] + bias2, h_node[0]*weights22[0] + h_node[1]*weights22[1] + h_node[2]*weights22[2] + h_node[3]*weights22[3] + bias2] print(outputs) | cs |
나는 위의 코드를 다층 퍼셉트론 아키텍처의
원형 그대로 최적화 하려고 한다.
최대한 설계 그대로 한다면
아래와 같은 코드가 나올 수 있다.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | inputs = [3, 1, 5.5] weights1 = [[0.3, 0.4, -0.7], [0.5, -0.33, -0.26], [-0.26, -0.57, 0.57], [0.7, -0.22, 0.43]] weights2 = [[0.5, -0.3, -0.2, 0.4], [0.33, -0.33, -0.34, 0.2]] bias1 = 2 bias2 = 3 h_node = [inputs[0]*weights1[0][0] + inputs[1]*weights1[0][1] + inputs[2]*weights1[0][2] + bias1, inputs[0]*weights1[1][0] + inputs[1]*weights1[1][1] + inputs[2]*weights1[1][2] + bias1, inputs[0]*weights1[2][0] + inputs[1]*weights1[2][1] + inputs[2]*weights1[2][2] + bias1, inputs[0]*weights1[3][0] + inputs[1]*weights1[3][1] + inputs[2]*weights1[3][2] + bias1] outputs = [h_node[0]*weights2[0][0] + h_node[1]*weights2[0][1] + h_node[2]*weights2[0][2] + h_node[3]*weights2[0][3] + bias2, h_node[0]*weights2[1][0] + h_node[1]*weights2[1][1] + h_node[2]*weights2[1][2] + h_node[3]*weights2[1][3] + bias2] print(outputs) | cs |
나머지 코드는 그대로 가져가고,
원래 W1,W2였던 가중치(Weight) 값들을 하나로 묶었다.
물론 여기서 bias(편향)의 값들도
하나로 묶어서 리스트 형태로 저장할 수도 있으나,
위에서도 언급했다시피 나는
설계 그대로의 최적화를 목표로 했었기 때문에
그대로 두었다.
위의 코드를 실행한다면 아래와 같은 결과가 나온다.
하지만, 이런 방식의 코딩 방식은 매우 불편하다.
왜냐하면,
만약에 Input과 Output의 요소들의 갯수가
적어지거나 많아질 경우 h_node와 outputs 변수들의 코드를
모두 수정해야하기 때문이다.
물론 지금의 코드의 경우 매우 간단한
아키텍처를 구현했기 때문에 조금 귀찮을 정도이지만
일반적으로 사용되어지는 딥 러닝이나 다른 머신 러닝의 경우는
매우 많은 노드들이 사용되어지기 때문에
이런 코딩 방식은 매우 부적절하고
프로젝트 입장에서 보면 퍼포먼스가 매우 떨어진다.
희망적이게도 Python에는 이미
이에 대한 라이브러리가 존재한다.
바로 numpy라는 라이브러리이다.
Numpy 라이브러리를 이용한 코드 최적화
위에서 코드 최적화를 진행한 바가 있다.
Numpy를 이용하면,
여기서 한 단계 더 최적화를 한 단계 더 진행할 수 있다.
어떻게 본다면
몇 단계는 더 진행할 수 있다고 볼 수 있을지는 모르겠다.
왜냐하면 매개변수만 정해주면,
매개변수를 내부를 보고 API가 가변적으로
자동으로 맞춰주기 때문이다.
numpy의 dot이라는 메소드가 이 역할을 완벽히 수행해준다.
numpy를 이용한다면 아래와 같이 최적화가 가능하다.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | import numpy as np inputs = [3, 1, 5.5] weights1 = [[0.3, 0.4, -0.7], [0.5, -0.33, -0.26], [-0.26, -0.57, 0.57], [0.7, -0.22, 0.43]] weights2 = [[0.5, -0.3, -0.2, 0.4], [0.33, -0.33, -0.34, 0.2]] bias1 = 2 bias2 = 3 h_node = np.dot(weights1,inputs) + bias1 outputs = np.dot(weights2,h_node) + bias2 print(outputs) | cs |
위의 코드에서 보이는바와 같이
h_node와 outputs의 코드가 1줄로 간결하게 표현되는 것을 볼 수 있다.
즉, dot이라는 메소드가 정확히 노드 계산을 가변적으로
매우 편리하게 해준다는 것을 확인할 수 있다.
이전 최적화 코드와
dot메소드를 이용해 최적화 코드를 실행하면 아래와 같은 결과 값이 나온다.
클래스로 구현한 다층 퍼셉트론
위의 코드를 클래스로 구현해
하나의 레이어 별 객체로 가지고 있을 수 있다면
비록 작은 프로그램이지만
좀 더 훌륭한 프로그램이 될 수 있을 것이며,
Python으로 구현하는 의미가 있을 것 이다.
여러가지 방법이 있을 수 있겠으나
나의 코드는 아래와 같다.
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 | import numpy as np #랜덤 값 시드 생성 np.random.seed(0) input_data = [3, 1, 5.5] class Layer_Dense: def __init__(self, n_inputs, n_neurons): #randn : 0으로 중심으로한 가우스 분포를 무작위 생성 #실제 randn 함수는 1을 초과한 값을 출력하기 때문에 0.10을 곱함 self.weights = 0.10 * np.random.randn(n_inputs, n_neurons) #뉴런 수만 큼 0값을 가지는 편향 생성 self.biases = np.zeros((1, n_neurons)) def forward(self, inputs): #순방향 전파 수식을 표현 self.output = np.dot(inputs, self.weights) + self.biases #입력이 3개, 출력 노드가 4개인 레이어 객체 생성 hidden_layer = Layer_Dense(3,4) #입력이 4개, 출력 노드가 2개인 레이어 객체 생성 output_layer = Layer_Dense(4,2) #히든 레이어의 노드 값 계산 hidden_layer.forward(input_data) #히든 레이어의 노드 값을 기반으로 출력 값 산출 output_layer.forward(hidden_layer.output) print(output_layer.output) | cs |
Layer_Dense라는 클래스를 생성해
Layer_Dense라는 클래스를 생성해
매개변수로 입력 데이터의 수와 출력할 노드의 수를 받아
생성자에 이를 통해 가중치 값들을 무작위로 얻고,
편향을 0로 초기화 했다.
또한 해당 레이어의 순방향 전파를 계산하기 위한
수식도 메소드로 구현 했다.
앞서 구현한 것과 동일한 코드이다.
앞에서 설계한 아키텍처와 같이
3개의 노드를 가지는 입력 레이어와
4개의 노드를 가지는 히든 레이어
마지막으로 2개의 노드를 가지는 출력 레이어가 되도록
히든 레이어와 출력 레이어를 객체로 만들었다.
그 다음 입력 레이어의 값으로
히든 레이어의 값을 산출하고,
산출한 히든 레이어의 값으로
이 프로그램으로 얻고자하는
출력 레이어의 값을 산출 할 수 있다.
코드를 실행해보면 아래와 같은 결과 값이 나온다.
무작위 값을 얻을 수 있는 메소드를 사용했기 때문에
매번 값은 다를 수 있다.
마치며
지금 까지 해서 간단한 코드 최적화와
Numpy 라이브러리를 이용해 간단한 다층 퍼셉트론 구현에 대한
이야기를 해보았다.
퍼셉트론의 계산식은 노드 수에 따라
히든 레이어의 개수에 따라 달라질 수 있기 때문에
일일이 코딩하는 것이 매우 번거로우나
(유지・보수면에서 봐도 마찬가지이다.)
Python의 Numpy 라이브러리가
이를 가변적으로 대응해주기 때문에
단 한 줄로 코드를 작성할 수 있게 되었다.
물론 이걸로 완성된 것은 전혀 아니다.
여기에 활성화 함수를 추가해야 하고,
역전파 또한 구현되어야만 한다.
