인공지능 및 머신러닝 기초를 위한 MLP 구현

1. MLP(Multi Layer Perceptron)의 발전과
다층 레이어를 통한 선형 분류가 불가능한 문제 해결 과정
1. 서론
1) 인공 신경망의 발견
2) 뉴런이란
3) 단층 퍼셉트론
4) 단층 퍼셉트론의 한계 및 극복방안
2. 본론
1) 다층신경망 MLP란
2) MLP 계산식
3) 역전파 다층 신경망의 학습 방법
4) 역전파 다층 신경망 구현
3. 구현 및 결과
1) Numpy 모듈을 이용해 XOR 구현
2) 상동 및 AND 구현
3) 상동 및 OR구현
4) Tensorflow를 통해 XOR MLP구현
5) 종합 결과
4. 결론
1) MLP의 특징
2) 구현 및 결과 분석
3) MLP의 한계점
4) 그 외의 신경망
5. 부록
1) numpy 모듈로 구현한 MLP
2) tensorflow로 구현한 MLP

2. 1. 서론
1) 인공 신경망의 발견
1997년 5월, IBM은 체스 게임을 할 수 있는 인공지능을 가진 딥 블루로 체스 세계 챔피언
인 개리 캐스파로브를 꺾는 기교를 선보였다. 딥 블루라는 슈퍼 컴퓨터는 초당 2억 개의 포
지션을 분석하여 체스 세계 챔피언과의 대결에서 승리를 이끌 수 있었다. 초당 엄청난 수의
앞 수를 둬봄으로써 사람보다 월등히 빠른 수 계산을 할 수 있었지만 조금 더 발전된 전략
을 세우기 위해서는 고정된 알고리즘이 아닌 경험을 통해 성능을 향상시켜야 한다는 생각을
가졌다. 먼저 기계가 학습한다는 개념을 잡기위해 사람의 두뇌를 개발 모델로 삼았는데 시
냅스는 뉴런에, 수상·축색 돌기는 링크(간선, edge)에 빗대어 인공 신경망(ANN, Artifical
Neural Network)을 개발한다.
인공신경망은 기존 인공지능과 다르게 반복된 경험을 통해 잘못된 답으로 이끄는 뉴런들 사
이의 연결은 약화시키고, 올바른 답으로 이끄는 연결은 강화한다. 그 결과로, 인공 신경망에
경험을 통한 학습 능력이 생긴다. 우리는 이를 기계가 학습하는 것으로 취급한다.
그렇다면 ANN은 어떻게 학습할 수 있을까? ANN내의 뉴런은 링크로 연결되어있고 각 링크
는 뉴런과 연관된 수치적인 가중치를 포함한다. 이 가중치는 ANN의 장기 기억을 위한 기본
적인 수단으로 바로 이 가중치를 반복적으로 조정함으로 인해 학습을 할 수 있게 된다.
2)뉴런이란
ANN을 구성하는 주요 요소인 뉴런은 입력 링크에서 여러 입력 신호를 받고 활성화 함수를
통해 새로운 활성화 수준을 계산하고 결과를 출력 링크로 내보낸다. 출력 링크로 보내지는
출력 신호는 최종적인 해(solution)이거나 다른 뉴런에 입력으로 입력될 수 있다.
위에서 언급된 활성화 함수는 다양한 종류가 존재하는데, 아래는 그 중 가장 일반적인 4개
의 활성화 함수이다.
3) 단층 퍼셉트론
퍼셉트론은 신경망의 가장 간단한 형태이다. 퍼셉트론의 주요 목적은 들어온 입력을 두 개
의 클래스로 분리하는 것이다. 따라서 기본적인 퍼셉트론의 경우, n차원의 초평면을 두 개의
결정 영역으로 나눈다. 초평면을 정답에 근사하여 분리하는 n-1차 식을 도출하기 위해 반복
적인 학습으로 가중치와 임계값을 조정한다.
단층 퍼셉트론은 두 개의 결정영역으로 분류하기 위한 가장 간단한 구조로써 조정 가능한
가중치와 활성화 함수를 포함한 단일 뉴런으로 구성된다. 아래 그림은 입력 노드가 2개인
단층 퍼셉트론을 보여준다.

