■인공 신경망 ( 신경망의 활성화 함수, 3층 신경망 구현 )
퍼셉트론 -----------------------> 신경망
↓
and 게이트
or 게이트
nand 게이트
xor 게이트
결과를 보려면 w를 사람이 직접 ----> 신경망은 w를 랜덤으로 지정해주기만 하면
정해줬어야 했는데 컴퓨터가 알아서 w를 알아낸다
■ 활성화 함수(p.66)
"입력신호의 총 합을 출력신호로 변환하여
신호를 보낼 지 안 보낼지 결정하는 함수"
"신호를 강하게 보낼지 약하게 보낼지를 결정하는 함수"
k = x0*w0 + x1*w1 + x2*w2
■ 활성화 함수의 종류 3가지
(x가 입력값, y가 출력값)
1. step 함수(계단함수)
-숫자 0과 1을 출력(리턴)하는 함수
-0은 신호 안흐름/ 1은 신호 흐름
-0과 1사이의 숫자들은 파악할 수 없다.
-예를들어 부자와 가난한 자는 파악할 수 있으나
중간계층을 파악할수 없다.
2. sigmoid 함수
- 0과 1 사이의 실수를 출력(리턴)하는 함수
-예를들어 0.84 , 0.23 두 숫자처럼 1에 가까운 큰 숫자일 수록
-강한 신호라는 것을 파악할 수 있다.
-부자,거지, 중간층도 파악 가능하다.
3. Relu 함수
-입력이 0을 넘으면 그 입력을 그대로 출력하고(1이상도 출력함),
0 이하면 0을 출력(리턴)하는 함수다.
우리가 흔히 사용하는 함수다. 음수 값이 없다.
Relu함수가 학습이 가장 잘된다. 확실할 수록 큰 신호를 보내니까
학습이 빨리 된다.
■ 시그모이드 함수의 유래
"통계학에서는 성공확률이 실패확률보다 얼마나 클지를 나타내는
오즈비(율) 이라는 값이 있다" 오즈비(율): how? success > failure
오즈는 성공할 확률이 실패할 확률의 몇 배인지를 나타낸다.
오즈는 음이 아닌 실수이고
성공할 가능성이 실패할 가능성보다 많을 때는 1.0보다 큰 값을 갖는다.
오즈가 4.0이면 성공확률이 실패확률의 4배 이고,
반대로 오즈가 1/4이면 실패확률이 성공확률의 4배가 되어,
4번의 실패마다 한번의 성공을 기대할 수 있다는 의미이다.
Odds = 성공/실패 = P / 1-P
이 그래프는 P의 값이 1 에 가까우면 오즈값이 급격히 커져버리는 현상이 일어나
P / 1-P 에 로그를 취한게
로짓함수이다 log ( P / 1-P )
↓
1에 가까울 때 급격하게 증가하던 현상이 감소했다.
0.5를 기준으로 0에 가까우면 개, 1에 가까우면 고양이를 뜻한다.
log ( P / 1-P ) = w*x + b
상용로그 : log 10
자연로그 : log e ---> ln
오즈비율 함수 ----> 로짓 함수 ----> 시그모이드 함수
↓ ↓ ↓
실패할 확률대비 오즈비 함수에 로짓함수를 신경망에서
성공할 확률을 로그를 사용한 함수 P(확률)값을 계산하기 편하도록
구하는 함수 지수형태로 바꾼 함수
P P 1
------------ log (-------) h(x) = -----------------
1 - P 1 - P 1 + exp(-x)
↓
자연상수 e
문제44. 파이썬으로 계단함수를 만드시오!
"숫자0과 1을 리턴하는 함수"
x<=0 ------------> 0을 출력
x>0 --------------> 1을 출력
예시: x_data=np.array ( [ -1, 0, 1 ] )
import numpy as np
Def step_function(x):
Return np.where(x>0,1,0)
x_data = np.array([-1,0,1])
print(step_function(x_data))
[0 0 1]
-----------------------------------
이수답:
x_data = np.array([-1, 0, 1])
def step_function(x_data):
import numpy as np
y = x_data>0
y_data = y.astype(np.int) #[0 0 1]---> false:0, true:1
y_data1=y
return y_data, y_data1
print(step_function(x_data))
문제45. 계단함수를 파이썬으로 시각화 하시오
import matplotlib.pylab as plt
import numpy as np
x_data = np.array([-1, 0, 1])
x=np.arange(-5, 5, 0.1)
print(x)
def step_function(x_data):
y = x_data>0
y_data = y.astype(np.int) #[0 0 1]---> false:0, true:1
return y_data
#print(step_function(x_data))
y=step_function(x)
plt.plot(x,y)
plt.ylim(-0.1 , 1.1) #범위수동지정 xlim, ylim: x와 y축의 최소,최대값을 정해줌
plt.show()
문제46. 시그모이드 함수를 파이썬으로 구현하시오
1
*시그모이드 함수식: h(x) = ----------------------
1 + exp(-x)
↓
e(자연상수)
import matplotlib.pylab as plt
import numpy as np
x_data = np.array([1.0, 2.0])
#x=np
def sigmoid(x_data):
return 1 / (1 + np.exp(-x))
print(sigmoid(x_data))
결과:
[ 0.73105858 0.88079708]
문제47. 시그모이드 함수의 그래프를 그리시오
import matplotlib.pylab as plt
import numpy as np
x_data = np.array([1.0, 2.0])
x=np.arange(-5, 5, 0.1)
def sigmoid(x_data):
return 1 / (1 + np.exp(-x)) #exp: np에서 로그화시키는 함수
print(sigmoid(x_data))
y=sigmoid(x)
plt.plot(x,y)
plt.ylim(-0.1 , 1.1) #범위수동지정 xlim, ylim: x와 y축의 최소,최대값을 정해줌
plt.show()
■ Relu 함수 ( Rectified Linear Unit)
"정류된"
relu는 입력이 0을 넘으면 그 입력을 그대로 출력하고
0 이하면 0을 출력하는 함수
신경망 학습이 잘되어서 현업에서 주로 사용하는 함수
문제48. relu 함수를 생성하시오
결과:
print(relu (-2) ) #0
print(relu (0.3) ) #0.3
----------------------------------
def relu(x_data):
if x_data>0:
return x_data
else:
return 0
print(relu(0.3))
---------------------------
넘파이값 반환하는거
def relu(x):
return np.where(x>0,x,0)
================
다른방법: (책 77p)
def relu(x_data):
return np.maximum(0,x) #0과 x값 중에 큰 값을 출력해라
print(relu(x_data))
문제49. (점심시간 문제)
relu 함수의 그래프로 그리시오
import matplotlib.pylab as plt
import numpy as np
x=np.arange(-5, 5, 0.1)
x_data=np.array([-2 , 0.3])
def relu(x):
return np.where(x>0,x,0)
print(relu(x_data))
y=relu(x)
plt.plot(x,y)
plt.ylim(-0.5 , 5.5) #범위수동지정 xlim, ylim: x와 y축의 최소,최대값을 정해줌
# relu 함수 특징상 y값 리미트 해제시켜야함
plt.show()
---------------------------------------------------------
다른방법:
import matplotlib.pylab as plt
import numpy as np
x=np.arange(-5, 5, 0.1)
x_data=np.array([-2 , 0.3])
def relu(x_data):
t = np.where(x_data>0, x_data, 0) # np.where 로 한번에 됨
# x_data>0 면 x_data를 출력, else는 0
return t
print(relu(x_data))
y=relu(x)
plt.plot(x,y)
plt.ylim(-0.5 , 5.5) #범위수동지정 xlim, ylim: x와 y축의 최소,최대값을 정해줌
plt.show()
-----------------------------------------------------------
다른방법: (책 77p)
def relu(x_data):
return np.maximum(0,x) #0과 x값 중에 큰 값을 출력해라
print(relu(x_data))
[ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.
0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.
0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.
0. 0. 0. 0. 0. 0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9
1. 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 2. 2.1 2.2 2.3 2.4
2.5 2.6 2.7 2.8 2.9 3. 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9
4. 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9]
■ 다차원 배열의 계산 (p.77)
넘파이로 행렬을 만들고 차원 수(ndim) 확인과
몇 행 몇 열(shape)인지 확인하는 방법
예: 아래의 3행 2열의 행렬을 만드시오
1 2
3 4
5 6
import numpy as np
b= np.array([[1,2],[3,4],[5,6]])
print(b)
print(np.ndim(b)) #차원 수 : 2
print(b.shape) #몇 행 몇 열: 3행2열 (*반환값 ( ) 튜플 주의)
■행렬의 내적
(행렬곱)*그냥 곱이랑 다름, 열*행 의 곱
1행*1열 = 1행1열의 첫번째 값
1행*2열 = 1행1열의 두번째 값
:
:
2행*2열 = 2행2열의 두번째 값
문제50. 위 그림같이 두 개의 행렬의 내적을 numpy 로 구현하시오
import numpy as np
a = np.array([[1,2],[3,4]])
b = np.array([[5,6],[7,8]])
print(np.dot(a,b))
[[19 22]
[43 50]]
print(np.array(a*b))
[[ 5 12]
[21 32]]
또는
np.matrix 로 구현할 수 있다. (내적행렬을 위한 함수 matrix)
import numpy as np
a = np.matrix([[1,2],[3,4]])
print(a.shape)
b = np.matrix([[5,6],[7,8]])
print(a*b)
※ array 와 matrix 의 차이는
1. array 는 다차원을 나타낼 수 있는데 matrix 는 2차원 밖에 안된다.
2. array 는 matrix를 포함하고 있기 때문에 matrix 는 array 가 쓰는 모든 함수는
사용할 수 있다.
= matrix 가 array 의 한 종류 이므로 array 의 속성을 다 받을 수 있다.
3. matrix는 array 와 달리 dot 를 사용하지 않고 곱하기 연산자로
내적을 할 수 있다.
문제51.
아래의 2차원 행렬을 만드시오
import numpy as np
b= np.array([[1,2,3],[4,5,6],[7,8,9]])
print(np.ndim(b)) #차원 수
문제52.
3차원 행렬을 만들어 보시오
import numpy as np
a = np.array( [ [[1,2], [3,4]], [[1,2], [3,4]] ])
print( a.ndim)
※ 2차원 행렬 2개가 앞뒤로 놓인 거다. 그래서 3차원.
1차원: a=np.array([1,2])
2차원: a=np.array([[1,2]])
3차원: a=np.array( [ [[1,2]],[[3,4]] ] )
문제53.
4차원 행렬을 만들어 보시오
a = np.array( [ [[[1,2], [3,4]], [[1,2], [3,4]]], [[[1,2], [3,4]], [[1,2], [3,4]]]])
print(a)
print( a.ndim)
[[[[1 2]
[3 4]]
[[1 2]
[3 4]]]
[[[1 2]
[3 4]]
[[1 2]
[3 4]]]]
4
문제54. 아래의 3차원 행렬에서 숫자 5를 출력하시오
※ 설명
2차원의 요소 검색 --> a[n][n]
3차원의 요소 검색 --> a[n][n][n]
a = np.array( [[[1,2], [3,4]], [[5,6], [7,8]]])
print(a[1][0][0])
print( a.ndim)
3차원이 2차원 2개니까,
뒤에꺼 2차원 a[1] = ( [ [5,6],[7,8] ] )에서
1행렬=a[0]에서 [0]번째인 5를 출력
문제55. 아래의 4차원 행렬에서 숫자 5를 출력하시오
a = np.array( [ [ [[1,2], [3,4]], [[5,6], [7,8]] ] , [ [[9,10],[11,12]],[[13,14],[15,16]] ]])
print(a)
print(a[0][1][0][0])
print( a.ndim)
[[[[ 1 2]
[ 3 4]]
[[ 5 6]
[ 7 8]]]
[[[ 9 10]
[11 12]]
[[13 14]
[15 16]]]]
5
4
문제56. 아래의 행렬의 내적을 파이썬으로 구현하시오
1 2 3 5 6
◎ 7 8 = ?
4 5 6 9 10
◎ <--내적연산 기호는 앞으로 이렇게 쓰겠다.
import numpy as np
a = np.matrix([[1,2,3],[4,5,6]])
#print(a.shape)
b = np.matrix([[5,6],[7,8],[9,10]])
print(a*b)
------------------
또는 다른 답
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
#print(a.shape)
b = np.array([[5,6],[7,8],[9,10]])
print(np.dot(a,b))
[[ 46 52]
[109 124]]
■ 신경망의 내적 (p82)
문제57. 위의 신경망과 연관된 아래의 방정식에서 x1 = 1, x2 = 2 이면
y1 과 y2 의 값은 무엇인가?
파이썬의 numpy로 y1, y2, y3 을 출력하시오 !
x1*1 + x2*2 = y1
x1*3 + x2*4 = y2
x1*5 + x2*6 = y3
(x1 x2) ◎ ( 1 3 5 ) = ( y1 y2 y3 )
2 4 6
import numpy as np
a=np.array([[1,3,5],[2,4,6]]) #shape(2,3)
x=np.array([[1,2]]) #shape(2,1)
print(np.dot(x,a)) #a,x 순서로 출력하면 dim 에러나온다.
# 행렬의 내적이 [앞의 열* 뒤의 행] 의 연산이다.
그래서 앞의 행과 뒤의 열이 일치해야 내적연산이 가능하다.
[[ 5 11 17]]
문제58. 아래의 단층 신경망의 출력값 y값들을 출력하시오
import numpy as np
a=np.array([[8,21,1],[4,5,9],[6,34,4],[12,2,5]])
x=np.array([[4,5,7,2]])
print(np.dot(x,a))
[[118 351 87]]
※ T 시켜서 풀어보시오
import numpy as np
a=np.array([[8,21,1],[4,5,9],[6,34,4],[12,2,5]])
x=np.array([[4,5,7,2]])
a=a.T
print(np.sum(x*a, axis=1))
문제59.
문제 57번 신경망에 가중의 총 합인 y값을 시그모이드 함수에 통과시켜서 나온
y_hat 을 출력하시오
import numpy as np
a = np.array([[1,2]])
b = np.array([[1,3,5],[2,4,6]])
y = np.dot(a,b) #5,11,17
def sigmoid(x):
return 1 / (1 + np.exp(-x)) #exp: np에서 로그화시키는 함수
y_hat= sigmoid(y)
print(y_hat)
[[ 0.99330715 0.9999833 0.99999996]]
문제60.
아래의 3층 신경망을 구현하고 J1 과 J2 를 출력하시오
import numpy as np
a = np.array([[1,2]])
b = np.array([[1,3,5],[2,4,6]])
y = np.dot(a,b)
def sigmoid(x):
return 1 / (1 + np.exp(-x)) #exp: np에서 로그화시키는 함수
y_hat= sigmoid(y)
c=y_hat
d=np.array([[3,4],[5,6],[7,8]])
k=np.dot(c,d)
k_hat=sigmoid(k)
e = k_hat
f = np.array([[4,5],[6,7]])
j = np.dot(e,f)
print(j)
[[ 9.99999866 11.99999833]]
■ 출력층 함수 (p.90)
"출력층의 함수는 그 동안 흘러왔던 확률들의 숫자를 취합해서
결론을 내줘야하는 함수 ! "
신경망으로 구현하고자 하는 문제가
1. 회귀 라면? 항등함수
예: 독립변수(콘크리트 재료 : 자갈 200kg, 시멘트 20포대...)
종속변수(콘크리트 강도)
2. 분류 라면? 소프트맥스 함수
예: 정상 폐사진 VS 폐결절 사진
문제61.
입력값을 받아 그대로 출력하는 항등함수를 identify_function 이라는 이름으로
생성하시오 !
import numpy as np
a = np.array([[1,2]])
def identify_function(x):
return x
print(identify_function(a))
[[1 2]] #[1 2] 로 출력하고 싶으면 x[0]
문제62.
문제61번에서 만든 3층 신경망의 3층 출력층에 항등함수를 달아서
J1_hat 과 J2_hat 을 구하는 코드로 완성 시키시오
import numpy as np
def sigmoid(x):
return 1/(1+np.exp(-x))
def identify_func(x):
return x
# 0층 (입력 층)
x=np.array([[1,2]])
# 1층 (은닉 1층)
y=np.array([[1,3,5],[2,4,6]]) #1층의 가중치(w1)
y_hat=sigmoid(np.dot(x,y))
# 2층 (은닉 2층)
k=np.array([[3,4],[5,6],[7,8]]) #2층의 가중치(w2)
k_hat=sigmoid(np.dot(y_hat,k))
# 3층 (출력 층)
j=np.array([[4,5],[6,7]]) #3층의 가중치(w3)
j_hat=np.dot(k_hat,j)
print(identify_func(j_hat))
문제63.
위의 3층 신경망에 활성화 함수를 relu 함수로 변경하시오
import numpy as np
def relu(x):
return np.where(x>0,x,0)
def identify_func(x):
return x
# 0층 (입력 층)
x=np.array([[1,2]])
# 1층 (은닉 1층)
y=np.array([[1,3,5],[2,4,6]]) #1층의 가중치
y_hat=relu(np.dot(x,y))
# 2층 (은닉 2층)
k=np.array([[3,4],[5,6],[7,8]]) #2층의 가중치
k_hat=relu(np.dot(y_hat,k))
# 출력 층
j=np.array([[4,5],[6,7]]) #3층의 가중치
j_hat=np.dot(k_hat,j)
print(identify_func(j_hat))
문제63.
위의 3층 신경망에 활성화 함수를 relu 함수로 변경하시오
import numpy as np
def relu(x):
return np.where(x>0,x,0)
def identify_func(x):
return x
# 0층 (입력 층)
x=np.array([[1,2]])
# 1층 (은닉 1층)
y=np.array([[1,3,5],[2,4,6]]) #1층의 가중치
y_hat=relu(np.dot(x,y))
# 2층 (은닉 2층)
k=np.array([[3,4],[5,6],[7,8]]) #2층의 가중치
k_hat=relu(np.dot(y_hat,k))
# 출력 층
j=np.array([[4,5],[6,7]]) #3층의 가중치
j_hat=np.dot(k_hat,j)
print(identify_func(j_hat))
[[2088 2499]]
----------만약, np.where 함수 안쓰면 for문 돌려서 값하나씩 대입시켜줘야 하는데
relu(np.dot(_,_) 할때 ,for문 돌려서 계산시켜야 한다.
■ 3층 신경망
화면 캡처: 2019-01-11 오후 1:53
*3층 신경망의 가중치인 w1, w2, w3 을 하나로 모아서 심플하게 코드를 작성하려면?
"딕셔너리를 활용하면 된다"
예:
import numpy as np
network = {}
network['w1'] = np.array([[1,3,5],[2,4,6]])
network['w2'] = np.array([[3,4],[5,6],[7,8]])
network['w3'] = np.array([[4,5],[6,7]])
print(network.keys())
print(network.values())
dict_keys(['w1', 'w2', 'w3'])
dict_values([array([[1, 3, 5],
[2, 4, 6]]), array([[3, 4],
[5, 6],
[7, 8]]), array([[4, 5],
[6, 7]])])
-------------for문 돌리면
import numpy as np
network = {}
network['w1'] = np.array([[1,3,5],[2,4,6]])
network['w2'] = np.array([[3,4],[5,6],[7,8]])
network['w3'] = np.array([[4,5],[6,7]])
for i in network.keys():
print (i)
for i in network.values():
print (i)
w1
w2
w3
[[1 3 5]
[2 4 6]]
[[3 4]
[5 6]
[7 8]]
[[4 5]
[6 7]]
문제72.
위의 코드를 함수로 만들어서 아래와 같이 실행될 수 있게 하시오
def init_network():
import numpy as np
network = {}
network['w1'] = np.array([[1,3,5],[2,4,6]])
network['w2'] = np.array([[3,4],[5,6],[7,8]])
network['w3'] = np.array([[4,5],[6,7]])
return network
network = init_network() #함수를 변수에 담아서 쓸 수 있습니다
print(network['w1'])
[[1 3 5]
[2 4 6]]
■ 함수를 변수에 담아 사용하기
def other_method(a):
print(a)
val = other_method #함수를 val 라는 변수에 담는다
other_method(123)
val(123)
문제73.
위에서 만든 init_network() 함수안에 키 w1,w2,w3 의 값을
변수 w1,w2,w3 에 담으시오 !
def init_network():
import numpy as np
network = {}
network['w1'] = np.array([[1,3,5],[2,4,6]])
network['w2'] = np.array([[3,4],[5,6],[7,8]])
network['w3'] = np.array([[4,5],[6,7]])
return network
network = init_network()w1, w2, w3 = network['w1'], network['w2'], network['w3']
print(w1, w2, w3)
문제74.
위의 문제73번의 코드를 가지고 어제 만든 3차신경망 코드를 다시 작성하시오
(sigmoid 함수)
import numpy as np
def sigmoid(x):
return 1 / (1 + np.exp(-x)) #exp: np에서 로그화시키는 함수
def identify_func(x):
return x
def init_network():
import numpy as np
network = {}
network['w1'] = np.array([[1,3,5],[2,4,6]])
network['w2'] = np.array([[3,4],[5,6],[7,8]])
network['w3'] = np.array([[4,5],[6,7]])
return network
network = init_network()
w1, w2, w3 = network['w1'], network['w2'], network['w3']
# 0층 (입력 층)
x=np.array([[1,2]])
# 1층 (은닉 1층)
#y=np.array([[1,3,5],[2,4,6]]) #1층의 가중치
a1=sigmoid(np.dot(x,w1)) #예전 y값을 위 딕셔너리에서 w값을 가져온다.
# 2층 (은닉 2층)
#k=np.array([[3,4],[5,6],[7,8]]) #2층의 가중치
a2=sigmoid(np.dot(a1,w2))
# 출력 층
#j=np.array([[4,5],[6,7]]) #3층의 가중치
a3=np.dot(a2,w3)
print(identify_func(a3))
■ 신경망 안에 들어가는 함수들
1. 가중치(w)를 만드는 함수 : init_network()
2. 순전파 시키는 함수 : forward()
-> 입력*가중치 가 순전히 잘 흘러가게 해주는 함수(0->1->2->3층)
3. 역전파 시키는 함수 : backward()
4. 활성화 함수들(확률정해줌) : step, sigmoid, relu function
5. 출력층 함수들(답내려줌) : identify_function() -회귀분석 목적
softmax() -분류를 목적
6. 오차 함수들 : 평균오차함수(회귀분석),
교차엔트로피 함수(분류문제)
문제75.
입력층, 은닉1층, 은닉2층, 출력층 코드를 가지고
forward 라는 함수를 생성하시오
import numpy as np
def relu(x):
return np.where(x>0,x,0)
def sigmoid(x):
return 1 / (1 + np.exp(-x)) #exp: np에서 로그화시키는 함수
def identify_func(x): #항등함수
return x
def init_network(): #가중치 생성 함수
import numpy as np
network = {}
network['w1'] = np.array([[1,3,5],[2,4,6]])
network['w2'] = np.array([[3,4],[5,6],[7,8]])
network['w3'] = np.array([[4,5],[6,7]])
return network
def forward(network,x): #순전파 함수
w1, w2, w3 = network['w1'], network['w2'], network['w3']
# 1층 (은닉 1층)
a1=sigmoid(np.dot(x,w1))
# 2층 (은닉 2층)
a2=sigmoid(np.dot(a1,w2))
# 출력 층
a3=np.dot(a2,w3)
return identify_func(a3)
network = init_network() # 가중치 생성
x=np.array([[1,2]]) # 0층 (입력 층), #입력값
print( forward( network, x) ) #순전파
문제76.
입력값이 1,2 가 아니라 4,5 일때의 위의 3층 신경망을 통과한 결과를 아래와 같이
출력되게 하시오
import layers_3 as lay
import numpy as np # 입력층에서 np 쓰니까
network = lay.init_network() # 가중치 생성
x=np.array([[4,5]]) # 0층 (입력 층), #입력값
print( lay.forward( network, x) ) #순전파
==================================
from 으로 불러오면 위 코드처럼 일일이 lay를 안붙여도 된다 !!!!
from layers_3 import *
import numpy as np
network = init_network() # 가중치 생성
x=np.array([[4,5]]) # 0층 (입력 층), #입력값
print( forward( network, x) ) #순전파
■ 출력층 함수: 소프트맥스함수(p91)
"분류를 위한 출력층 함수인데 0~1 사이의 숫자를 출력하는 함수"
"순전파로 흘러왔던 확률(숫자)을 가지고 결론을 내주는 함수"
결론이 뭐냐면? 개와 고양이 분류라면 개인지 고양이인지 결론을 내준다.
정상폐, 폐결정, 폐결핵 3개 중 어떤 사진인지 결론을 내야한다면
이 3개 중 한 가지로 결론을 내려주는 함수
※ 소프트맥스 공식
import numpy as np
print( np.exp(0.4)/( np.exp(0.4) + np.exp(0.9) ) )
print( np.exp(0.9)/( np.exp(0.4) + np.exp(0.9) ) )
print( 0.3775 + 0.6224 )
0.377540668798
0.622459331202
0.9999
위 공식을 파이썬으로 구현해보니, 작은값은 출력가능하다.
※ 소프트맥스 함수 수학식을 컴퓨터코드로 구현할 때 주의사항?
소프트맥스 함수는 지수 함수를 사용하는데 이 지수함수라는 것이
쉽게 아주 큰 값을 내뱉는다.
e ( 스위스의 수학자 오일러가 발견한 무리수 )의 10승은
20,000 이 넘고 e의 100승은 숫자가 40개가 넘고
e의 1000승은 무한대를 뜻하는 inf 가 출력되어 돌아오므로
컴퓨터로 계산을 할 수가 없다.
import numpy as np
print( np.exp(1) )
print( np.exp(1000) )
결과:
2.71828182846
inf
__main__:4: RuntimeWarning: overflow encountered in exp
문제77.
아래의 리스트를 무리수(자연상수)의 제곱으로 해서
계산한 값이 무엇인가?
import numpy as np
a = np.array([1010,1000,990])
print(np.exp(a))
[ inf inf inf]
이렇게 숫자가 크면 inf가 떠서
뭐가 개고 뭐가 고양이인지 알 수가 없다.
문제78.
a = np.array([1010,1000,990])
a 리스트에서 각 요소값을 가장 큰 요소의 값으로 뺀 결과를 출력하시오
※ 힌트 : np.max( )
import numpy as np
a = np.array([1010,1000,990])
c = np.max(a)
print( (a-c) )
[ 0 -10 -20]
이제 exp 처리 해보면
print(np.exp(a-c))
[ 1.00000000e+00 4.53999298e-05 2.06115362e-09]
문제79. 위의 [ 0 -10 -20] 을 자연상수 e의 제곱으로 해서
출력된 결과가 무엇인지 확인하시오
import numpy as np
a = np.array([1010,1000,990])
c = np.max(a)
print( np.exp(a-c) )
[ 1.00000000e+00 4.53999298e-05 2.06115362e-09]
문제80.
위의 코드를 softmax 라는 함수 이름으로 만드시오
(분자식 만드는 공식)
import numpy as np
a = np.array([1010,1000,990])
def softmax(a):
c = np.max(a)
return np.exp(a-c)
print(softmax(a))
※ 출력값의 최대값으로 C값을 주고
그걸 빼줌으로서 softmax의 계속 커지는 성질을 죽여준다.
문제81.
위 문제80번의 분자구하는 공식에다 분모구하는 공식까지 더해서
softmax 함수를 완성 시키시오
import numpy as np
a = np.array([1010,1000,990])
def softmax(a):
c = np.max(a)
return np.exp(a-c) / np.sum( np.exp(a - c) )
print(softmax(a))
[ 9.99954600e-01 4.53978686e-05 2.06106005e-09]
문제82.(오늘의 마지막 문제)
위의 출력된 결과의 합이 1인지 확인하시오 !
[오전에 푼 알고리즘 문제랑 같이 글게재]
import numpy as np
a = np.array([1010,1000,990])
def softmax(a):
c = np.max(a)
return np.exp(a-c) / np.sum( np.exp(a - c) )
print(np.sum( softmax(a)) )
1.0
■ 출력층 softmax 함수 재정리
출력층 함수 2가지?
1. 항등함수
2. 소프트맥스 함수
역할: 0~1사이의 값을 나타내서 가장 확률이 높은것이 무엇인지
결론을 내려주는 역할
정상폐 1.2 0.46
폐결절 0.9 ===>소프트맥스===> 0.34
폐결핵 0.4 0.20
*다 더하면 1
"정상폐를 보고 정상폐 일 확률이 가장 높다라고 결론을 내려줬다."
문제91. 문제75번까지 해서 만들었던 3층 신경망(항등함수로 구현된)의
출력층 함수를 소프트맥스 함수로 변경하시오
layers_3 패키지 불러와서
softmax 함수 집어넣어서 값 바꿔주기
↓↓↓↓↓↓↓↓↓↓↓
import numpy as np
def relu(x):
return np.where(x>0,x,0)
def sigmoid(x):
#import numpy as np
return 1 / (1 + np.exp(-x)) #exp: np에서 로그화시키는 함수
def softmax(x):
c = np.max(x)
return np.exp(x-c) / np.sum( np.exp(x - c) )
#def identify_func(x):
# return x
def init_network():
#import numpy as np
network = {}
network['w1'] = np.array([[1,3,5],[2,4,6]])
network['w2'] = np.array([[3,4],[5,6],[7,8]])
network['w3'] = np.array([[4,5],[6,7]])
return network
def forward(network,x):
#import numpy as np
w1, w2, w3 = network['w1'], network['w2'], network['w3']
# 1층 (은닉 1층)
a1=sigmoid(np.dot(x,w1))
# 2층 (은닉 2층)
a2=sigmoid(np.dot(a1,w2))
# 출력 층
a3=np.dot(a2,w3)
return softmax(a3)
network = init_network() # 가중치 생성
x=np.array([[4,5]]) # 0층 (입력 층), #입력값
#print( forward( network, x) ) #순전파
============================
from layers_3 import *
import numpy as np
network = init_network() # 가중치 생성
x=np.array([[1,2]]) # 0층 (입력 층), #입력값
print( forward( network, x) ) #순전파
■ mnist 구현
※ p.95
신경망 학습 --------->소프트맥스 함수를 사용한다
(추론)테스트-----------> 소프트맥스 함수를 사용하지 않는다
*자원낭비를 줄이려고
■ 출력층의 뉴런 수 구하기
출력층의 뉴런 수?
1. 분류하고자 하는 사진- 개, 고양이 분류 -----------> 2개
2. 분류하고자 하는 사진- 정상폐, 폐결절, 폐결핵--> 3개
3. mnist 데이터(필기체 숫자 0~9 까지의 사진)-----> 10개
■ mnist(손글씨 필기체) 데이터를 파이썬으로 로드하는 방법
1. 책 소스코드와 데이터를 다운로드 받는다.(dataset.zip)
2. dataset 이라는 폴더를 working 디렉토리에 가져다 둔다
(실행하는 소스가 있는 디렉토리)
3. 아래의 파이썬 코드를 실행해서 필기체 데이터 하나를 시각화 한다
↓↓↓↓↓↓↓
# coding: utf-8
import sys, os
sys.path.append(os.pardir) # 부모디렉토리의 파일을 가져올수
# 있도록 설정
import numpy as np
from dataset.mnist import load_mnist
#dataset 에 load_mnist 갖고오시오
#mnist 데이터셋을 내려받아 이미지를 넘파이 배열로 변환해주는
#파이썬 스크립트를 제공합니다
from PIL import Image
def img_show(img): # 이미지를 출력하는 함수
pil_img = Image.fromarray(np.uint8(img))
# 파이썬 이미지 객체로 변환
pil_img.show() # pil_img 객체의 show 라는 메소드를 실행
(x_train, t_train), (x_test, t_test) = load_mnist(flatten=True, normalize=False)
#훈련데이터 , 테스트 데이터
# x_train = 60000
# t_train = label
# x_test = 10000
# t_test = label
# flatten = True 는 일렬로 죽 늘어놓겠다
#그래서 일렬로 계속 숫자를 늘여놓게 된다( 1 차원 화)
img = x_train[0] # 0~59999로 숫자 바꿀 수 있다
label = t_train[0] # 0~59999 로 숫자 바꿀 수 있다
print(label) # 5
print(img.shape) # (784,)
img = img.reshape(28, 28)
img_show(img)
===========================
print(x_train.shape) #60000
print(t_train.shape)
print(x_test.shape)
print(t_test.shape)
(60000, 784)
(60000,)
(10000, 784)
(10000,)
색이 진하면 숫자가 높고
색이 옅으면 0에 가까워 진다
출력층은 필기체수 10개고
입력층은 픽셀수 784개다.
문제92.
아래의 코드의 dataset 패키지의 mnist.py 에 load_mnist 라는 함수가 있는지
확인하시오
*파이참에서는 ctrl 키를 누르고 아래의 코드중에 load_mnist 에
마우스를 가져다대면 바로 볼 수 있다*
# coding: utf-8
import sys, os
sys.path.append(os.pardir) # 부모디렉토리의 파일을 가져올수
# 있도록 설정
import numpy as np
from dataset.mnist import load_mnist
#dataset 에 load_mnist 갖고오시오
#mnist 데이터셋을 내려받아 이미지를 넘파이 배열로 변환해주는
#파이썬 스크립트를 제공합니다
from PIL import Image
def img_show(img): # 이미지를 출력하는 함수
pil_img = Image.fromarray(np.uint8(img))
# 파이썬 이미지 객체로 변환
pil_img.show() # pil_img 객체의 show 라는 메소드를 실행
(x_train, t_train), (x_test, t_test) = load_mnist(flatten=True, normalize=False)
#훈련데이터 , 테스트 데이터
# x_train = 60000
# t_train = label
# x_test = 10000
# t_test = label
# flatten = True 는 일렬로 죽 늘어놓겠다. 1차원 나오고 값은 784
img = x_train[0] # 1로 숫자 바꾸면 0 나온다.
label = t_train[0] # 1로 숫자 바꾸면 0 나온다.
print(label) # 5
print(img.shape) # (784,)
img = img.reshape(28, 28)
img_show(img)
문제93. x_train 을 프린트 해보시오
print(x_train.shape) # 60000,784
print(x_train)
[[0 0 0 ..., 0 0 0] -----> 784개의 열
[0 0 0 ..., 0 0 0] ↓ 60,000개의 행
[0 0 0 ..., 0 0 0]
...,
[0 0 0 ..., 0 0 0]
[0 0 0 ..., 0 0 0]
[0 0 0 ..., 0 0 0]]
문제94. x_train 의 데이터가 6만장이 맞는지 확인하시오
print(x_train.shape) # 60000,784
print(len(x_train)) # 60000 (행의 갯수)
차원수는
print(x_train.ndim) # 2차원
문제95. 아래의 리스트를 numpy array 리스트로 변경하시오 !
x = [[0.1,0.05,0.1,0.0,0.05,0.1,0.0,0.1,0.0,0.0],
[0.1,0.05,0.2,0.0,0.05,0.1,0.0,0.6,0.0,0.0],
[0.0,0.05,0.3,0.0,0.05,0.1,0.0,0.6,0.0,0.0],
[0.0,0.05,0.4,0.0,0.05,0.0,0.0,0.5,0.0,0.0],
[0.0,0.05,0.5,0.0,0.05,0.0,0.0,0.4,0.0,0.0],
[0.0,0.05,0.6,0.0,0.05,0.0,0.0,0.3,0.0,0.0],
[0.0,0.05,0.7,0.0,0.05,0.0,0.0,0.2,0.0,0.0],
[0.0,0.1,0.8,0.0,0.1,0.0,0.0,0.2,0.0,0.0],
[0.0,0.05,0.9,0.0,0.05,0.0,0.0,0.0,0.0,0.0]]
import numpy as np
print(np.array(x))
결과:
[[ 0.1 0.05 0.1 0. 0.05 0.1 0. 0.1 0. 0. ]
[ 0.1 0.05 0.2 0. 0.05 0.1 0. 0.6 0. 0. ]
[ 0. 0.05 0.3 0. 0.05 0.1 0. 0.6 0. 0. ]
[ 0. 0.05 0.4 0. 0.05 0. 0. 0.5 0. 0. ]
[ 0. 0.05 0.5 0. 0.05 0. 0. 0.4 0. 0. ]
[ 0. 0.05 0.6 0. 0.05 0. 0. 0.3 0. 0. ]
[ 0. 0.05 0.7 0. 0.05 0. 0. 0.2 0. 0. ]
[ 0. 0.1 0.8 0. 0.1 0. 0. 0.2 0. 0. ]
[ 0. 0.05 0.9 0. 0.05 0. 0. 0. 0. 0. ]]
문제96. 위의 numpy array 로 변경한 리스트의 차원을 확인하시오
(그냥 리스트 x 일때는 차원값 못 구함)
x = [[0.1,0.05,0.1,0.0,0.05,0.1,0.0,0.1,0.0,0.0],
[0.1,0.05,0.2,0.0,0.05,0.1,0.0,0.6,0.0,0.0],
[0.0,0.05,0.3,0.0,0.05,0.1,0.0,0.6,0.0,0.0],
[0.0,0.05,0.4,0.0,0.05,0.0,0.0,0.5,0.0,0.0],
[0.0,0.05,0.5,0.0,0.05,0.0,0.0,0.4,0.0,0.0],
[0.0,0.05,0.6,0.0,0.05,0.0,0.0,0.3,0.0,0.0],
[0.0,0.05,0.7,0.0,0.05,0.0,0.0,0.2,0.0,0.0],
[0.0,0.1,0.8,0.0,0.1,0.0,0.0,0.2,0.0,0.0],
[0.0,0.05,0.9,0.0,0.05,0.0,0.0,0.0,0.0,0.0]]
import numpy as np
print(np.array(x).ndim)
2
문제97. 위의 리스트를 1차원으로 변경하시오
x = [[0.1,0.05,0.1,0.0,0.05,0.1,0.0,0.1,0.0,0.0],
[0.1,0.05,0.2,0.0,0.05,0.1,0.0,0.6,0.0,0.0],
[0.0,0.05,0.3,0.0,0.05,0.1,0.0,0.6,0.0,0.0],
[0.0,0.05,0.4,0.0,0.05,0.0,0.0,0.5,0.0,0.0],
[0.0,0.05,0.5,0.0,0.05,0.0,0.0,0.4,0.0,0.0],
[0.0,0.05,0.6,0.0,0.05,0.0,0.0,0.3,0.0,0.0],
[0.0,0.05,0.7,0.0,0.05,0.0,0.0,0.2,0.0,0.0],
[0.0,0.1,0.8,0.0,0.1,0.0,0.0,0.2,0.0,0.0],
[0.0,0.05,0.9,0.0,0.05,0.0,0.0,0.0,0.0,0.0]]
import numpy as np
a = np.array(x)
a2 = a.flatten()
print(a2.ndim)
문제98. mnist 데이터를 load_mnist 함수로 로드할 때 flatten을 false로 해서
로드하고 훈련 데이터의 shape를 확인해보시오
import sys, os
sys.path.append(os.pardir) # 부모디렉토리의 파일을 가져올수
# 있도록 설정
import numpy as np
from dataset.mnist import load_mnist
from PIL import Image
def img_show(img): # 이미지를 출력하는 함수
pil_img = Image.fromarray(np.uint8(img))
# 파이썬 이미지 객체로 변환
pil_img.show() # pil_img 객체의 show 라는 메소드를 실행
(x_train, t_train), (x_test, t_test) = load_mnist(flatten=False, normalize=False)
print(x_train.shape)
print(t_train.shape)
print(x_test.shape)
print(t_test.shape)
(60000, 1, 28, 28) # False 하니까 4차원으로 바뀌었다.
↑ ↑ ↑ ↑
전체장수 흑백 가로 세로
※컬러면? RGB 값으로 해서 1있는 자리에 3 이 출력됨
(60000,)
(10000, 1, 28, 28)
(10000,)
문제99. x_train[0] 이 숫자 5였는데 x_train[0] 의 라벨(정답)인
t_train[0] 을 출력해서 숫자 5가 맞는지 확인하시오 !
img = x_train[0]
label = t_train[0]
print(t_train[0]) <-여기만 바꿔줌
문제100.
t_train 데이터를 출력할 때 one_hot_encoding 을 True 로 해서 출력하시오
img = x_train[0]
label = t_train[0]
print(t_train[0])
[ 0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]
0 1 2 3 4 5 6 7 8 9
5에서 True 값 1이 나온걸 볼 수 있다.
문제101.
mnist 데이터를 가져오는 코드를 가지고
아래의 get_data() 함수를 생성하고 아래와 같이 실행되게 하시오
x , t = get_data()
print(x.shape) # (10000 , 784)
print(t.shape) # (10000, )
--------------------------------------------------------
import sys, os
sys.path.append(os.pardir) # 부모디렉토리의 파일을 가져올수
# 있도록 설정
import numpy as np
from dataset.mnist import load_mnist
from PIL import Image
def get_data():
(x_train, t_train), (x_test, t_test) =\
load_mnist(flatten=True, normalize=True, one_hot_label=False)
return x_test, t_test
(x , t) = get_data()
print(x.shape)
print(t.shape)
■ 필기체 데이터 60000장을 충분히 학습시키고 만들어 낸 가중치값(저자가 미리 생성함)
init_network 함수로 가져오는 방법
import pickle
def init_network():
with open("C:\\Users\itwill\sample_weight\sample_weight.pkl",'rb') as f:
network = pickle.load(f)
return network
network = init_network()
print(network['W1'].shape)
(784, 50)
*훈련 데이터의 행렬모습이 60000 * 784 임을 확인한다
print(x_train.shape) # 60000, 784
*훈련 데이터 각각의 가중치값을 확인하시오
import pickle
def init_network():
with open("C:\\Users\itwill\sample_weight\sample_weight.pkl",'rb') as f:
network = pickle.load(f)
return network
network = init_network()
print(network['W1'].shape) #784*50
print(network['W2'].shape) #50*100
print(network['W3'].shape) #100*10 (출력층 10개와 맞추고 있다)
(784, 50) #내적을 위해 열값이 일치하는것을 확인할 수 있다.
(50, 100)
(100, 10)
#바이어스를 보면 (->바이어스는 x0*w0 했던거. 이게 합해져서 함수처리가는거)
#바이어스는 은닉층 노드의 갯수
print(network['b1'].shape)
print(network['b2'].shape)
print(network['b3'].shape)
(50,)
(100,)
(10,)
■ 저자가 이미 최적화 해놓은 w1, w2, w3, b1, b2, b3를 가지고 만든
3층 신경망 코드
import sys, os
sys.path.append(os.pardir)
import numpy as np
from dataset.mnist import load_mnist
from PIL import Image
import pickle
import numpy as np
# 신경망 함수들
def sigmoid(num):
rst = (1 / (1 + np.exp(-num)))
return (rst)
def identity_function(x):
return x
def softmax(a):
c = np.max(a)
minus = a - c
exp_a = np.exp(minus)
sum_exp_a = np.sum(exp_a)
y = exp_a / sum_exp_a
return y
def init_network():
with open("sample_weight.pkl",'rb') as f:
network = pickle.load(f)
return network
def predict(network, x): #우리가 만들었던 forward랑 같음
W1, W2, W3 = network['W1'], network['W2'], network['W3']
b1, b2, b3 = network['b1'], network['b2'], network['b3']
a1 = np.dot(x,W1) + b1
z1 = sigmoid(a1)
a2 = np.dot(z1,W2) + b2
z2 = sigmoid(a2)
a3 = np.dot(z2,W3) + b3
y = softmax(a3)
return y
def get_data(): #mnist 시키는 함수
(x_train, t_train) , (x_test, t_test) = \
load_mnist(normalize=True, flatten=True, one_hot_label=False)
return x_test, t_test #1만장 행렬, 1만장의 라벨
#flatten 으로 28*28=784를 일렬러 풀어해침
x, t = get_data()
network = init_network() #피클가중치 불러와서 network 라고 선언
y = predict(network,x[0]) # 숫자 5
print(y)
결과:
[ 8.44125680e-05 2.63506809e-06 7.15495204e-04 1.25862740e-03
1.17279649e-06 4.49908512e-05 1.62693183e-08 9.97065008e-01
9.37448840e-06 8.18311993e-04]
※소프트맥스를 거쳐나온 값이기에 다 합하면 1.0 이다
여기서 가장 확률 높은값만 보려면 p.101 나온 np.argmax() 함수를 이용한다
y = predict(network,x[0])
y = np.argmax(y)
print(y)
결과: 7
라벨값도 보려면
print(t[0])
결과 : 7
->라벨값도 똑같이 7 나오는걸 확인할 수 있다.
문제102.(오늘의 마지막 문제)
그림판에서 만든 28*28 픽셀의 숫자를 flatten 된 numpy 배열로 만드시오
#1. 흑백으로 변경
j = 'C:\\Users\\itwill\\number_paint.jpg' #역슬래시 2개씩 안쓰면 에러뜸
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
def rgb2gray(rgb):
return np.dot(rgb[...,:3], [0.299, 0.587, 0.114])
img = mpimg.imread(j)
gray = rgb2gray(img)
plt.imshow(gray, cmap = plt.get_cmap('gray'))
plt.show()
print(gray.shape)
#2. 입력값으로 쓰이기 위해 (784,) 로 변경해줌
a = np.array(gray)
x= a.flatten()
print(x.shape)
#3. 신경망에 넣어줌
import sys, os
sys.path.append(os.pardir)
import numpy as np
from dataset.mnist import load_mnist
from PIL import Image
import pickle
import numpy as np
# 신경망 함수들
def sigmoid(num):
rst = (1 / (1 + np.exp(-num)))
return (rst)
def identity_function(x):
return x
def softmax(a):
c = np.max(a)
minus = a - c
exp_a = np.exp(minus)
sum_exp_a = np.sum(exp_a)
y = exp_a / sum_exp_a
return y
def init_network():
with open("C:\\Users\itwill\sample_weight\sample_weight.pkl",'rb') as f:
network = pickle.load(f)
return network
def predict(network, x):
W1, W2, W3 = network['W1'], network['W2'], network['W3']
b1, b2, b3 = network['b1'], network['b2'], network['b3']
a1 = np.dot(x,W1) + b1
z1 = sigmoid(a1)
a2 = np.dot(z1,W2) + b2
z2 = sigmoid(a2)
a3 = np.dot(z2,W3) + b3
y = softmax(a3)
return y
def get_data():
(x_train, t_train) , (x_test, t_test) = \
load_mnist(normalize=True, flatten=True, one_hot_label=False)
return x_test, t_test
#x, t = get_data() #우리가 손으로 그린 그림 넣어야 되니까
#위 get_data 함수도 안 씀. mnist 안쓰고
#우리가 만든 그림으로 학습시키니까.
network = init_network()
y = predict(network,x)
y = np.argmax(y)
print(y)
#print(t[0])
다시 짚어보기:
3장. 3층 신경망 구현하는 방법
-활성화 함수
1. sigmoid 함수
2. relu 함수
3. step 함수
-출력층 함수
1. 항등함수
2. 소프트맥스 함수
-오차함수
필기체를 인식하는 3층 신경망을 구현
■ 오차함수를 이해하기 위해 기본적으로 알아야할 파이썬 문법
↓
신경망의 정확도를 출력하기 위해 기본적으로 알아야 하는 파이썬 문법
오차함수? 예측값과 실제값의 차이를 구하는 함수
문제116.
아래의 10개의 원소를 갖는 x라는 리스트를 만들고
x리스트에 가장 큰 원소가 몇 번째 인덱스인지 알아내시오
import numpy as np
x= [0.05, 0.01, 0.02, 0.1, 0.2, 0.3, 0.4, 0.05, 0.04]
print(x.index(max(x)))
또는(행렬로 해서)
x= np.array(x)
print(np.argmax(x, axis=0)) # axis 왜 쓴거지 ( 열 자리에서 최대값 갖고오란 말 )
문제117.
아래의 리스트를 numpy array 리스트로 만들고
shape으로 몇 행렬을 확인하시오
x = [[0.1,0.05,0.1,0.0,0.05,0.1,0.0,0.1,0.0,0.0],
[0.1,0.05,0.2,0.0,0.05,0.1,0.0,0.6,0.0,0.0],
[0.0,0.05,0.3,0.0,0.05,0.1,0.0,0.6,0.0,0.0],
[0.0,0.05,0.4,0.0,0.05,0.0,0.0,0.5,0.0,0.0],
[0.0,0.05,0.5,0.0,0.05,0.0,0.0,0.4,0.0,0.0],
[0.0,0.05,0.6,0.0,0.05,0.0,0.0,0.3,0.0,0.0],
[0.0,0.05,0.7,0.0,0.05,0.0,0.0,0.2,0.0,0.0],
[0.0,0.1,0.8,0.0,0.1,0.0,0.0,0.2,0.0,0.0],
[0.0,0.05,0.9,0.0,0.05,0.0,0.0,0.0,0.0,0.0],
[0.0,0.05,0.6,0.0,0.05,0.0,0.0,0.3,0.0,0.0] ]
y = np.array(x)
print(y.shape)
(10, 10)
문제118.
아래의 10행 10열 행렬에서 각 행에서 가장 큰 원소가 몇 번째 있는지
출력하시오
x = [[0.2,0.05,0.1,0.0,0.05,0.0,0.0,0.1,0.0,0.0],
[0.1,0.05,0.2,0.0,0.05,0.1,0.0,0.6,0.0,0.0],
[0.0,0.05,0.3,0.0,0.05,0.1,0.0,0.6,0.0,0.0],
[0.0,0.05,0.4,0.0,0.05,0.0,0.0,0.5,0.0,0.0],
[0.0,0.05,0.5,0.0,0.05,0.0,0.0,0.4,0.0,0.0],
[0.0,0.05,0.6,0.0,0.05,0.0,0.0,0.3,0.0,0.0],
[0.0,0.05,0.7,0.0,0.05,0.0,0.0,0.2,0.0,0.0],
[0.0,0.1,0.8,0.0,0.1,0.0,0.0,0.2,0.0,0.0],
[0.0,0.05,0.9,0.0,0.05,0.0,0.0,0.0,0.0,0.0],
[0.0,0.05,0.6,0.0,0.05,0.0,0.0,0.3,0.0,0.0] ]
y = np.array(x)
print(y.shape)
print(np.argmax(x, axis=1)) #행에서 큰 값 뽑아야 하니까 axis = 1
[0 7 7 7 2 2 2 2 2 2]
※ 설명:
axis = 0 :열
axis = 1 : 행
문제119.
테스트 데이터 하나 x[34] 의 필기체의 라벨이 무엇인지 확인하시오
힌트 : x, t = get_data()
print(x.shape)
import sys, os
sys.path.append(os.pardir) # 부모디렉토리의 파일을 가져올수
# 있도록 설정
import numpy as np
from dataset.mnist import load_mnist
from PIL import Image
def get_data():
(x_train, t_train), (x_test, t_test) =\
load_mnist(flatten=True, normalize=True, one_hot_label=False)
return x_test, t_test #x_test = 입력, t_test = 라벨
(x , t) = get_data()
print(t[34])
print(x.shape)
print(t.shape)
7
(10000, 784)
(10000,)
문제120.
테스트 데이터 하나인 x[34] 의 필기체를 신경망에 넣고
신경망이 예측한 것과 라벨이 서로 일치하는지 확인하시오
import sys, os
sys.path.append(os.pardir)
import numpy as np
from dataset.mnist import load_mnist
from PIL import Image
import pickle
import numpy as np
# 신경망 함수들
def sigmoid(num):
rst = (1 / (1 + np.exp(-num)))
return (rst)
def identity_function(x):
return x
def softmax(a):
c = np.max(a)
minus = a - c
exp_a = np.exp(minus)
sum_exp_a = np.sum(exp_a)
y = exp_a / sum_exp_a
return y
def init_network():
with open("C:\\Users\itwill\sample_weight\sample_weight.pkl",'rb') as f:
network = pickle.load(f)
return network
def predict(network, x):
W1, W2, W3 = network['W1'], network['W2'], network['W3']
b1, b2, b3 = network['b1'], network['b2'], network['b3']
a1 = np.dot(x,W1) + b1
z1 = sigmoid(a1)
a2 = np.dot(z1,W2) + b2
z2 = sigmoid(a2)
a3 = np.dot(z2,W3) + b3
y = softmax(a3)
return y
def get_data():
(x_train, t_train) , (x_test, t_test) = \
load_mnist(normalize=True, flatten=True, one_hot_label=False)
return x_test, t_test
x, t = get_data()
network = init_network()
y = predict(network,x[34])
print(np.argmax(y))
print(t[34])
print(7==7)
7
7
True
문제121.
위의 코드에 for loop 문을 입혀서 테스트 데이터 10000장을 위의 3층 신경망에 넣고
10000장 중 몇 장을 3층 신경망이 맞추는지 확인하시오
구현결과 : 9352
import sys, os
sys.path.append(os.pardir)
import numpy as np
from dataset.mnist import load_mnist
from PIL import Image
import pickle
import numpy as np
# 신경망 함수들
def sigmoid(num):
rst = (1 / (1 + np.exp(-num)))
return (rst)
def identity_function(x):
return x
def softmax(a):
c = np.max(a)
minus = a - c
exp_a = np.exp(minus)
sum_exp_a = np.sum(exp_a)
y = exp_a / sum_exp_a
return y
def init_network():
with open("C:\\Users\itwill\sample_weight\sample_weight.pkl",'rb') as f:
network = pickle.load(f)
return network
def predict(network, x):
W1, W2, W3 = network['W1'], network['W2'], network['W3']
b1, b2, b3 = network['b1'], network['b2'], network['b3']
a1 = np.dot(x,W1) + b1
z1 = sigmoid(a1)
a2 = np.dot(z1,W2) + b2
z2 = sigmoid(a2)
a3 = np.dot(z2,W3) + b3
y = softmax(a3)
return y
def get_data():
(x_train, t_train) , (x_test, t_test) = \
load_mnist(normalize=True, flatten=True, one_hot_label=False)
return x_test, t_test
x, t = get_data()
network = init_network()
cnt=0
for i in range(10000):
y = predict(network,x[i]) # predict 함수가 소프트맥스 처리해서 y값 리턴
if np.argmax(y) == t[i]: # y에서 argmax 처리해서 확률높은 값을 갖고온다
cnt+=1
print(cnt)
#print(np.argmax(y))
#print(t[34])
문제122.
위의 결과가 9352 가 아니라 아래와 같이 정확도로 출력되게 하시오
정확도 : 0.9352
cnt=0
for i in range(10000):
y = predict(network,x[i])
if np.argmax(y) == t[i]:
cnt+=1
print("정확도:",cnt*0.0001) #토탈이 10000장 이니까
p.101 보면
↓↓↓↓↓↓↓↓↓↓↓↓↓↓
cnt=0
for i in range(len(x)):
y = predict(network,x[i])
if np.argmax(y) == t[i]:
cnt+=1
print("정확도:",cnt/len(x))
■ 배치처리 (p.102)
"신경망에 데이터 입력시 배치(batch)로 입력하는 방법"
"이미지를 한 장씩 처리하는 게 아니라 여러장을 한 번에 처리"
1. 이미지를 한 장씩 처리한 신경망
p.103 에 그림 3-26
2. 이미지를 100장씩 처리한 신경망
*60000장의 사진을 학습시키려면 위 과정을 600번 돌리면 된다.
■ 배치로 신경망을 학습 시키기 위한 코드를 이해하기 위해
기본적으로 알아야하는 파이썬 코드 연습
문제123.
아래의 결과를 출력하시오
결과: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
result = [ i for i in range(10) ]
print(result)
또 다른방법
y = list(range(10))
print(y)
문제124.
아래의 결과를 출력하시오
결과: [0, 3, 6, 9]
result = [i for i in range(10)]
print(result[0::3])
y = list(range(0,10,3))
print(y)
문제125.
아래의 리스트에서 최대값의 원소 인덱스를 출력하시오
결과: 3
import numpy as np
y = list(range(0,10,3))
print(y.index(max(y)))
또는
y = list(range(0,10,3))
y = np.array(y)
print(np.argmax(y))
문제126.
아래의 행렬을 numpy 배열 4*3행렬로 생성하시오
import numpy as np
x = [0.1, 0.8, 0.1, 0.3, 0.1, 0.6, 0.2, 0.5, 0.3, 0.8, 0.1, 0.1]
x = np.array(x)
x = x.reshape(4,3)
print(x)
[[ 0.1 0.8 0.1]
[ 0.3 0.1 0.6]
[ 0.2 0.5 0.3]
[ 0.8 0.1 0.1]]
문제127.
numpy의 argmax 를 이용해서 아래의 행렬에서 행 중에
최대값 원소의 인덱스를 출력하시오
import numpy as np
x = [0.1, 0.8, 0.1, 0.3, 0.1, 0.6, 0.2, 0.5, 0.3, 0.8, 0.1, 0.1]
x = np.array(x)
x = x.reshape(4,3)
print( np.argmax( x , axis=1 ) )
[1 2 1 0]
*axis = 1 은 행
문제128.
아래의2개의 리스트를 만들고 서로 같은 자리에 같은 숫자가 몇 개가 있는지
출력하시오
import numpy as np
x = [2,1,3,5,1,4,2,1,1,0]
y = [2,1,3,4,5,4,2,1,1,2]
result = [ 1 if i1==i2 else 0 for i1, i2 in zip(x,y) ]
print(sum(result))
또다른방법
import numpy as np
x = [2,1,3,5,1,4,2,1,1,0]
y = [2,1,3,4,5,4,2,1,1,2]
x = np.array(x)
y = np.array(y)
print(x==y)
print( np.sum(x==y) )
문제129.
아래의 리스트를 x라는 변수에 담고 앞에 5개의 숫자만 출력하시오
결과: [7, 3, 2, 1, 6]
x = [7,3,2,1,6,7,7,8,2,4]
print(x[:5])
문제130.
결과: [100,200,300,400,.......10000]
result = [i for i in range(100,10001,100)]
print(result)
또 다른 답
import numpy as np
print(np.arange(100,10001,100)) #콤마없이 출력됨
문제131.
아래의 코드를 mnist 의 훈련 데이터를 100개씩 가져오는 코드로 작성하시오
1 장씩 신경망에 입력하는 코드
↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
x, t = get_data()
network = init_network()
for i in range(10000):
y = predict(network,x[i])
print(len(y))
100장씩 신경망에 입력하는 코드
↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
x, t = get_data()
network = init_network()
batch_size = 100
for i in range(0,len(x),batch_size):
x_batch = x[i:i+batch_size]
print(len(x_batch))
※ 설명:
0~99
100~199
200~299
300~399
:
:
9900~9999
문제132.
100개씩 가지고 온 훈련 데이터를 predict 함수에 입력해서 예측숫자 100개를
출력하는 코드를 작성하시오
x, t = get_data()
network = init_network()
batch_size = 100
for i in range(0,len(x),batch_size):
x_batch = x[i:i+batch_size]
#print(len(x_batch))
y_batch=predict(network, x_batch)
print(len(y_batch))
결과:
100
100
100
:
:
100
문제133.
위의 코드에서 y_batch 의 shape 를 확인하시오
100*10 의 shape 를 갖는 y_batch 에서 행의 최대값의 원소의 인덱스를
np.argmax 이용해서 출력하시오
x, t = get_data()
network = init_network()
batch_size = 100
for i in range(0,len(x),batch_size):
x_batch = x[i:i+batch_size]
print(len(x_batch))
y_batch=predict(network, x_batch)
print(y_batch.shape)
(100, 10) 100행 10열
***출력층이 10이라서 10열
--> 10개씩 값이 들어있는 행이 100개씩 출력되는데
(총 1만장이니까) 그렇게 100번 출력된다.
x, t = get_data()
network = init_network()
batch_size = 100
for i in range(0,len(x),batch_size):
x_batch = x[i:i+batch_size]
print(len(x_batch))
y_batch=predict(network, x_batch)
print(np.argmax(y_batch,axis=1))
# 10개 값 들어있는 하나의 행에서 최대값 뽑음.
#그렇게 100개가 루프 1번임
# X는 10000개 니까
# 100개가 100번 출력됨
print(y_batch.shape)
문제134.(오늘의 마지막 문제)
위의 예측한 100개의 숫자와 실제 숫자(라벨)와 비교해서 정확도를 출력하시오
힌트1:
x, t = get_data()
t_batch = t[i:i+batch_size]
힌트2:
[2,1,3,5,1,........,4,2,1,1,0] # 100개의 예측 숫자
[2,3,2,5,1,........,5,2,1,1,2] # 100개의 실제 숫자(라벨)
print(x==y)
print(np.sum(x==y)
import sys, os
sys.path.append(os.pardir)
import numpy as np
from dataset.mnist import load_mnist
from PIL import Image
import pickle
import numpy as np
# 신경망 함수들
def sigmoid(num):
rst = (1 / (1 + np.exp(-num)))
return (rst)
def identity_function(x):
return x
def softmax(a):
c = np.max(a)
minus = a - c
exp_a = np.exp(minus)
sum_exp_a = np.sum(exp_a)
y = exp_a / sum_exp_a
return y
def init_network():
with open("C:\\Users\itwill\sample_weight\sample_weight.pkl",'rb') as f:
network = pickle.load(f)
return network
def predict(network, x):
W1, W2, W3 = network['W1'], network['W2'], network['W3']
b1, b2, b3 = network['b1'], network['b2'], network['b3']
a1 = np.dot(x,W1) + b1
z1 = sigmoid(a1)
a2 = np.dot(z1,W2) + b2
z2 = sigmoid(a2)
a3 = np.dot(z2,W3) + b3
y = softmax(a3)
return y
def get_data():
(x_train, t_train) , (x_test, t_test) = \
load_mnist(normalize=True, flatten=True, one_hot_label=False)
return x_test, t_test
##############################################################
x, t = get_data()
network = init_network()
batch_size = 100
result = 0
for i in range(0,len(x),batch_size):
x_batch = x[i:i+batch_size]
y = predict(network, x_batch)
p = np.argmax(y,axis=1) #예상값
#print(p)
t_batch = t[i:i+batch_size] #실제값 (t 라벨. 이미 최대값 뽑아서 나온 실제답임)
result += np.sum( p==t_batch )
print(result/len(x))
0.9352
'deeplearning' 카테고리의 다른 글
| 5장. 오차 역전파 ( 계산 그래프, 연쇄법칙, 역전파 ) (0) | 2019.03.27 |
|---|---|
| 4장. 인공 신경망을 학습시킴(손실(오차)함수, 수치 미분, 경사하강법, 학습 알고리즘 구현) (0) | 2019.03.27 |
| 2장. 퍼셉트론Perceptron (0) | 2019.03.27 |
| 1장. deeplearning에 필요한 파이썬 기본문법 (0) | 2019.03.27 |
| Intro.딥러닝 소개 (0) | 2019.03.27 |
