seujung tech blog

meta learning - Matching Network

Wed, 25 Jul 2018 01:07:12 +0900

시작하기

저번 시간에 meta learning 학습 방법 중 하나인 Few Shot learning 에 대해 설명하였습니다. 이번에는 이러한 meta learning 학습 방법 중의 하나인 Matching Network에 대해 설명하고자 합니다.

meta learning - Few Shot Learning

Fri, 29 Jun 2018 23:12:32 +0900

시작하기

최근에 가장 많이 연구되고 있는 분야 중 하나가 바로 meta learning 입니다. meta learning 은 learning-to-learning 이라고도 불리고 있습니다. 이런 meta learning을 학습하는 방법 중 하나가 few-shot learning이라는 방법이 있습니다. 이 few-shot learning의 경우에는 classification과는 다른 방법으로 문제 및 데이터 샛을 정의 합니다. 저도 기존의 방법과 다른 형태다 보니 이해하는데 많은 시간이 소요 되었습니다. 이번 post에서는 few-shot learning에 대해 소개해드리고자 합니다.

Few-Shot Learning 이란

Few-Shot Learning이란 해당 용어가 말하는 대로 아주 적은 데이터르도 데이터의 특징을 식별할 수 있도록 하는 것입니다. 강아지의 경우를 예로 들면 사람은 한 장의 사진을 통해 강아지라는 Class의 Concept를 학습할 수 있습니다. 하지만 기존의 Deep learning의 경우에는 수백장 또는 수천장의 사진을 통해서 강아지라는 class의 특성을을 학습합니다.

이에 Network 학습시에도 class 별로 적은 양의 이미지를 보여주어서 네트워크를 학습 시키고 학습한 Network를 테스트 하는 것이 Few-Shot Learning의 수행 Process 입니다

Few-Shot Learning 관련 주요 용어

n-way : 각 batch 별로 선택하는 label의 개수(N)
K-Shot : 각 class별로 선택하는 Data 개수(K)
support : 해당 batch에서 fine tuning을 위해 학습하는 셋
query : 해당 batch에서 class를 예측해야 하는 데이터 셋
episode : 한 epoch 당 수행하는 iteration 횟수

Few_Shot Data 생성 Process

[Step1] 가장 처음에는 Train/Test/(Valid) Set으로 데이터를 분할합니다. 이 방법은 기존에 알고리즘 학습을 위한 방법과 동일한 방법 입니다.

[Step2] 그 다음에는 각각 Dataset에서 N개의 Class에 대해 Sampling 작업을 수행 합니다.

[Step3] Sampling한 Label을 기준으로 하여 K개씩 데이터를 생성합니다. 이 때 2가지 Data Set(support/query)을 생성합니다. 이 때 support/query set은 서로 겹치지 않도록 합니다. 해당 데이터를 기준으로 support Set으로 모델을 학습을 먼저 수행하고, 모뎔에 대한 평가는 query로 판단합니다.

[주의사항]

Few-Shot Learning 에서 기존 데이터 생성과의 가장 큰 차이점은 Sampling 수행 시 label의 index가 계속 바뀐다는 점입니다. 기존 모델 학습의 경우 CIFAR-10의 경우를 예로 든다고 하면 airplane = 0 ,…,truck = 9 로 label에 대한 index를 부여한다고 하면 이 label은 동일한 상태로 유지됩니다. 하지만 Few-Shot Learning의 경우에는 sampling 에 따라 airplane의 label이 0이 될 수도 있고 2가 될 수도 있습니다. 이 점이 기존 classification가 가장 차별된 점입니다. 하지만 sampling 돤 데이터 에서 support Set 과 query는 동일한 label을 유지합니다. 이래야만 모델이 어떤 데이터가 어떤 label을 의미하는지를 알고 예측할 수 있기 때문입니다.

지금까지 이야기한 내용을 한 장으로 압축한 그림의 형태가 다음과 같은 형태 입니다.

Reference

https://www.slideshare.net/JisungDavidKim/oneshot-learning
Ravi, Sachin and Larochelle, Hugo. Optimization as a model for few-shot learning. In International Conference on Learning Representations (ICLR), 2017. link

WaveNet Review

