불굴의관돌로그

1. Stochastic Gradient descent(SGD)

추출된 데이터 한 개에 대해서 error gradient를 계산하고, gradient descent 알고리즘을 적용하는 방법이다.

모델의 레이어 층은 하나의 행렬곱으로 생각할 수 있고, 여러개의 묶음 데이터는 행렬이라고 생각할 수 있다.

SGD의 장점

위 그림에서 볼수 있듯이 Shooting이 일어나기 때문에 local optimal에 빠질 리스크가 적다.

step에 걸리는 시간이 짧기 때문에 수렴속도가 상대적으로 빠르다.

SGD의 단점

global optimal을 찾지 못 할 가능성이 있다.

데이터를 한개씩 처리하기 때문에 GPU의 성능을 전부 활용할 수 없다.

코드로 살펴보면 다음과 같다.

class SGD:
    def __init__(self,lr=0.01):
        self.lr=lr
        
    def update(self,params, grads):
        for key in params.keys():
            params[key]-=self.lr*grads[key]
            

[출처] light-tree.tistory.com/133

2.  Momentum

모멘텀(momentum)은 '운동량'을 뜻하는 단어로, 물리와 관계가 있다. 

W는 갱신할 가중치 매개변수, dL/dW는 W에 대한 손실 함수의 기울기, η은 학습률이다. v라는 변수가 새로 나오는데, 이는 물리에서 말하는 valocity에 해당한다. 

momentum은 위 그림과 같이 공이 그릇의 바닥을 구른는 듯한 움직임을 보여준다.

코드로 살펴보면 다음과 같다.

class Momentum:
    def __init__(self, lr=0.01,momentum=0.9):
        self.lr=lr
        self.momentum=momentum
        self.v=None
    
    def update(self,params,grads):
        if self.v is None:
            self.v={}
            for key, val in params.items():
                self.v[key]=np.zeros_like(val)
            
            for key in params.keys():
                self.v[key]=self.momentum*self.v[key]-self.lr*grads[key]
                params[key]+=self.v[key]
                

위 그림에서 볼 수있듯, 모멘텀의 갱신 경로는 공이 그릇 바닥을 구르듯 움직인다. SGD와 비교하면 '지그재그 정도'가 덜한 것을 알 수 있다. 즉, x축의 힘은 아주 작지만 방향은 변하지 않아서 한 방향으로 일정하게 가속하기 때문이다. 거꾸로 y축의 힘은 크지만 위아래로 번갈아 받아서 상충하여 y축 방향의 속도는 안정적이지 않다. 전체적으로 SGD보다 x축 방향으로 빠르게 다가가 지그재그 움직임이 줄어든다.

3. AdaGrad

신경망 학습에서는 학습률(수식에서는 η로 표기) 값이 중요하다. 

이 학습률을 정하는 효과적 기술로 learning rate decay(학습률 감소)가 있다. 이는 학습률을 점차 줄여가는 방법이다.

학습률을 서서히 낮추는 가장 간단한 방법은 매개변수 '전체'의 합습률 값을 일괄적으로 낮추는 것이다. 이를 더욱 바전시킨 것이 AdaGrad이다. AdaGrad는 '각각의' 매개변수에 '맞춤형'값을 만들어준다.

AdaGrad는 개별 매개변수에 적응적으로 학습률을 조정하면서 학습을 진행한다. AdaGrad의 갱신 방법은 수식으로는 다음과 같다.

[Note] AdaGrad는 과거의 기울기를 제곱하여 계속 더해간다. 그래서 학습을 진행할수록 갱신 강도가 약해진다. 실제로 무한히 계속 학습한다면 어느 순간 갱신량이 0이 되어 전혀 갱신되지 않게 된다. 이 문제를 개선한 기법으로서 RMSProp이라는 방법이 있다. RMSProp은 과거의 모든 기울기를 균일하게 더해가는 것이 아니라, 먼 과거의 기울기는 서서히 잊고 새로운 기울기 정보를 크게 반영한다. 이를 Exponential Moving average,EMA(지수이동평균)이라 하며, 과거 기울기의 반영 규모를 기하급수적으로 감소시킨다.

코드로 살펴보면 다음과 같다.

class AdaGrad:
    def __init__(self,lr=0.01):
        self.lr=lr
        self.h=None
        
    def update(self,params,grads):
        if self.h is None:
            self.h={}
            
            for key, val in params.items():
                self.h[key]=np.zeros_like(val)
            for key in params.keys():
                self.h[key]+=grads[key]*grads[key]
                params[key]-=self.lr*grads[key]/(np.sqrt(self.h[key])*1e-7)
                

위 코딩에서 주의해야 할 점은 마지막 줄에 1e-7이라는 작은 값을 더하는 부분이다. 이 작은 값은 self.h[key]에 0이 담겨 있다 해도 0으로 나누는 사태를 막아준다. 대부분의 딥러닝 프레임워크에서는 이 값도 인수로 설정할 수 있다.

위 그림을 보면 최솟값을 향해 효율적으로 움직이는 것을 알 수 있다. y축 방향은 기울기가 커서 처음에는 크게 움직이지만, 그 큰 움직임에 비례해 갱신 정도도 큰 폭으로 작아지도록 조정된다. 그래서 y축 방향으로 갱신 강도가 빠르게 약해지고, 지그재그 움직임이 줄어든다.

4. Adam

모멘텀은 공이 그릇 바닥을 구르는 듯한 움직임을 보였다. AdaGrad는 매개변수의 원소마다 적응적으로 갱신 정도를 조정했다. 그 두 기법을 융합한 아이디어에서 출발한 기법이 Adam이다. 

Adam의 갱신 과정도 그릇 바닥을 구르듯 움직인다. 모멘텀과 비슷한 패턴이지만, 모멘텀보다 공의 좌우 흔들림이 적다.

[Note]

Adam은 하이퍼파라미터를 3개 설정한다. 하나는 지금까지의 학습률(논문에서는 α로 등장), 나머지 두 개는 일차 모멘텀용 계수 β1과 이차 모멘텀용 계수 β2이다. 논문에 따르면 기본 설정값은 β1은0.9, β2는0.999이며, 이 값이면 많은 경우에 좋은 결과를 얻을 수 있다.

SGD, Momentum, AdaGrad, Adam 총 4가지의 optimizer를 알아보았다. 하지만 모든 경우에 항상 뛰어난 기법은 없다. 각자의 장단점이 있기 때문에 해당 issue에 맞는 optimizer를 선택하는게 좋다. 

앞 장에서 신경망 학습에 대해 배웠다. 가중치 매개변수에 대한 손실 함수의 기울기는 수치 미분을 통해 구했다. 하지만 수치 미분은 단순하고 구현하기도 쉽지만 계산이 오래걸린다는 단점이 있다. 이에 효율적으로 계산하는 오차역전파법(backpropagation)을 알아보자.

5.1 계산그래프

계산 그래프는 계산 과정을 그래프로 나타낸 것이다. 이는 복수의 노드와 에지로 표현된다. 

다음 문제를 확인해보자.

문제1: 현빈 군은 슈퍼에서 1개에 100원인 사과를 2개 샀다. 이때 지불 금액을 구하라. 단, 소비세가 10%부과된다.

위 그림과 같이 처음 사과의 100원이 '*2'노드로 흐르고 200원이 되어 다음 노드로 전달된다. 이제 200원이 '*1.1' 노드를 거쳐 220원이 된다. 그러므로 최종 답은 220원이 된다.