3. 이 단층 퍼셉트론이 학습하는 과정으로는 다음과 같은 4개의 단계를 따른다.
- 1단계 : 초기화 – 가중치 Wi와 임계값 θ을 [-0.5, 0.5] 구간의 임의의 값으로 설정한다.
- 2단계 : 활성화 – 입력        와 목표 출력  를 적용하여
퍼셉트론을 활성화 시킨다. 여기서 n은 퍼셉트론의 입력 개수고 활성화 함수로는 step
활성 함수를 사용한다. step 활성화 함수로 나온 실제 출력 Y를 목표 출력 Yd와 차를
내어 에러(e)를 구한다.
- 3단계 : 가중치 학습 – 퍼셉트론의 가중치를 갱신한다.( wi(p+1) = wi(p) + Δwi(p),
Δwi(p) = learning rate * xi(p) * e(p) )
- 4단계 : 반복 – 반복 횟수 p값을 1 증가시키고, 2단계로 돌아가서 e가 0에 수렴할 때까지
과정을 반복한다.
4) 단층 퍼셉트론의 한계 및 극복방안
위와 같은 방법으로 AND 논리 연산자와 OR 논리 연산자의 입력 패턴을 분류하도록
훈련시킬 수 있다. 하지만, XOR 연산자는 단층 퍼셉트론으로 학습시킬 수 없다. 선형
분리가 불가능하기 때문인데
그림에서 볼 수 있듯이 AND연산자와 OR연산자는 식 1개로 입력 패턴을 분류 할 수 있다.
하지만 XOR연산자는 식 1개로 정확하게(최대한 근사하게) 입력 패턴을 분류 하는 것이
불가능하다.
이는 층이 1개인 퍼셉트론의 문제점으로 활성화 함수를 바꾼다고 근본적인 문제가 해결이
되지는 않는다.
따라서 우리는, 다층 신경망 MLP(Multi Layer Perceptron)를 통해 XOR연산자의 입력 패턴을

4. 분류하는 것을 목표로 한다.
2. 본론
1) 다층신경망 MLP란
다층 신경망은 하나 이상의 은닉층이 있는 신경망이다. 일반적으로 이 신경망은 공급
뉴런으로 이루어진 입력층 하나, 하나 이상의 은닉층, 계산 뉴런들로 이루어진 출력층
하나로 이루어져 있다. 공급 뉴런의 입력 신호는 한 층식 순방향(feedforward)으로 전파된다.
다층 신경망의 학습은 퍼셉트론과 유사하게 진행된다. feedforwarding에서는 1.3의
1~4단계로 진행하지만 출력 패턴에 대한 오차를 줄이도록 가중치를 조절하는 과정에서 역
전파(back propagation)를 하게된다.
2) 오차 역전파
100가지 이상의 서로 다른 학습 알고리즘이 존재하지만 다층 신경망을 학습하는 가장 인기
있는 방법은 역전파 방식이다. feedforwarding으로 출력층에서 출력 패턴이 생성될 떄까지
층에서 층으로 입력 패턴을 전파하다가 출력 패턴이 도출 되었을 때 목표패턴과 비교한다.
만약 목표 패턴과 다르면 그 오차를 계산한 후 출력층에서 입력층까지 신경망을 따라
거꾸로 전파(역 전파)한다. 그 오차가 전파되면서 가중치가 수정된다.
단층 퍼셉트론과 다른 점은 역 전파뿐만 아니라 활성 함수로 시그모이드 함수를 사용한다는
점이다. 이 함수의 미분은 계산하기가 쉬워 오차 기울기를 계산하기에 매우 적합하다. 즉,
순수한 역전파 알고리즘보다 학습속도가 빨라진다.
3) 역전파 다층 신경망의 학습 방법
역전파 신경망이 학습하는 과정으로는 다음과 같은 4개의 단계를 따른다.
- 1단계 : 초기화 – 가중치 Wi와 임계값 θ을 범위의 균등분포를 따라 임의의
수로 놓는다. 여기서 Fi는 신경망에 있는 각 뉴런i의 총 입력 개수다.
- 2단계 : 활성화 – 입력        와 목표 출력
        를 적용하여 퍼셉트론을 활성화 시킨다. 활성화 함수로는
