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 |