다른 계산 그래프를 살펴보자.

위 그림은 사칙기호만을 노드에 넣고 나머지는 에지를 통해 들어가는 모습이다.

문제2: 현빈 군은 슈퍼에서 사과를 2개, 귤을 3개 샀다. 사과는 1개에 100원, 귤은 1개 150원이다. 소비세가 10%일 때 지불 금액을 구하라.

이 문제에는 덧셈 노드인 '+'가 새로 등장하여 사과와 귤의 금액을 합산한다.

계산 그래프를 이용한 문제 풀이는 다음 흐름으로 진행된다.

1. 계산 그래프를 구성한다.

2. 그래프에서 계산을 왼쪽에서 오른쪽으로 진행한다.

여기서 '계산을 왼쪽에서 오른쪽으로 진행'하는 단계를 순전파(forward propagation)

반대 방향의 전파를 역전파(backward propagation)이라 부른다.

5.1.2 국소적 계산

계산 그래프의 특징: '국소적 계산'을 전파함으로써 최종 결과를 얻는다는 점에 있다.

국소적 계산은 결국 전체에서 어떤 일이 벌어지든 상관없이 자신과 관계된 정보만으로 결과룰 출력할 수 있다는 것이다.

위 그림의 핵심은 각 노드에서의 계싼은 국소적 계산이라는 점이다. 즉, 노드는 자신과 관련한 계산 외에는 아무것도 신경 쓸게 없다. 전체 계산이 제 아무리 복잡하더라도 각 단계에서 하는 일은 해당 노드의 '국소적 계산'이며 국소적 계산은 단순하지만, 전체를 구성하는 복잡한 계산을 해낼 수 있다.

5.1.3 왜 계산 그래프로 푸는가?

계산 그래프의 이점은 다음과 같다.

1. 국소적 계산

2. 계산 그래프는 중간 계산 결과를 모두 보관할 수 있다.

실제 계산 그래프르 사용하는 가장 큰 이유는 역전파를 통해 미분을 효율적으로 계산할 수 있는 점에 있다.

5.2 연쇄법칙

그동안 해온 계산 그래프의 순전파는 계산 결과를 왼쪽에서 오른쪽으로 전달했다. 한편 역전파는 '국소적이 미분'을 순방향과는 반대인 오른쪽에서 왼쪽으로 전달한다. 또한 이 '국소적 미분'을 전달하는 원리는 연쇄법칙(chain rule)에 따른 것이다.

5.2.1 계산 그래프의 역전파

생략)

5.2.2 연쇄법칙이란?

연쇄법칙은 합성 함수의 미분에 대한 성질이며 다음과 같이 정의된다.

합성 함수의 미분은 합성 함수를 구성하는 각 함수의 미분의 곱을 나타낼 수 있다.

5.2.3 연쇄법칙과 계산 그래프

위 식 5.4의 연쇄법칙 계산을 계산 그래프로 나타내보자. 

위 그림과 같이 계산 그래프의 역전파는 오른쪽에서 왼쪽으로 신호를 전파한다. 

역전파의 계산 절차에서는 노드로 들어온 입력 신호에 그 노드의 국소적 미분(편미분)을 곱한 후 다음 노드로 전달한다.

즉, 역전파가 하는 일은 연쇄 법칙의 원리와 같다.

5.3 역전파

연산을 예로 들어 역전파의 구조를 살펴보자.

덧셈 노드의 역전파

z=x+y라는 식을 대상으로 살펴보자.

계산 그래프를 살펴보면,

곱셈 노드의 역전파

z=xy라는 식을 생각해보자.

계산 그래프로 나타내면,

곱셈 또한 덧셈과 크게 다를 것이 없다. 

5.4 단순한 계층 구현하기

5.4.1 곱셈 계층

모든 계층은 forward() 와 backward()라는 공통의 메서드(인터페이스)를 갖도록 구현할 것이다. forward()는 순전파, backward()는 역전파를 처리한다.

다음 코드를 살펴보자.

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
        dy=dout*self.x
        return dx,dy

__init__에서 인스턴스 변수 x,y 초기화. 이는 순전파 시의 입력 값을 유지하기 위해서 사용한다.

forward()에선 x,y를 인수로 받아 두값을 곱해 반환.

backward()에선 미분에 순전파 때의 값을 '서로 바꿔' 곱한 후 넘긴다.

사과예를 살펴보자.

<순전파>

apple=100
apple_num=2
tax=1.1

mul_apple_layer=MulLayer()
mul_tax_layer=MulLayer()

apple_price=mul_apple_layer.forward(apple,apple_num)
price=mul_tax_layer.forward(apple_price,tax)
print(price)

220.00000000000003

<역전파>

dprice=1
dapple_price,dtax=mul_tax_layer.backward(dprice)
dapple,dapple_num=mul_apple_layer.backward(dapple_price)

print(dapple,dapple_num,dtax)

2.2 110.00000000000001 200

5.4.2 덧셈 계층

덧셈 계층 코딩은 다음과 같다.

class AddLayer:
    def __init__(self):
        pass
    def forward(self,x,y):
        out=x+y
        return out
    def backward(self,dout):
        dx=dout*1
        dy=dout*1
        return dx,dy
    

이 계산 그래프를 코딩으로 구현하면,

apple=100
apple_num=2
orange=150
orange_num=3
tax=1.1

mul_apple_layer=MulLayer()
mul_orange_layer=MulLayer()
add_apple_orange_layer=AddLayer()
mul_tax_layer=MulLayer()

apple_price=mul_apple_layer.forward(apple,apple_num)
orange_price=mul_orange_layer.forward(orange,orange_num)
all_price=add_apple_orange_layer.forward(apple_price,orange_price)
price=mul_tax_layer.forward(all_price,tax)

dprice=1
dall_price,dtax=mul_tax_layer.backward(dprice)
dapple_price,dorange_price=add_apple_orange_layer.backward(dall_price)
dorange,dorange_num=mul_orange_layer.backward(dorange_price)
dapple,dapple_num=mul_apple_layer.backward(dapple_price)

print(price)
print(dapple_num,dapple,dorange,dorange_num,dtax)

715.0000000000001
110.00000000000001 2.2 3.3000000000000003 165.0 650

5.5 활성화 함수 계층 구현하기

활성화 함수에 관련하여 앞선 포스트에 세밀하게 해놓았다. 그러므로 이번은 코딩으로 구현하는 것만 확인하겠다.

ReLU

class Relu:
    def __init__(self):
        self.mask=None
    def forward(self,x):
        self.mask=(x<=0)
        out=x.copy()
        out[self.mask]=0
        return out
    def backward(self,dout):
        dout[self.mask]=0
        dx=dout
        
        return dx
    

x=np.array([[1.0,-.5],[-2.0,3.0]])
print(x)

[[ 1.  -0.5]
 [-2.   3. ]]
 
mask=(x<=0)
print(mask)

[[False  True]
 [ True False]]

Sigmoid

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

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
    

Softmax-with-Loss

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

이번장은 신경망 학습이다.

학습: 훈련 데이터로부터 가중치 매개변수의 최적값을 자동으로 획득하는 것을 뜻한다.

신경망을 학습할 수 있도록 해주는 지표인 손실 함수를 알아보자.

4.1.0 데이터에서 학습한다

신경망의 특징은 데이터를 보고 학습할 수 있다는 것이다. 즉, 데이터에서 학습한다는 것은 가중치 매개변수의 값을 데이터를 보고 자동으로 결정한다는 의미이다. 