Sun, 03 Jun 2018 05:21:48 +0900

논문 개요

딥마인드에서 오디오 시그널에 대한 모델로 제시한 network 입니다. 해당 논문이 가지는 가장 큰 장점은 오디오의 waveform 자체 데이터를 활용해서 모델링을 수행한 점입니다. 또한 이를 통해 생성한 TTS는 기존의 결과보다 많이 나은 성능을 보여주고 있습니다. 최근에는 Google Home에 해당 네트워크가 탑제되었으며 wav 파일 관련해서 reference network로 많이 활용되고 있습니다. Paper Deepmind blog

Network Architecture 설명

네트워크를 이해하기 위해서는 해당 내용에 대한 개념을 먼저 이해해야 합니다.

stack of dilated casual convolution
Residual and skip connection
softmax distribution

stack of dilated casual convolution

우선 WAV 데이터 형태는 1차원의 데이터 형태이기 때문에 CNN 적용 시 Conv1D 를 기본적으로 활용하고 있습니다. 해당 네트워크 구조를 이해하기 위해서는 우선적으로 dilation 개념에 대한 이해가 먼저 필요 합니다. dilation의 의미는 CNN 수행 시 커널을 구성함에 있어서 커널의 Pixel 사이에 얼마나 빈 공간을 줄 것인가 하는 점입니다. 기본적으로 사용하는 커널은 dilation=1 이며 dilation 값이 추가 될 수록 커널 사이에 빈 공간이 추가 된다고 보시면 됩니다.

WaveNet에서 사용하는 stacked of dilated casual convolution의 경우 1D Conv를 누적으로 쌓는 형태를 기본으로 한 후 누적 시 마다 dilation의 값을 2의 배수 만큼 증가시키는 형태압니다. 이 때 사용하는 parameter가 depth 값이며 만약 depth =10 이면 1, 2, 4, 8, 16 ,…, 512 순서로 stack 작업을 수행합니다.

Residual and Skip connections

Input Data(x)가 네트워크로 들어오면 다음의 Process 과정을 거칩니다.

tanh(x), sigmoid(x), skip_connection(x) 의 3가지 network path을 설정
3가지 path에 대해 Dilated Conv를 적용
tanh와 sigmoid의 경우에는 Gate Activation Unit 방법을 적용

$z = tanh(W_{f,k} * x) \odot \sigma(W_{g,k} * x)$

3의 결과에 1X1 Conv 적용
4의 결과와 Input Data(x)와 resudial 적용
5의 결과와 skip_connection(x)와 sum 적용
6의 결과에 대해 Relu - 1X1 Conv -Relu - 1X1 Conv - Softmax 를 적용하여 최종 Output을 산출

Softmax Disribution

WaveNet 적용 시 output class는 Audio의 timestep 별 integer 값 입니다. 하지만 이 값이 상당히 많은 range 값을 가지고 있습니다.(16bit의 경우에 65,534(2의 16제곱) 값을 가짐) 따라서 Output class 의 범위를 좁히는 과정이 필요한데 이 때 사용하는 방법이 $\mu$ -law companding transformation 입니다. 해당 방법을 적용하면 우리가 설정한 $\mu$ 값으로 class 범위를 줄일 수 있습니다.

$f(x_{t}) = sign(x_{t})\frac {ln(1+\mu|x_{t}|)}{ln(1+\mu)}$

Python을 이용한 구현

WaveNet을 구현하기 위해 다음의 Module을 lading 합니다.

%matplotlib inline
import numpy as np
from matplotlib import pyplot as plt
import mxnet as mx
from mxnet import gluon, autograd, nd
from mxnet.gluon import nn,utils 
import mxnet.ndarray as F
from IPython.display import Audio
from scipy.io import wavfile
from tqdm import tqdm
import sys

WaveNet 구현을 위한 필요 Class를 정의 합니다. 우선적으로 integer 값을 one-hot 으로 변환하기 위한 class를 정의 합니다.

class One_Hot(nn.Block):
    def __init__(self, depth):
        super(One_Hot,self).__init__()
        self.depth = depth
    def forward(self, X_in):
        with X_in.context:
            X_in = X_in
            self.ones = nd.one_hot(nd.arange(self.depth),self.depth)
            return self.ones[X_in,:]
    def __repr__(self):
        return self.__class__.__name__ + "({})".format(self.depth)

