def forward(network, x):
W1, W2, W3 = network['W1'], network['W2'], network['W3']
b1, b2, b3 = network['b1'], network['b2'], network['b3']
z1 = sigmoid(x.dot(W1) + b1) # 첫번째 은닉층 전파(propagation)
z2 = sigmoid(z1.dot(W2) + b2) # 두번째 은닉층 전파(propagation)
y = softmax(z2.dot(W3) + b3) # 출력층 전파(propagation)
return y
class Sigmoid:
def __init__(self):
# x.self = None
self.y = None # forward 메소드의 리턴값 y를 저장하기 위한 필드
# def f_sigmoid(self,x):
# x.self = x
# return 1/ (1+ math.exp(-x))
# def back_sigmoid(self, x):
# x.self = x
# y = 1/ (1+ math.exp(-x))
# return self.y(1- self.y)
def forward(self, x):
y = 1/ (1+ np.exp(-x)) # 행렬이 들어와도 계산이 가능하다
self.y = y
return y
def backward(self, dout):
# back propagation: 미분값에 곱해줘야한다
# 정의: y(1 - y)
return dout * self.y * (1 - self.y) # self.. 뭐야 순서에 왤케 민감ㅎ ㅠㅜ
# dy/dx
# above, we know the rules and derivatives
# But if not,
# 아주작은 h에 대해서 [(f+h) - (f-h)]/h 계산
h = 1e-7
dx2 = (sigmoid(0. + h) - sigmoid(0. - h)) / h
print('dx2 = ', dx2)
def forward(netwrok, x):
"""
forward propagation(순방향 전파)
forward(각 가중치 행렬, x = 이미지 1장)
파라미터 x: 이미지 한 개의 정보를 가지고 있는 배열(784,) / 사이즈만 있고, 1차원인 배열
행이 1개이고 원소의 갯수가 784개인 데이터
"""
# 가중치 행렬(weight matrices)
W1, W2, W3 = network['W1'], network['W2'], network['W3']
b1, b2, b3 = network['b1'], network['b2'], network['b3']
# 첫번쨰 은닉층
a1 = x.dot(W1) + b1
# 첫번째 은닉층에서 나오는 출력값 (z1)
z1 = sigmoid(a1)
# shorcut: z1 = sigmoid(x.dot(W1) + b1)
# 두번째 은닉층
a2 = z1.dot(W2) + b2
z2 = sigmoid(a2)
# 출력층
a3 = z2.dot(W3) + b3
y = softmax(a3)
return y
def forward(network, x):
W1, W2, W3 = network['W1'], network['W2'], network['W3']
b1, b2, b3 = network['b1'], network['b2'], network['b3']
z1 = sigmoid(x.dot(W1)+b1)
z2 = sigmoid(z1.dot(W2)+b2)
y = softmax(z2.dot(W3)+b3)
return y
def forward(network,x): # x는 1차원이 아닌 2차원이라고 가정한다
# 가중치 행렬
W1, W2, W3 = network['W1'], network['W2'], network['W3']
b1, b2, b3 = network['b1'], network['b2'], network['b3']
z1 = sigmoid(x.dot(W1) + b1) # 첫번째 은닉층 (propagation)
z2 = sigmoid(z1.dot(W2) + b2) # 두번째 은닉층 (propagation)
y = softmax(z2.dot(W3) + b3) # output layer
return y
def predict(network, X_test):
"""
신경망에서 사용되는 가중치행렬과 테스트 데이터를 전달받아서
테스트 데이터의 예측값(배열)을 리턴
"""
W1, W2, W3 = network['W1'], network['W2'], network['W3']
b1, b2, b3 = network['b1'], network['b2'], network['b3']
a1 = X_test.dot(W1) + b1
z1 = sigmoid(a1)
a2 = z1.dot(W2) + b2
z2 = sigmoid(a2)
pred = z2.dot(W3) + b3
return softmax(pred)
def forward(network, x):
"""
x : 이미지 한 개의 정보를 가지고 있는 배열(784, )
"""
# 가중치, 편향 행렬
W1, W2, W3 = network['W1'], network['W2'], network['W3']
b1, b2, b3 = network['b1'], network['b2'], network['b3']
a1 = x.dot(W1) + b1
z1 = sigmoid(a1)
a2 = z1.dot(W2) + b2
z2 = sigmoid(a2)
a3 = z2.dot(W3) + b3
y = softmax(a3)
return y
def forward(network, x):
""" ex08의 forward에서 마지막에 mini_batch 활성 함수에 넣어줌 """
# 가중치 행렬 (weight matrices)
W1, W2, W3 = network['W1'], network['W2'],network['W3']
b1, b2, b3 = network['b1'], network['b2'],network['b3']
# 첫번째 은닉층
a1 = x.dot(W1) + b1
z1 = sigmoid(a1)
# 두번째 은닉층
a2 = z1.dot(W2) + b2
z2 = sigmoid(a2)
#output layer
a3 = z2.dot(W3) + b3
y = softmax(a3)
return y
def forward(network, x):
"""
순방향 전파(forward propagation). 입력 -> 은닉층 -> 출력.
:param network: 신경망에서 사용되는 가중치/bias 행렬들을 저장한 dict
:param x: 입력 값을 가지고 있는 (1차원) 리스트. [x1, x2]
:return: 2개의 은닉층과 출력층을 거친 후 계산된 출력 값. [y1, y2]
"""
# 가중치 행렬:
W1, W2, W3 = network['W1'], network['W2'], network['W3']
# bias 행렬:
b1, b2, b3 = network['b1'], network['b2'], network['b3']
# 은닉층에서 활성화 함수: sigmoid 함수
a1 = x.dot(W1) + b1
z1 = sigmoid(a1) # 첫번째 은닉층 전파
z2 = sigmoid(z1.dot(W2) + b2) # 두번째 은닉층 전파
# 출력층: z2 @ W3 + b3 값을 그대로 출력
y = z2.dot(W3) + b3
# return identity_function(y) # 출력층의 활성화 함수를 적용 후 리턴
return softmax(y) # 출력층의 활성화 함수로 softmax 함수를 적용
def forward(network, x):
"""
순방향 전파(forward propagation) : 입력층 -> 은닉층 -> 출력층
은닉층의 활성화 함수 : 시그모이드 함수
:param network: 신경망에서 사용되는 가중치와 bias 행렬들을 저장한 dict
:param x: 입력값을 가지고 있는 1차원 리스트 -> ex, [x1, x2]
:return: 2개의 은닉층과 1개의 출력층을 거친 후 계산된 최종 출력값 -> ex, [y1, y2]
"""
W1, W2, W3 = network['W1'], network['W2'], network['W3']
b1, b2, b3 = network['b1'], network['b2'], network['b3']
a1 = x.dot(W1) + b1
z1 = sigmoid(a1)
z2 = sigmoid(z1.dot(W2) + b2)
y = z2.dot(W3) + b3
return softmax(y)
def forward(network, x):
"""
:param network: 신경망에서 사용되는 가중치/bias 행렬들을 저장한 dict
:param x: 입력 값을 가지고 있는 (1차원) 리스트 [x1, x2]
:return: 2개의 은닉층과 출력층을 거친 후 계산된 출력 값. [y1, y2]
"""
# 가중치 행렬들
W1, W2, W3 = network['W1'], network['W2'], network['W3']
# bias 행렬:
b1, b2, b3 = network['b1'], network['b2'], network['b3']
# 은닉층에서 활성화 함수: sigmoid 함수
a1 = x.dot(W1) + b1
z1 = sigmoid(a1) # 첫번째 은닉층 전파
z2 = sigmoid(z1.dot(W2) + b2) # 두번째 은닉층 전파
# 출력층: z2 @ W3 + b3 값을 그대로 return
y = z2.dot(W3) + b3
return softmax(y) # 출력층의 활성화 함수로 softmax 함수 적용
def forward(network, x):
"""
순방향전파(forward propagation). 입력 -> 은닉층 -> 출력
:param network: 신경망에서 사용되는 가중치/bias 행렬들을 저장한 dict
:param x: 입력 값을 가지고 있는 (1차원) 리스트 [x1, x2]
:return: 2개의 은닉층과 출력층을 거친 후 계산된 출력값. [y1, y2]
"""
# 가중치 행렬:
W1, W2, W3 = network['W1'], network['W2'], network['W3']
# bias 행렬
b1, b2, b3 = network['b1'], network['b2'], network['b3']
# 은닉층에서 활성화 함수: sigmoid 함수
a1 = x.dot(W1) + b1
z1 = sigmoid(a1) #첫번째 은닉층 전파
z2 = sigmoid(z1.dot(W2) + b2) #두번째 은닉층 전파
# 출력층: z2 @ W3 + b3
# 일관성을 유지하기위해서 항등함수를 만들어서 사용 -> ?? 교재에서는 그렇게 함ㅇㅅㅇ!
y = z2.dot(W3) + b3
# return identity_function(y) # 출력층에 활성화 함수를 적용후 리턴
return softmax(
y
) # 출력층의 활성화 함수로 softmax 함수를 적용 -> 숫자가 아닌 클래스를 예측하고 싶을 때 (i.e. iris의 품종)
def forward(network, x):
"""
순방향 전파(forward propagation).
파라미터 x: 이미지 한 개의 정보를 가지고 있는 배열. (784,)
"""
# 가중치 행렬(Weight Matrices)
W1, W2, W3 = network['W1'], network['W2'], network['W3']
# bias matrices
b1, b2, b3 = network['b1'], network['b2'], network['b3']
# 첫번째 은닉층
a1 = x.dot(W1) + b1
z1 = sigmoid(a1)
# 두번째 은닉층
a2 = z1.dot(W2) + b2
z2 = sigmoid(a2)
# 출력층
a3 = z2.dot(W3) + b3
y = softmax(a3)
return y
import numpy as np
from ch03.ex01 import sigmoid
x = np.array([1, 2])
# a1 = x @ W1 + b1
W1 = np.array([[1, 2, 3], [4, 5, 6]])
b1 = np.array([1, 2, 3])
a1 = x.dot(W1) + b1
print('a(1) =', a1)
# 출력 a1에 활성화 함수를 sigmoid 함수로 적용
# z1 = sigmoid(a1)
z1 = sigmoid(a1)
print('z(1) =', z1)
# 두번째 은닉층에 대한 가중치 행렬 W2와 bias 행렬 b2를 작성
W2 = np.array([[0.1, 0.4], [0.2, 0.5], [0.3, 0.6]])
b2 = np.array([0.1, 0.2])
a2 = z1.dot(W2) + b2
print('a(2) =', a2)
# a2에 활성화 함수(sigmoid)를 적용
y = sigmoid(a2)
print('y =', y)
import numpy as np
from ch03.ex01 import sigmoid
x = np.array([1, 2])
W_1 = np.array([[1,2,3],
[4,5,6]])
b_1 = np.array([1,2,3])
a_1 = x.dot(W_1) + b_1
print('a_1 :', a_1)
z_1 = sigmoid(a_1)
print('z_1 :', z_1)
# 두번째 은닉층에 대한 가중치 행렬 w_2와 bias 행렬 b_2 작성
w_2 = np.array([[0.1, 0.4],
[0.2, 0.5],
[0.3, 0.6]])
b_2 = np.array([0.1, 0.2])
a_2 = z_1.dot(w_2) + b_2
print('a_2 :', a_2)
y = sigmoid(a_2)
print('y :', y)
# forward 메소드의 리턴값 y를 저장하기 위한 field
self.y = None
def forward(self, x):
y = 1 / (1 + np.exp(-x))
self.y = y
return y
def backward(self, dout):
return dout * self.y * (1 - self.y)
if __name__ == '__main__':
# Sigmoid 뉴런을 생성
sigmoid_gate = Sigmoid()
# x = 1일 때 sigmoid 함수의 리턴값(forward)
y = sigmoid_gate.forward(x=0.)
print('y =', y) # x = 0일 때 sigmoid(0) = 0.5
# x = 0에서의 sigmoid의 gradient(접선의 기울기)
dx = sigmoid_gate.backward(dout=1.)
print('dx =', dx)
# 아주 작은 h에 대해서 [f(x + h) - f(x)]/h를 계산
h = 1e-7
dx2 = (sigmoid(0. + h) - sigmoid(0.)) / h
print('dx2 = ', dx2)