4.1.1 데이터 주도 학습

Machine Learning은 데이터가 생명이다. 데이터에서 답을 찾고 데이터에서 패턴을 발견하고 데이터로 이야기를 만드는, 그것이 바로 기계학습이다. 인간과 기계학습의 차이점을 본다면, 인간은 경험과 직관을 단서로 시행착오를 거듭하여 일을 진행한다. 이에 반해 기계학습은 사람의 개입을 최소화하고 수집한 데이터로부터 데이터를 찾으려 시도한다. 

우리가 흔히 아는 MNIST를 본다면, 이미지에서 특징을 추출하고 그 특징의 패턴을 기계학습 기술로 학습하는 방법이 있다. 이와 같이 기계학습에서는 모아진 데이터로부터 규칙을 찾아내는 역할을 '기계'가 담당한다. 하지만, 이미지를 벡터로 변환할 때 사용하는 특징은 여전히 '사람'이 설계한다.

4.1.2 훈련 데이터와 시험 데이터

기계학습에서는 문제를 다룰 때 데이터를 훈련데이터(Train Data)와 시험데이터(Test Data)로 나눠 학습과 실험을 수행하는 것이 일반적이다. 

1. 우선 훈련 데이터만 사용하여 학습하면서 최적의 매개변수를 찾는다.

2. 그 후, 시험 데이터를 사용하여 앞서 훈련한 모델의 실력을 평가한다.

이렇게 나누는 이유는 뭘까?

우리가 설계하는 이유는 갖고 있는 데이터를 통해서만 사용하는 것이 아닌, 범용적으로 사용하기 위한 모델을 만들기 위해서이다. 다시말해, 아직 보지 못한 데이터(훈련 데이터에 포함되지 않는 데이터)로도 문제를 올바르게 풀어내는 능력이다.

또한, 수중의 데이터셋은 제대로 맞히더라도 다른 데이터셋에는 엉망인 일도 벌어진다. 이와 관련해, 한 데이터셋에만 지나치게 최적화된 상태를 오버피팅(overfitting)이라고 한다.

오버피팅(overfitting): 특정 데이터셋에만 너무 많이 들어서 편견이 생겨버린 상태로 이해하자. 과적합, 과대적합, 과학습 등 다양하게 번역되어있다.

4.2 손실함수

인간이 예를 들어 행복의 지수를 수치로 파악하고, 이를 근거로 '최적의 인생'을 탐색하듯, 신경망도 '하나의 지표'를 기준으로 최적의 매개변수 값을 탐색한다. 신경망 학습에서 사용하는 지표는 손실함수(loss function)이라고 한다.

이 손실 함수는 임의의 함수를 사용할 수도 있지만, 일반적으로 평균 제곱 오차(MSE)와 교차 엔트로피 (Cross entropy error)를 사용한다.

4.2.1 평균 제곱 오차(Mean Squared Error)

가장 많이 쓰이는 손실 함수는 평균 제곱 오차이다. 

여기서 yi는 신경망의 출력(신경망이 추정한 값), ti는 정답 레이블, i는 데이터의 차원수를 나타낸다.  코딩의 예를 통해 살펴보자. 

def mean_squared_error(y,t):
    return 0.5*np.sum((y-t)**2)
#정답은 '2'
t=[0,0,1,0,0,0,0,0,0,0]

#예1: '2'일 확률이 가장 높다고 추정함(0.6)
y1=[.1,.05,.6,.0,.05,.1,.0,.1,.0,.0]
print(mean_squared_error(np.array(y1),np.array(t)))

#예2: '7'일 확률이 가장 높다고 추정함(0.6)
y2=[.1,.05,.1,.0,.05,.1,.0,.6,.0,.0,]
print(mean_squared_error(np.array(y2),np.array(t)))

0.09750000000000003
0.5975

첫 번째 예는 정답이 '2'고 신경망의 출력도 '2'에서 가장 높은 경우다.

두 번째 예는 정답은 똑같이 '2'지만, 신경망의 출력은 '7'에서 가장 높다. 위 실험의 결과로 첫 번째 손실함수 쪽 출력이 작으며 정답레이블과의 오차도 작은 것을 알 수 있다. 즉, 평균 제곱 오차를 기준으로는 첫 번째 추정 결과가 정답에 더 가까운 것으로 판단 할 수 있다.

4.2.2 교차 엔트로피(Cross Entropy Error)

또 다른 손실 함수로서 교차 엔트로피 오차(Cross entropy error)도 자주 이용한다. 

log는 밑이 e인 자연로그, yk는 신경망의 출력, tk는 정답 레이블이다. tk는 정답에 해당하는 인덱스의 원소만 1이고 나머지는 0이다(원-핫 인코딩). 코딩의 예를 통해 살펴보자.

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]
y1=[.1,.05,.6,.0,.05,.1,.0,.1,.0,.0]
y2=[.1,.05,.1,.0,.05,.1,.0,.6,.0,.0]
print(cross_entropy_error(np.array(y1),np.array(t)))
print(cross_entropy_error(np.array(y2),np.array(t)))

0.510825457099338
2.302584092994546

첫 번째 예는 정답일 때의 출력이 .6인 경우로, 이때의 교차 엔트로피 오차는 약 .51이다. 

두 번째 예는 정답일 때의 출력이 .1인 경우로, 이때의 교차 엔트ㄹ로피 오차는 무려 2.3이다.

즉, 결과(오차)가 더 작은 첫 번째 추정이 정답일 가능성이 높다고 판단한 것으로 앞서 MSE와 일치하다.

4.2.3 미니배치 학습

기계학습 문제는 훈련 데이터에 대한 손실 함수의 값을 구하고, 그 값을 최대한 줄여주는 매개변수를 찾아낸다. 이렇게 하려면 모든 훈련 데이터를 대상으로 손실 함수 값을 구해야 한다. 즉, 훈련 데이터가 100개 있으면 그로부터 계산하 100개의 손실 함수 값들의 합을 지표로 삼는 것이다. 

앞선 내용에서는 데이터 하나에 대한 손실 함수만 생각했으니, 이제 훈련 데이터 모두에 대한 손실 함수의 합을 구하는 방법을 보자.

교차 엔트로피 공식은 다음과 같다.

이때, 데이터가 N개라면 tnk는 n번째 데이터의 k번째 값을 의미한다.(ynk는 신경망의 출력, tnk는 정답 레이블)

앞선 한 개의 대한 CEE에서 단순히 N개의 데이터로 확장했을 뿐이다. 다만, 마지막에 N으로 나누어 정규화하고 있다.

즉, N으로 나눔으로써 '평균 손실 함수'를 구하는 것이다. 이렇게 평균을 구해 사용하면 훈련 데이터의 개수와 상관없이 언제든 통일된 지표를 얻을 수 있다. 

생각해보자. 실제 빅데이터를 다루게 된다면 수천만도 넘는 거대한 데이터를 다루게 될텐데 과연 이를 일일이 손실함수를 계산하는게 현실적인가? 아니라고 본다. 그러므로 일부 데이터를 Random sampling을 통해 수집하고 학습하는게 더 효율적일 것이다. 이러한 학습 방법을 미니배치 학습이라고 한다.  코딩의 예를 통해 살펴보자.

from keras.datasets import mnist
(X_train,t_train),(X_test,t_test)=mnist.load_data()

Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 1s 0us/step

print(X_train.shape)
print(t_train.shape)
(60000, 28, 28)
(60000,)