다음으로 WaveNet Class를 정의 합니다.

class WaveNet(nn.Block):
    def __init__(self, mu=256,n_residue=32, n_skip= 512, dilation_depth=10, n_repeat=5):
        # mu: audio quantization size
        # n_residue: residue channels
        # n_skip: skip channels
        # dilation_depth & n_repeat: dilation layer setup
        super(WaveNet, self).__init__()
        self.dilation_depth = dilation_depth
        self.dilations = [2**i for i in range(dilation_depth)] * n_repeat      
        with self.name_scope():
            self.one_hot = One_Hot(mu)
            self.from_input = nn.Conv1D(in_channels=mu, channels=n_residue, kernel_size=1)
            self.conv_sigmoid = nn.Sequential()
            self.conv_tanh = nn.Sequential()
            self.skip_scale = nn.Sequential()
            self.residue_scale = nn.Sequential()
            for d in self.dilations:
                self.conv_sigmoid.add(nn.Conv1D(in_channels=n_residue, channels=n_residue, kernel_size=2, dilation=d))
                self.conv_tanh.add(nn.Conv1D(in_channels=n_residue, channels=n_residue, kernel_size=2, dilation=d))
                self.skip_scale.add(nn.Conv1D(in_channels=n_residue, channels=n_skip, kernel_size=1, dilation=d))
                self.residue_scale.add(nn.Conv1D(in_channels=n_residue, channels=n_residue, kernel_size=1, dilation=d))
            self.conv_post_1 = nn.Conv1D(in_channels=n_skip, channels=n_skip, kernel_size=1)
            self.conv_post_2 = nn.Conv1D(in_channels=n_skip, channels=mu, kernel_size=1)
        
    def forward(self,x):
        with x.context:
            output = self.preprocess(x)
            skip_connections = [] # save for generation purposes
            for s, t, skip_scale, residue_scale in zip(self.conv_sigmoid, self.conv_tanh, self.skip_scale, self.residue_scale):
                output, skip = self.residue_forward(output, s, t, skip_scale, residue_scale)
                skip_connections.append(skip)
            # sum up skip connections
            output = sum([s[:,:,-output.shape[2]:] for s in skip_connections])
            output = self.postprocess(output)
        return output
        
    def preprocess(self, x):
        output = F.transpose(self.one_hot(x).expand_dims(0),axes=(0,2,1))
        output = self.from_input(output)
        return output

    def postprocess(self, x):
        output = F.relu(x)
        output = self.conv_post_1(output)
        output = F.relu(output)
        output = self.conv_post_2(output)
        output = nd.reshape(output,(output.shape[1],output.shape[2]))
        output = F.transpose(output,axes=(1,0))
        return output
    
    def residue_forward(self, x, conv_sigmoid, conv_tanh, skip_scale, residue_scale):
        output = x
        output_sigmoid, output_tanh = conv_sigmoid(output), conv_tanh(output)
        output = F.sigmoid(output_sigmoid) * F.tanh(output_tanh)
        skip = skip_scale(output)
        output = residue_scale(output)
        output = output + x[:,:,-output.shape[2]:]
        return output, skip
  

코드 구성은 앞에서 설명한 Process로 진행합니다. stack of dilated casual convolution을 수행한 후에 residual_forward를 거친 후 최종적으로 Softmax를 거쳐서 우리가 원하는 class별 확률 값을 산출합니다.

다음으로 Softmax Distribution 적용을 위한 Encoder/Decoder 함수를 정의합니다. 함수 내용은 앞에서 설명드린 수식을 코드로 표현한 결과 입니다.

def encode_mu_law(x, mu=256):
    mu = mu-1
    fx = np.sign(x)*np.log(1+mu*np.abs(x))/np.log(1+mu)
    return np.floor((fx+1)/2*mu+0.5).astype(np.long)

def decode_mu_law(y, mu=256):
    mu = mu-1
    fx = (y-0.5)/mu*2-1
    x = np.sign(fx)/mu*((1+mu)**np.abs(fx)-1)
    return x  

