■퍼셉트론
퍼셉트론?
"인간의 뇌세포 중 하나를 컴퓨터로 구현해 봄 (뉴런) "
*뉴런의 갯수
1. 사람: 850억개
2. 고양이: 10억개
3. 쥐: 7천 5백만개
4. 바퀴벌레: 몇백만개
5. 하루살이: 지금현재까지 나온 최첨단 인공지능의 뉴런 수 보다 많다.
"1957년에 프랑크 로젠 블라트가 퍼셉트론 알고리즘을 고안했다.
사람의 뇌의 동작을 전기 스위치인 온/오프로 흉내 낼 수 있다는 이론을
증명했다"
"인간의 신경세포 하나하나를 흉내낸 것이다.
고등학교 생물시간에 배운 3가지 용어?
1.자극(stimulus)
2. 반응(response)
3. 역치(threshold)
"특정 자극이 있다면 그 자극이 어느 역치 이상일 때 세포가 반응한다.
예를 들면, 짜게 먹는 사람은 자기가 평소에 먹는 만큼 음식이 짜지 않으면
싱겁다고 느낀다
(=역치 이하의 자극은 무시한다)
즉, 역치란 임계값으로 이해할 수 있다."
"싱겁게 먹던 사람은 짜게 먹기 시작하면 오랜 시간 지나면
예전에 먹던 싱거운 음식에 만족하지 못한다(역치가 올라감)"
*머신러닝(컴퓨터가 스스로 학습하는 알고리즘)의 종류 3가지
인공지능----> 머신러닝----> 딥러닝
※딥러닝을 있게한 알고리즘이 퍼셉트론이다.
※ 지도학습과 강화학습은 케잌의 크림과 체리에 해당하고
비지도 학습은 케잌의 빵에 해당한다.
1. 지도학습 : 정답이 있는 상태에서 학습 [케잌의 크림]
(*딥러닝이 지도학습에 속한다)
예: 개 사진이 10000장, 고양이 사진 10000장을 계속 컴퓨터에게
보여주면서 이 사진은 개다
이 사진은 고양이다 라고
계속 알려주는 것이다.
2. 비지도학습 : 정답이 없는 상태에서 학습[케잌의 빵]
3. 강화학습 : 보상을 통해서 학습 데이터를 만들며 학습[케잌의 체리]
문제26.
AND 게이트 퍼셉트론을 구현하기 위해서
입력값과 target 그리고 가중치를 아래와 같이 numpy로 만드시오!
(numpy array)
입력값(inputs): [[0,0],[0,1],[1,0],[1,1]]
traget: [[0],[0],[0],[1]]
가중치(w): [[0.4],[0.35],[0.05]]
import numpy as np
inputs=np.array([[0,0],[0,1],[1,0],[1,1]])
target=np.array([[0],[0],[0],[1]])
w=np.array([[0.4],[0.35],[0.05]])
print(inputs) #4행2열
print(target) #4행 1열
print(w) #3행 1열
[[0 0]
[0 1]
[1 0]
[1 1]]
[[0]
[0]
[0]
[1]]
[[ 0.4 ]
[ 0.35]
[ 0.05]]
문제27.
0보다 크면 1을, 0보다 같거나 작으면 0을 출력하는 함수를 생성하시오
def active_function(n):
if n>0:
return 1
elif n<=0:
return 0
print(active_function(0.4))
print(active_function(-0.2))
문제28.
아래의 numpy array로 만든 입력값(x) 와 가중치(w)의 행렬곱을 구하시오
x=np.array([0,1])
w=np.array([0.5,0.5])
print(x*w)
[ 0. 0.5]
문제29. 위에서 출력된 2개의 원소의 합을 출력하시오
x=np.array([0,1])
w=np.array([0.5,0.5])
print(np.sum(x*w))
문제30. 아래의 입력값(x)과 가중치(w)의 곱의 합을 출력하시오
import numpy as np
x=np.array([[-1,0,0],[-1,0,1],[-1,1,0],[-1,1,1]]) #4행3열
print(x)
target=np.array([[0],[0],[0],[1]])
w=np.array([[0.4],[0.35],[0.05]]) #3행1열
print(w)
w를 전치시켜서 1행3열로 바꿔야 브로드캐스트가 가능하다.
※ w 행렬을 전치하는 방법
w=np.array([[0.4],[0.35],[0.05]])
print(w.shape)
print(w.T.shape)
(3, 1)
(1, 3)
아니면 애초에 그냥
w=np.array([[0.4,0.35,0.05]])
이렇게 써서 1행 3열로 만든다.
↓
성호답:
import numpy as np
x = np.array( [ [-1, 0, 0], [-1, 0, 1], [-1, 1, 0], [-1, 1, 1] ] )
target = np.array( [[0], [0], [0], [1]] )
w = np.array ( [0.4, 0.35, 0.05] )
x0 = np.array( [-1] )
def and_sum(x,w):
xx = x*w
return np.round(sum(xx.T),decimals=2) #decimals=소숫점2자리까지 나오게하라
print(and_sum(x,w))
[-0.4 -0.35 -0.05 -0. ]
***decimals 빼고, ----> axis 랑 .round(2) 이용한 방법
import numpy as np
x = np.array( [ [-1, 0, 0], [-1, 0, 1], [-1, 1, 0], [-1, 1, 1] ] )
target = np.array( [[0], [0], [0], [1]] )
w = np.array ( [0.4, 0.35, 0.05] )
x0 = np.array( [-1] )
def and_sum(x,w):
xx = x*w
return np.sum(xx,axis=1).round(2)
print(and_sum(x,w))
※ np.sum 의 axis 의 활용 방법
1: 행 끼리 합을 구할 때
0: 열 끼리 합을 구할 때
예:
[ [-0.4, 0. ,0. ]
[-0.4, 0. , 0.05]
[-0.4, 0.35, 0. ]
[-0.4, 0.35, 0.05] ]
axis=1 하면 [-0.4 -0.35 -0.05 -0. ]
지엽답:
import numpy as np
x=np.array([ [-1,0,0],[-1,0,1],[-1,1,0],[-1,1,1] ])
w=np.array( [ [0.4, 0.35, 0.05] ] )
target=np.array( [ [0],[0],[0],[1] ] )
def and_sum(x,w):
k=[]
for i in range(len(x)): # len(x)=4 , range(len(x)) : 0 ~ 3
k.append(np.sum(x[i]*w))
return k
print(and_sum(x,w))
[-0.40000000000000002,
-0.35000000000000003,
-0.050000000000000044,
-4.163336342344337e-17]
문제31. 위에서 나온 결과를 문제27번의 활성화 함수를 통과 시켜서
아래와 같이 결과가 출력되게 하시오
print(and_sum(x,w))
결과:
[-0.4 -0.35 -0.05 -0]
↓
[0 0 0 0]
import numpy as np
x = np.array( [ [-1, 0, 0], [-1, 0, 1], [-1, 1, 0], [-1, 1, 1] ] )
target = np.array( [[0], [0], [0], [1]] )
w = np.array ( [0.4, 0.35, 0.05] )
x0 = np.array( [-1] )
def and_sum(x,w):
q=[]
xx = x*w
n=np.sum(xx,axis=1).round(2)
for i in n:
if i>0:
q.append(1)
elif i<=0:
q.append(0)
return q
print(and_sum(x,w)) #근데 이건 오답, 리스트형식으로 나오면 안되고
np.array 형식으로 뽑아내야 하니까(사이사이 컴마 없음)
소현답:
import numpy as np
x = np.array( [ [-1, 0, 0], [-1, 0, 1], [-1, 1, 0], [-1, 1, 1] ] )
target = np.array( [[0], [0], [0], [1]] )
w = np.array ( [0.4, 0.35, 0.05] )
def active_func(k):
if k > 0:
return 1
else:
return 0
def and_sum(x,w):
k_list = np.round( np.sum(x*w, axis=1), decimals=2 )
return np.array([ active_func(i) for i in k_list ])
print(and_sum(x,w))
성호답:(활성화 함수 안쓴거)
import numpy as np
x = np.array( [ [-1, 0, 0], [-1, 0, 1], [-1, 1, 0], [-1, 1, 1] ] )
target = np.array( [[0], [0], [0], [1]] )
w = np.array ( [0.4, 0.35, 0.05] )
x0 = np.array( [-1] )
def and_sum(x,w):
xx = x*w
xw = np.round(np.sum(xx, axis =1),decimals=2)
lo = xw > 0
return lo.astype(int)
print((and_sum(x,w)))
문제32. 위에서 나온 결과를 target 값의 차이를 출력하는데(=오차값)
결과가 아래와 같이 출력되게끔 코드를 작성하시오
결과: target = np.array([[0],[0],[0],[1] ]) #실제값 (ex:개,개,개,고양이)
[0 0 0 0] #예상값 (ex:개,개,개,개)
오차: 예상값-실제값
결과: [ 0 0 0 -1 ]
import numpy as np
x = np.array( [ [-1, 0, 0], [-1, 0, 1], [-1, 1, 0], [-1, 1, 1] ] )
target = np.array( [[0], [0], [0], [1]] )
w = np.array ( [0.4, 0.35, 0.05] )
def active_func(k):
if k > 0:
return 1
else:
return 0
def and_sum(x,w):
k_list = np.round( np.sum(x*w, axis=1), decimals=2 )
return np.array([ active_func(i) for i in k_list ])-target.T
print(and_sum(x,w))
[[ 0 0 0 -1]]
문제33. (오늘의 마지막 문제)
아래의 공식을 대입해서 최적의 가중치인 w0,w1,w2를
출력하게끔 and_sum 함수에 코드를 추가하시오
공식: wi = wi + 0.05*xi * (target - k)
↑ ↑
running rate 예상값(활성함수 통과한 결과)
힌트: if ( targets[i][0] - k ) != 0:
for j in range(len(w) ) :
w[ j ] = w[ j ] + 0.05 * x[ i ][ j ] * (target[ i ][ 0 ] - k)
w0 ---> 0.4
w1---> 0.35
w2---> 0.1
import numpy as np
x = np.array( [ [-1, 0, 0], [-1, 0, 1], [-1, 1, 0], [-1, 1, 1] ] )
target = np.array( [[0], [0], [0], [1]] )
#print(target.T)
w = np.array ( [0.4, 0.35, 0.05] )
#print(w)
x0=np.array([-1])
def active_func(k):
if k > 0:
return 1
else:
return 0
def and_sum(x,w):
k_list = np.round( np.sum(x*w, axis=1), decimals=2 )
ocha=target.T-np.array([ active_func(i) for i in k_list ]) #오차값
ocha1=ocha
while np.sum(ocha1)!=0:
k_list = np.round( np.sum(x*w, axis=1), decimals=2 )
ocha1=target.T-np.array([ active_func(i) for i in k_list ]) #오차값
#print(ocha1.T) [[ 0 0 0 -1]]
count=-1
for z in ocha1.T:
count+=1
if z !=0: #4번째가 -1 이니까, count==3, z=-1
for i in range(len(w)): #0,1,2
w[i]=w[i] +0.05 * x[count][i] * z
return w
print(and_sum(x,w))
※직접대입 오차0 구현
x0 x1 x2 y
-1 0 0 0 w0=0.4
-1 0 1 0 w1=0.35
-1 1 0 0 w2=0.05
-1 1 1 1
x0*w0 + x1*w1 + x2*w2
<<시도 : 1 >>
[[ 입력 1 ]]
x*w = [-0.4 0. 0. ]
K = -0.4
target : [0]
활성화함수값 : 0
오차 : [0]
[[ 입력 2 ]]
x*w = [-0.4 0. 0.05]
K = -0.35
target : [0]
활성화함수값 : 0
오차 : [0]
[[ 입력 3 ]]
x*w = [-0.4 0.35 0. ]
K = -0.05
target : [0]
활성화함수값 : 0
오차 : [0]
[[ 입력 4 ]]
x*w = [-0.4 0.35 0.05]
K = -0.0
target : [1]
활성화함수값 : 0
오차 : [1]
입력4에서 오차가 발생했으므로 가중치를 갱신합니다.
w[0] = 0.35
w[1] = 0.4
w[2] = 0.1
바뀐가중치 = [ 0.35 0.4 0.1 ]
오차배열 : [[0 0 0 1]]
<<시도 : 2 >>
[[ 입력 1 ]]
x*w = [-0.35 0. 0. ]
K = -0.35
target : [0]
활성화함수값 : 0
오차 : [0]
[[ 입력 2 ]]
x*w = [-0.35 0. 0.1 ]
K = -0.25
target : [0]
활성화함수값 : 0
오차 : [0]
[[ 입력 3 ]]
x*w = [-0.35 0.4 0. ]
K = 0.05
target : [0]
활성화함수값 : 1
오차 : [-1]
입력3에서 오차가 발생했으므로 가중치를 갱신합니다.
w[0] = 0.4
w[1] = 0.35
w[2] = 0.1
바뀐가중치 = [ 0.4 0.35 0.1 ]
[[ 입력 4 ]]
x*w = [-0.35 0.4 0.1 ]
K = 0.15
target : [1]
활성화함수값 : 1
오차 : [0]
오차배열 : [[ 0 0 -1 0]]
<<시도 : 3 >>
[[ 입력 1 ]]
x*w = [-0.4 0. 0. ]
K = -0.4
target : [0]
활성화함수값 : 0
오차 : [0]
[[ 입력 2 ]]
x*w = [-0.4 0. 0.1]
K = -0.3
target : [0]
활성화함수값 : 0
오차 : [0]
[[ 입력 3 ]]
x*w = [-0.4 0.35 0. ]
K = -0.05
target : [0]
활성화함수값 : 0
오차 : [0]
[[ 입력 4 ]]
x*w = [-0.4 0.35 0.1 ]
K = 0.05
target : [1]
활성화함수값 : 1
오차 : [0]
오차배열 : [[0 0 0 0]]
<< 시도 횟수 = 3 회, 최적의 가중치 = [ 0.4 0.35 0.1 ] >>
■ 퍼셉트론 단층 신경망
퍼셉트론?
사람의 뇌세포 하나를 인공신경망으로 구현. N개의 이진수가 하나의 뉴런을 통과해서 가중의 합이 0보다 크면 활성화 되는 가장 간단한 신경망
입력신호의 연결강도가 가중치인데 가중치의 값이 클수록 "강한신호"이다
입력신호가 뉴런에 보내질 때는 각각의 고유한 가중치가 곱해진다.
w1*x1 + w2*x2 <= 임계값(세타) ----> 0 (신호가 안흐른다)
w1*x1 + w2*x2 <= 임계값(세타) ----> 1 (신호가 흐른다)
뉴런에서 보내온 신호의 총합이 정해진 한계(임계값)을 넘어설 때만 1을 출력을 한다.
퍼셉트론은 n개의 이진수가 하나의 뉴런을 통과해서
가중의 합이 0보다 크면 활성화 되는 가장 간단한 신경망이다.
퍼셉트론을 학습시키는 방법은 간단한데, 보통 목표치를 정해주고
현재 계산한 값이 목표치와 다르면 그 만큼의 오차를 다시 퍼셉트론에
반영해서 오차를 줄여나가는 방법이다.
퍼셉트론에서 b(바이어스)는 편향을 나타내는 매개변수로,
뉴런이 얼마나 쉽게 활성화되느냐를 제어합니다.
w1, w2는 각 신호의 가중치를 나타내는 매개변수로, 각 신호의 영향력을 제어합니다.
경사하강법:
X와 평행한 기울기는 0이 되는 값이고, 우리가 찾는 최소값이다.
이게 최적의 가중치w 고 우리가 퍼셉트론을 하는 궁극적인 목표다
■ 퍼셉트론 다층 신경망
■ 퍼셉트론 게이트 4가지
① AND 게이트
|
x1 |
x2 |
y |
|
0 |
0 |
0 |
|
0 |
1 |
0 |
|
1 |
0 |
0 |
|
1 |
1 |
1 |
② OR 게이트
|
x1 |
x2 |
y |
|
0 |
0 |
0 |
|
0 |
1 |
1 |
|
1 |
0 |
1 |
|
1 |
1 |
1 |
③ NAND 게이트 (not and)
|
x1 |
x2 |
y |
|
0 |
0 |
1 |
|
0 |
1 |
1 |
|
1 |
0 |
1 |
|
1 |
1 |
0 |
④ XOR 게이트 (exclusive or 라는 뜻으로 둘 중에 하나만 1이 될때 1이 된다.)
|
x1 |
x2 |
y |
|
0 |
0 |
0 |
|
0 |
1 |
1 |
|
1 |
0 |
1 |
|
1 |
1 |
0 |
※ 선형분류가 안되서 위 그림과 같은 비선형분류로 다층신경망을 구현했다
문제34. 아래의 식을 파이썬으로 구현하시오
x1*w1 + x2*w2 = ?
x1: 0
x2: 1
w1: 0.5
w2: 0.5
답:
import numpy as np
x=np.array([[0],[1]])
w=np.array([[0.5],[0.5]])
print(x*w)
print(np.sum(x*w))
[[ 0. ]
[ 0.5]]
0.5
**위 2행2열을 아래의 1행 2열로 바꿔서 계산
import numpy as np
x=np.array([[0,1]])
w=np.array([[0.5,0.5]])
print(x*w)
print(np.sum(x*w))
[[ 0. 0.5]]
0.5
문제35. 위의 식에 책52쪽에 나오는 편향을 더해서 완성한 아래의 식을
파이썬으로 구현하시오
b + x1*w1 + x2*w2 = ?
b(편향) = -.07
x1: 0
x2: 1
w1: 0.5
w2: 0.5
답:
import numpy as np
x=np.array([[0,1]])
w=np.array([[0.5,0.5]])
b=np.array([-0.7])
print(x*w)
print((np.sum(x*w))+b)
[[ 0. 0.5]]
[-0.2]
문제36. AND게이트를 파이썬으로 구현하시오
주어지는 값:
w1: 0.5
w2: 0.5
theta: 0.7
x1*w1 + x2*w2 <= theta ----> 0
x1*w1 + x2*w2 > theta ----> 1
구현: print(AND(0,0) ) #0 이 출력
print(AND(1,1) ) #1 이 출력
-----------------------------------------------------
x1=np.array([[0,1,0,1]])
x2=np.array([[0,0,1,1]])
def AND(x1,x2):
w1,w2,theta=0.5,0.5,0.7
if x1*w1+x2*w2 <= theta:
return 0
elif x1*w1+x2*w2 > theta:
return 1
print( AND(0,0) )
print( AND(0,1) )
print( AND(1,0) )
print( AND(1,1) )
0
0
0
1
용원답:
def AND(x1,x2):
w1,w2,theta = 0.5,0.5,0.7
return 0 if (w1*x1 + w2*x2 <= theta) else 1
print( AND(0,0) )
print( AND(0,1) )
print( AND(1,0) )
print( AND(1,1) )
문제37. 위에서 만든 and퍼셉트론 함수를 이용해서
아래의 inputdata 를 이용해서 출력결과를 for loop 문으로 한번에 출력하시오
결과:
---------AND 퍼셉트론---------
0,0 ===> 0
0,1 ===> 0
1,0 ===> 0
1,1 ===> 1
def AND(x1,x2):
w1,w2,theta = 0.5,0.5,0.7
return 0 if (w1*x1 + w2*x2 <= theta) else 1
import numpy as np
inputData = np.array([[0,0],[0,1],[1,0],[1,1]])
print( "--- And 퍼셉트론 ---")
for i in inputData:
print("%d, %d → %d" %(i[0],i[1], AND(i[0],i[1])))
문제38. OR퍼셉트론 함수를 만들어서 문제37번과 같은 결과를 구현하시오
def OR(x1,x2):
w1,w2,theta = 0.5,0.5,0
return 0 if (w1*x1 + w2*x2 <= theta) else 1
import numpy as np
inputData = np.array([[0,0],[0,1],[1,0],[1,1]])
print( "--- OR 퍼셉트론 ---")
for i in inputData:
print("%d, %d → %d" %(i[0],i[1], OR(i[0],i[1])))
--- OR 퍼셉트론 ---
0, 0 → 0
0, 1 → 1
1, 0 → 1
1, 1 → 1
문제39.(점심시간문제)
Not_And_Perceptron 함수를 구현하시오
def Not_And_Perceptron(x1,x2):
w1,w2,theta = 0.5,0.5,0.7
return 1 if (w1*x1 + w2*x2 <= theta) else 0
import numpy as np
inputData = np.array([[0,0],[0,1],[1,0],[1,1]])
print( "--- Not_And_Perceptron 퍼셉트론 ---")
for i in inputData:
print("%d, %d → %d" %(i[0],i[1], Not_And_Perceptron(i[0],i[1])))
--- Not_And_Perceptron 퍼셉트론 ---
0, 0 → 1
0, 1 → 1
1, 0 → 1
1, 1 → 0
■ 퍼셉트론 함수 4가지
1. AND 게이트 함수 : 단층
2. OR 게이트 함수 :단층
3. NAND 게이트 함수 ( Not AND ): 단층
4. XOR 게이트 함수 ( Exclusive OR ) : 다층!!
■ 단층 신경망과 다층 신경망의 차이
-1958년 로젠 블래트가 퍼셉트론을 제안했다.
-1959년 민스키(로젠 사촌)가 기존 퍼셉트론의 문제점을 지적했는데
XOR 분류를 못한다는 문제점을 지적하고 인공지능의 겨울기가
시작되었다.
즉 XOR 게이트는 단층 신경망으로는 구현이 안되는 것이었다.
XOR 게이트는 다층 신경망으로 구현해야하는 것이었다.
1. XOR 게이트 진리 연산표
XOR X1 X2 t
0 0 0
1 0 1
0 1 1
1 1 0
2. 중간층을 넣어서
s1 s2 y
XOR X1 X2 or게이트 결과, NAND결과, AND결과
0 0 0 1 0
1 0 1 1 1
0 1 1 1 1
1 1 1 0 0
문제40. 위에서 만든 3개의 함수(OR,NAND,AND)를 이용해서
XOR 함수를 생성해서 아래와 같이 결과를 출력하시오
결과:
------exclusive_or_Perceptron----------
0,0 0
1
1
0
이것만 추가하면 됨!
def XOR(x1,x2):
s1=OR(x1,x2)
s2=NAND(x1,x2)
y=AND(s1,s2)
return y
----------------------------------------------
import numpy as np
x1=np.array([[0,1,0,1]])
x2=np.array([[0,0,1,1]])
def OR(x1,x2):
w1,w2,theta = 0.5,0.5,0
return 0 if (w1*x1 + w2*x2 <= theta) else 1
def NAND(x1,x2):
w1,w2,theta = 0.5,0.5,0.7
return 1 if (w1*x1 + w2*x2 <= theta) else 0
def AND(x1,x2):
w1,w2,theta = 0.5,0.5,0.7
return 0 if (w1*x1 + w2*x2 <= theta) else 1
def XOR(x1,x2):
s1=OR(x1,x2)
s2=NAND(x1,x2)
y=AND(s1,s2)
return y
import numpy as np
inputData = np.array([[0,0],[0,1],[1,0],[1,1]])
print( "--- XOR Perceptron 퍼셉트론 ---")
for i in inputData:
print("%d, %d → %d" %(i[0],i[1], XOR(i[0],i[1])))
문제41.
2장에서 배운 퍼셉트론의 4개의 게이트 함수를 이용해서
아래의 결과를 출력하시오 !
--- AND Perceptron 퍼셉트론 ---
0, 0 → 0
0, 1 → 0
1, 0 → 0
1, 1 → 1
--- OR Perceptron 퍼셉트론 ---
0, 0 → 0
0, 1 → 1
1, 0 → 1
1, 1 → 1
--- NAND Perceptron 퍼셉트론 ---
0, 0 → 1
0, 1 → 1
1, 0 → 1
1, 1 → 0
--- XOR Perceptron 퍼셉트론 ---
0, 0 → 0
0, 1 → 1
1, 0 → 1
1, 1 → 0
import numpy as np
x1=np.array([[0,1,0,1]])
x2=np.array([[0,0,1,1]])
def AND(x1,x2):
w1,w2,theta = 0.5,0.5,0.7
return 0 if (w1*x1 + w2*x2 <= theta) else 1
import numpy as np
inputData = np.array([[0,0],[0,1],[1,0],[1,1]])
print( "--- AND Perceptron 퍼셉트론 ---")
for i in inputData:
print("%d, %d → %d" %(i[0],i[1], AND(i[0],i[1])))
def OR(x1,x2):
w1,w2,theta = 0.5,0.5,0
return 0 if (w1*x1 + w2*x2 <= theta) else 1
import numpy as np
inputData = np.array([[0,0],[0,1],[1,0],[1,1]])
print( "--- OR Perceptron 퍼셉트론 ---")
for i in inputData:
print("%d, %d → %d" %(i[0],i[1], OR(i[0],i[1])))
def NAND(x1,x2):
w1,w2,theta = 0.5,0.5,0.7
return 1 if (w1*x1 + w2*x2 <= theta) else 0
import numpy as np
inputData = np.array([[0,0],[0,1],[1,0],[1,1]])
print( "--- NAND Perceptron 퍼셉트론 ---")
for i in inputData:
print("%d, %d → %d" %(i[0],i[1], NAND(i[0],i[1])))
def XOR(x1,x2):
s1=OR(x1,x2)
s2=NAND(x1,x2)
y=AND(s1,s2)
return y
import numpy as np
inputData = np.array([[0,0],[0,1],[1,0],[1,1]])
print( "--- XOR Perceptron 퍼셉트론 ---")
for i in inputData:
print("%d, %d → %d" %(i[0],i[1], XOR(i[0],i[1])))
-------------------------
서영이코드:
import numpy as np
def AND(x1,x2):
x= np.array([x1,x2])
theta = np.array([0.7])
w = np.array([0.5, 0.5])
res = np.sum(x * w)
if res > theta:
return 1
elif res <= theta:
return 0
def OR(x1,x2):
x= np.array([x1,x2])
theta = np.array([0])
w = np.array([0.5, 0.5])
res = np.sum(x * w)
if res > theta:
return 1
elif res <= theta:
return 0
def NAND(x1,x2):
x= np.array([x1,x2])
theta = np.array([0.7])
w = np.array([0.5, 0.5])
res = np.sum(x * w)
if res > theta:
return 0
elif res <= theta:
return 1
def XOR(x1,x2):
or1 = OR(x1,x2)
nand1 = NAND(x1,x2)
and1 = AND(or1,nand1)
return and1
inputData = np.array([[0,0],[0,1],[1,0],[1,1]])
print("------------AND퍼셉트론------------")
for i in inputData:
print("%d, %d → %d" %(i[0],i[1], AND(i[0],i[1])))
print("------------OR퍼셉트론------------")
for i in inputData:
print("%d, %d → %d" %(i[0],i[1], OR(i[0],i[1])))
print("------------NAND퍼셉트론------------")
for i in inputData:
print("%d, %d → %d" %(i[0],i[1], NAND(i[0],i[1])))
print("------------XOR퍼셉트론------------")
for i in inputData:
print("%d, %d → %d" %(i[0],i[1], XOR(i[0],i[1])))
문제42.(미리내는 오늘의 마지막 문제)
책 62p 에 나오는 2장 퍼셉트론 총정리에 나오는 맨 마지막 글
---> 다층 퍼셉트론은 (이론상) 컴퓨터를 표현할 수 있다.
위 내용을 파이썬 코드로 구현하시오
1. 어제 구현한 단층 함수인 AND 퍼셉트론 함수로
AND에 해당하는 w0,w1,w2 만 변경했는데
2. 다층은 AND, NAND, OR 3개의 함수의 각각의 w0,w1,w2를 갱신해야 한다.
결과: **사람마다 다르게 나옴, 준하답
NAND의 w : [ -0.1 -0.05 -0.05 ]
OR의 w : [ 0.15 0.45 0.25 ]
AND의 w : [ 0.2 -0.05 0.25 ]
내꺼 결과
NAND의 w :[ 0.05 0.15 0.05]
OR의 w :[ 0.15 0.45 0.25]
AND의 w :[ 0.4 0.35 0.1 ]
-------------------------------------------------------------
def active_func(k):
if k > 0:
return 1
else:
return 0
def NAND(x,w):
x = np.array( [ [-1, 0, 0], [-1, 0, 1], [-1, 1, 0], [-1, 1, 1] ] )
w = np.array ( [0.4, 0.35, 0.05] )
target = np.array( [[1], [1], [1], [0]] )
k_list = np.round( np.sum(x*w, axis=1), decimals=2 )
ocha=target.T-np.array([ active_func(i) for i in k_list ]) #오차값
ocha1=ocha
while np.sum(ocha1)!=0:
k_list = np.round( np.sum(x*w, axis=1), decimals=2 )
ocha1=target.T-np.array([ active_func(i) for i in k_list ]) #오차값
#print(ocha1.T) [[ 0 0 0 -1]]
count=-1
for z in ocha1.T:
count+=1
if z !=0: #4번째가 -1 이니까, count==3, z=-1
for i in range(len(w)): #0,1,2
w[i]=w[i] +0.05 * x[count][i] * z
return w
print(NAND(x,w))
#############################
def active_func(k):
if k > 0:
return 1
else:
return 0
def OR(x,w):
x = np.array( [ [-1, 0, 0], [-1, 0, 1], [-1, 1, 0], [-1, 1, 1] ] )
w = np.array ( [0.4, 0.35, 0.05] )
target = np.array( [[0], [1], [1], [1]] )
k_list = np.round( np.sum(x*w, axis=1), decimals=2 )
ocha=target.T-np.array([ active_func(i) for i in k_list ]) #오차값
ocha1=ocha
while np.sum(ocha1)!=0:
k_list = np.round( np.sum(x*w, axis=1), decimals=2 )
ocha1=target.T-np.array([ active_func(i) for i in k_list ]) #오차값
#print(ocha1.T) [[ 0 0 0 -1]]
count=-1
for z in ocha1.T:
count+=1
if z !=0: #4번째가 -1 이니까, count==3, z=-1
for i in range(len(w)): #0,1,2
w[i]=w[i] +0.05 * x[count][i] * z
return w
print(OR(x,w))
##############################
def active_func(k):
if k > 0:
return 1
else:
return 0
def AND(x,w):
x = np.array( [ [-1, 0, 0], [-1, 0, 1], [-1, 1, 0], [-1, 1, 1] ] )
w = np.array ( [0.4, 0.35, 0.05] )
target = np.array( [[0], [0], [0], [1]] )
k_list = np.round( np.sum(x*w, axis=1), decimals=2 )
ocha=target.T-np.array([ active_func(i) for i in k_list ]) #오차값
ocha1=ocha
while np.sum(ocha1)!=0:
k_list = np.round( np.sum(x*w, axis=1), decimals=2 )
ocha1=target.T-np.array([ active_func(i) for i in k_list ]) #오차값
#print(ocha1.T) [[ 0 0 0 -1]]
count=-1
for z in ocha1.T:
count+=1
if z !=0: #4번째가 -1 이니까, count==3, z=-1
for i in range(len(w)): #0,1,2
w[i]=w[i] +0.05 * x[count][i] * z
return w
print(AND(x,w))
------------------------------
선혜코드:(간결하고 좋음)
def AND(target):
global w
while 1:
result = np.array([1 if i > 0 else 0 for i in np.sum(x * w, axis=1)])
error = target - result
if all(target == result):
print(cnt)
return np.round(w,2)
for i in range(len(result)):
if error[i] != 0:
w = w + 0.05 * x[i] * error[i]
def perceptron():
fun = ["NAND", "OR", "AND"]
target = [ [1, 1, 1, 0],[0, 1, 1, 1], [0, 1, 1, 0]]
for i, j in zip(fun, target):
if i=='AND':
for n in range(len(x)):
x[n][1] = target[0][n]
x[n][2] = target[1][n]
print("%s의 w : " % i, AND(j))
else:
print("%s의 w : " % i, AND(j))
import numpy as np
x = np.array([[-1, 0, 0], [-1, 0, 1], [-1, 1, 0], [-1, 1, 1]])
w = np.array([0.4, 0.35, 0.05])
perceptron()
'deeplearning' 카테고리의 다른 글
| 5장. 오차 역전파 ( 계산 그래프, 연쇄법칙, 역전파 ) (0) | 2019.03.27 |
|---|---|
| 4장. 인공 신경망을 학습시킴(손실(오차)함수, 수치 미분, 경사하강법, 학습 알고리즘 구현) (0) | 2019.03.27 |
| 3장. 인공 신경망 ( 신경망의 활성화 함수, 3층 신경망 구현 ) (0) | 2019.03.27 |
| 1장. deeplearning에 필요한 파이썬 기본문법 (0) | 2019.03.27 |
| Intro.딥러닝 소개 (0) | 2019.03.27 |