여기서 mnist 데이터셋을 불러오는 방법은 keras,tensorflow등 다양하니 참고하길 바란다.

train_size=X_train.shape[0]
batch_size=10
batch_mask=np.random.choice(train_size,batch_size)
x_batch=X_train[batch_mask]
t_batch=t_train[batch_mask]
np.random.choice(600000,10)
array([ 70533, 465580, 501527, 363874, 118036, 136283,  57982, 367151,
       514364, 529300])

훈련 데이터는 60000개고, 입력 데이터는 28*28인 이미지 데이터임을 알 수 있다. np.random.choice()로는 지정한 범위의 수 중에서 random sampling을 할 수 있다. 예를 들면, np.random.choice(60000,10)은 0 이상 60000미만의 수 중에서 무작위로 10개를 골라낸다는 의미이다.

4.2.4 (배치용) 교차 엔트로피 오차 구현하기

#정답 레이블이 원-핫 인코딩일 경우
def input_by_onehot_cross_entropy_error(y,t):
    if y.dim==1:
        t=t.reshape(1,t.size)
        y=y.reshape(1,y.size)
        
    batch_size=y.shape[0]
    return -np.sum(t*np.log(y))/batch_size

#정답 레이블이 '2'나 '7' 처럼 숫자 레이블일 경우
def input_by_shape_cross_entropy_error(y,t):
    if y.dim==1:
        t=t.reshape(1,t.size)
        y=y.reshape(1,y.size)
    batch_size=y.shape[0]
    return -np.sum(np.log(y[np.arange(batch_size),t]))/batch_size

이 구현에서 원-핫 인코딩일 때 t가 0인 원소는 교차 엔트로피 오차도 0이므로, 그 계산은 무시해도 좋다는 것이 핵심이다. 다시 말해, 정답에 해당하는 신경망의 출력만으로 교차 엔트로피의 오차를 계산할 수 있다.

4.2.5 왜 손실 함수를 성정하는가?

앞선 내용에서는 왜 손실 함수를 설정하는가에 대한 상세한 설명이 없었다.

그렇다면 왜 굳이 손실 함수를 사용해야할까?

이를 위해서는 우리가 기계학습을 하는 궁극적 목표를 생각해봐야 한다. 우리의 목적은 높은 '정확도'를 끌어내는 매개변수 값을 찾는 것이다.

하지만 '정확도'라는 질표를 놔두고 '손실 함수의 값'이라는 우회적인 방법을 선택하는 이유는 무엇일까?

이는 '미분'과 관련이 있다. 이는 다음장에서 설명을 하고, 간단하게 설명하자면 신경망 학습에서는 최적의 매개변수(가중치와 편향)를 탐색할 때 손실함수의 값을 가능한 작게 하는 매개변수 값을 찾는다. 이때 매개변수의 미분(정확히 기울기)을 계산하고, 그 미분 값을 단서로 매개변수의 값을 서서히 갱신하는 과정을 반복한다.

가중치 매개변수의 손실함수의 미분이란 '가중치 매개변수의 값을 아주 조금 변화시켰을 때, 손실 함수가 어떻게 변하나'라는 의미이다.

미분값이 음이면 그 가중치를 양으로, 반대로 양이면 가중치를 음으로 변화시켜 손실 함수의 값을 줄일 수 있다.

미분 값이 0이면 가중치 매개변수를 어느 쪽으로 움직여도 손실 함수의 값은 달라지지 않는다. 그래서 그 가중치 매개변수의 갱신은 거기서 멈춘다. 

즉, 이말은 미분 값이 대부분이 장소에서 0이 되어 매개변수를 갱신할 수 없기 때문이다.

정리하자면,

신경망을 학습할 때 정확도를 지표로 삼아서는 안된다. 정확도를 지표로 하면 매개변수의 미분이 대부분의 장소에서 0이되기 때문이다.

정확도는 매개변수의 미소한 변화에는 거의 반을을 보이지 않고, 반응이 있더라고 그 값이 불연속적으로 갑자기 변화한다. 이는 '계단 함수'를 활성화 함수로 사용하지 않는 이유와도 들어맞는다. 반대로 sigmoid 함수를 생각해보자. 시그모이드 함수는 출력(세로축의 값)이 연속적으로 변하고 곡선의 기울기도 연속적으로 변한다. 즉, 시그모이드 함수의 미분은 어느 장소라도 0이 되지는 않는다는 의미이다. 

4.3,4.4 수치 미분, 기울기

미분과 관련하여는 자세하게 설명하지 않겠다. 본인은 수리통계학을 공부하기에 이는 따로 수리통계학에 정리하여 올리도록 하겠다.

대략 미분, 편미분,기울기,경사하강법,신경망에서의 기울기 등이 있는데 이는 생략한다.

하이퍼파라미터

학습률 같은 매개변수를 하이퍼파라미터(hyper parameter,초매개변수)라고 한다. 이는 가중치와 편향 같은 신경망의 매개변수와는 성질이 다른 매개변수이다. 신경망의 가중치 매개변수는 훈련 데이터와 학습 알고리즘에 의해서 '자동'으로 획득되는 매개변수인 반면, 학습률 같은 하이퍼파라미터는 사람이 직접 설정해야하는 매개변수인 것이다. 일반적으로 이들 하이퍼파라미터는 여러 후보 값 중에서 시험을 통해 가장 장 학습하는 값을 찾는 과정을 거쳐야 한다.

이와 관련하여 CNN Hyperparameter Optimization Based on CNN Visualization and Perception Hash Algorithm 논문을 조만간 리뷰하도록 하겠다.

4.5 학습 알고리즘 구현하기

Given

신경망에서 적응 가능한 가중치와 편향이 있고, 이 가중치와 편향을 훈련 데이터에 적응하도록 조정하는 과정을 '학습'이라 한다. 신경망 학습은 다음과 같이 4단계로 수행한다.

Stage1.-Mini Batch

훈련 데이터 중 일부를 무작위로 가져온다. 이렇게 선별한 데이터를 미니배치라 하며, 그 미니배치의 손실 함수 값을 줄이는 것이 목표이다.

Stage2.-Calculating Slope

미니배치의 손실 함수 값을 줄이기 위해 각 가중치 매개변수의 기울기를 구한다. 기울기는 손실 함수의 값을 가장 작게 하는 방향을 제시한다.

Stage3.-Renewing Parameter

가중치 매개변수를 기울기 방향으로 아주 조금 갱신한다.

Stage4.-Repetition

Stage1~Stage3를 반복한다.

이것이 신경망 학습이 이뤄지는 순서이다. 이는 경사 하강법으로 매개변수를 갱신하는 방법이며, 이때 데이터를 미니배치로 무작위로 선정하기 때문에 확률적 경사 하강법(Stochastic Gradient descent, SGD)라고 부른다. 

즉, '확률적으로 무작위로 골라낸 데이터'에 대해 수행하는 경사 하강법이라는 의미이다. 대부분의 딥러닝 프레임워크는 확률적 경사 하강법의 영어 머리글자를 딴 SGD라는 함수로 이 기능을 구현한다.

4.5.1,2 전체 코딩 

2-Layer Net

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
        z1=sigmoid(a1)
        a2=np.dot(z1,W2)+b2
        y=softmax(a2)
        
        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'])
        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['b1'])
        
        return grads
    
    
    

미니배치 학습 구현하기

(x_train,t_train),(x_test,t_test)=mnist.load_data()

train_loss_list=[]