다음으로 네트워크 학습을 위해 네트워크를 정의하고, parameter 및 Optimizer를 설정 합니다. Gluon에서 GPU를 사용하기 위해서는 별도의 context를 지정해주어야 하기 때문에 그 부분을 포함해서 코드를 작성합니다.

ctx = mx.gpu(1)
net = WaveNet(mu=128,n_residue=24,n_skip=128,dilation_depth=10,n_repeat=2)
net.collect_params().initialize(ctx=ctx)
#set optimizer
trainer = gluon.Trainer(net.collect_params(),optimizer='adam',optimizer_params={'learning_rate':0.01 })
g = data_generation(data,fs,mu=128, seq_size=20000,ctx=ctx)
batch_size = 64
loss_fn = gluon.loss.SoftmaxCrossEntropyLoss()

WAV 데이터는 다음의 module을 통해 불러 올 수 있습니다. 이 때 loading WAV 가 stereo인 경우에는 2-dim 형태이기 때문에 이를 mono 형태로 변환을 해주어야 합니다.

import os
from scipy.io import wavfile
fs, data = wavfile.read(os.getcwd()+'/parametric-2.wav')
## stereo convert to mono
data = data.sum(axis=1) / 2

해당 module을 통해 입력한 데이터를 Softmax Distribution을 수행하기 전에 전처리 과정을 거쳐야 합니다. 이 때 중요한 점은 우리의 데이터의 -1 ~ 1 사이의 scale로 변환을 반드시 시켜야 합니다. 그 이후에 학습을 위한 데이터를 random으로 생성하기 위해 while문을 활용하였습니다.

def data_generation(data,framerate,seq_size = 6000, mu=256,ctx=ctx):
    div = max(data.max(),abs(data.min()))
    data = data/div
    while True:
        start = np.random.randint(0,data.shape[0]-seq_size)
        ys = data[start:start+seq_size]
        ys = encode_mu_law(ys,mu)
        yield nd.array(ys[:seq_size],ctx=ctx)

그 다음에는 네트워크를 학습합니다. 본 코드에서는 1000epoch를 학습하는 형태로 작성 하였습니다.

loss_save = []
max_epoch = 1000
best_loss = sys.maxsize
for epoch in range(max_epoch):
    loss = 0.0
    for _ in tqdm(range(batch_size)):
        batch = next(g)
        x = batch[:-1]
        with autograd.record():
            logits = net(x)
            sz = logits.shape[0]
            loss = loss + loss_fn(logits, batch[-sz:])
            #loss = loss/batch_size
        loss.backward()
        trainer.step(1,ignore_stale_grad=True)
    loss_save.append(nd.sum(loss).asscalar()/batch_size)

    #save the best model
    current_loss = nd.sum(loss).asscalar()/batch_size
    if best_loss > current_loss:
        print('epoch {}, loss {}'.format(epoch, nd.sum(loss).asscalar()/batch_size))
        print("====save best model====")
        filename = '/home/skinet/work/research/WaveNet/models/best_perf_epoch_'+str(epoch)+"_loss_"+str(current_loss)
        net.save_params(filename)
        best_loss = current_loss
    
    # monitor progress
    if epoch%100==0:        
        batch = next(g)
        logits = net(batch[:-1])
        #_, i = logits.max(dim=1)
        i = logits.argmax(1).asnumpy()
        plt.figure(figsize=[16,4])
        plt.plot(list(i))
        plt.plot(list(batch.asnumpy())[sum(net.dilations)+1:],'.',ms=1)
        plt.title('epoch {}'.format(epoch))
        plt.tight_layout()
        plt.show()

네트워크 학습을 수행한 후에 학습 결과를 바탕으로 하여 generation을 수행합니다. generation은 다음의 함수를 통해 수행할 수 있습니다. 지금 보여드리는 코드는 for-loop 형태로 되어 있어서 속도가 다소 느릴 수 있습니다. 이 부분은 추후에 개선이 필요한 부분 입니다.