sigmoid 활성 함수를 사용한다.
(a) 은닉층에 있는 뉴런의 실제 출력을 계산한다. n은 은닉층에 있는 뉴런 j의 입력 개수
(b) 출력층에 있는 뉴런의 실제 출력을 계산한다. m은 출력층에 있는 뉴런 k의 입력 개수
  


  

×



- 3단계 : 가중치 학습 – 출력 뉴런과 연관된 오차를 역방향으로 전파시키면서 역전파
신경망의 가중치를 갱신해 나간다.
(a) 출력층에 있는 뉴런 먼저 오차 기울기를 계산한다.     ×     ×  

5. 여기서 에러 계산은 다음과 같다.       
가중치 보정값을 계산한다. ∆    × ×  
출력 뉴런에서의 가중치를 갱신한다.   ∆
(b) 은닉층에 있는 뉴런의 오차 기울기를
계산한다.    ×     ×   

 ×  
출력층과 다른점은 에러 대신 앞쪽 뉴런의 값을 사용한다.
가중치 보정값을 계산한다. ∆    × ×  
은닉층에서의 가중치를 갱신한다.   ∆
- 4단계 : 반복 – 반복 횟수 p값을 1 증가시키고, 2단계로 돌아가서 e가 선택한 오차
기준에 수렴할 때까지 과정을 반복한다.
4) 역전파 다층 신경망의 구현
MLP를 통해 XOR연산자의 입력 패턴을 분류하기 위한 이론 및 학습 과정을 다루었다. 이제
학습과정을 실제 프로그램 코드로 구현한다.
최종적으로 위 그림과 같은 2층(입력을 제외한) 레이어 신경망을 구현하는 것을 목표로
한다.
구현 언어 및 인터프리터로는 python 3.6, 모듈은 numpy(산술 연산)와 matplotlib(시각화)를
사용한다.

6. 3. 구현 및 결과
1) XOR 연산자 입력 패턴 분류기
2) AND 연산자 입력 패턴 분류기
3) OR 연산자 입력 패턴 분류기
4) Tensorflow 라이브러리를 활용한 MLP 구현
위 1,2,3,4는 구현한 MLP 연산자 입력 패턴 분류기를 의미하며 그 결과에 대해서는
3.5절에서 서술한다.
5) 종합 결과
총 4만회의 학습을 시킨다.
100 에폭마다 현재 학습상태의 에러를 구하여 리스트에 추가한다. 에러를 구할 때는
1에폭을 시행하여 나온 에러를 제곱하여 더한다.
최종적으로 누적된 에러 리스트값을 이용해 그래프를 그린다.
위 과정을 본문에 수식에 맞게 연산하면 [그림 1]과 같이 XOR 연산자 입력 패턴 분류기는
[0,1], [1,0] 입력에서 1에 수렴하고 그 외 패턴에서는 0으로 수렴하는 모습을 볼 수 있다.
AND와 OR 연산자 입력 패턴 분류기 역시 입력값에 알맞은 출력 값에 근접한 것을 볼 수
있다.
여러 번 돌렸을 때 각각 가중치 값과 임계값은 랜덤으로 생성 할당되므로 그에 따른
Gradient Descent 도 달라지게 된다. 따라서 오차 그래프 모양과 분류기 성능에 약간씩
차이가 있음을 확인 할 수 있었다. [그림 2,3]
그림 1
그림 2