iters_num=10000
train_size=x_train.shape[0]
batch_size=100
learning_rate=.1
network=TwoLayerNet(input_size=784,hidden_size=50,output_size=10)

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)
    
    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)

Published by the IEEE Computer Society  

[Korea University]

Kang-Min Kim Jun-Hyung Park Woo-Jong Ryu Sang-Keun Lee

위 논문은 고려대학교 논문을 발췌해 리뷰를 한것이다.

[논문 발췌]라고 적힌 문장들은 본인이 읽으며 중요하다고 생각하는 문장들을 적어 놓은 것이다.

Intro.

As the usage..

스마트폰 사용량이 증가함에 따라 WhatsApp,Viber,Snapchat 등 많은 채팅어플리케이션이 사용된다.

또한, 자주 사진을 문자만큼이나 많이 공유한다. 수치로는 매일 45억개의 사진을, 55억개의 문자를 보내는데 이는 Whatsapp 플랫폼에서만의 기준이다.

최근들어 Intelligent assistant 기술이 스마트폰 메시지 어플에 많이 접목된다. 예를들면, google allo, google assistant등.. 이것때문에 대화를 더욱 편하고 풍부하게 사용할 수 있게 되었다.

Figure 1. Scenario of meChat

대부분의 Intelligent assistant는 대화영 인터페이서 서버쪽에 자리잡고 있다. 그 말인 즉슨, 서버는 사진을 분석하고 수집한다는 말인데 이는 정보 보안에 민감하다.

[논문 원문 발췌]

Thus, it may lead to privacy leaks.

즉, 이는 정보 유출의 가능성도 있다. 

*흔히 2020 빅데이터 컨퍼런스에서도 가장 중요한 주제 중 하나는 데이터가 많아지면 많아질수록 데이터에 대한 보안이 가장 중요하다 하였다. 이에 대한 해결법으로 블록체인을 얘기하기도...

이 논문에서는 스마트폰 내부의 on-device형식인 personal assistant를 이용한 meChat을 이야기한다.

meChat의 세가지 기능.

-사용자 간의 대화 문맥을 이해한다.

-사진의 의미를 수집한다.

-마지막으로 대화 문맥과 관련 있는 의미를 찾아내어 in-device형식으로 사진을 찾는다.

주목해야 할 점은, meChat은 conversation text를 semantic space로 프로젝트 한다 이와 동시에 photos를 semantic space로 프로젝트 한다.

[논문 원문 발췌]

Thus, meChat is able to model, understant and compare different modalities on top of a single unified semantic space.

흥미로운 점은 앞서 언급된 것처럼 meChat은 on-device text intelligence형식이므로, intelligent assistants 를 독립형 방식으로 수행한다.

[논문 원문 발췌]

Thus, meChat works in a privacy-protecting manner without sending out any in-device photos out-side. It does not suffer from any communication latency to the external server.

-meChat SCENARIO

Figure 1. 을 살펴보면, meChat이 어떤 방식으로 사용자를 도우는지 알 수 있다. 대략 논문을 간단하게 표현해 보면, Ella는 친구와 대화를 하며, 저녁을 먹자 하고, 이에 대해 @mechat을 외치며 사진을 보내달라한다. 이에 meChat은 앞서 말한 in-device형식으로 스마트폰 내부 저장소에서 안전하게 사진을 가져온다. 여러개의 매칭된 사진을 나열시켜 보여주고 이에 사용자는 원하는 사진을 선택한다.

[논문 원문 발췌]

Notably, meChat intelligently searches indevice photos against the semantics of conversations on smartphones, whereas most existing intelligent assistants work it on their servers. Thus, meChat does not send in-device photos outside or suffer from communication latency to the servers.

-METHODOLOGY

meChat을 구상하며, ODP(Open Directory Project) 기반으로 의미적 접근을 하였다. 

의미적 접근(sementic approach)는 의미적 분류(semantic classification) 과 의미적 순위법(semantic ranking)으로 구성되 어있고 훈련은 ODP를 통해서 훈련되어졌다.

ODP를 좀더 설명하자면 최대 15레벨의 웹 디렉토리, 360만 개 이상의 웹페이지가 백만개의 카테고리로 구성되어있는 

고품질 및 대규모 분류체계 사이트이다.

Conversation Classification

사용자를 이해하는 것이 meChat의 본질적인 일이다. 이에 진행중인 대화가 사용자를 이해하는데 아주 중요하다는것에 중점을 두어 연구했다.

[논문 발췌]

We interpret the classified ODP categories as conversation contexts.

좀더 구체적으로 보자면, vector space model을 기반으로 한 term vector로써 대화속에 텍스트들을 표현한다.

이후 Conversation Vector와 ODP categories vector들 간에 Cosine similarity를 측정한다. 분류에서, 각각의 ODP category는 vector space model에 기반한 그 각각의 category의 의미를 표현하는 vector을 갖고있다.

이후 , meChat은 몇 가지 계산된 Cosine Similarity를 기반으로한 관련성 높은 ODP categories를 얻는다.

Photo Classification

in-device photos의 의미를 찾기 위해 meChat은 ODP categories로 사진들을 분류함으로써 ODP semantic space에 사진을 project한다. 

*여기서 project는 같은 의미로 벡터사영이라고 해도 이해해도 괜찮을 것 같다.

결과적으로, in-device의 object와 place 정보 두가지를 활용한다. meChat은 Tensorflow Lite에 의해 제공된 MobileNets를 사용한 사진속 object를 인식한다.

[논문 발췌]

In particular, meChat uses venue categories as place information obtained from Foursquare APIs. Subsequently, meChat puts both the recognized objects and the obtained venue categories together into a single contextual text, which are then classified into a few highly related ODP categories. 

위 과정이 meChat이 ODP category로 분류하는 과정의 세심한 내용이며 본인도 중요하다 생각해 발췌한다.

[논문 발췌]

Notably, meChat is able to model, understand, and compare conversation text and in-device photos on top of a single ODP semantic space, by transforming both into ODP categories. This is one-of-a-kind in the literature.

주목할 점은, meChat은 모델링하고,이해하며 대화 텍스트와 기기 내 비교 단일 ODP semantic 공간위에 있는 사진 둘다 ODP 범주로 변환한다. 이는 문학에서 유일무이하다.

Photo Ranking

meChat은 in-device에서 대화 문맥과 사진을 match한다.

[논문 발췌]

To this end, it utilizes GraphScore to effectively measure the semantic similarity between the conversation and in-device photos.

*특히 GraphScore는 ODP taxonomy로부터 얻은 Similarity graph에 대한 wPPR(weighted Personalized Page Rank) function을 computing함으로써  sementic similarity를 얻는다.

[Definition of GraphScore]

where) C and P are a set of top-k classified ODP categories of conversation and in-device photos, respectively.

wPPR(c,p)는 c와 p의 semantic relevance이고, 반면에 cw(c)와 cw(p)는 각 c와 p의 classification score 이다.

[논문 발췌]

Finally, it obtains a ranked list of semantically relevant in-device photos to the given conversation.

Prototype of meChat

meChat을 테스트해보기 위해 사용한 스마트폰은 

-Samsung Galaxy S7 with Android 6.0.1 Marshmallow

-LG Nexus 5X with Android 8.1 Oreo

특히, tiny text intelligence라 불리는 on-device text intelligence를 활용했다. 이를 'me' 라고 부른다.

이것의 지식 기반은 잘 구성된 전체 892개의 category를 가진 ODP taxonomy로 만들어졌다.