def generate_slow(x,models,dilation_depth,n_repeat,ctx, n=100):
    dilations = [2**i for i in range(dilation_depth)] * n_repeat 
    res = list(x.asnumpy())
    for _ in tqdm(range(n)):
        x = nd.array(res[-sum(dilations)-1:],ctx=ctx)
        y = models(x)
        res.append(y.argmax(1).asnumpy()[-1])
    return res

수행 결과 다음과 같은 loss 흐름을 보이며 학습이 진행 되었습니다.

Reference

Relational Network Review

Tue, 29 May 2018 19:11:31 +0900

논문 개요

Visual QA 문제에서 관계형 추론 (relational reasoning) 이란 방법을 제시하여서 높은 성능을 보인 Deep Mind 논문에 대해서 설명하고자 합니다. 상당히 간단한 구조의 알고리즘을 통해 기존 방법과 확연한 차이를 보인 점이 가장 큰 장점입니다. 또한 해당 논문에서 제시한 방법은 QA 문제를 넘어서 다양한 Domain에서도 활용할 수 있다는 점이 또 하나의 큰 장점 입니다.

https://arxiv.org/pdf/1706.01427.pdf

문제 사항 설명

해당 논문에서 주요 다룬 데이터는 CLEVR data set을 사용 하였습니다. 해당 데이터의 주요 구조는 다음과 같습니다.

Original image 데이터를 보고 text로 구성된 질문에 대한 답을 제시하는 형태입니다. 질문은 크게 2가지 형태로 구성되오 있습니다.

Relational question : 이미지 안에 있는 object 간의 관계를 파악하여서 정답을 제시하는 구조
- 위의 그림을 예로 들면 각각 object 간의 형태 및 특징을 파악 한 다음에 서로의 특징을 비교하는 형태의 질문을 의미합니다.(노란색 원통형 물체와 같은 물체가 있는가?)
Non-relational question : 이미지 안에 있는 하나의 object의 특성을 제시하는 구조
- 위의 그림을 예로 들면 어떤 특정 물체의 모양/색깔/크기 등을 직접적으로 물어보는 질문을 의미합니다(갈색 공의 크기는 어떠한가?)

Network Architecture

relational network은 다음의 수식 형태로 표현할 수 있습니다.

$RN(O) = f_\phi\left(\sum_{i,j} g_\theta(o_i, o_j)\right)$

데이터 형태를 object로 변환한 다음에 각각의 object를 input으로 하는 함수 $ g_\theta $ 에 대입하고 난 후 그 결과를 합한 이후에 $ f_\phi $ 에 다시 통과하는 형태 입니다.

해당 수식을 그림으로 표헌하면 다음과 같습니다.

relational network에서 가장 중요한 것은 우리가 파악하고자 하는 대상을 domain에 상관없이 object라는 객체로 변환하여 해당 object 간의 관계를 파악하는 것입니다. 여기에서 이미지 데이터는 CNN을 통해 산출한 Feature maps을 질문의 경우에는 LSTM을 통과한 결과 값을 object로 간주합니다. 우리는 이미지와 문장 간의 관계가 아닌 object와 object 간의 관계를 파악하는 것으로 문제를 변환하게 됩니다. 관계를 파악 하는 방법은 의외로 간단합니다. 각 object 별로 concat을 수행한 후에 MLP($ g_\theta $) 의 input을 하게 됩니다. $ g_\theta $를 통과하고 나온 값에 대해 element-wise sum을 수행한 후 다시 한 번 MLP($ f_\phi $)를 수행하여서 최종적으로 우리가 알고 싶은 class에 대한 값을 산출하게 됩니다.

이 때 가장 중요한 점은 RN 부분에서의 input data size가 달라지는 점입니다. pair 개수만큼 새로 데이터를 생성하는 형태이기 때문에 $ pair^2 $ 만큼의 데이터가 증가하게 됩니다. 증가된 데이터가 $ g_\theta $ 를 통과하게 되고 증가한 만큼의 데이터를 원래의 size로 줄이기 위해 element-wise sum 을 수행하개 됩니다.

수행 결과

성능은 기존의 알고리즘에 비해 월등히 좋은 것을 확인 할 수가 있습니다.

Test 데이터 구조

CLEVR 데이터로 실험을 바로 수행하면 좋으나 Data Set 크기 및 학습 속도를 고러하여 CLEVR 데이터를 사용하지 않고 논문에서 제시한 Sort-of-CLEVR 데이터 셋을 사용 하였습다