7. 그림 2-1
[그림 2-1]은 XOR 연산자 입력 패턴에 따라 결과를 분류 할 수 있도록 4만회 학습된
분류기의 2차원 도면이다.
직선 1개로 분류가 안되던 XOR연산은 MLP를 통해 직선 2개로 분류할 수 있음을 알 수
있다.
그림 3 그림 4
[그림 4]는 2.3절의 1단계를 범위의 균등분포로 가중치와 바이어스를 초기화 한
경우이다.
그림 5
하지만 좁은 범위의 균등 분포로 가중치와 바이어스를 초기화 하더라도 [그림 5]와 같이

8. 불안정한 훈련이 진행될 수 있다.
그림 6
그림 7
그림 8
[그림 6,7,8] TensorFlow로 구현한 MLP이다. 각각 XOR, AND, OR에 대한 연산자 입력패턴
분류기의 훈련과정(오차값)을 보여준다.
TensorFlow 라이브러리에서는 신경망 훈련을 위해 다양한 오차계산방법과 오차 최적화
방법을 제공해준다. 실제로 아래 3가지 cost 연산은 전부 다른 오차 감소율을 보여준다.
35 cost = tf.reduce_mean(
36 ((y * tf.log(y_5)) + ((1 - y) * tf.log(1.0 - y_5))) * -1
37 )
40 cost = tf.reduce_mean( tf.squared_difference(y_5, y)) # 오차 제곱의 합
41 cost = tf.nn.l2_loss( y - y_5 ) # 일반적인 오차 계산
따라서 목적이 같은 신경망을 구현하더라도 구현방법과 어떤 활성함수, 어떤 최적화
알고리즘을 사용하느냐에 따라 오차 제곱의 합이 폭발적으로 감소함을 알 수 있었다.

9. 4. 결론
지금까지 다층 신경망 MLP의 구현과 결과에 대해 알아보았다.
1) MLP의 특징으로는,
a. 선형으로 분리할 수만 있던 퍼셉트론의 한계를 극복하고자 발전되었으며, 퍼셉트론과는
다르게 입력 층과, 출력 층, 그리고 1개 이상의 은닉층으로 이루어져있다.
b. Error Backpropagation방법으로 오차를 역으로 전파하는 역전파 학습을 통해 신경망의
가중치와 바이어스를 조절한다.
c. 일반적으로 순수한 역전파 알고리즘은 계산 부담이 크고 학습이 느리기 때문에
시그모이드와 같은 활성화 함수를 이용하여 학습 효율을 높힌다.
d. 역전파 알고리즘으로 훈련된 다층 신경망은 패턴 인식 문제에 주로 활용된다.
2) 구현 및 결과 분석을 통해 파악된 사실로는,
a. 훈련에 사용되는 각 뉴런사이의 가중치나 뉴런의 바이어스 초기값 설정에 따라 신경망
성능의 편차가 생기므로 초기값 설정이 매우 중요하다.
b. 같은 가중치를 갖고 학습을 시작해도 활성화 함수 및 오차계산방법, 오차최적화
알고리즘에 따라 훈련속도가 크게 달라진다.
3) MLP에도 한계점은 존재한다.
a. Supervised 학습이다. 즉, 학습데이터셋과 목표데이터셋을 주어야만이 학습할 수 있다.
b. fully connected라는 특징 때문에 입력 뉴런과 층이 많을 수록 연산속도가 매우
느려진다.
c. 무한히 레이어를 늘릴 수 없다. 레이어가 많아질수록 Error Backpropagation 과정에서
앞 쪽 레이어로 역전파 할수록 Gradient가 0으로 수렴하는 Vanishing Gradient 현상이
발생한다. 따라서 앞 쪽 레이어의 학습 속도는 매우 느려지게 된다.
d . 따라서, MLP는 출력층을 포함하여 2~5층이 적절하며 그 이상은 적재하기 힘들다.
4) 또한 MLP로 해결할 수 없는 분야의 문제도 많이 존재한다. 이러한 문제들을 해결하기
위해 목적에 따라 순환 신경망(홉필드 신경망), BAM신경망, 자기조직 신경망 등 각기 다른
신경망이 등장하고 그 이외의 신경망들도 새로이 연구되고 있다.