ODP knowledge-base의 top에서 'me'는 semantic classification과 semantic ranking을 지원한다.

SQLite를 사용함으로써, 38.9MB 되는 크기의 'me'를 smartphone에 넣는다. 

추가적으로 meChat의 실행가능성을 시험해보기 위해 두개의 스마트폰에 messaging application을 설치한다.

*실제 구현을 보고싶다면 다음 링크를 확인해보자.  https://youtu.be/ 4BzwMrhW8Ac.

위 Figure 2는 meChat의 architecture을 보여준다.

'me'와 context analyzer, photo analyzer, photo searcher을 포함한 세가지 software module을 포함하고 있다.

context analyzer과 photo analyzer은 on-going 대화와 in-device 사진들을 각각 분류한다. 

photo searcher는 on-going 대화와 사진들 사이의 semantic similarity을 기반으로 in-devices 사진에 순위를 매긴다.

[논문 발췌]

In me Chat, the photo analyzer works offline(i.e., when taking photos), while the context analyzer and photo searcher work online(i.e., when calling meChat)

meChat에서, photo analyzer는 offline으로 수행하는(사진을 찍을때) 반면 context analyzer과 photo searcher은 온라인으로 수행한다(meChat을 부를때).

합리적인 정확성 뿐만아니라 스마트폰에 어울리는 적당한 사이즈를 고려하여 모델을 선택했는데 photo analyzer에서 기기 내 사진의 GPS에 해당하는 장소 category를 얻기 위해  Place API of Foursquare을 사용했고, in-device 사진들의 objects를 인식하기 위해  'MobileNet_v1_1.0_224_quant'이라는 computer vision model을 활용했다.

*Place API of Four Square http://(https://developer.foursquare.com/places-api/)

*MobileNet_v1_1.0_224_quant (https://github.com/ tensorflow/models/blob/master/research/slim/ nets/mobilenet_v1.md/)

Performance Evaluation

[논문 발췌]

The goal of our experiments is to examine the efficacy of meChat in daily life conversations.

이 실험의 목표는 일상 대화에서의 meChat의 efficacy이다. 

*세명의 졸업생으로부터 211개의 위치가 저장되어있는 in-device 사진들을 수집.

* 이전 작업으로부터 사용한 33개의 scenario-based 기기 내 사용 데이터를 빌린다.

* 33개의 scenario 중 오직 16개의 sms text scenario를 대화로서 가져왔다 .이유는 남은 17개의 대화는 수집한 사진과 연관성이 없기 때문!

*이에 수집한 사진과 연관이 있는 다른 시나리오에 대한 17개의 대화 데이터를 추가적으로 구축하였다.

*마침내, 평균 136 term 길이의 33개 대화 데이터를 얻었다.

Conversation and Photo Classification

-Conversation classification의 성능 테스트

*대화가 주어지면 상위 5개 ODP 분류 카테고리와 관련하여 문장을 추론한다.

*그 다음, 세가지 다른 크기로 각각 ODP 카테고리를 label을 부여하는데 관계있고, 어느정도 관계있고, 관계없는 것으로 처리한다.

*k정확도와 관련하여 성능을 측정한다. (이 성능 metric은 추천 알고리즘 분야에서 가장 많이 쓰이는 것)

위 table을 보면 meChat은 conversation classification에서 준수한 성능을 보여주고 있다.

-classifuing in-device photos

*이와 관련하여 성능에 대한 세가지 접근을 비교했다. 

1) 앞서 제안된 GPS와 일치하는 장소 정보만을 분류하는 접근. (denoted as meChat pla)

2) 사진객체만을 단지 분류하는 접근 (denoted as meChat obj)

3) 위치정보와 객체 두가지를 넣음으로써 생성된 문맥 텍스트를 분류하는 접근. (denoted as meChat pla+obj)

*여기서 meChat(pla)가 가장 나쁜 성능을 보여줬다. 이유는 대부분 in-device photos는 더 낮은 위치 정보에 대한 정확도를 제공해주는 도심지역에서 찍혔기 때문이다.

*또한, 각 장소에서 얻어진 장소 category는 일반적으로 classification 성능을 낮게하는 결과를 만든 적어도 하나의 관련없는 category를 포함한다.

*meChat(obj)도 여전히 낮은 성능을 보여준다. 경험적으로 MobileNets의 낮은 객체 인식성능으로부터 이 결과가 나온건데 이는 5가지 정확도분석과 관련하여 거의 18퍼센트정도 낮게 측정되었다.

*주목해야할점은, meChat(pla+obj)는 가자 좋은 성능을 보여주었다. 특히, 정확성과 관련하여 meChat(pla)보다는 58.5%, meChat(obj) 보다는 13.9% 이상의 향상을 보여주었다. 

[논문 발췌]

The above experimental results clearly show that it is effective to project both place information and objects of photos on an ODP semantic space with respect to enriching the semantics of photos.

하지만, 전반적인 현실의 in-device photos분류의 저조한 성능은 다양한 관점에서 개선할 방법이 여전히 많다는걸 의미한다.

-Photo Ranking 성능 테스트

대화와 관련하여 정확성에 대한 k 와 MRR(mean reciprocal rank)를 이용해 in-device photo ranking을 평가하였다.

오직 top-ranked in-device photo에만 집중을 하였다. 왜냐하면 스마트폰은 사진을 보여주기에는 너무나 제한적인 화면이기 때문.

*기본적으로, syntactic 접근을 사용하였다. 이 접근은 대화와 in-device photo로부터 추출한 정보사이의 cosine similarity를 기반으로 하였다. 

*위 사진을 보면, meChat(pla+obj)는 k와 MRR정확성에 대한 접근에서 다른 것보다 월등한 성능을 보여줬다.

*구체적으로, meChat(pla+obj)의 성능은 세가지 추천된 사진들에 대해 적어도 하나는 공유되어진다는 것이다.

*위 깊이 분석을 통해서, 다음과 같은 observations를 만들었다.

[논문 발췌]

1) Utilizing both place information and objects of photos is much more effective than utilizing either of them alone. 2) Each semantic approach (i.e., meChat) achieves better performance than corresponding syntactic approach (i.e., Keyword).

1)place information과 photos의 objects 두개를 활용하는 것이 각각을 따로 사용하는것보다 더 나은 성능을 보여준다.

2)각각의 semantic approach는 일치하는 syntactic approach보다 더 나은 성능을 보여준다.

-System 성능 테스트

이를 시험하기에 앞서 Samsung Galaxy S7 smartphone 의 런타임과 에너지 소비를 먼저 측정하였다. 

*우선 런타임과 관련하여 클라우드 기반 text classification 과 meChat을 비교했다.

위 table3와 같이 meChat이 IBM보다 더 나은 성능을 보여준다. 

*런타임의 차이점은 mobile broadband 환경에 따라 증가한다. 

*Monsoon power meter을 사용한 meChat의 에너지 소비를 추가로 측정하였다.

*이는 음악을 듣는것 에너지 소비와 동일하다. 

*이후에, meChat과 Microsoft cognitive service의 image classification을 사용한 Mobile-Nets을 비교했다.

*클라우드 기반 Ms categorize는 그들의 86가지 category를 기반으로한 image categorizing을한다. 이에 대해 사진 한장에 MobileNets은 0.160s 가 걸리고 반면 클라우드 기반 MS는 7.338걸린다.

[논문 발췌]

The above-mentioned experimental results quantitatively indicate that privacy and latency benefit greatly from ondevice intelligence.

