NCS 시험문제 2번
import numpy as np
x = np.random.rand(100, 784)
def softmax(x):
if x.ndim == 2:
x = x.T
print(np.max(x,axis=0))
x = x - np.max(x, axis=0)
return x.T
x2 = softmax(x)
print(x2.shape)
print(sum(x[0]))
print(sum(x2[0]))
■ 4장. 신경망 학습
* 4장 목차
1. 신경망의 학습이 무엇인지?
2. 비용함수(손실함수) 2가지
-평균 제곱 오차
- 교차 엔트로피 오차
3. 미니 배치 학습
4. 수치 미분
5. 편미분
6. 기울기
7. 경사하강법
8. 신경망에서의 기울기
9. 학습 신경망 구현하기
■ 4. 수치미분
진정한 미분은 컴퓨터로 구현하기 어렵기 때문에
중앙 차분 오차가 발생하지만 컴퓨터로 미분을 구현하기 위해서
수치미분을 사용해야한다.
p 123(수치 미분 공식)
f(x+h) - f(x-h)
---------------
2*h
h = 0.0001 ( 0을 4개)
문제 74. 아래의 함수를 미분해서 x = 3 에서의 미분계수를 구하시오 !
y = x^2 + 4^2
def samplefun1(x):
return x **2 + 4**2
def numericalDiff(f,x):
h = 0.0001
return(f(x+h) - f(x-h)) / (2*h)
print (numericalDiff(samplefun1, 3) )
결과 :
6.00000000000378
■ 미분한 함수를 x =4 로 했을때는
def samplefun1(x):
return x **2 + 4**2
def numericalDiff(f,x):
h = 0.0001
return(f(x+h) - f(x-h)) / (2*h)
print (numericalDiff(samplefun1, 4) )
결과 :
7.999999999999119
---------------------------
중앙 차분 오차 ---> 진정한 미분이 아니라 수치미분이기 때문에
중앙 차분 오차가 발생하고 있다.
문제 75. 아래의 함수를 시각화하시오 ! (matplotlib 사용)
x = np.arrange(0.0, 20.0, 0.1) #부터 20까지 0.1 간격의 배열 x 생성
y = x^2 + 4^2 <---- 이 함수를 시각화 하시오 !
import numpy as np
import matplotlib.pylab as plt
def samplefunc1(x):
return x **2 + 4**2
x = np.arange(0.0, 20.0, 0.1)
y = samplefunc1(x)
plt.plot(x,y)
plt.show()
■ 5. 편미분
변수가 2개 이상인 함수를 미분할 때 미분 대상 변수 외에
나머지 변수를 상수처럼 고정시켜 미분하는것을 편미분이라고 한다.
f(x0,x1) = x0^2 + x1^2 의 그래프를 보면 아래와 같다.
문제 76. f(x0,x1) = x0^2 + x1^2 함수를 편미분하는데
x0=3, x1=4 일때
∂ f
---------- = 2*x0 = 2*3 = 6
∂ x0
def samplefun3(x):
return x**2 + 4**2
def numericalDiff(f,x):
h = 0.0001
return(f(x+h) - f(x-h)) / (2*h)
print( numericalDiff(samplefun3, 3) )
결과 :
6.00000000000378
문제 77. x0=3 이고 x1 =4 일때 아래의 함수를 아래와 같이 편미분하시오 !
f(x0, x1) = x0^2 + x1^2
∂ f
----------
∂ x1
import numpy as np
def func1(x):
return np.square(x) + np.square(3)
def numberical_diff(f,x,h=1e-4):
return (f(x+h) - f(x-h)) / (h*2)
print(numerical_diff(func1,4))
결과 :
8.0
문제 78. 아래의 함수를 x0 로 편미분 하시오!
(x0=3, x1=4)
f(x0,x1) = 2*x^2 + 3*x1^2
∂ f
----------
∂ x0
import numpy as np
def func1(x):
return 2*np.square(x) + 3*np.square(4)
def numberical_diff(f,x,h=1e-4):
return (f(x+h) - f(x-h)) / (h*2)
print(numerical_diff(func1,3))
결과 :
12.0
문제 79. 아래의 함수를 편미분하시오!
(x0=6, x1=7)
f(x0,x1) = 6*x0^2 + 2*x1^2
∂ f
----------
∂ x1
func = lambda x1 : 6*6**2 + 2*x1**2
print(numerical_diff(func, 7))
결과 :
27.999999999792635
문제 80. (점심시간 문제) for loop 문을 이용해서 아래의 함수를 x0 로
편미분하고 x1 로 편미분이 각각 수행되게 하시오 !
(x=0.6, x1=7)
f(x,x1) = 6*x0^2 + 2*x1^2
∂ f
1. ----------
∂ x1
∂ f
2. ----------
∂ x0
코드 :
func = {}
func[0] = lambda x0:6*x0**2
func[1] = lambda x1:2*x1**2
value = [6,7]
for idx,value in enumerate(value):
print(numerical_diff(func[idx],value))
결과 :
71.9999999998322
27.999999999934744
■ 기울기
앞에서는 x0 와 x1 편미분을 변수별로 따로따로 계산을 했다.
그럼 x0 와 x1의 편미분을 동시에 계산을 하고 싶다면
어떻게 해야할까?
모든 변수의 편미분을 벡터 정리한것을 기울기 (gradient) 라고 한다.
그럼 x0와 x1의 편미분을 동시에 계산을 하고 싶다면 어떻게 해야할까?
가령 x0 = 3, x1 = 4 일때 (x0, x1) 양쪽의 편미분을 묶어서
f(x0,x1) = x0^2 + x1^2
∂f ∂f
( ---, --- ) = (6, 8)
∂x0 ∂x1
모든 변수의 편미분을 벡터 정리한것을 기울기(gradient)라고 한다.
문제81. 위의 편미분을 벡터로 나타내는것을 파이썬으로 구현하시오
def _numerical_gradient_no_batch(f, x):
h = 1e-4 # 0.0001
grad = np.zeros_like(x) # x와 형상이 같은 배열을 생성
for idx in range(x.size):
tmp_val = x[idx]
# f(x+h) 계산
x[idx] = float(tmp_val) + h
fxh1 = f(x)
# f(x-h) 계산
x[idx] = tmp_val - h
fxh2 = f(x)
grad[idx] = (fxh1 - fxh2) / (2*h)
x[idx] = tmp_val # 값 복원
return grad
def samplefunc4(x):
return x[0] **2 + x[1] ** 2
print(_numerical_gradient_no_batch(samplefunc4, np.array(3.0,4.0)))
x = np.array([3.0, 4.0])
grad = np.zeros_like(x)
print(grad.shape)
문제83. x0= 0.0 x1 =2.0 일때의 기울기 벡터를 구하시오 !
문제84. x0=3.0 , x1=0.0 일대의 기울기 벡터를 구하시오
■ 경사 감소법 (p129)
딥러닝은 경사감소법으로 싲가해서 경사감소법으로 끝난다 해도 과언이 아니다
지난번 배운 선형회귀를 복습해보면 y = ax + b 의 직선식을 구하는게 선형회귀의 목표였다. 그런데 딥러닝에서는
위의 식을 y = W1 * x + B 로 나타낼 수 있다.
잔차 오차 에러를 우리는 cost라고 할 것이다. 틀리면 틀릴수록 손해를 보는 비용이 많이 든다는 얘기
y = W*x + B에서 w와 b의 값ㅇ르 계속 튜닝해 나갈 것이다
그러면 이 값을 어떻게 업데이트 해 나갈것이냐?
cost = ∑ 1/2 * ( y - y` ) ^2
실제값 - 예상값
제곱을 쓰는 이유는 음수가 있을 수 있기 때문이고
음수가 안나오게 하면서 차이에 대해 제곱을 하면
패널티를 더 크게 해줄 수 있다.
y = W*x + B
y 의 B절편은 축으로 두고 직선을 돌리면서 점점데이터에 맞느 ㄴ직선을 알아내 간다고 보면 COST에 대해서는
2차 함수가 그려지게된다.
오차를 알고 있으니까 W(기울기) 값을 변화시켜 위의 그래프를 그린게 COST함수 그래프이다
깅루기가 점점작아질수록COST도 점점작아진다
대신 COST 가 0 은 안된다 .왜냐면 데이터가 완전한 직서에 있기는 불가능하기 때문이다.데이터들은
어떻게든 랜덤함 특성이 있기 때문에 0 이되긴 어렵다 만약 0 이 된다면 굳이
LINE FITTING을 할 필요가 없다 우리가 찾아야할것은 COST가 가장 작은 W의 값이 얼마냐 인것을 찾는것이다.
COST를 분석해서 W의 지점을 알아야 하는게 이것을 찾는 가장 쉬운 방법이있다. 바로 COST를 미분했을때 0
이되는 그 지점이 최솟점이 된다. 거기에 W를 읽어오면 된다.
df
----- 이게 0 인 점을 찾아가는 것이다.
d w1
그런데 한번에 익밧을 알아내기는 힘들다
그래서 추정값을 찾아서 계속 근사값을 찾아가는데 경사 감소법이다.
w1 이 3에서 기울기가 5가 나왔다면 3-5 = -2 쪽으로 갑니다.
y = W1 * x1 + W2 * x2 + W3 * x3
집값 평수 학군 편의시설
w1 = w1 - ? * ∂f/∂w1
w2 = w2 - ? * ∂f/∂w2
? : 러닝 레이트 (학습률)
왜 러닝 레이트가 필요한가 ? 미분한 기울기 값이 너무 크면 발산해버리기 때문에 cost를
0 으로 수렴시키기 위해서 필요하다.
너무 크면 발산하고
너무 작으면 학습이 안된다.
안장점이나 극소값이 최소 값인줄알고 정체기에 빠진다느 말이 무엇인가.
|
책 p130 페이지 안장점과 극솟값이 최솟값인줄 알고 정체기에 빠진다는것은 ? |
문제85. 경사 감소 함수를 파이썬으로 구현하시오 !
(비용함수를 미분해서 기울기가 0에 가까워지는 그 지점의 기울기를 구한다 )
def gradient_descent(f, init_x, lr = 0.01, step_num = 100):
x = init_x
for i in range(step_num):
grad = numerical_gradient(f, x)
x -= lr * grad
return x
import numpy as np
def numerical_gradient(f, x): # x의 모습[3.0, 4.0]
h = 1e-4 # 0.0001
grad = np.zeros_like(x) # x와 형상이 같은 배열을 생성
for idx in range(x.size): # x.size에 2가 들어가니까 0,1fh loop 돈다.
tmp_val = x[idx]
# f(x+h) 계산
x[idx] = float(tmp_val) + h #x의 모습[3.00001, 4.0]
fxh1 = f(x)
# f(x-h) 계산 25.00060001
x[idx] = tmp_val - h #[2.9999,4.0]
fxh2 = f(x)
#print(fxh1) #25.00060001
#print(fxh2) #24.99940001
grad[idx] = (fxh1 - fxh2) / (2*h)
#print('ekq')
#print((fxh1 - fxh2) / (2*h))
x[idx] = tmp_val # 값 복원
return grad
def gradient_descent(f, init_x, lr=0.01, step_num=100):
x = init_x
for i in range(step_num):
grad = numerical_gradient(f, x)
x -= lr * grad
return x
def function_2(x):
return x[0]**2 + x[1]**2
def samplefunc4(x):
return x[0] **2 + x[1] ** 2
init_x = np.array([2.0,4.0])
print( gradient_descent(function_2, init_x, lr=0.1, step_num=10))
print(numerical_gradient(samplefunc4, np.array([3.0, 4.0])))
print(numerical_gradient(samplefunc4, np.array([0.0, 2.0])))
print(numerical_gradient(samplefunc4, np.array([3.0, 0.0])))
print(numerical_gradient(samplefunc4, np.array([1.0, 0.0])))
[ 4.07407195e-10 8.14814391e-10]
거의 (0 , 0 )에 가까운 결과가 출력되었다.
문제86. 위의 식을 글대로 사용해서 테스트를 수행하는데 학습률이 너무 크면 (10)면 발산하고
학습률이 작으면(1e-10)으면 수렴을 못한다는 것을 테스트 하시오 !
문제87. 러닝 레이트를 1e-10으로 했을때 기울기가 0 으로 수렴하려면
step_num을 몇으로 줘야하나?
* 4장 목차
1. 신경망의 학습이 무엇인지?
2. 비용함수(손실함수) 2가지
-평균 제곱 오차
- 교차 엔트로피 오차
3. 미니 배치 학습
4. 수치 미분
5. 편미분
6. 기울기
7. 경사하강법
8. 신경망에서의 기울기
9. 학습 신경망 구현하기
■ 4.8. 신경망에서의 기울기 (p 133)
어제 경사감소법에서 구했떤 기울기는?
f(x0, x1) = x0^2 + x1^2
x0 =3 , x1 = 4 일때 각각 x0와 x1로 편미분한 결과 기울기를 벡터로
(6,8)로 구현한 기울기 였고 .
신경망에서의 기울기를 구한다는것은?
w11 w21 w31
w = ( )
w12 w22 w32
비용함수의 기울기를 구하기 위해서 비요함수를 수치미분했다.
∂ 비용함수(L)
------------ = (
∂ w
문제88. p134를 코딩해보자
문제89. 문제88번에서 만든 신경망에 입력값 [0.6, 0.9] 을 입력하고
target은 [0,0,1]로 해서 즉 정답 레이블이 2번이다 라고 가정하고서
오차 [에러] 가 얼마나 발생하는지 확인하시오
문제90. 어제 만든 수치미분함수에 위에서 만든 신경망 비용함수와 가중치(2x3)의 가중치를 입력해서 기울기를 구하시오(2x3)
def f(W):
return net.loss(x,t)
dw = numerical_gradient(f, net.W)
■ 기울기를 구한 이유?
손실(비용) 함수의 값을 가장 작게하는 방향을 제시하게끔
가중치를 갱신할대 필요한 값이기 때문에 기울기를 구해야한다.
- 경사하강법
- 확률적 경사 하강법 : 훈련 데이터에서 하나씩 데이터를 선택해 가중치를 갱신하는 방법
단점 : 하나의 데이터 마다 오차를 계산해서 신경망의 가중치를
조절하기 대문에 가중치 조절은 빠르나 학습 데이터마다
가중치가 갱신됨으로써 성느잉 들숙날쑥하다
- 배치법 : 모든 데이터를 학습하고 오차를 이용하여 가중치를 갱신하는 방법
단점: global mininum(최소값) 이 아닌 local mininum(극소값)에 수렴할 수도 있다.
최소값? -> 우리가 수렴해야할 값
극소값 -> 오해할수 있는 수렴점 (안장점 같은곳)
- 미니 배치법 : 위 두개의 단점을 보완한 방법
훈련데이터에서 소량의 데이터를 적당히 선택해 가중치를 갱신하는 방법
" 위의 두가지 경사 하강법의 단점을 보완하면서 또한
GPU기반의 병렬처리가 가능하다. "
■ 학습 알고리즘 구현하기 (p136)
1단계 - 미니배치 : 데이터를 미니배치로 무작위(랜덤 사용)로 선정한다.=확률적 경사 하강법 이라고 한다.
2단계 - 기울기 산출
3단계 - 매개변수 갱신
4단계 - 1단계 ~ 3단계 반복
■ 2층 신경망 구현하기
단층 입력층 ---> 출력층
다층 얕은 신경망 (2층) : 입력층 --> 은닉층 1개 --> 출력층
심층 신경망(3층) : 입력층 ---> 은닉층 들 --> 출력층
문제 93. 아래의 배열을 눈으로 확인하시오 !
import numpy as np
b1 = np.zeros(50)
print(b1)
결과:
[ 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.]
문제 94. 아래의 x(입력값), t(target 값) y(예상값) 을 아래와 같이 설정하고
위에서 만든 2층 신경망을 객체화 해서 W1,W2,B1,B2의 차원이 어떻게
되는지 프린트하시오 !
net = TwoLayerNet(input_size=784, hidden_size=100, ouput_size=10)
x = np.random.rand(100,784)
y = net.predict(x)
t = np.random.rand(100,10)
===================================================================================
# coding: utf-8
import sys, os
sys.path.append(os.pardir) # 부모 디렉터리의 파일을 가져올 수 있도록 설정
import numpy as np
import matplotlib.pyplot as plt
from dataset.mnist import load_mnist
from common.functions import *
from common.gradient import numerical_gradient
class TwoLayerNet:
def __init__(self, input_size, hidden_size, output_size, weight_init_std=0.01):
self.params = {}
self.params['W1'] = weight_init_std * np.random.randn(input_size, hidden_size)
self.params['b1'] = np.zeros(hidden_size)
self.params['W2'] = weight_init_std * np.random.randn(hidden_size, output_size)
self.params['b2'] = np.zeros(output_size)
def predict(self, x):
W1, W2 = self.params['W1'], self.params['W2']
b1, b2 = self.params['b1'], self.params['b2']
a1 = np.dot(x, W1) + b1 # 100 x 784 * 784 * 50 + 50 = 100 x 50
z1 = sigmoid(a1) # 100 x 50
a2 = np.dot(z1, W2) + b2 # 100 x 50 * 50 x 10 + 10 = 100 x 10
y = softmax(a2) # 100 x 10
return y
def loss(self, x,t):
y = self.predict(x)
return cross_entropy_error(y, t)
def accuracy(self, x, t):
y = self.predict(x)
y = np.argmax(y, axis=1)
t = np.argmax(t, axis=1)
accuracy = np.sum(y == t) / float(x.shape[0])
return accuracy
def numerical_gradient(self,x,t):
loss_W = lambda W: self.loss(x,t)
grads = {}
grads['W1'] = numerical_gradient(loss_W, self.params['W1']) # 784 x 50 기울기
grads['b1'] = numerical_gradient(loss_W, self.params['b1']) # 50개의 bias
grads['W2'] = numerical_gradient(loss_W, self.params['W2']) # 50 x 10 기울기
grads['b2'] = numerical_gradient(loss_W, self.params['b2']) # 10개의 bias
return grads
net = TwoLayerNet(input_size=784, hidden_size=100, output_size=10)
x = np.random.rand(100,784)
y = net.predict(x)
t = np.random.rand(100,10)
print(net.params['W1'].shape) #(784, 100)
print(net.params['W2'].shape) #(100, 10)
print(net.params['b1'].shape) #(100,)
print(net.params['b2'].shape) #(10,)
결과 :
(784, 100)
(100, 10)
(100,)
(10,)
문제 95. 아래의 x(입력값), t(target 값) y(예상값) 을 아래와 같이 설정하고
위에서 만든 2층 신경망을 객체화 해서 W1,W2,B1,B2의 기울기의 차원이 어떻게
되는지 프린트하시오 !
net = TwoLayerNet(input_size=784, hidden_size=100, output_size=10)
x = np.random.rand(100,784)
y = net.predict(x)
t = np.random.rand(100,10)
# coding: utf-8
import sys, os
sys.path.append(os.pardir) # 부모 디렉터리의 파일을 가져올 수 있도록 설정
import numpy as np
import matplotlib.pyplot as plt
from dataset.mnist import load_mnist
from common.functions import *
from common.gradient import numerical_gradient
class TwoLayerNet:
def __init__(self, input_size, hidden_size, output_size, weight_init_std=0.01):
self.params = {}
self.params['W1'] = weight_init_std * np.random.randn(input_size, hidden_size)
self.params['b1'] = np.zeros(hidden_size)
self.params['W2'] = weight_init_std * np.random.randn(hidden_size, output_size)
self.params['b2'] = np.zeros(output_size)
def predict(self, x):
W1, W2 = self.params['W1'], self.params['W2']
b1, b2 = self.params['b1'], self.params['b2']
a1 = np.dot(x, W1) + b1 # 100 x 784 * 784 * 50 + 50 = 100 x 50
z1 = sigmoid(a1) # 100 x 50
a2 = np.dot(z1, W2) + b2 # 100 x 50 * 50 x 10 + 10 = 100 x 10
y = softmax(a2) # 100 x 10
return y
def loss(self, x,t):
y = self.predict(x)
return cross_entropy_error(y, t)
def accuracy(self, x, t):
y = self.predict(x)
y = np.argmax(y, axis=1)
t = np.argmax(t, axis=1)
accuracy = np.sum(y == t) / float(x.shape[0])
return accuracy
def numerical_gradient(self,x,t):
loss_W = lambda W: self.loss(x,t)
grads = {}
grads['W1'] = numerical_gradient(loss_W, self.params['W1']) # 784 x 50 기울기
grads['b1'] = numerical_gradient(loss_W, self.params['b1']) # 50개의 bias
grads['W2'] = numerical_gradient(loss_W, self.params['W2']) # 50 x 10 기울기
grads['b2'] = numerical_gradient(loss_W, self.params['b2']) # 10개의 bias
return grads
net = TwoLayerNet(input_size=784, hidden_size=100, output_size=10)
x = np.random.rand(100,784)
y = net.predict(x)
t = np.random.rand(100,10)
#print(net.params['W1'].shape) #(784, 100)
#print(net.params['W2'].shape) #(100, 10)
#print(net.params['b1'].shape) #(100,)
#print(net.params['b2'].shape) #(10,)
print(net.params['W1'].shape)
grads=net.numerical_gradient(x,t)
print(grads['W1'].shape)
print(grads['W2'].shape)
print(grads['b1'].shape)
print(grads['b2'].shape)
■ 미니배치 학습 구현하기 (pg 141)
문제96. 10000번 돌때 마다 정확도가 조금씩 오라가는지
아래와 같이 출력되게 코드를 수정하시오
train acc, test acc | 0.112366666667, 0.1135
train acc, test acc | 0.708783333333, 0.7126
train acc, test acc | 0.8502, 0.8537
train acc, test acc | 0.884533333333, 0.8878
train acc, test acc | 0.898816666667, 0.9018
train acc, test acc | 0.906716666667, 0.9098
train acc, test acc | 0.9126, 0.9149
train acc, test acc | 0.917033333333, 0.9196
train acc, test acc | 0.919666666667, 0.9223
train acc, test acc | 0.924016666667, 0.9261
train acc, test acc | 0.9276, 0.9285
train acc, test acc | 0.930216666667, 0.9315
train acc, test acc | 0.932316666667, 0.9325
train acc, test acc | 0.935583333333, 0.9346
train acc, test acc | 0.936483333333, 0.9363
train acc, test acc | 0.9393, 0.9383
train acc, test acc | 0.94075, 0.9402
# coding: utf-8
import sys, os
sys.path.append(os.pardir) # 부모 디렉터리의 파일을 가져올 수 있도록 설정
import numpy as np
import matplotlib.pyplot as plt
from dataset.mnist import load_mnist
from two_layer_net import TwoLayerNet
# 데이터 읽기
(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, one_hot_label=True)
network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10)
# 하이퍼파라미터
iters_num = 10000 # 반복 횟수를 적절히 설정한다.
train_size = x_train.shape[0]
batch_size = 100 # 미니배치 크기
learning_rate = 0.1
train_loss_list = []
train_acc_list = []
test_acc_list = []
# 1에폭당 반복 수
iter_per_epoch = max(train_size / batch_size, 1)
for i in range(iters_num):
# 미니배치 획득
batch_mask = np.random.choice(train_size, batch_size)
x_batch = x_train[batch_mask]
t_batch = t_train[batch_mask]
# 기울기 계산
#grad = network.numerical_gradient(x_batch, t_batch)
grad = network.gradient(x_batch, t_batch)
# 매개변수 갱신
for key in ('W1', 'b1', 'W2', 'b2'):
network.params[key] -= learning_rate * grad[key]
# 학습 경과 기록
loss = network.loss(x_batch, t_batch)
train_loss_list.append(loss)
# 1에폭당 정확도 계산
if i % iter_per_epoch == 0:
train_acc = network.accuracy(x_train, t_train)
test_acc = network.accuracy(x_test, t_test)
train_acc_list.append(train_acc)
test_acc_list.append(test_acc)
print("train acc, test acc | " + str(train_acc) + ", " + str(test_acc))
# 그래프 그리기
markers = {'train': 'o', 'test': 's'}
x = np.arange(len(train_acc_list))
plt.plot(x, train_acc_list, label='train acc')
plt.plot(x, test_acc_list, label='test acc', linestyle='--')
plt.xlabel("epochs")
plt.ylabel("accuracy")
plt.ylim(0, 1.0)
plt.legend(loc='lower right')
plt.show()
문제97. (오늘의 마지막 문제) numerical_gradient 함수 말고 5장에서 배울 오차 역전파로 (gradient)함수를 사용해서
정확도를 계산하게 코드를 수정하시오
'딥러닝' 카테고리의 다른 글
| 딥러닝 4장. 신경망 학습 (0) | 2017.07.26 |
|---|---|
| 딥러닝 3장. 신경망 (0) | 2017.07.26 |
| 딥러닝 2장. 퍼셉트론 (0) | 2017.07.26 |
| 딥러닝 1장. Numpy, matplotlib 사용법 (0) | 2017.07.26 |
딥러닝 4장. 신경망 학습
딥러닝2017. 7. 26. 10:51
- 4장 목차
- 신경망의 학습이 무엇인가?
- 비용함수(손실함수) 2가지
- 평균 제곱 오차
- 교차 엔트로피 오차
- 미니 배치 학습
- 수치 미분
- 편미분
- 기울기
- 경사하강법
- 신경망에서의 기울기
- 학습 신경망 구현하기
■ 1. 신경망의 학습이 무엇인지?
- 학습이란 ? 신경망에서 우너하는 결과를 얻기 위해 뉴런 사이의 적당한 가중치를 알아내는것을 말한다.
즉, 가중치를 최적화 하는 것이다.
- 퍼셉트론에서는 가중치 매개변수를 사람이 수작업으로 설정했다.
왜냐면 매개변수가 겨울 3개였기 때문이다.
예 : and 연산의 가중치 : 0.5 , 0.5 세타 : 0.7
or 연산의 가중치 : 0.5 , 0.5 세타 : 0.7
그러나 신경망에서는 매개변수가 몇개가 될까
어제 구현한 mnist의 가중치도 은닉층 1만 50개, 은닉층 2가 100개 였다.
층이 더 깊어지면 수억에 이를 수도 있기 때문에
사람이 일일이 수작업을 할 수가 없다.
이미지(필기체) 숫자 5를 기계가 인식하게 하는 방법 3가지 ? (p110)
1.5 ----------- 사람이 생각한 알고리즘 ------------> 결과
2.5 ----------- 사람이 생각한 특징 -- 기계학습 ---> 결과
(sift, hog 등) (svm, knn)
3.5 ----------- 신경망(딥러닝) -------------------> 결과
딥러닝을 종단간 기계학습(end-to-end 머신러닝) 이라고 한다 .
↓
이미지, 영상을 던져주고 알아서 분석
■ 훈련데이터와 시험 데이터
학습(훈련) 데이터에 너무 지나치게 맞추다 보면 일빈화 성능이 떨어지는 것을 과적합이라고 한ㄷㅏ.
- 평균 제곱 오차
import numpy as np
def mean_squared_error(y, t):
return 0.5 * np.sum((y-t)**2)
t = [0,0,1,0,0,0,0,0,0,0]
y = [0.1, 0.05, 0.6 ,0.0, 0.05, 0.1 , 0.0 , 0.1, 0.0, 0.0]
print(np.shape(t))
print(np.shape(y))
print(mean_squared_error(np.array(y),np.array(t)))
y = [0.1, 0.05, 0.6 ,0.0, 0.05, 0.1 , 0.0 , 0.6, 0.0, 0.0]
print(mean_squared_error(np.array(y),np.array(t)))
결과 :
0.0975
0.2725
- 교차 엔트로피
import numpy as np
def cross_entropy_error(y,t):
delta = 1e-7
return -np.sum(t*np.log(y+delta))
t = [0,0,1,0,0,0,0,0,0,0]
y = [0.1, 0.05, 0.6 ,0.0, 0.05, 0.1 , 0.0 , 0.1, 0.0, 0.0]
print(cross_entropy_error(np.array(y),np.array(t)))
y = [0.1, 0.05, 0.1 ,0.0, 0.05, 0.1 , 0.0 , 0.6, 0.0, 0.0]
print(cross_entropy_error(np.array(y),np.array(t)))
결과 :
0.510825457099
2.30258409299
설명 : 정답 레이블과의 오차가 mse 보다 훨씬 더 큰 것으로 확인이 되고 잇ㄷ.
문제67. (점심시간문제) 아래의 넘파이 배열(확률)을 교차 엔트로피 오차 함수를 이용해서
오차율이 어떻게 되는지 for loop 문을 사용해서 한번에 알아내시오 !
|
t = [0,0,1,0,0,0,0,0,0,0] # 숫자2 y1 = [0.1,0.05,0.1,0.0,0.05,0.1,0.0,0.1,0.0,0.0] |
정리 :
1.one-hot-encoding = False
입력값 ----> 신경망 ----> 출력값 (숫자) ---> 라벨 비교 ---> 정확도
숫자가 맞냐 안맞냐
2.one-hot-encoding =True
입력값 ----> 신경망 ----> 소프트맥스 함수 ---> 출력값(확률) ---> 비용함수
↓
오차
0.23, 0.59
정확도를 올리거나 오차를 낮추거나 해야해요
정확도보다 오차를 보는게 더 유용한 이유 .
정확도는 23 24이렇게 생겼는데
오차는 0.2424, .54
매개변수값에 예민한것 => 비용함수의 값
0.23.
0.21
0.19
비용함수에 넣고 오차를 구하는것이 더 학습에 유리하다 .
매개변수에 더 잘 반응 함 .
□ 4.3 미니 배치 학습
미니배치 학습이란 훈련 데이터로 부터 일부만 골라서 학습을 수행하는 방식이다.
앞에서 손실함수를 배웠는데 손실함수가 필요한 이유는
예상값과 실제값을 오차를 계산해서 오차를 줄이는 방향으로
가중치를 조정하려고 필요했다.
지금까지는 딱 하나의 데이터만 가지고 손실함수 계산을 한 것이었다.
t = [0,0,1,0,0,0,0,0,0,0] # 숫자2
y1 = [0.1,0.05,0.1,0.0,0.05,0.1,0.0,0.1,0.0,0.0]
mnist 데이터만 해도 훈련데이터가 6만장인데 ---> 비용함수
계산
한장씩 입력하면 계산을 6만번을 해야하기 때문에 여러장을 모아서 입력하고 계산을 한번만 하게 하자
이것이 미니배치 학습입니다.
훈련데이터 중 일부만 골라서 학습 하는 방법 : 표본을 뽑아서 학습 한다.
표본을 뽑아서 학습 시키는 장점 :
한번에 넣어서 한번에 계산하게함 == 미니배치학습
mnist 데이터를 가지고 미니배치 학습을 시켜보자
문제68
6만 미만의 숫자중에 무작위로 10만 출력하시오
print(np.random.choice(60000, 10))
문제69. mnnist 60000장의 훈련 데이터 중에 무작위로 10장을 골라
import sys, os
sys.path.append(os.pardir) # 부모 디렉터리의 파일을 가져올 수 있도록 설정
import numpy as np
import pickle
# (p98) mmist 데이터셋을 읽어올 때 인터넷이 연결되어 있는 상태에서 가져와야하는데 이때 시간이 걸린다.
# 가져온 이미지를 로컬에 저장할 때 pickle 파일로 생성이 되고 로컬에 저장되어 있으면 순식간에 읽을 수 있기 때문에 임포트 해야함
from dataset.mnist import load_mnist
from common.functions import sigmoid, softmax
(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, flatten=True, one_hot_label=True)
print(x_train.shape)
print(t_train.shape)
train_size = 60000
batch_size = 10
batch_mask == np.random.choice( train_size , batch_size )
x_batch = x_train[batch_mask]
t_batch = x_train[batch_mask]
print(len(x_batch)) # 10
print( x_batch.shape)
문제70. 데이터 1개를 가지고 오차를 구하는 교차 엔트로피 오차 함수는 아래와 같이 만들었다.
그렇다면 배치용 교차 엔트로피 오차는 어떻게 생성해야 하는가 ?
import numpy as np
def corss_entropy_error(y, t):
delta = 1e-7
return -np.sum(t * np.log(y + delta))
답 :
import numpy as np
def corss_entropy_error(y, t):
delta = 1e-7
return -np.sum(t * np.log(y + delta)) / len(y)
문제71. SK PT 64 페이지를 참고해서 교차 엔트로피 오차 사용 코드를 구현하시오 !
(mnist 데이터셋의 테스트 데이터를 가지고 구현)
언제 몇시까지 ?
몇시까지 갈게영!
되물어여!
잘 못들었을때 한번더 ㅋ캐캐캐캨
정보조사
홈페이지 인재상 기업연역
대표인사 ?
열정 리더쉬 키워드 ㅋㅋ
아이티는 앙데
아이티는 사업영역
아이티는
내가 사용한적있는 제품?
고객사?
솔루션 제품
솔루션 제품 의 기능
블로그나 카페?
최근 게시글 릭고가 여 ㅇ ㅋ
나에 맞추어서 질문 준비
복장
속도 = 거리 / 시간
df(x) / dx =
속도는 거리를 시간으로 나눈것인데 순간 속도는 시간이 한없이 0 으로 가는 멈춰있는 그 특정 순간의 속도를 말한다.
고등학교 때 배운 미분을 컴퓨터 구현하면 문제가 생긴다. 왜냐면 시간이 0 은 아닌데 0 에 무한히 가까워지는 그 수식을 표현하려면
0.00000000 .... 000001 로 표현해야 한다.
print( np.float32(1e-50))
결과 0.0
그래서 그냥 0.0001로 표현할 수 밖에 없다.
h 를 0으로 좁히는 게 불가능 하다 보니
df(x) f(x+h) - f(x) f(x+h) - f(x-h)
--------- = limit --------------- = limit -------------------
dx h->0 h h->0 2 * h
↓ ↓
진정한 미분식 근사로 구한 접선 (수치미분)
문제72. 근사로 구한 미분 함수를 파이썬으로 구하시오
( h - 0.0001 ) 함수 이름 : numerical_diff
f(x+h) - f(x-h)
limit ----------------
h->0 2 * h
답 :
def numerical_diff(f,x):
h = 0.0001
return ( f(x+h) - f(x-h) / (2*h)
문제73. y= 0.01 * x^2 + 0.1 * x 함수를 미분하는데 x 가 10일때 미분 계수는 어떻게 되는가 ?
def func73(x):
return 0.01 * x ** 2 + 0.1 * x
def numerical_diff(f,x):
h = 0.0001
return (f(x+h) - f(x-h)) / (2*h)
print(numerical_diff(func73,10))
0.2999999999986347
'딥러닝' 카테고리의 다른 글
| 딥러닝 5장 . (0) | 2017.07.26 |
|---|---|
| 딥러닝 3장. 신경망 (0) | 2017.07.26 |
| 딥러닝 2장. 퍼셉트론 (0) | 2017.07.26 |
| 딥러닝 1장. Numpy, matplotlib 사용법 (0) | 2017.07.26 |
딥러닝 3장. 신경망
딥러닝2017. 7. 26. 10:51
■ 3장 목차
- 활성화 함수 (active function)
- 계단함수
- 시그모이드 함수
- Relu 함수
- 행렬의 내적 문제
- 신경망을 파이썬으로 구현
- 손글씨 인식 신경망을 구현 (순전파)
■ 퍼셉트론과 신경망의 차이점?
퍼셉트론? 원하는 결과를 출력하도록 가중치의 값을 적절히 정하는 작업을
사람이 수동으로 해야한다.
- 신경망? 가중치 매개변수의 적절한 값ㅇ르 기계가 데이터로 부터 자동으로 학습해서 알아냄
■ 편향을 명시한 퍼셉트론 (p65)
단층 퍼셉트론 : 계단 함수 (선형함수) ---> 0 또는 1 의 값을 출력
다층 퍼셉트론 : 시그모이드 or Relu (비선형 함수) --> 0 ~ 1 사이의 실수
예 : 0.731, 0.880
def step_function(x):
y = x > 0
return y.astype(np.int)
x_data = np.array([-1,0,1])
print(step_function(x_data))
문제36. 위의 step_function 함수를 이용해서 계단함수 그래프를 그리시오
def step_function(x):
y = x > 0
return y.astype(np.int)
x = np.arange(-5.0,5.0,0.1)
y = step_function(x)
plt.plot(x,y)
plt.show()
문제37 위의 step_function 함수를 이용해서 계단함수 그래프를 반대로 그리시오
def step_function(x):
y = x > 0
return -y.astype(np.int)
x = np.arange(-5.0,5.0,0.1)
y = step_function(x)
plt.plot(x,y)
plt.show()
문제38. (점심시간 문제 )
x0, x1, x2 = -1, 0, 0
w0, w1, w2 = .3, .4, .1
일 때 ㄱ
를 코드로 나타내 보아라 !
x = np.array([x0,x1,x2])
w = np.array([w0,w1,w2])
a = np.sum(x*w)
def step(x):
y = x > 0
return y.astype(np.int)
print(step(a))
■ 시그모이드 함수
계단함수 (단층 퍼셉트론) vs 시그모이드 함수(다층 퍼셉트론)
이 둘의 차이점과 공통점?
차이점 ? 계단함수는 숫자 1과 0만 출력한느데
시그모이드 함수는 0과 1사이의 실수를 출력한다.
f(가중의 합) = 0.8834
공통점 ? 둘다 0과 1사이의 데이터만 출력하는것이 공통점이다.
1
시그모이드 함수식 = -------------
1 + exp(-x)
↓
e(자연상수)^-x
h(1,0) = 0.731 , h(2.0) = 0.880
문제39. 진짜로 시그 모이드 함수를 생성해보자
def sigmoid(x):
return 1 / (1+np.exp(-x))
x = np.array([1.0,2.0])
print(sigmoid(x))
문제40. 시그모이드 함수를 그래프로 그리시오 !
def sigmoid(x):
return 1 / (1+np.exp(-x))
x = np.arange(-8.0,8.0,0.1)
y = sigmoid(-x)
plt.plot(x,y)
plt.show()
문제41. 시그모이드 반대록 ㄱㄱ
def sigmoid(x):
return 1 / (1+np.exp(x))
x = np.arange(-8.0,8.0,0.1)
y = sigmoid(x)
plt.plot(x,y)
plt.show()
둘다 나타내봐라 계단이랑 시그모이드
def sigmoid(x):
return 1 / (1 + np.exp(-x))
def sigmoid(x):
return 1/(1+np.exp(-x))
plt.figure(figsize=(6,4))
x1 = np.arange(-6.0,6.0,0.1)
y1 = step_function(x1)
plt.plot(x1,y1,linestyle='--')
y = sigmoid(x1)
plt.plot(x1, y)
plt.show()
■ ReLu 함수 (Rectified Linear Unit)
정류된
ReLu는 입력이 0을 넘으면 그 입력을 그대로 출력하고
0 이하이면 0을 출력하는 함수
x (x > 0)
h(x) = [
0 (x<= 0)
학습이 잘 되어서 현업에서 주로 사용하는 함수
문제43. ReLu 함수를 생성하시오 !
def relu(x):
return np.maximum(0,x)
print (relu(-2))
print (relu(0.3))
문제44. Relu 함수를 그래프로 그리시오
def relu(x):
return np.maximum(0, x)
x = np.arange(-15.0,15.0,0.1)
y= relu(x)
plt.figure(figsize=(10,10))
plt.plot(x,y)
plt.show()
■ 3.2 행렬의 내적 (p77 다차원 배열계산)
문제45. 아래의 행렬 곱 (행렬내적) 을 파이썬으로 구현하시오 !
1 2 3 5 6
[ ] * [ 7 8 ] = ?
4 5 6 9 10
2 x 3 * 3 x 2 = 2 x 2
a=np.array([[1,2,3],[4,5,6]])
b=np.array([[5,6],[7,8],[9,10]])
print(np.dot(a,b))
[[ 46 52]
[109 124]]
문제46. 아래의 행렬곱을 파이썬으로 구현하시오!
5 6 1
( 7 8 ) * ( ) = ?
9 10 2
a=np.array([[5,6],[7,8],[9,10]])
b=np.array([[1],[2]])
print(np.dot(a,b))
[[17]
[23]
[29]]
■ 신경망 내적
문제47. 아래 그림을 numpy 로 구현하시오
x = np.array([1,2])
y = np.array([[1,3,5],[2,4,6]])
b = np.array([7,8,9])
print(np.dot(x,y)+b)
문제48. 위의 문제에서 구한 입력신호의 가중의 합인 y 값이
활성함수인 sigmoid 함수를 통과하면 어떤 값으로 출력되는지
z 값을 확인하시오.
x = np.array([1,2])
y = np.array([[1,3,5],[2,4,6]])
b = np.array([7,8,9])
print(np.dot(x,y)+b)
문제49. 아래의 신경망 그림을 파이썬으로 구현하시오
import numpy as np
def sigmoid(x):
return 1 / (1 + np.exp(-x))
x = np.array([4.5, 6.2])
w = np.array([[0.1, 0.3], [0.2, 0.4]])
b = np.array([0.7, 0.8])
l1 = sigmoid(np.dot(x, w)+b)
w = np.array([[0.5, 0.7], [0.6, 0.8]])
l2 = sigmoid(np.dot(l1, w)+b)
w = np.array([[0.1, 0.3], [0.2, 0.4]])
l3 = np.dot(l1, w)+b
print(l3)
[ 0.98967405 1.47095426]
■ 출력층에서 사용하는 활성화 함수
- 분류 : 소프트 맥스 함수 ( 0 ~ 1 사이의 숫자로 출력되는 함수 )
1.2 0.46
[ 0.9 ] ---> 소프트맥스 --->[ 0.34 ]
0.4 0.20
p96.
y0 = 0(확률 = 0.2 : 20%)
필기체 2 ---> 신경망 y1 = 1(확률 = 0.1 : 10%)
y2 =2(확률 = 0.46 : 46%)
:
y9 = 9(확률 = 0.01 : 1 %)
2.회귀 : 항등함수 ( 입력값을 그대로 출력하는 함수 )
문제50. 소프트맥스 함수를 파이썬으로 구현하시오 !
def softmax(a):
c = np.max(a)
exp_a = np.exp(a - c)
sum_exp_a = np.sum(exp_a)
y = exp_a / sum_exp_a
return y
c = np.max(a)
exp_a = np.exp(a - c)
sum_exp_a = np.sum(exp_a)
y = exp_a / sum_exp_a
return y
[ 0.01821127 0.24519181 0.73659691] <- 확률 벡터
" 인공 신경망의 출력값으로 확률 벡터를 얻고 싶을때 사용한다."
문제51. 입력값을 그대로 출력하는 항등 함수를 파이썬으로 구현하시오
def identity_function(x):
return x
문제52. 책 88 페이지에 나오는 3층 신경망을 파이썬으로 구현하시오 !
(오늘의 마지막 문제)
import numpy as np
def sigmoid(x):
return 1 / (1 + np.exp(-x))
x= np.array([1.0, .5])
W1 = np.array([[.1, .3, .5], [.2, .4, .6]])
W2 = np.array([[.1, .4],[.2, .5] ,[.3, .6]])
W3 = np.array([[.1, .3],[.2,.4]])
b1 = np.array([.1,.2,.3])
b2 = np.array([.1,.2])
b3= np.array([.1,.2])
l1 = sigmoid(np.dot(x,W1)+b1)
print(l1)
l2 = sigmoid(np.dot(l1,W2)+b2)
print(l2)
l3 = np.dot(l2,W3)+b3
print(l3)
test
import numpy as np
import matplotlib.pyplot as plt
# A = np.array([[1,1,-1],[4,0,2],[1,0,0]])
# B = np.array([[2,-1],[3,-2],[0,1]])
#
# print(np.dot(A,B))
#
# A = np.matrix([[1,1,-1],[4,0,2],[1,0,0]])
# B = np.matrix([[2,-1],[3,-2],[0,1]])
#
# print(A*B)
def softmax(a):
c = np.max(a)
exp_a = np.exp(a - c)
sum_exp_a = np.sum(exp_a)
y = exp_a / sum_exp_a
return y
x0, x1, x2 = .2, .7, .9
w11, w12, w13 = 2, 4, 3
w21, w22, w23 = 2, 3, 5
w31, w32, w33 = 2, 4, 4
b1, b2, b3 = -3, 4, 9
x = np.array([x0,x1,x2])
w1 = np.array([[w11, w21, w31],[w12, w22, w32],[w13, w23, w33]])
b = np.array([b1,b2,b3])
result = softmax(np.dot(x,w1)+b)
print(result)
x = np.arange(-1.,1.,0.001)
plt.plot(x , result[1])
plt.show()
■ 3장 목차
- 활성화 함수 (active function)
- 계단함수
- 시그모이드 함수
- Relu 함수
- 행렬의 내적 문제
- 신경망을 파이썬으로 구현
- 손글씨 인식 신경망을 구현 (순전파)
■ 출력층의 활성화 함수 2가지 ?
- 분류 : 소프트 맥스 함수
질문 예: 데이터가 어느 클래스에 속하는지 확인
(사진속 인물의 성별 분류)
2.회귀 : 항등 함수
질문 예 : 입력 데이터에서 연속적인 수치를 예측하는 문제
( 사진 속 인물의 몸무게를 예측하는 문제)
" 소프트 맥스 함수는 a의 원소의 대소 관계가 y의 원소의
대소 관계로 그대로 이어지기 때문에 출력이 가장 큰 뉴런의 위치는 변하지 않는다.
결과적으로 지수 함수 계산에 드는 자원 낭비를 줄이고자 출력층의 소프트 맥스 함수는
생략하는 것이 일반적이다. "
학습 ----------------------> 추론(테스트) --> 해야할 진짜 일
↓ ↓
소프트 맥스 함수 사용 o 소프트 맥스 함수 사용 x
■ 손글씨 숫자 인식 (p 96)
- mnist ? 손글씨 숫자 이미지 집합 데이터 셋
0 ~ 9 까지의 숫자 이미지로 구성되어있고
훈련 이미지가 60000 장, 시험 이미지가 10000 장이 준비됨
- 28 x 28 크기의 회색조 이미지 (총 784개의 픽셀)
- 각 픽셀은 0 ~ 255 까지의 값을 취한다. 숫자가 커질수록 픽셀이 진해짐
- 각 이미지에는 숫자 7,2,1 과 같은 이미지가 레이블되어 있다.
# coding: utf-8
import sys, os
sys.path.append(os.pardir) # 부모 디렉터리의 파일을 가져올 수 있도록 설정
import numpy as np
from mnist import load_mnist
from PIL import Image
def img_show(img):
pil_img = Image.fromarray(np.uint8(img))
pil_img.show()
테스트데이터, 테스트데이터라벨
↓ ↓
(x_train, t_train), (x_test, t_test) = load_mnist(flatten=True, normalize=False)
↑ ↑
훈련 데이터, 훈련데이터 라벨
# 설명 : flatten = True 라는 것은 립력이미지를 평탄하게 1차원 배열로 변환하라
# normalize : 입력 이미지의 픽셀 값을 0 ~ 1 사이로 할지 아니면 원래 값인 0 ~ 255 로 할지
결정하는 함수
# 0 ~ 255 범위의 각 픽셀의 값을 0.0 ~ 1.0 사이 범위로 변환능ㄹ 하는데 이렇게 특정 범위로
# 변환 처리하는 것을 ?
# "정규화" 라고 한다
#신경망의 입력 데이터에 특정 변환을 가하는 것을
# "전처리" 라고 한다.
img = x_train[0]
label = t_train[0]
print(label) # 5
print(img.shape) # (784,)
img = img.reshape(28, 28) # 형상을 원래 이미지의 크기로 변형
print(img.shape) # (28, 28)
img_show(img)
문제53. x_train 의 0 번째 요소의 필기체 숫자를 5였다. 그렇다면 x_train 의 1번재 요소의 필기체 숫자는 무엇인지 확인하시오
7
• mnist파라미터 설명
a. flatten
i. true : 입력이미지를 평탄하게 1차원 배열로 변환하는 것 (학습시킬때는 변환해야함)
ii. false : 입력이미지를 평탄하게 1차원 배열로 변환하지 않는것 (이미지를 표시해야 함)
b. normalize
i. true : 픽셀의 값을 0~1 사이로 변환한다. (전처리 작업)
ii. false : 픽셀의 값을 0~255 사이로 그대로 둔다.
c. one_hot_label
§ 0~9의 숫자가 라벨로 저장되어 있음 [0,0,0,0,0,0,0,1,0,0] --> 7을 의미한다.
i. true : 원-핫 인코딩 (one-hot encoding) 형태로 저장한다.
false : 레이블을 원-핫 인코딩 형태로 저장안한다.
# coding: utf-8
import sys, os
sys.path.append(os.pardir) # 부모 디렉터리의 파일을 가져올 수 있도록 설정
import numpy as np
import pickle
# (p98) mmist 데이터셋을 읽어올 때 인터넷이 연결되어 있는 상태에서 가져와야하는데 이때 시간이 걸린다.
# 가져온 이미지를 로컬에 저장할 때 pickle 파일로 생성이 되고 로컬에 저장되어 있으면 순식간에 읽을 수 있기 때문에 임포트 해야함
from dataset.mnist import load_mnist
from common.functions import sigmoid, softmax
def get_data():
(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, flatten=True, one_hot_label=False)
#(학습데이터, 학습라벨), (테스트데이터, 테스트라벨)
# 60000장 , 10000장
return x_test, t_test
#테스트 데이터만 return. 학습할 필요 x
#훈련시킬려는 목적 x
def init_network():
with open("C:\\sample_weight.pkl", 'rb') as f:
# (훈련되어있는 매개변수, 가중치) 가지고 추론
network = pickle.load(f)
return network
# sample_weight.pkl 파일안에 학습된 가중치, 바이어스가 다 계산되어서 들어있음
# 신경망 어떻게 구현해서 학습한것인지 확인(추정)
# 이 최종결과가 sample어쩌구 저 파일에 있다
# 그니까 여기 안엔 학습코드 x. 학습된거 가지고 추론하는거임
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
# [0.05, 0.05, 0.7, 0.01 ...]
# 2
## 2가 맞는지 확인
x, t = get_data()
# 테스트 데이터(x), 테스트 라벨(t)
# t에는 숫자가 들어있을 것(원핫인코딩x)
network = init_network()
##파이썬 함수의 4가지 특징
#1. 변수에 할당할 수 있다
#2. 다른 함수 내에서 정의될 수 있다
#3. 함수의 매개변수로 함수가 전달될 수 있다
#4. 함수의 반환값이 될 수 있다
accuracy_cnt = 0 #정확도를 출력해주기 위한 변수
for i in range(len(x)):
y = predict(network, x[i])
# x 784개...
# y가 [0.05, 0.05, 0.7, 0.01 ..]
p= np.argmax(y) # 확률이 가장 높은 원소의 인덱스를 얻는다. #2
if p == t[i]: # t: 타겟(숫자있음.. 원핫인코딩안했으니깐...)
accuracy_cnt += 1
print("Accuracy:" + str(float(accuracy_cnt) / len(x)))
문제56. 위의 코드를 수정해서
■ 배치처리 (p102)
이미지를 한장씩 처리하는게 아니라 여러장르 한번에 처리
이미지를 한장씩 처리함
이미지는 50페이지씩 처리함
추론(테스트)를 배치 단위로 진행하면 결과를 훨씬 빠르게 얻을 수 있다.
- 배치로 돌리는 코드를 이해하기 위한 사전 파이썬 코드의 이해
list( range(0, 10) ) <--- 이 결과를 프린트하면 ?
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
문제57. [0, 3, 6, 9]로 결과를 출력하려면 ?
print(list(range(0,10,3)))
문제58. 아래의 리스트를 만들고
[0, 3, 6, 9] 이중의 최대 값을 출력하라 인덱스도
x= list(range(0,10,3))
print(max(x))
print(x.index(max(x)))
문제59. numpy를 이용해서 아래의 리스트에 최대값의 인덱스를 출력하시오 !
import numpy as np
x= list(range(0,10,3))
print(np.argmax(x))
문제60. 아래의 행렬 배열을 생성하고 각 행의 최대값을 갖는 인덱스가
출력되게 하시오
0.1 0.8 0.1 1
0.3 0.1 0.6 2
0.2 0.5 0.3 1
0.8 0.1 0.1 0
import numpy as np
a = np.array([[ 0.1, 0.8 , 0.1 ],
[ 0.3 , 0.1 , 0.6 ],
[ 0.2 ,0.5, 0.3 ],
[ 0.8, 0.1 , 0.1 ] ])
for i in range(len(a)):
print(np.argmax(a[i]))
for i in range(a.shape[0]):
print(np.argmax(a[i])
print(np.argmax(a, axis = 1))
axis = 0 : 열
axis = 1 : 행
print(a.shape[0])
for i in range(a.shape[0]):
print(np.argmax(a[i]))
print(np.argmax(a, axis = 0))
[3 0 1]
문제61. 아래의 2개의 리스트를 만들고 서로 같은 자리에 같은 숫자가 몇개가 있는지 출력하시오 !
[2,1,3,5,1,4,2,1,1,0]
[2,1,3,4,5,4,2,1,1,2]
결과 : 7
a = [2,1,3,5,1,4,2,1,1,0]
j = 0
b= [2,1,3,4,5,4,2,1,1,2]
for i inrange(len(a)):
if (a[i] == b[i]):
j+=1
print(j)
a = [2,1,3,5,1,4,2,1,1,0]
b= [2,1,3,4,5,4,2,1,1,2]
a= np.array(a)
b= np.array(b)
print(np.sum(a==b))
문제62. 아래의 리스트를 x라는 변수에 담고 앞에 5개의 숫자만 출력하시오
[1,2,3,4,5,6,7,8,9,10]
결과 : [1,2,3,4,5]
답 :
a=[1,2,3,4,5,6,7,8,9,10]
print(a[0:5]
print(a[0:5]
문제63. 100장의 이미지를 한번에 입력츠엥 넣어서 정확도를
추론하는 신경망 코드를 수행하시오 !
# coding: utf-8
import sys, os
sys.path.append(os.pardir) # 부모 디렉터리의 파일을 가져올 수 있도록
import numpy as np
import pickle
from dataset.mnist import load_mnist
from common.functions import sigmoid, softmax
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
def init_network():
with open("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
x, t = get_data()
network = init_network()
batch_size = 1 # 배치 크기
accuracy_cnt = 0
for i in range(0, len(x), batch_size):
x_batch = x[i:i+batch_size]
y_batch = predict(network, x_batch)
p = np.argmax(y_batch, axis=1)
accuracy_cnt += np.sum(p == t[i:i+batch_size])
print("Accuracy:" + str(float(accuracy_cnt) / len(x)))
문제64. batch_size를 1로 했을 때와 batch_size를 100으로 했을 떄
수행속도의 차이가 있는지 확인하시오 ! (정확도와 수행속도)
100개씩
0.046002864837646484
Accuracy:0.9352
1개씩
0.7430424690246582
Accuracy:0.9352
문제65. 훈련 데이터 (6만개)로 batch_size 1 로 했을 때와
batch_size 100으로 했을때의 정확도와 수행속도차이를 비교하시오 (오늘의 마지막 문제 )
100 개씩
0.239013671875
Accuracy:0.9357666666666666
1개씩
4.204240560531616
Accuracy:0.9357666666666666
4장을 미리 읽으세요
'딥러닝' 카테고리의 다른 글
| 딥러닝 5장 . (0) | 2017.07.26 |
|---|---|
| 딥러닝 4장. 신경망 학습 (0) | 2017.07.26 |
| 딥러닝 2장. 퍼셉트론 (0) | 2017.07.26 |
| 딥러닝 1장. Numpy, matplotlib 사용법 (0) | 2017.07.26 |
딥러닝 2장. 퍼셉트론
딥러닝2017. 7. 26. 10:50
- 머신러닝과 딥러닝의 차이점은?
붓꽃의 종을 구별하는 임무가 있다고 했을때 머신러닝은
사람이 붓꽃의 특성을 정의하고 데이터 세트를 만들고나서
컴퓨터가 데이터 세트를 기반으로 붓꽃을 구별하는 판별식을 결정하는 방법
|
머신러닝 딥러닝 딥러닝은 알고리즘에 의해 컴퓨터가 붓꽃의 사진을 보고 스스로 특성을 찾아내고 판별해 내는 방법이다. |
■ 복습
- 머신러닝과 딥러닝의 차이?
딥러닝은 알고리즘에 의해 컴퓨터가 붓꽃의 사진을 보고 스스로 특성을 찾아내고 판별해내는 방법
'깊은 학습'
신경망츠잉 여러개이기 때무넹
- 신경망을 구현하기 위한 라이브러리 2개?
- numpy
- matplotlib
■ 2장. 퍼셉트론 (Perceptron)
머신러닝의 한 부류인 딥러닝(이미지를 기계가 직접 인식해서 학습)
↓
퍼센트론 ---> 신경망
결론은 ? 분류를 하겟다.
신경망을 통해서 구현하고자 하는 목표는 ? 분류
- 붓꽃 사진을 보고 종을 분류
- 고양이 사진, 개 사진 분류
퍼셉트론도 분류인데 숫자 0과 1을 분류한다.
1943년에 미국의 신경외과 의사인 워렌 맥컬록에 의해 발다닝 되었고
1957년에 프랑크 로젠 블라트가 퍼센트론 알고리즘을 고안했다
사람의 뇌의 동자긍ㄹ 전기 스위치의 on/off로 흉내 낼 수 있다는 이론을
증명하였다.
간단히 말하면 인간의 신경세포 한를 흉대는 냈는데
고등하굑 생물시간에 배운 3가지 용어 ?
- 자극(stinulus)
- 반응(response)
- 역치(threshold)
"특정 자극이 있다면 그 자극이 어느 역치 이상이여야만 세포가 반응한다."
예 : 짜게 먹는 사람은 자기가 평소에 먹는 만큼 음식이 짜지 않으면 싱겁다고 느낀다.
( 역치 이하의 자극은 무시)
싱겁게 먹는 사람이 짜게 먹기 시작해서 오랜 시간이 지나면
예전에 먹던 싱거운 음식에 만족하지 못한다( 역치가 올라감)
1969년 : 퍼센터론은 단순 선형분류기에 불과하다
왜냐면? xor분류도 못한다고 단정을 지음
인공지능의 침체기 (인공지능의 빙하기)
1970년 중반 : 중요한 논문이 하나 발표 : 역전파 알고리즘 (다층 퍼센트론)
당시의 컴퓨터 연산으로는 이 이론을 구현하기가 어려웠음
1986년 : 은닉층을 갖는 다층 퍼센트론 + 오류 역전파 학습 알고리즘 구현 되기 시작함
↓
오늘날
입력 신호 가중치 출력신호
입력신호의 연결강도가 가중치인데 가중치의 갑싱 클수록 강한 신호이다
입력신호가 뉴런에 보내질때는 각각의 고유하 가중치가 곱해진다.
w1 * x1 + w2 * x2 <= 임계값(θ) ---> 0 (신호가 안 흐른다)
w1 * x1 + w2 * x2 > 임계값(θ) ---> 1 (신호가 흐른다)
뉴런에서 보내온 신호의 총합이 정해진 한계(임계값)을 넘어설때만 1을 출력한다.
퍼셉트론은 n 개의 이진수가 하나의 뉴런을 통과해서 가중의 합이 0 보다 크면 활성화되는
가장 간단한 신경망이다.
퍼셉트론을 학습시키는 방법은 간단한데, 보통 목표치를 정해주고
현재 계산한 값이 목표치와 다른면 그 만큼의 오차를 다시 퍼센트론에
반영해서 오차를 줄여나가는 방법
문제27. 아래의 식을 파이썬으로 구현하시오 !
x1 w1
↘
?
↗
x2 w2
x1 * w1 + x2 * w2 = ?
x1 : 0
x2 : 1
w1 : 0.5
w2 : 0.5
(0 1) * (0.5 0.5)
input=np.array([0,1])
weight=np.array([0.5, 0.5])
np.sum(input*weight)
문제28. 위의 식에 책 52쪽에 나오는 편향을 더해서 완성한 아래의 식을
파이썬으로 구현하시오 !
b + w1*x1 + w2*x2
b(편향) = -0.7
x1 : 0
x2 : 1
w1 : 0.5
w2 : 0.5
input=np.array([0,1])
weight=np.array([0.5, 0.5])
b=0.7
print(np.sum(input*weight) + b)
weight=np.array([0.5, 0.5])
b=0.7
print(np.sum(input*weight) + b)
문제29. AND게이트를 파이썬으로 구현하시오
def AND(x1, x2):
return x1&x2
def AND(x1, x2):
w1, w2, theta = 0.5, 0.5, 0.7
tmp = x1*w1 + x2*w2
if tmp <= theta :
return 0
elif tmp > theta:
return 1
■ 편향까지 포함해서 AND 게이트를 구현
"가중치는 입력신호가 결과에 주는 영향력(중요도)를 조절하는
매개변수이고 편향은 뉴런이 얼마나 쉽게 활성화(결과로 1을 출력)
하느냐를 조정하는 매개변수이다. "
예를들어 b 가 -0.1 이면 각 입력신호에 가중치를 곱한 값들의 합이 0.1 을
초과할 때만 뉴런이 활성화 된다.
만약 편향이 -20 이면 입력신호에 가중치를 곱한 ㅎ바이 20을 넘지 않으면 뉴런은 활성화
되지 않는다.
문제30. 문제29번의 편향을 포함해서 AND 게이트 함수를 구현하시오 !
가중치 : 0.5, 0.5
편 향 : -0.7
def AND(x1, x2):
w1, w2, theta = 0.5, 0.5, -0.7
tmp = x1*w1 + x2*w2
if tmp <= theta :
return 0
elif tmp > theta:
return 1
- 다층 퍼셉트론
-XOR 게이트 구현
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 X1 X2 Y
0 0 1
0 1 1
1 0 1
1 1 1
xor 는 eXclusive OR 라는 뜻으로 둘중에 하나만 1일때 1 이 된다.
XOR x1 x2 y
0 0 0
0 1 1
1 0 1
1 1 1
"이 처럼 층이 여러개인 퍼셉트론을 다층 퍼셉트론이라고 한다."
문제31. AND 함수를 이용해서 NAND함수를 만드시오
def AND(x1, x2):
x = np.array([x1,x2])
w = np.array([0.5,0.5])
b = -0.7
tmp = np.sum(w*x) + b
if tmp <= 0:
return 0
elif tmp > 0:
return 1
def NAND(x1, x2):
x = np.array([x1,x2])
w = np.array([-0.5,-0.5])
b = 0.7
tmp = np.sum(w*x) + b
if tmp <= 0:
return 0
elif tmp > 0:
return 1
문제32. OR 함수를 파이썬으로 구현하시오
def OR(x1, x2):
x = np.array([x1, x2])
w = np.array([0.5, 0.5])
b = -0.3
tmp = np.sum(w * x) + b
if tmp <= 0:
return 0
elif tmp > 0:
return 1
문제33. XOR 함수를 파이썬으로 구현하시오 !
print(XOR(1,0))
def XOR(x1, x2):
s1 = NAND(x1, x2)
s2 = OR(x1, x2)
y = AND(s1, s2)
return y
print(XOR(0,0))
print(XOR(0,1))
print(XOR(1,0))
print(XOR(1,1))
#
'딥러닝' 카테고리의 다른 글
| 딥러닝 5장 . (0) | 2017.07.26 |
|---|---|
| 딥러닝 4장. 신경망 학습 (0) | 2017.07.26 |
| 딥러닝 3장. 신경망 (0) | 2017.07.26 |
| 딥러닝 1장. Numpy, matplotlib 사용법 (0) | 2017.07.26 |
딥러닝 1장. Numpy, matplotlib 사용법
딥러닝2017. 7. 26. 10:49
■딥러닝
■일정 7월 18일
6월 22일 ~ 7월 13일 (3주) : R 수업 - 매일 쪽지시험 2개
7월 13일 ~ 8월 3일 (3주) : 딥러닝 - 개념을 잡는 문제
8월 3일 ~ 8월 23일 (3주) : 텐써플로우 + 개인 프로젝트 (포트폴리오)
신경망에 대해서 얘기 해보세요
시그모이드 함수가 뭔가요
그게 왜 필요한가요 ?
거기에 대한 대답을 할 줄 알아야 한다
코딩만 하다보면 대답을 잘 모해
밑 바닥 부터 시작하는 딥러닝 책이 총7 챕터 까지 잇다
총 7장 수업
하루에 한 챕터씩 하더라도 다음주 화요일이면 끝이 난다.
그래서
수업과 그리고 오오오 쪽지시험 개념
- 총7장 수업
- 쪽지시험 (개념설명 <=-== 면접대비, ncs 시험문제)
- 딥러닝은 평가방법 포트폴리오 (개인프로젝트)
8월 4일 프로젝트 계획서 제출 ( 주제, 참여 인원수, 기간, 상세기간에 계획)
- 2~3명 : 좀더 좋은 결과물이 나와야하고
- 1명 : 계획을 잘 짜서 -> 계획대로 진행
8월 4일까지 계획서 제출
7월 17일
7월 24일
7월 31일
8월 7일 : 개인 프로젝트
8월 14일
8월 21 ----- 8월 23일 (수)
■ 밑바닥 부터 시작하는 딥러닝
■ 1장. Numpy, matplotlib 사용법
*1장 목차.
- 딥러닝이 무엇인가?
- 넘파이
■ 1. 딥러닝이 무엇인가?
■ 머신러닝의 종류 3가지
1.지도학습
- 분류 : knn : 과일인지 야채인지 단백질인지 분류
유방암 종양크기와 둘레로 양성이닞 악성인지 분류
동물의 형태로 어떤 종류의 동물인지 분류
나이브베이즈 : 스팸과 햄 메일 분류
직업, 나이, 성별만 가지고 선호하는
영화 장르
결정트리 : 1. 대출위험대상자(개인,기업) 분류
2.지방간인지 아닌지
3.베드민턴 플레이에 날씨가 미치는 영향
4.스킨샵 쿠폰반응 여부
svm : 서포트벡터머신:
1.중산층 분류 실습
2.필기체 분류 숫자
3.필기체 분류 영어
4.대장균
5.iris
6.mnist(필기체)
7.보스톤 하우징 데이터 분류
- 회귀 : 선형회귀
1.코스피 지수
2.탄닌과 애벌레성장
3.미국대학 입학에 미치는 가장큰 변수
4.챌린저호 폭파원인분석
5.보험비에 미치는 변수(담배, 비만지수)
6.스마트폰 구매에 미치는 변수(외관)
신경망
1.콘크리트 강도에 미치는 변수
2.필기체 인식
2.비지도학습 : k-means
1.sns 10대들의 관심사를 가지고 10대를
5개의 부류로 분류함
2.가요와 클래식 음악분류
3.강화학습 : 틱택토, 핑퐁
■ 머신러닝과 딥러닝의 차이?
- 딥러닝은 머신러닝에서 나온 한 갈래임
- 머신러닝이란?
프로그래머의 프로그래밍없이 컴퓨터에게 배우게 하는
능력을 갖게하는 컴퓨터 과학의 한 종류
예 : 우리가 책상이라는 이미지를 인식하는건 그냥 어렸을때 부터 그게 책상이었고
그냥 그런가보다 해서 자연스럽게 알게된것이다.
컴퓨터에게 이게 책상이다 라고 알려주는 것은 쉬울것 같지만
사실 굉장히 어려운 일이다.
우리가 책상을 보고 이게 책상이다라고 알 때에
우리 뇌에서 일어나느 일들을 우리는 다 알지도 못하고
안다해도 그 과정을 프로그래밍 한다는것은 무지막지하게
복잡한 일 일것이다.
그래서 이런 프로그램을 사람이 작성하는 대신 기계가
프로그램을 작성하도록 접근한 것이 머신러닝이다.
- 머신러닝과 딥러닝의 차이점은?
붓꽃의 종을 구별하는 임무가 있다고 했을때 머신러닝은
사람이 붓꽃의 특성을 정의하고 데이터 세트를 만들고나서
컴퓨터가 데이터 세트를 기반으로 붓꽃을 구별하는 판별식을 결정하는 방법
|
머신러닝 딥러닝 딥러닝은 알고리즘에 의해 컴퓨터가 붓꽃의 사진을 보고 스스로 특성을 찾아내고 판별해 내는 방법이다.
딥(deep) 이라는 말은 신경망의 층이 많고 각 층마다 고려되는
변수가 많다는 뜻이다.
개인프로젝트;
|
8월 4일 프로젝트 계획서 제출 ( 주제, 참여 인원수, 기간, 상세기간에 계획)
- 2~3명 : 좀더 좋은 결과물이 나와야하고
- 1명 : 계획을 잘 짜서 -> 계획대로 진행
■ 밑바닥 부터 시작하는 딥러닝
1장. 파이썬 사용법
2장. 퍼셉트론
3장. 신경망
4장. 신경망 학습
5장. 오차역전파법
6장.학습 관련 시술들
7장. 합성곱 신경망(cnn)
8장. 딥러닝
■ 1장. Numpy, matplotlib 사용법
1.2 넘파이 (numPy)
- python 언어에서 기본적으로 지원하지 않는
배열 (array) 혹은 행렬(matrix)의 계산을 쉽게 해주는 라이브러리
- 머신러닝에서 많이 사용하는 선형대수학에 관련된 수식들을
파이썬에서 쉽게 프로그래밍 할 수 있게 해준다.
예제1 : 배열 만들기
import numpy as np
a = np.array([[1,2],[3,4]])
print(a)
결과 [[1,2]
[3 4]]
예제2 : 사직연산
a + n : 배열의 모든 원소에 n 만큼을 더합니다.
a - n : 배열의 모든 원소에 n 만큼을 뺀다 .
a * n : 배열의 모든 원소에 n 만큼을 곱한다 .
a / n : 배열의 모든 원소에 n 만큼을 나눈다..
문제1. 아래의 a 배열에 모든 원소에 5를 더한 결과를 출력하시오
a = np.array([[1,2],[3,4]])
문제2. 아래의 배열의 원소들의 평균값을 출력하시오 !
a = numpy.array([1,2,3,4,5,5,6,10])
답:
import numpy as np
a = np.array([1,2,3,4,5,5,6,10])
print(np.mean(a))
문제3. a 배열의 중앙값을 출력하시오
import numpy as np
a = np.array([1,2,3,4,5,5,6,10])
print(np.median(a))
문제4. a 배열의 최대값과 최소값을 출력하시오
print(np.max(a))
print(np.min(a))
print(np.min(a))
문제5. a 배열의 표준편차와 분산을 출력하시오
print(np.std(a))
print(np.var(a))
문제6. 아래의 행렬식으로 numpy로 구현하시오 !
1 3 7 0 0 5
[ ] + [ ]
1 0 0 7 5 0
a=np.array([[1,3,7],[1,0,0]])
b=np.array([[0,0,5],[7,5,0]])
print(a+b)
b=np.array([[0,0,5],[7,5,0]])
print(a+b)
문제7. 아래의 numpy 배열을 생성하고 원소중에 10만 출력해보시오 !
1 2 3
[4 10 6 ]
8 9 20
답 :
a=np.array([[1,2,3],[4,10,6],[8,9,20]])
print(a[1][1])
문제8.아래의 행렬 연산을 파이썬으로 구현하시오 ! (점심시간문제)
1 2
( ) * ( 10 20 ) =?
3 4
a= np.array([[1,2],[3,4]])
b= np.array([10,20])
print(a*b)
문제9. 아래의 그림의 행렬 연산을 numpy로 구현하시오 !
a=np.array([[0],[10],[20],[30]])
b=np.array([0,1,2])
print(a+b)
문제10. 아래의 행렬 식을 numpy로 구현하고 아래의 요소에서
15 이상인 것만 출력하시오
55 55
( 14 19 )
0 4
a=np.array([[55,55],[14,19],[0,4]])
a=a.flatten() # 1차원 배열로 변환 시켜준다.
a[a>15]
문제11. 아래의 행렬식을 numpy를 이용하지 않고 list변수로 구현하고
아래의 행렬식에서 행의 갯수가 몇개인지 출력하시오
1 3 7
1 0 0
a=[[1,3,7],[1,0,0]]
print(len(a))
2
문제12. 아래의 행렬식을 numpy를 이용하지 않고 list 변수로 구현하고
열의 갯수가 몇개 인지 출력하시오
1 3 7
1 0 0
a=[[1,3,7],[1,0,0]]
print(len(a[0]))
문제13. 아래의 행렬식의 덧셈 연산을 numpy 이용하지 않고 수행하시오
a=[[1,3,7],[1,0,0]]
b=[[0,0,5],[7,5,0]]
res=[[0,0,0],[0,0,0]]
for i in range(len(a)):
for j in range(len(a[0])):
res[i][j]=a[i][j]+b[i][j]
print(res)
b=[[0,0,5],[7,5,0]]
res=[[0,0,0],[0,0,0]]
for i in range(len(a)):
for j in range(len(a[0])):
res[i][j]=a[i][j]+b[i][j]
print(res)
문제14. 아래의 행렬식을 numpy이용하지 않고 구현하시오 !
1 2 5 6
x = ?
3 4 7 8
#넘파이 이용
import numpy as np
a=np.array([[1,2],[3,4]])
b=np.array([[5,6],[7,8]])
a=np.array([[1,2],[3,4]])
b=np.array([[5,6],[7,8]])
print(a*b)
# 넘파이 안 이용
a=[[1,2],[3,4]]
b=[[5,6],[7,8]]
res=[[0,0],[0,0]]
for i in range(len(a)):
for j in range(len(a[0])):
res[i][j]=a[i][j]*b[i][j]
print(res)
b=[[5,6],[7,8]]
res=[[0,0],[0,0]]
for i in range(len(a)):
for j in range(len(a[0])):
res[i][j]=a[i][j]*b[i][j]
print(res)
문제15. 아래의 행렬 연산을 numpy와 numpy를 이용하지 않았을때 2가지 방법으로 구현하시오
10 20 - 5 6 = ?
30 40 7 8
#넘파이 이용
a= np.array([[10,20],[30,40]])
b= np.array([[5,6],[7,8]])
print(a-b)
a= np.array([[10,20],[30,40]])
b= np.array([[5,6],[7,8]])
print(a-b)
#넘파이 안 이용
a= [[10,20],[30,40]]
b= [[5,6],[7,8]]
res=[[0,0],[0,0]]
for i in range(len(a)):
for j in range(len(a[0])):
res[i][j]=a[i][j]-b[i][j]
print(res)
res=[[0,0],[0,0]]
for i in range(len(a)):
for j in range(len(a[0])):
res[i][j]=a[i][j]-b[i][j]
print(res)
문제16. numpy의 브로드캐스트를 사용한 연산을 numpy를 이용하지 않는 방법으로 구현하시오 (점심시간 문제를 넘파이 이용하지 않고 )
1 2
( ) * ( 10 20 ) =?
3 4
a= [[1,2],[3,4]]
b= [10,20]
res=[[0,0],[0,0]]
for i in range(len(a)):
for j in range(len(b[0])):
res[i][j]=a[i][j]-b[j]
print(res)
■ 3. matplotlib 사용법 (p41)
딥러닝 실험에서는 그래프 그리기와 데이터 시각화가 중요하다
matplotlib 는 그래프를 그리기 위한 라이브러리이다.
matplotlib를 이용하면 그래프를 그리기가 쉬워진다.
예제1:
import matplotlib.pyplot as plt
plt.figure() #객체를 선언한다.
plt.plot([1,2,3,4,5,6,7,8,9,8,7,6,5,4,3,2,1,0])
plt.show()
import matplotlib.pyplot as plt
import numpy as np
t = np.arange(0,12,0.01)
print(t)
plt.figure() #객체를 선언한다.
plt.plot(t)
plt.show()
import numpy as np
t = np.arange(0,12,0.01)
print(t)
plt.figure() #객체를 선언한다.
plt.plot(t)
plt.show()
문제17. 위의 그래프에 grid(격자)를 추가하시오!
import matplotlib.pyplot as plt
import numpy as np
t = np.arange(0,12,0.01)
print(t)
plt.figure() #객체를 선언한다.
import numpy as np
t = np.arange(0,12,0.01)
print(t)
plt.figure() #객체를 선언한다.
plt.plot(t)
plt.grid()
plt.show()
문제18. 위의 그래프에 x축의 이름을 size라고 하고 y축의 이름을 cost라고 하시오 !
import matplotlib.pyplot as plt
import numpy as np
t = np.arange(0,12,0.01)
print(t)
plt.figure() #객체를 선언한다.
plt.plot(t)
import numpy as np
t = np.arange(0,12,0.01)
print(t)
plt.figure() #객체를 선언한다.
plt.plot(t)
plt.grid()
plt.xlabel('size')
plt.ylabel('cost')
plt.show()
문제19. 위의 그래프에 전체 제목을 size & cost라고 하시오
import matplotlib.pyplot as plt
import numpy as np
t = np.arange(0,12,0.01)
print(t)
plt.figure() #객체를 선언한다.
plt.plot(t)
import numpy as np
t = np.arange(0,12,0.01)
print(t)
plt.figure() #객체를 선언한다.
plt.plot(t)
plt.grid()
plt.xlabel('size')
plt.ylabel('cost')
plt.title('size & cost')
plt.show()
문제20. 아래의 numpy 배열로 산포도 그래프를 그리시오 !
x = np.array([0,1,2,3,4,5,6,7,8,9])
y = np.array([9,8,7,9,8,3,2,4,3,4])
plt.figure()
plt.scatter(x,y)
plt.show()
문제21. 위 그래프를 선이 그어지게 하시오
문제22. 치킨집 창업 데이터를 읽어와 그래프를 그리시오
import numpy as np
from matplotlib import pyplot as plt
chi = np.loadtxt('d:\\data\\창업건수.csv', skiprows=1 , unpack=True,delimiter=',')
x = chi[0]
y = chi[4]
plt.figure()
plt.plot(x,y)
plt.xlabel("YEAR")
plt.ylabel('JIP')
plt.title('chicken jip open per year')
from matplotlib import pyplot as plt
chi = np.loadtxt('d:\\data\\창업건수.csv', skiprows=1 , unpack=True,delimiter=',')
x = chi[0]
y = chi[4]
plt.figure()
plt.plot(x,y)
plt.xlabel("YEAR")
plt.ylabel('JIP')
plt.title('chicken jip open per year')
문제23. 폐업건수도 위의 그래프에 겹치게 해서 출력하시오 !
import numpy as np
from matplotlib import pyplot as plt
from matplotlib import pyplot as plt
chi = np.loadtxt('d:\\data\\창업건수.csv', skiprows=1 , unpack=True,delimiter=',')
pe = np.loadtxt('d:\\data\\창업건수.csv', skiprows=1 , unpack=True,delimiter=',')
# unpack=True 세로로 읽겠다
x = chi[0]
y = chi[4]
p = pe[4]
plt.figure()
y = chi[4]
p = pe[4]
plt.figure()
plt.plot(x,y)
plt.plot(x,p)
plt.xlabel("YEAR")
plt.ylabel('JIP')
plt.ylabel('JIP')
plt.title('chicken jip open per year')
plt.show()
문제24. 위의 그래프에 legend도 출력하시오 (
import numpy as np
from matplotlib import pyplot as plt
from matplotlib import pyplot as plt
chi = np.loadtxt('d:\\data\\창업건수.csv', skiprows=1 , unpack=True,delimiter=',')
pe = np.loadtxt('d:\\data\\창업건수.csv', skiprows=1 , unpack=True,delimiter=',')
# unpack=True 세로로 읽겠다
x = chi[0]
y = chi[4]
p = pe[4]
plt.figure()
y = chi[4]
p = pe[4]
plt.figure()
plt.plot(x,y)
plt.plot(x,p)
plt.xlabel("YEAR")
plt.ylabel('JIP')
plt.ylabel('JIP')
plt.title('chicken jip open per year')
plt.legend()
plt.show()
문제25. 책 44 페이지의 이미지 표시를 파이썬으로 구현하시오 !
import numpy as np
from matplotlib import pyplot as plt
from matplotlib.image import imread
img = imread('d:\\data\\lena.png')
plt.imshow(img)
from matplotlib import pyplot as plt
from matplotlib.image import imread
img = imread('d:\\data\\lena.png')
plt.imshow(img)
plt.show()
문제26. 고양이 사진을 출력하시오!
import numpy as np
from matplotlib import pyplot as plt
from matplotlib.image import imread
img = imread('d:\\data\\고양.png')
plt.imshow(img)
from matplotlib import pyplot as plt
from matplotlib.image import imread
img = imread('d:\\data\\고양.png')
plt.imshow(img)
plt.show()
- 파이썬은 익히기 쉬운 프로그래밍 언어이다
- 파이썬오픈 소스다
- 이책의 딥러닝 구현은 파이썬 3버전을 이용한다
- 외부 라이브러리로는 numpy와 matplotlib을 사용했따.
- 파이썬에서는 함수와 클래스 같은 ㅇ모듈로 구현을 정히 할 수 잇따.
- 넘파이느 ㄴ다차원 배열을 다루는 편리한 메서드를 많이 제공한ㄷ.
넘파이를 이용했을때 vs 넘파이를 이용하지 않았을 대
■ 2장. 퍼셉트론 (Perceptron)
머신러닝의 한 부류인 딥러닝(이미지를 기계가 직접 인식해서 학습)
↓
퍼센트론 ---> 신경망
1943년에 미국의 신경외과 의사인 워렌 맥컬록에 의해 발다닝 되었고
1957년에 프랑크 로젠 블라트가 퍼센트론 알고리즘을 고안했다
사람의 뇌의 동자긍ㄹ 전기 스위치의 on/off로 흉내 낼 수 있다는 이론을
증명하였다.
간단히 말하면 인간의 신경세포 한를 흉대는 냈는데
고등하굑 생물시간에 배운 3가지 용어 ?
- 자극(stinulus)
- 반응(response)
- 역치(threshold)
"특정 자극이 있다면 그 자극이 어느 역치 이상이여야만 세포가 반응한다."
예 : 짜게 먹는 사람은 자기가 평소에 먹는 만큼 음식이 짜지 않으면 싱겁다고 느낀다.
( 역치 이하의 자극은 무시)
싱겁게 먹는 사람이 짜게 먹기 시작해서 오랜 시간이 지나면
예전에 먹던 싱거운 음식에 만족하지 못한다( 역치가 올라감)
1969년 : 퍼센터론은 단순 선형분류기에 불과하다
왜냐면? xor분류도 못한다고 단정을 지음
인공지능의 침체기 (인공지능의 빙하기)
1970년 중반 : 중요한 논문이 하나 발표 : 역전파 알고리즘 (다층 퍼센트론)
당시의 컴퓨터 연산으로는 이 이론을 구현하기가 어려웠음
1986년 : 은닉층을 갖는 다층 퍼센트론 + 오류 역전파 학습 알고리즘 구현 되기 시작함
↓
오늘날
'딥러닝' 카테고리의 다른 글
| 딥러닝 5장 . (0) | 2017.07.26 |
|---|---|
| 딥러닝 4장. 신경망 학습 (0) | 2017.07.26 |
| 딥러닝 3장. 신경망 (0) | 2017.07.26 |
| 딥러닝 2장. 퍼셉트론 (0) | 2017.07.26 |