10. 5. 부록
1) numpy 모듈로 구현한 소스코드
1 # -*- coding: utf-8 -*-
2 import numpy as np
3 from matplotlib import pyplot as plt
4 import copy
5
6 def sigmoid (X, diff =False ):
7 if diff :
8 return sigmoid (X ) * (1 - sigmoid (X ))
9 return 1 / (1 + np.exp (-X ))
10
11 def gradient (y_parent, e ):
12 return y_parent * (1 - y_parent ) * e
13
14
15 a = 0.1
16
17 input_size = 2
18 hidden_size = 2
19 output_size = 1
20 F = 2.4 / (input_size + hidden_size + output_size )
21
22
23 class SingleLayer :
24 def __init__(self, w, b, name ):
25 self.weight = w
26 self.bias = b
27 self.delta_weight = None
28 self.delta_bias = None
29 self.out = None # same in y
30 self.name = name
31
32
33 class MLP :
34 def __init__(self, input_size, hidden_size, output_size, name ):
35 # hidden size = ex) [2,3,5] . num of neruon, each hidden layer.
36 self.a = 0.1
37 self.name = name
38
39 weight_input = np.random.uniform (-F, F, input_size * hidden_size
).reshape (hidden_size, input_size )
40 bias_input = np.random.uniform (-F, F, hidden_size ).reshape
(hidden_size, -1 )
41
42 weight_output = np.random.uniform (-F, F, hidden_size * output_size
).reshape (output_size, hidden_size )
43 bias_output = np.random.uniform (-F, F, output_size ).reshape
(output_size, -1 )
44
45 """
46 weight_input = np.array([[0.5, 0.4], [0.9, 1.0]])

11. 47 bias_input = np.array([[0.8], [-0.1]])
48
49 weight_output = np.array([[-1.2, 1.1]])
50 bias_output = np.array([[0.3]])
51 """
52
53 self.layers = [ None , SingleLayer (weight_input, bias_input, "hidden1"),
SingleLayer (weight_output, bias_output, "output") ]
54
55 def test (self, train_data ):
56
57 self.layers.pop (0 )
58 self.layers.insert (0 , train_data )
59
60 prevLayer = None
61 err = None
62 X = None
63 y = None
64 for layer in self.layers :
65 if type (layer ) != SingleLayer :
66 # prevLayer 중복지정 방지때문에 if then else로 처리
67 pass
68 else :
69 X = self.step1_calDot (layer, prevLayer )
70 y = self.step2_calSig (X )
71 layer.out = y
72
73 prevLayer = layer
74
75 #err = self.step3_calErr(supervised, y)
76 return y
77
78
79 def errorRate (self, train_data ,supervised ):
80 y = self.test (train_data )
81
82 return self.calcError (y, supervised )
83
84 def calcError (self, y, supervised ):
85
86 return y - supervised
87
88 def step1_calDot (self, layer, prevLayer ):
89 if type (prevLayer ) != SingleLayer : # 이전층이 최초 인풋일경우
90 result = np.dot (layer.weight, prevLayer ) - layer.bias
91 return result
92 else :
93 result = np.dot (layer.weight, prevLayer.out ) - layer.bias
94 return result
95
96
97
98
99 def step2_calSig (self, X ):