CONCLUSION

외부 서버에 의존하지 않은 스스로 작업을 할 수 있는 meChat은 사용자들에게 in-device photos와 관련하여 의미적인 공유를 도와줄 수 있다. 

외부 서버를 사용할 시에는 보안에 대해 가장 민감하기에 위 방법은 아주 참신하다.

[논문 발췌]

We believe meChat is oneof-a-kind personal assistant in that it works in a privacy-protecting manner with low perceived latency and energy consumption

meChat의 고유한 기능은 model,understand를 가능하게 해주고  통합된 ODP sematic spacec에서 in-device와 photos에 대한 대화 문맥을 비교할 수 있게 해준다.

2021-01-18~ 2021-01-21

meChat: In-Device Personal Assistant for Conversational Photo Sharing.

논문 해석 및 리뷰 완료.

-불굴의관돌이

3.3 다차원 배열

-다차원 배열

넘파이의 다차원 배열을 사용한 계산법을 숙달하면 신경망을 효율적으로 구현 가능하다.

다차원 배열도 기본은 '숫자의 집합'인데, N차원으로 나열하는 모든 것을 통틀어 다차원 배열이라 한다.

import numpy as np
A=np.array([1,2,3,4]) # 1차원 배열
print(A)
[1 2 3 4]

np.ndim(A)
1
A.shape
(4,)
A.shape[0]
4

B=np.array([[1,2],[3,4], [5,6]) #2차원 배열
print(B)
[[1 2]
 [3 4]
 [5 6]]
 
np.ndim(B)
2
B.shape
(3,2)

배열에 대해서는 다들 잘 알것이기에 간단하게 생략하고 넘어가겠다.

-행렬의 내적(행렬 곱)

이공계 출신이라면 당연히 내적을 할 줄 알것이라 믿는다. 그러므로 설명은 생략하고 파이썬을 통해 어떻게 내적을 구현하는지 살펴보자.

A=np.array([[1,2],[3,4]]) #2차원 배열 #2x2 행렬
B=np.array([[5,6],[7,8]]) #2차원 배열 #2x2 행렬

np.dot(A,B)

array([[19, 22],
       [43, 50]])

우리는 행렬의 내적을 할때 numpy 함수 np.dot()을 통해 계산할 수 있다. np.dot()은 넘파이 배열 2개를 인수로 받아 그 내적을 반환한다. 하지만 주의해야할 점은 np.dot(A,B)와 np.dot(B,A)는 다른 값이 될 수 있다는 점을 꼭 기억하자. 

또한 우리가 행렬의 곱을 할때는 중요한 점이 하나 있는데, 

다음과 같이 곱에서 차원의 원소수는 일치시켜야 한다. 그것이 약속이다!

-신경망의 내적

이번에는 신경망을 생각해보자, 

위 신경망은 편향과 활성화 함수를 생략하고 가중치만 갖는다. 위 그림을 파이썬으로 구현해보자.

X=np.array([1,2]) #1x2 행렬
W=np.array([[1,3,5],[2,4,6]]) #2x3 행렬
Y=np.dot(X,W)
print(Y)

[ 5 11 17]

-3층 신경망 구현하기

2층신경망까지 구현했다면, 3층 신경망은 어떨까? 

위 신경망은 입력층(0층)은 2개, 첫 번째 은닉층(1층)은 3개, 두 번째 은닉층(2층)은 2개, 출력층(3층)은 2개의 뉴런으로 구성된다.

표기법은 다음과 같다.

-각 층의 신호 전달 구현하기

우선 그림을 확인해보자.

편향을 뜻하는 뉴런 (1)이 추가되었다. 편향은 오른쪽 아래 인덱스가 하나밖에 없다는 것에 주의하자.

또한, 편향의 입력 신호는 항상 1임을 기억하자.

계산은 다음과 같다. 설명은 생략하겠다.

where)

코딩으로 구현하면,

X=np.array([1.0,.5])
W1=np.array([[.1,.3,.5],[.2,.4,.6]])
B1=np.array([.1,.2,.3])

A1=np.dot(X,W1)+B1
print(A1)

[0.3 0.7 1.1]

다음은 1층의 활성화 함수에서의 처리를 살펴보자. 이 과정은 다음과 같다.

위 그림과 같이 은닉층에서의 가중치 합(가중 신호와 편향의 총합)을 a로 표기하고 활성화 함수h()로 변환된 신호를 z로 표기한다. 여기서 활성화 함수로 앞선 포스팅에서 배운 시그모이드를 사용한다. 

코딩으로 살펴보자

def sigmoid(x):
    return 1/(1+np.exp(-x))
X=np.array([1.0,.5])
W1=np.array([[.1,.3,.5],[.2,.4,.6]])
B1=np.array([.1,.2,.3])

A1=np.dot(X,W1)+B1
Z1=sigmoid(A1)
print(A1)
print(Z1)

[0.3 0.7 1.1]
[0.57444252 0.66818777 0.75026011]

그 다음은 1층에서 2층으로 가는 과정을 살펴보자. 우선 그림은 다음과 같다.

구현 방식은 똑같다.

이제 코딩으로 구현해보자.

def sigmoid(x):
    return 1/(1+np.exp(-x))
X=np.array([1.0,.5])
W1=np.array([[.1,.3,.5],[.2,.4,.6]])
B1=np.array([.1,.2,.3])

A1=np.dot(X,W1)+B1
Z1=sigmoid(A1)
W2=np.array([[.1,.4],[.2,.5],[.3,.6]])
B2=np.array([.1,.2])

A2=np.dot(Z1,W2)+B2
Z2=sigmoid(A2)

print(A1)
print(Z1)
print(A2)
print(Z2)

[0.3 0.7 1.1]
[0.57444252 0.66818777 0.75026011]
[0.51615984 1.21402696]
[0.62624937 0.7710107 ]

마지막으로 2층에서 출력층으로의 신호 전달을 살펴보자. 우선은 그림은 다음과 같다.

출력층의 구현도 그동안의 구현과 거의 동일하다. 딱 한가지 다른점은, 활성화 함수만 지금까지의 은닉층과 다르다는 점이다. 

이를 코딩으로 구현해보자.

def sigmoid(x):
    return 1/(1+np.exp(-x))
X=np.array([1.0,.5])
W1=np.array([[.1,.3,.5],[.2,.4,.6]])
B1=np.array([.1,.2,.3])

A1=np.dot(X,W1)+B1
Z1=sigmoid(A1)
W2=np.array([[.1,.4],[.2,.5],[.3,.6]])
B2=np.array([.1,.2])

A2=np.dot(Z1,W2)+B2
Z2=sigmoid(A2)

def identity_function(x):
    return x

W3=np.array([[.1,.3],[.2,.4]])
B3=np.array([.1,.2])

A3=np.dot(Z2,W3)+B3
Y=identity_function(A3)
print(A1)
print(Z1)
print(A2)
print(Z2)
print(A3)
print(Y)

[0.3 0.7 1.1]
[0.57444252 0.66818777 0.75026011]
[0.51615984 1.21402696]
[0.62624937 0.7710107 ]
[0.31682708 0.69627909]
[0.31682708 0.69627909]

-출력층 설계하기

신경망은 분류와 회귀 모두에 이용 가능하다. 다만 둘 중 어떤 문제냐에 따라 출력층에서 사용하는 활성화 함수가 달라진다. 일반적으로 회귀에는 항등 함수를 분류에는 소프트맥스 함수를 사용한다. 