Sort-of-CLVR 데이터 셋 구조

이미지 형태는 1 X 75 X 75 형태이며 각각 이미지당 20개의 질문(10 relational / 10 non-relational)으로 구성되어 있습니다. 질문의 형태는 다음과 같습니다.

Non-relational Question Case
- query shape : 빨강색 물체의 형태는?
- query horiziontal position : 빨간색 물체 왼쪽에 물체가 있는가?
- query vertical position : 빨간색 물체 위에 물체가 있는가?
Relational Question Case
- closest-to : 녹색 물체와 가장 가까운 물체의 형태는?
- furthest-from : 녹색 물체와 가장 먼 물체의 형태는?
- count : 녹색 물체는 총 몇 개인가?

질문에 대한 대답은 총 10가지 형태 입니다

color : red, green, black, orange, yellow, gray
Yes/No : yes , no
object 형테 : rectangle, circle

relational network 주요 Code

Convolution feature generation code
relational network code

Performance

추가 활용 방안

해당 방법은 다른 영역에서도 활용이 가능합니다. 만약 내가 3가지 형태의 domain 데이터가 있고 이들의 관계를 통해 어떤 결과를 알고 싶다고 하면 다음과 같은 형태로도 활용이 가능합니다.

우리가 알고 싶은 영역의 데이터에 대해 object로 변환을 하고 해당 object 간의 관계를 파악하는 형태로 하여 relational network를 활용 할 수 있습니다.

참조 코드

relational network를 MXNet(Gluon)을 활용하여서 구현을 해 보았습니다. 해당 코드는 다음 링크를 통 해 확인하시기 바랍니다. Source Code

pytorch - gluon 함수 Mapping

Sun, 01 Apr 2018 19:41:00 +0900

목적

Deep learning 관련 Open Framework 중 mxnet(gluon) 으로 구현 시에 보통은 pytorch 코드를 참조하여서 구현을 많이 하고 있음(gluon user 부족으로 인해…)
대부분의 구조가 거의 비슷하지만 일부 함수의 경우에는 내용이 달라서 pytorch 함수를 gluon 함수로 변환하는 과정이 필요함

함수 mapping 표 (update 진행 중)

Function	Pytorch	Gluon	비고
Dimension 삽입	torch.unsqueeze(data,1)	data.expand_dims(1)
Reshape	x.view(1,2,3)	x.reshape(shape=(1,2,3))
Swap shape	x.permute(0,2,1)	x.swapaxes(1,2)	F.swapaxes(x,1,2)는 deprecated 됨
Data Copy	x.repeat(1,25,1,1)	F.repeat(x,repeats=25,axis=1)
Concat data	torch.cat([a,b],3)	F.concat(a,b,dim=3)
Return specific shape	x.size()[2]	x.shape[2]
Batch matrix product	x.bmm(y)	nd.linalg_gemm2(x, y)
Clipping	x.clamp(min, max)	nd.clip(x, min, max)
Convert to numpy	x.numpy()	x.asnumpy()
transposein 2 dim	torch.t(x)	x.T
inner product	x.dot(y)

Reference

PyTorch to MXNET

gradient를 활용한 DNN 해석 방안

Tue, 19 Dec 2017 17:43:59 +0900

목적

Deep learning의 경우에는 일반적으로 결과에 대한 해석이 black-box 인 것으로 알려져 있음
최근에 이미지 데이터의 경우에는 gradient 기반으로 class 산출 결과에 대한 해석 방안이 언급되고 있음(Ex. grad-CAM 등)
gradient 값을 활용하여 class 예측에 주요 영향을 주는 input variable을 찾고자 함

가정 사항 및 접근 방법

deep learning 학습 시 weight matrix 의 경우에는 input data에서 주요 의미가 있는 feature에 대해 추상화 작업을 하는 것으로 의미적으로 해석이 가능함
학습된 deep learning 모형을 대상으로 하여 feature 특성을 발현할 수 있는 loss를 강제로 생성함
해당 loss에 대해 back propagation을 수행하여 최초의 weight matrix의 gradient 값을 계산함
해당 gradient에 대해 input feature 단위로 summary를 한다고 하면 해당 feature별로 발현되는 gradient 값을 산출 할 수 있음
이 때 gradient 값이 큰 feature가 해당 class를 설명해주는 주요한 feature일 것이다.