12. 100 return sigmoid (X )
101
102 def step3_calErr (self, y, supervised ):
103 return supervised - y
104
105 def step4_calGrad (self, y, prev_err ):
106 return gradient (y, prev_err )
107
108 def step5_calDelta (self, learn_rate, postLayer, grad ):
109 if type (postLayer ) != SingleLayer : # 바이어스도 해당
110 result = learn_rate * postLayer * grad
111 return result
112 result = learn_rate * postLayer.out * grad
113 return result
114
115
116 def train (self, train_data, supervised ):
117
118 self.layers.pop (0 )
119 self.layers.insert (0 , train_data )
120
121 prevLayer = None
122 err = None
123 X = None
124 y = None
125 for layer in self.layers :
126 if type (layer ) != SingleLayer :
127 # prevLayer 중복지정 방지때문에 if then else로 처리
128 pass
129 else :
130 X = self.step1_calDot (layer, prevLayer )
131 y = self.step2_calSig (X )
132 layer.out = y
133
134
135 prevLayer = layer
136
137 err = self.step3_calErr (y, supervised )
138
139 self.layers.reverse ()
140 prev_grad = err
141 prev_layer = None
142 #가중치 계산
143 for idx, layer in enumerate (self.layers ):
144 if (idx == len (self.layers )-1 ): # input data까지 갔을 시.
145 continue
146 if (idx == 0 ): # output layer일 경우 바로 err
147 prev_grad = self.step4_calGrad ((layer.out ).T, prev_grad )
148 else :
149 prev_grad = self.step4_calGrad ((layer.out ).T, prev_grad *
prevLayer.weight )
150 delta_W = self.step5_calDelta (self.a, self.layers [idx +1 ] ,prev_grad
).T
151 delta_b = self.step5_calDelta (self.a, (-1 ), prev_grad ).T

13. 152 layer.delta_weight = delta_W
153 layer.delta_bias = delta_b
154
155 prevlayer = layer
156
157 # 가중치 실 적용
158 for idx, layer in enumerate (self.layers ):
159 if (idx == len (self.layers ) - 1 ): # input data까지 갔을 시.
160 continue
161
162 layer.weight = layer.weight + layer.delta_weight
163 layer.bias = layer.bias + layer.delta_bias
164
165 # 원상복구
166 self.layers.reverse ()
167 return prev_grad
168
169 def printParam (self ):
170 print ("======={0}======".format (self.name ))
171
172 for layer in self.layers :
173 if type (layer ) != SingleLayer :
174 # prevLayer 중복지정 방지때문에 if then else로 처리
175 pass
176 else :
177 print ("-------{0}-------".format (layer.name ))
178 print (layer.weight )
179 print (layer.bias )
180 print ("")
181
182
183
184
185 mlp_xor = MLP (2 ,2 ,1 , "xor")
186 mlp_and = MLP (2 ,2 ,1 , "and")
187 mlp_or = MLP (2 ,2 ,1 , "or")
188
189
190
191 train_data_xor = np.array ([[[1 ], [1 ]],[[1 ],[0 ]], [[0 ],[1 ]], [[0 ],[0 ]]])
192 supervised_xor = np.array ([[0 ], [1 ], [1 ], [0 ]])
193
194 train_data_and = np.array ([[[1 ], [1 ]],[[1 ],[0 ]], [[0 ],[1 ]], [[0 ],[0 ]]])
195 supervised_and = np.array ([[1 ], [0 ], [0 ], [0 ]])
196
197 train_data_or = np.array ([[[1 ], [1 ]],[[1 ],[0 ]], [[0 ],[1 ]], [[0 ],[0 ]]])
198 supervised_or = np.array ([[1 ], [1 ], [1 ], [0 ]])
199
200 errListXor = []
201 errListAnd = []
202 errListOr = []
203 errIndex = []
204
205 tr_rand_xor_test = copy.deepcopy (train_data_xor )