활성함수는 앞선 포스트에 열심히 다뤄놓았으니 필요하면 꼭 찾아서 보길 바란다.

-출력층의 뉴런 수 정하기

출력층의 뉴런 수는 주어진 문제에 맞게 적절히 정해야 한다. 일반적으로 분류하고 싶은 클래스 수로 설정한다. 책의 예를 빌리자면, 흔히 MNIST 과정에서 숫자 이미지 0~9중 하나로 분류하는 문제라면 출력층의 뉴런의 수는 10개로 설정한다.

뒤에 손글자 숫자 인식은 너무나 흔하며, 실제 이 과정을 더 심화로 다루는 것이 뒤에 나오니 지금은 생략하도록 하겠다. 그럼 20000

가중치 매개 변수의 적절한 값을 데이터로부터 자동으로 학습하는 능력이 이제부터 살펴볼 신경망의 중요한 성질이다. 

3.1 퍼셉트론에서 신경망으로 

3.1.1 신경망의 예

신경망을 그림으로 나타내면 위와 같다. 여기서 왼쪽부터 입력층, 은닉층, 출력층이라고 한다. 은닉층의 뉴런은 (입력층이나 출력층과 달리) 사람 눈에는 보이지 않는다. 그래서 '은닉'이라고한다.

*위 그림의 신경망은 모두 3층으로 구성되지만, 가중치를 갖는 층은 2개뿐이기 때문에 '2층 신경망'이라고 한다. 문헌마다 다를 수도 있으니 주의하자.

3.1.2 퍼셉트론 복습 

퍼셉트론에 관하여는 이전 포스팅에 잘 정리해 놓았으므로 생략한다.

3.1.3 활성화 함수의 등장

입력 신호의 총합을 출력 신호로 변환하는 함수를 일반적으로 활성하 함수(activation function)라 한다. '활성화'라는 이름이 말해주듯 활성화 함수는 입력 신호의 총합이 활성화를 일으키는지를 정하는 역할을 한다.

a=b+w1x1+w2x2 [식 3.4]

식 3.4는 가중치가 달린 입력 신호와 편향의 총합을 계싼하고 이를 a라 한다.

y=h(a) [식 3.5]

식 3.5는 a를 함수 h()에 넣어 y를 출력하는 흐름이다.

이를 그림으로 나타내면 다음과 같다.

가중치 신호를 조합한 결과가 a라는 노드가 되고, 활성화 함수 h()를 통과하여 y라는 노드로 변환하는 과정이 나타나 있다.

3.2 활성화 함수

이는 개인적인 포스팅을 하겠다.

출처는 blog.naver.com/handuelly/221824080339에서 많은 자료를 공유했다.

1. Sigmoid 함수

신경망에서 자주 사용하는 함수이다. 이는 흔히 통계학에서 사용하는 Logistic 함수라고 불리기도 하며, input 값에 따라 0~1을 출력하는 s형 곡선 함수이다. 식과 정의는 다음과 같다.

코딩으로 출력해보면,

import numpy as np
import matplotlib.pylab as plt

def sigmoid(x):
    return 1/(1+np.exp(-x))

x=np.linspace(-10,10,100)
y=sigmoid(x)
plt.figure(figsize=(4,4))
plt.plot(x,y,'black',linewidth=3)

plt.xlim(-10,10)
plt.grid(True)
plt.show()

2. Tanh 함수

Tanh함수는 쌍곡선 함수 중 하나로, 시그모이드 함수를 변형해서 얻을 수 있다. 

코딩으로 출력해보면,

def tanh(x,diff=False):
    if diff:
        return (1+tanh(x))*(1-tanh(x))
    else:
        return np.tanh(x)
        
x=np.linspace(-10,10,100)
y=tanh(x)
plt.figure(figsize=(4,4))
plt.plot(x,y,'black',linewidth=3)

plt.xlim(-10,10)
plt.grid(True)
plt.show()

3. ReLU

ReLu(Rectified Linear Unit,경사함수)는 가장 많이 사용되는 활성화 함수 중 하나이다.

Sigmoid와 tanh가 갖는 Gradient Vanishing문제를 해결하기 위한 함수이다.

코딩으로 출력해보면,

def relu(x):
    return np.maximum(0,x)
    
x=np.linspace(-10,10,100)
y=relu(x)
plt.figure(figsize=(4,4))
plt.plot(x,y,'black',linewidth=3)
plt.xlim(-10,10)
plt.grid(True)
plt.show()

4. Leaky ReLU

Leaky ReLU는 ReLU가 갖는 Dying ReLU(뉴런이 죽는 현상)을 해결하기 위해 나온 함수이다. 

위 출처 자료에서는 0.01이 아니라 매우 작은 값이라면 무엇이든 사용 가능하다고 한다.

Leaky ReLU는 x가 음수인 영역의 값에 대해 미분값이 0이 되지 않는다는 점을 제외하면 ReLU의 특성을 동일하게 갖는다.

코딩으로 출력해보면,

a=0.1
def leaky_ReLU(x):
    return np.maximum(a*x,x)

x=np.arange(-5.0,5.0,.1)
y=leaky_ReLU(x)

plt.plot(x,y)
plt.plot([0,0],[5.0,0.0],':')
plt.title('Leaky ReLU Function')
plt.show()

5.PReLU

Leaky ReLU와 거의 유사하지만 새로운 파라미터 α를 추가해 X가 음수인 영역에서도 기울기를 학습한다.

코딩으로 출력하면,

b=0.5  #새로운 파라미터 값은 임의로
def PReLU(x):
    return np.maximum(b*x,x)

x=np.arange(-5.0,5.0,.1)
y=PReLU(x)

plt.plot(x,y)
plt.plot([0,0],[5.0,0.0],':')
plt.title('PReLU Function')
plt.show()

6. ELU

Exponential Linear Unit은 ReLU의 모든 장점을 포함하며 Dying ReLU문제를 해결했다. 출력 값이 거의 zero-centered에 가까우며, 일반적인 ReLU와 다르게 exp 함수를 계산하는 비용이 발생한다.

코딩으로 표현해보면, 

def ELU(x,alpha):
    return (x>0)*x +(x<=0)*(alpha*(np.exp(x)-1))
x=np.arange(-5.0,5.0,.1)
y1=PReLU(x)
y2=ELU(x,alpha)
plt.plot(x,y2)
plt.plot([0,0],[5.0,0.0],':')
plt.title('ELU Function')
plt.show()

개형은 ReLU와 유사하며, 0보다 작은 경우는 alpha값을 이용해서 그래프를 부드럽게 만든다. 때문에 elu를 미분해도 부드럽게 이어지는 모습을 확인할 수 있다.

7. 소프트맥스 함수

은닉층에서 ReLU(또는 ReLU 변형) 함수들을 사용하는 것이 일반적이지만 그렇다고 해서 앞서 배운 시그모이드 함수나 소프트맥스 함수가 사용되지 않는다는 의미는 아니다. 분류 문제를 로지스틱 회귀와 소프트맥스 회귀를 출력층에 적용하여 사용한다.

코딩으로 출력해보면, 

def Softmax(x):
    return np.exp(x)/np.sum(np.exp(x))

x=np.arange(-5.0,5.0,.1)
y1=Softmax(x)
plt.plot(x,y1)
plt.title('Softmax Function')
plt.show()

(이미지 출처 : http://cs231n.github.io/neural-networks-3/)

참고자료: blog.naver.com/handuelly/221824080339