Test 수행 Approach

결국은 loss를 어떻게 생성하는지가 해당 방법에서 가장 중요한 사항임
loss 생성 관련 해서 다양한 테스트를 수행하여서 적합한 방법을 찾아보고자 함

Network 생성

3개 layer로 구성된 DNN 생성
각각 layer에 activation 함수로 ReLU 적용
최종으로 softmax 를 적용하여 각 class 별로 확률을 생성 하였으며, loss는 CrossEntropy를 적용함
loss는 Adam 적용(lr = default)
train 데이터 기준 20 epoch수행

Concept Test

Approach 1

input 데이터를 기준으로 하여 전혀 다른 label 값을 부여하여서 loss를 발생시킴
- 해당 class로 데이터를 fitting 하기 위해 1st layer에서 gradient 수정이 발생함
- gradient 값의 변화가 생기는 부분이 바로 원래 input data의 특성을 나타내는 부분 일 것이라는 가정으로 출발함
Test 수행 process
- MNIST 데이터 중 7번 class의 데이터를 100개 추출 - 해당 데이터에 대한 label을 0으로 강제 할당함(강제로 다른 label을 할당함) - loss를 산출하고 1st layer 의 weight의 gradient 값을 산출
- dimension을 input data와 동일한 형태로 변환
- sum, mean 두 가지 방법을 사용해 보았으니 큰 차이점은 없음
- 해당 Test에서는 mean 방법을 적용
- 해당 결과에 ReLU를 적용
Test 수행 결과

Input Data	gradient Data

input data의 특징알 가지는 형태로 gradient 값이 산출됨
여기서 의미있는 점은 input data의 경우에는 다양한 형태를 가지고 있으나 gradient 산출 결과는 이를 반영한 일종의 표준 형태라는 점임

Approach 2

Test 수행 process
- Approach 1과 기본적으로 동일한 방법으로 수행하나 label을 해당 label을 그대로 사용
- 1st layer의 weight의 gradient 산출
- 해당 gradient 값에 대해 1/(1-gradient) 형태로 값을 변환
Test 수행 결과

Input Data	gradient Data

Approach 1 보다 결과가 좋지 않음
- 1-gradient 값을 활용하였기 때문에 음영이 바뀌어서 나옴
- 해당 클래스 만의 특징을 추출 하였다고 보기 어려움

Approach 3

loss 를 기존과 다른 방법으로 산출함
- 1,2 의 경우에는 각 class별 확률 값을 기준으로 하여 loss 산출 결과를 활용함
- softmax를 통과하기 이전의 값을 기준으로 하여 해당 class의 값 만을 합한 형태로 하여 loss를 산출함

이후 방법은 Approach 1,2의 방법과 동일함
Test 수행 결과

Input Data	gradient Data

- Approach 1 과 유사한 결과를 보임 - Approach 1의 경우에는 다른 Class를 어떤 값으로 설정하는지가 gradient 산출에 중요한 영향을 주나 Approach 3의 경우에는 해당 Class만의 특징을 산출하는데에는 더 적합할 것으로 보임

Approach 4

Approach 3 + Approach 1의 방법으로 활용
- 전체적인 방법은 Approach 3의 방법을 활용하나 정답지 라벨을 기존 label과 다른 값을 선정함
gradient 값이 음수로 나오기 때문에 산출한 gradient 값에 -1 을 곱함
Test 수행 결과

Input Data	gradient Data

결론

first layer의 weight matrix에서의 gradient 값을 활용하여 input data 에서 의미있는 feature를 산출할 수 있을 것으로 보임
4가지 방법을 적용하여 test를 수행하였는데 3,4 번의 방법이 활용 관점에서 적절할 것으로 보임
- Approach 3의 경우에는 해당 Class의 특징을 산출하는데 활용할 수 있음
- Approach 4의 경우에는 다른 Class와 비교하여 어떤 차이점을 알고자 할 때 활용할 수 있음