14. 206 tr_rand_xor_supervise = copy.deepcopy (supervised_xor )
207
208 tr_rand_and_test = copy.deepcopy (train_data_and )
209 tr_rand_and_supervise = copy.deepcopy (supervised_and )
210
211 tr_rand_or_test = copy.deepcopy (train_data_or )
212 tr_rand_or_supervise = copy.deepcopy (supervised_or )
213
214
215
216
217
218
219 for i in range (20000 ):
220 epoch_shuffle = np.arange (4 )
221 np.random.shuffle (epoch_shuffle )
222 for idx in epoch_shuffle :
223 mlp_xor.train (train_data_xor [idx ], supervised_xor [idx ])
224 mlp_and.train (train_data_and [idx ], supervised_and [idx ])
225 mlp_or.train (train_data_or [idx ], supervised_or [idx ])
226
227 if i %100 ==0 :
228 tmpErrXor = []
229 tmpErrAnd = []
230 tmpErrOr = []
231
232 for j in range (len (tr_rand_xor_test )):
233 err = mlp_xor.errorRate (tr_rand_xor_test [j ], tr_rand_xor_supervise [j
])
234 tmpErrXor.append (err )
235
236 err = mlp_and.errorRate (tr_rand_and_test [j ], tr_rand_and_supervise
[j ])
237 tmpErrAnd.append (err )
238
239 err = mlp_or.errorRate (tr_rand_or_test [j ], tr_rand_or_supervise [j ])
240 tmpErrOr.append (err )
241
242 errListXor.append ( sum ([ x **2 for x in tmpErrXor ]).item () )
243 errListAnd.append ( sum ([ x **2 for x in tmpErrAnd ]).item () )
244 errListOr.append ( sum ([ x **2 for x in tmpErrOr ]).item () )
245 errIndex.append (i )
246
247
248 print ("=============================")
249 print (mlp_xor.test (np.array ( [[0 ],[0 ]] )))
250 print (mlp_xor.test (np.array ( [[0 ],[1 ]] )))
251 print (mlp_xor.test (np.array ( [[1 ],[0 ]] )))
252 print (mlp_xor.test (np.array ( [[1 ],[1 ]] )))
253 print ("=============================")
254 print (mlp_and.test (np.array ( [[0 ],[0 ]] )))
255 print (mlp_and.test (np.array ( [[0 ],[1 ]] )))
256 print (mlp_and.test (np.array ( [[1 ],[0 ]] )))
257 print (mlp_and.test (np.array ( [[1 ],[1 ]] )))

15. 258 print ("=============================")
259 print (mlp_or.test (np.array ( [[0 ],[0 ]] )))
260 print (mlp_or.test (np.array ( [[0 ],[1 ]] )))
261 print (mlp_or.test (np.array ( [[1 ],[0 ]] )))
262 print (mlp_or.test (np.array ( [[1 ],[1 ]] )))
263 print ("=============================")
264
265 # (w, h, index)
266 fig = plt.figure ()
267 fig.suptitle ("Multi Layered Perceptron boolean classfier")
268 ay1 = fig.add_subplot (1 ,3 ,1 )
269 ay2 = fig.add_subplot (1 ,3 ,2 )
270 ay3 = fig.add_subplot (1 ,3 ,3 )
271 ay1.plot (errIndex, errListXor, label ="y = sum of error_rate**2")
272 ay2.plot (errIndex, errListAnd, label ="y = sum of error_rate**2")
273 ay3.plot (errIndex, errListOr, label ="y = sum of error_rate**2")
274 plt.title ("Showing reduced error rate")
275
276 plt.show ()
277
278
279 """ 각 신경망의 파라미터들 출력 """
280 mlp_xor.printParam ()
281 mlp_and.printParam ()
282 mlp_or.printParam ()
283
284 from matplotlib import pyplot as plt
285 import numpy as np
286
287 #(w1 * x1) + (w2 * x2) - t
288
289
290 """ 훈련된 XOR 입력 패턴 분류 신경망 결과중 하나를 선택하여
291 파라미터로 도출한 2차원 도면 표현"""
292 w1_1 = 4.12375411
293 w2_1 = 4.11868558
294 t_1 = 6.31525069
295
296 x_1 = np.arange (-5 ,5 +1 )
297 y_1 = - (w1_1 * x_1 - t_1 ) / w2_1
298
299
300
301 w1_2 = 6.20146275
302 w2_2 = 6.17677067
303 t_2 = 2.66214285
304
305
306 x_2 = np.arange (-5 ,5 +1 )
307 y_2 = - (w1_2 * x_2 - t_2 ) / w2_2
308
309 # x1, y1, x2, y2, horizontal_line, vertical_line
310 plt.plot (x_1, y_1, "r-" , x_2, y_2, "b-", [0 ,0 ], [-5 ,5 ], "k-" ,[-5 ,5 ] ,[0 ,0
], "k-")

