chapter05 오차역전파법

합성함수?

-여러 함수로 구성된 함수

-합성함수의 미분은 합성 함수를 구성하는 각 함수의 미분의 곱으로 나타낸다.

 

덧셈 노드 역전파?

-덧셈 노드 역전파는 입력값을 그대로 흘려보낸다.

#덧셈 노드의 역전파

class AddLayer:

    def __init__(self):

        pass

    def forward(self, x, y):

        out = x + y

        return out

    def backward(self, dout):

        #위에 상류에서 받아온 값을 그냥 흘러보내기 위해 1만 곱해서 내보낸다

        dx = dout * 1

        dy = dout * 1

        return dx, dy

 

곱셈 노드 역전파?

-상류의 값에 순전파때 입력신호를 서로 바꾸어서 내보낸다.

#곱셈 노드 역전파

class MulLayer:

    def __init__(self):

        self.x = None

        self.y = None

    def forward(self, x, y):

        self.x = x

        self.y = y                

        out = x * y

        return out

    def backward(self, dout):

        dx = dout * self.y  #x와 y를 서로 바꾸어준다.

        dy = dout * self.x

        return dx, dy

 

오차역전파법?

-가중치 매개변수의 기울기를 효율적으로 계산하는 방법

-오차를 순전파가 아닌 역으로 전파시켜서 오차 역전파 법이라고 한다.

-연쇄법칙을 이용하여 국소적 미분을 전달한다.

-역전파는 순전파와 반대 방향으로 이동하며 국소적 미분을 곱해준다.

 

활성화 함수 ReLu

-ReLu의 미분은 x가 0보다 작거나 같으면 0 , 아니면 1이다.

class ReLu:

    #mask는 True,False로 구성된 넘파이 배열

    def __init__(self):

        self.mask=None

   

    def forward(self , x):

        self.mask=(x<=0)    #값이 0보다 작으면 True, 0보다 크면 False

        out=x.copy()

        out[self.mask]=0

        return out

   

    def backward(self , dout):

        dout[self.mask]=0

        dx=dout

        return dx

   

 

 

활성화 함수 시그모이드 함수(Sigmoid)

-역전파에서 시그모이드 함수는 상류에서 들어온 값에 -y^2을 곱하여 전달한다. 그리고 exp(-x)를 곱한후 -1을 곱하고 전달한다.

class Sigmoid:

    def __init__(self):

        self.out=None

    def forward(self, x):

        out=1/(1+np.exp(-x))

        self.out=out

        return out

   

    def backward(self, dout):

        dx=dout*(1.0 - self.out)*self.out

        return dx

 

 

어파인 계층?(Affine 계층)

-어파인 변환을 담당하는 계층

import numpy as np

class Affine:

    def __init__(self , W , b):

        self.W=W

        self.b=b

        self.x=None

        self.dw=None

        self.db=None

    def forward(self , x):

        self.x=x

        out=np.dot(x , self.w)+self.b

        return out

    def backward(self , dout):

        dx=np.dot(dout , self.W.T)

        self.dw=np.dot(self.x.T , dout)

        self.db=np.sum(dout , axis=0)

        return dx

---

오차역전파법 신경망 구현

 

 

import sys, os

sys.path.append(os.pardir)  # 부모 디렉터리의 파일을 가져올 수 있도록 설정

import numpy as np

from collections import OrderedDict

import numpy as np

def softmax(a):

    exp_a=np.exp(a)

    sum_exp_a=np.sum(exp_a)

    y=exp_a/sum_exp_a

    return y

def cross_entropy_error(y,t):

    delta=1e-7

    return -np.sum(t*np.log(y+delta))

   

class softmaxWithLoss:

    def __init__(self):

        self.loss=None

        self.y=None

        self.t=None

   

    def forward(self , x,t):

        self.t=t

        self.y=softmax(x)

        self.loss=cross_entropy_error(self.y , self.t)

        return self.loss

    def backward(self,dout=1):

        batch_size=self.t.shape[0]

        dx=(self.y-self.t)/batch_size

        return dx

class Relu:

    #mask는 True,False로 구성된 넘파이 배열

    def __init__(self):

        self.mask=None

   

    def forward(self , x):

        self.mask=(x<=0)    #값이 0보다 작으면 True, 0보다 크면 False

        out=x.copy()

        out[self.mask]=0

        return out

   

    def backward(self , dout):

        dout[self.mask]=0

        dx=dout

        return dx

   

class Affine:

    def __init__(self , W , b):

        self.W=W

        self.b=b

        self.x=None

        self.dw=None

        self.db=None

    def forward(self , x):

        self.x=x

        out=np.dot(x , self.w)+self.b

        return out

    def backward(self , dout):

        dx=np.dot(dout , self.W.T)

        self.dw=np.dot(self.x.T , dout)

        self.db=np.sum(dout , axis=0)

        return dx

class TwoLayerNet:

    #(입력층의 뉴런수 , 은닉층의 뉴런수 , 출력층의 뉴런수, 가중치 초기화시 정규분포 크기)

    def __init__(self, input_size, hidden_size, output_size, weight_init_std = 0.01):

       

        #params는 신경망의 매개변수(가중치 편향)을 저장하는 딕셔너리

        self.params = {}

        self.params['W1'] = weight_init_std * np.random.randn(input_size, hidden_size)#1번째 층의 가중치

        self.params['b1'] = np.zeros(hidden_size)#1번째 층의 편향

        self.params['W2'] = weight_init_std * np.random.randn(hidden_size, output_size) #2번째 층의 가중치

        self.params['b2'] = np.zeros(output_size)#2번째 층의 편향

        #계층들을 생성한다

        self.layers = OrderedDict()

        self.layers['Affine1'] = Affine(self.params['W1'], self.params['b1'])

        self.layers['Relu1'] = Relu()

        self.layers['Affine2'] = Affine(self.params['W2'], self.params['b2'])

        #신경망의 마지막 계층이다.

        self.lastLayer = softmaxWithLoss()

       

    def predict(self, x):

        for layer in self.layers.values():

            x = layer.forward(x)

       

        return x

       

    def loss(self, x, t):

        y = self.predict(x)

        return self.lastLayer.forward(y, t)

   

    def accuracy(self, x, t):

        y = self.predict(x)

        y = np.argmax(y, axis=1)

        if t.ndim != 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'])

        grads['b1'] = numerical_gradient(loss_W, self.params['b1'])

        grads['W2'] = numerical_gradient(loss_W, self.params['W2'])

        grads['b2'] = numerical_gradient(loss_W, self.params['b2'])

       

        return grads

       

    def gradient(self, x, t):

        # forward

        self.loss(x, t)

        # backward

        dout = 1

        dout = self.lastLayer.backward(dout)

       

        layers = list(self.layers.values())

        layers.reverse()

        for layer in layers:

            dout = layer.backward(dout)

        # 결과 저장

        grads = {}

        grads['W1'], grads['b1'] = self.layers['Affine1'].dW, self.layers['Affine1'].db

        grads['W2'], grads['b2'] = self.layers['Affine2'].dW, self.layers['Affine2'].db

        return grads