16. 2) TensorFlow 라이브러리로 구현한 소스코드
1 import tensorflow as tf
2 from matplotlib import pyplot as plt
3
4 def uniformRange(F):
5 return 2.4 / F
6
7
8 n_input = 2
9 n_hidden1 = 2
10 n_hidden2 = 1
11 n_output = 1
12
13 # [[0,0], [0,1], [1,0], [1,1]]
14 x = tf.placeholder(tf.float32 , [4 , n_input])
15
16 # [[0],[1],[1],[0]]
17 y = tf.placeholder(tf.float32 , [4 , n_hidden2])
18
19 init_range = uniformRange(n_hidden1 + n_hidden2)
20 learning_rate = 0.1
21
22 W = {
23 "hidden1": tf.Variable(tf.random_uniform([n_input , n_hidden1], -init_range ,
init_range)),
24 "hidden2": tf.Variable(tf.random_uniform([n_hidden1 , n_hidden2], -init_range
, init_range)),
25 }
26 b = {
27 "hidden1": tf.Variable(tf.random_uniform([n_hidden1], -init_range ,
init_range)),
28 "hidden2": tf.Variable(tf.random_uniform([n_hidden2], -init_range ,
init_range)),
29 }
30
31 y_34 = tf.sigmoid(tf.matmul(x , W["hidden1"]) + b["hidden1"])
32 y_5 = tf.sigmoid(tf.matmul(y_34 , W["hidden2"]) + b["hidden2"])
33
34 """
35 cost = tf.reduce_mean(
36 ((y * tf.log(y_5)) + ((1 - y) * tf.log(1.0 - y_5))) * -1
37 )
38 """
39
40 #cost = tf.reduce_mean( tf.squared_difference(y_5, y)) # 오차 제곱의 합
41 cost = tf.nn.l2_loss( y - y_5 ) # 일반적인 오차 계산
42
43 optimizer =
tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(cost)
44
45 data_xor_train = [[0 , 0 ], [0 , 1 ], [1 , 0 ], [1 , 1 ]]
46 data_xor_supervise = [[0 ], [0 ], [0 ], [1 ]]
47
48 init = tf.initialize_all_variables()

17. 49 session = tf.Session()
50 session.run(init)
51
52
53 errIndex = []
54 errListXor = []
55 for i in range(0 , 10000 + 1 ):
56 session.run(optimizer , feed_dict={x: data_xor_train , y: data_xor_supervise})
57
58 if i%100 == 0 :
59 errIndex.append(i)
60 errListXor.append( session.run(cost , feed_dict={x:data_xor_train ,
y:data_xor_supervise} ) )
61
62 """
63 if i % 1000 == 0:
64
65 print("==================================")
66 print("Epoch : {0}".format(i))
67 print("y5 : {0}".format(session.run(y_5, feed_dict={x: data_xor_train, y:
data_xor_supervise})))
68 #print("Weight1 : {0}".format(session.run(W["hidden1"])))
69 #print("Bias1 : {0}".format(session.run(b["hidden1"])))
70 #print("Weight2 : {0}".format(session.run(W["hidden2"])))
71 #print("Bias2 : {0}".format(session.run(b["hidden2"])))
72 print("cost : {0}".format(session.run(cost, feed_dict={x: data_xor_train, y:
data_xor_supervise})))
73 """
74
75 fig = plt.figure()
76 fig_sub1 = fig.add_subplot(1 ,1 ,1 )
77 fig_sub1.plot(errIndex , errListXor)
78
79 plt.title("Showing reduced error rate in AND")
80 plt.show()