1. GAN Inversion

GAN Inversion이란?

GAN : latent code(z) -> real image GAN inversion : real image -> latent code(z) => GAN inversion의 목표는 input image를 복원할 수 있는 가장 적절한 latent code를 찾아내는 것이다. 이미지를 나타내는 적절한 latent code를 찾아내면, 이를 이용해 GAN model을 통해 이미지를 생성할 수 있다.

2. Image Processing using Multi-Code GAN Prior

paper : Image Processing Using Multi-Code GAN Prior (2020 CVPR)

Goal

• GAN models as powerful prior to various image inversion tasks

기존의 Problems

• Expensive training
• 일반화 성능(Generalization)
• Single latent code는 하나의 image를 표현하기에 한정적이다.

Solution : mGANprior

• Pre-trained된 model을 사용한다.
• Multiple latent codes(z) -> multiple feature maps
• 한 개의 latent code를 사용하는 기존 선행연구의 방식들은 이미지의 정보를 전부 복원하기에 어렵다. 따라서, mGANprior는 N개의 latent code를 사용하여 target image의 sub-region을 복원할 수 있도록 한다.

Method

Multi-Code GAN Prior는 여러 개의 latent code를 적용하여, 여러 개의 feature map을 Generator의 중간 레이어에서 생성한다. 그 다음, Adaptive Channel Importance를 적용하여 Input 이미지를 복원한다. 자세한 과정은 다음과 같다.

1. N개의 random latent code z로부터 시작한다.
2. 각각의 z들은 Generator G1을 거쳐 feature를 형성한다.
3. Adaptive channel importance를 channel-wise하게 곱해서, N개의 feature마다 어떤 채널에 가중치를 줄 지 결정한다. 이를 통해, 더욱 다양한 정보를 표현할 수 있게 된다.
4. 최종적으로 형성된 N개의 feature들을 더해준 후, Generator G2를 거쳐 output을 만들어낸다.
5. Target image와 비교하여 loss function을 통해 latent code z를 업데이트하는 과정을 반복한다.

GAN Inversion

Baseline equation : $$ z^* = argmin_z\mathcal{L}(G(z),x) $$ Target Image x가 주어지면, GAN Inversion은 x와 가깝게 이미지를 제작할 수 있도록 적절한 latent code를 찾아 GAN의 generation process를 reversing할 수 있도록 한다. 기존의 연구들은 single latent code를 optimizing 하기 때문에 image를 잘 만들어 내는 데에 한계가 있었다. 따라서 mGANprior에서는 여러 개의 latent code를 사용하고, Adaptive channel importance를 가진 해당 intermediate feature map을 구성한다.

Feature Composition

GAN Inversion에서 가장 올바른 solution은 z_n_에서 제작된 이미지들을 Image Space X에 입히는 것이나, X는 linear space가 아니므로, 합성된 이미지를 linear하게 결합한다고 해서 의미론적인 이미지를 생성하기 어려우며, Input을 세부적으로 복원하기 어렵다. 따라서, mGANprior에서는 feature composition을 위하여 intermediate feature map을 사용한다. 즉, Generator가 두 개의 네트워크, $${G_1}^l, {G_2}^l $$ 로 나뉜다. 여기서 l은 feature composition을 위한 intermediate layer의 index이다.

Adaptive Channel Importance(α)

각각의 z_n이 이미지의 particular regions를 복구하여야 하기 때문에, adaptive channel importance(α)를 적용하여 object와 texture를 반영한 이미지를 복구할 수 있도록 한다. αn 은 adaptive channel importance로 표현되고 각각의 z_n에 대해 다른 semantic 정보를 반영하도록 도움을 준다. channel-wise multiplication이기 때문에, feature에 있는 각각의 channel에 multiplication을 취한다. $$ x^{inv} = G_2^{l}(\sum{n=1}^{N}(F_n^{l}\odotα_n)) $$

Optimization Function

• 위에서 제시한 Equation을 adaptive channel importance, feature composition을 적용한 식으로 바꾸면 아래와 같이 변환할 수 있다.
• Low-level과 high-level information을 알아내기 위하여 pixel-wise reconstruction error를 적용하여 Optimization 식이 아래와 같이 표현된다.

Applications

어떤 pre-trained GAN model을 사용하는지에 따라 다양한 활용이 가능하다.

Results

[Reference]

https://openaccess.thecvf.com/content_CVPR_2020/papers/Gu_Image_Processing_Using_Multi-Code_GAN_Prior_CVPR_2020_paper.pdf https://www.youtube.com/watch?v=RCSb6OMan8Q

Tell,Draw,and Repeat: Generating and Modifying Images Based on Continual Linguistic Instruction

Introduction

paper : Tell, Draw, and Repeat: Generating and Modifying Images Based on Continual Linguistic Instruction(2019 ICCV) GeNeVA는 Generative Neural Visual Artist로 빈 캔버스에 점진적으로 그림을 그리는 과정에 영감을 받았다. 주어진 caption(사진 삽화에 붙은 설명)에 따라 이미지를 만드는 것이 아닌 continual linguistic 입력을 기반으로 반복적으로 이미지를 생성한다.

Task and Datasets

GeNeVA는 Teller와 Drawer가 존재한다. Teller는 지시를 하고, Drawer는 지시에 맞게 캔버스에 그림을 반복적으로 그려나간다. Teller는 Drawer가 생성한 이미지를 통해 전체 과정의 진전을 판단하다. Drawer는 지시에 맞는 물체를 물체의 특성을 잘 살리면서 또한 물체들간의 위치를 고려하여 이미지를 생성해야 한다. Drawer는 또한 이전의 이미지와 지시를 유지하는 방식으로 이미지를 수정해 나가야한다. 따라서 이전의 이미지와 지시를 기억하고 있어야 한다.

사용한 데이터셋은 CoDraw dataset과 CLEVR dataset을 iterative하게 변형시킨 i-CLEVR dataset을 이용했다. CoDraw dataset과 i-CLEVR dataset 예시

두 dataset 모두 합성 이미지(실제 사진과 같은 이미지가 아닌)들로 구성된 dataset이다. 해당 논문의 저자들은 "합성 이미지를 통해 모델의 성능을 향상시킬 수 있었고, 사실적인 이미지(사진)는 더욱 도전적인 작업이지만, 이 모델은 합성 이미지를 생성하는데만 국한되지 않는다"고 밝혔다.

Contributions

• Instruction history의 맥락에서 이미지의 그럴듯한 수정에 특화된 새로운 recurrenct GAN을 제안한다.
• i-CLEVR dataset을 소개한다.
• 지시에 합당한 위치에 물체들을 위치시키는 능력을 평가하기 위해 rsim(relationship similarity) metric을 제안한다.
• 비반복적 생성 모델과 비교하며 반복적 생성 모델의 중요성을 설명한다.

Model

notation $x_{0}$: canvas Q = ($q_{1}$,...,$q_{n}$): sequence of instructions G/D: generator/discriminator R: second GRU $E_{G}$: image encoder(shallow CNN) $E_{D}$: image encoder for discriminator $z_{t}$: a noise vector sampled from N(0,1) $h_{t}$: context-aware condition $f_{G_{t-1}}$: context-free condition $x_{t}$: ground-truth image $\tilde{x}_{t}$: generated image

Generator part

t 시점의 합성된 이미지 $\tilde{x}{t}$ = G($z{t}$, $h_{t}$, $f_{G_{t-1}}$) 먼저 generator의 각 입력들에 대해 알아보자.

• $z_{t}$는 위의 notation과 마찬가지로 t 시점의 noise vector이다.
• $h_{t}$는 context-aware condition으로 $h_{t}$ = R($d_{t}$, $h_{t-1}$) 이다. 먼저 $d_{t}$는 t 시점의 instruction $q_{t}$를 bi-directional GRU GloVe word embedding을 이용해 인코딩 된 벡터이다. 따라서 $h_{t}$는 instruction encoding $d_{t}$와 t-1시점의 context-aware condition $h_{t-1}$을 입력으로 받아 R(GRU)를 통과하여 현 시점의 정보(insturction)와 이전 시점의 정보(instruction)를 종합하여 새로운 이미지를 그리는데 수정해야할 부분을 나나태는 벡터이다.
• $f_{G_{t-1}}$은 context-free condition으로 $f_{G_{t-1}}$ = $E_{G}$($\tilde{x}_{t-1}$)이다. 이전 시점에 생성된 이미지를 인코딩하여 현재 캔버스의 정보를 나타내는 벡터이다.

다음으로 t 시점의 합성된 이미지 $\tilde{x}_{t}$가 합성되는 과정을 확인하자.

1. t 시점의 instruction $q_{t}$를 language encoder를 통해 $d_{t}$를 생성
2. R($d_{t}$, $h_{t-1}$)을 통해 $h_{t}$ 생성
3. $z_{t}$와 conditioning augmentation_을 통한 $h{t}$를 concat하여 noise vector 생성
4. t-1 시점의 이미지를 image encoder를 통해 $f_{G_{t-1}}$를 생성

Conditioning Augmentation(CA)

이미지 출처:Stack-GAN

기존에는 text condition을 나타내는 $c$를 $\varphi_{t}$을 비선형 변환하여 생성했다. 하지만 이런 경우 고정된 $c$는 $\varphi_{t}$의 높은 차원(100-dimensions 이상)의 latent space를 잘 표현하지 못하고, 데이터의 양이 적을 경우 latent data manifold에 불연속성을 야기한다. 이러한 문제들은 generator 학습에서 바람직하지 못하다.

해당 문제들을 해결하기 위해 Stack-GAN에서 CA를 사용한다. CA는 위의 그림과 같이 $\mu_{0}$ = mean $\mu$($\varphi_{t}$), $\sigma_{0}$ = diagonal covariance matrix $\Sigma$($\varphi_{t}$)를 이용해 $\hat{c}$을 $N$($\mu_{0}$, $\sigma_{0}$)에서 랜덤 샘플링을 통해 생성한다. 랜덤 샘플링을 위해 표준정규분포에서 랜덤 샘플링한 $\epsilon$을 이용해 $\hat{c}$ = $\sigma_{0}$$\epsilon$ + $\mu_{0}$을 구한다.

CA를 통해 coditioning manifold의 작은 변화(perturbation)에 대한 robustness를 증가시킬 수 있다. 또한 CA의 randomness를 통해 text to image translation에서 동일한 text에 대해 다양한 포즈와 형태를 갖는 이미지를 얻을 수 있다.

추가로 conditioning manifold의 smoothness를 강화하고, overfitting을 막기 위해 KL divergence regularization: $$D_{KL}(N(\mu(\varphi_{t}),\Sigma(\varphi_{t}))||N(0,I))$$을 사용한다. 해당 regularization은 generator loss에 추가해서 regularize를 수행한다.

[Code]

# https://github.com/Maluuba/GeNeVA/blob/master/geneva/definitions/conditioning_augmentor.py 

class ConditioningAugmentor(nn.Module):
    def __init__(self, emb_dim, ca_dim):
        super(ConditioningAugmentor, self).__init__()
        self.t_dim = emb_dim
        self.c_dim = ca_dim

        self.fc = nn.Linear(self.t_dim, self.c_dim * 2, bias=True)
        self.relu = nn.ReLU()

    def encode(self, text_embedding):
        x = self.relu(self.fc(text_embedding))
        mu = x[:, :self.c_dim]
        logvar = x[:, self.c_dim:]
        return mu, logvar

    def reparametrize(self, mu, logvar):
        std = logvar.mul(0.5).exp_()
        eps = torch.cuda.FloatTensor(std.size()).normal_()
        return eps.mul(std).add_(mu)

    def forward(self, text_embedding):
        mu, logvar = self.encode(text_embedding)
        c_code = self.reparametrize(mu, logvar)
        return c_code, mu, logvar

Conditional Batch Normalize(CBN)

GeNeVA-GAN의 generator의 모든 convolution layer에 CBN을 적용했다. CBN은 condition에 따라 Batch Normalize(BN)을 적용하는 방법이다. 이미지 출처: Modulating early visual processing by language 논문

기존의 BN에 경우 text embedding 정보를 담고 있는 $\gamma$, $\beta$를 학습하기 여렵다. CBN은 text embedding을 MLP를 통과시킨 값을 기존의 BN에 추가하여 수행한다.

기존의 BN: BN($F_{i,c,h,w}$|$\gamma_{c}$, $\beta_{c}$) CBN: BN($F_{i,c,h,w}$|$\hat{\gamma_{c}}$, $\hat{\beta_{c}}$), $\hat{\gamma_{c}}$ = $\gamma_{c}$+$\Delta$$\gamma_{c}$, $\hat{\beta_{c}}$ = $\beta_{c}$ + $\Delta$$\beta_{c}$ $\gamma_{c}$, $\beta_{c}$: pre-trained된 값 또는 임의의 초기값 $\Delta$$\gamma_{c}$, $\Delta$$\beta_{c}$: MLP($e_{q}$), $e_{q}$ = text embedding

CBN의 장점: 컴퓨터 연산적 효율성이 늘어나고, text embedding으로 feature maps를 조작할 수 있게 된다.

[code]

# https://github.com/Maluuba/GeNeVA/blob/master/geneva/definitions/conditional_batchnorm.py

class ConditionalBatchNorm2d(nn.Module):
    def __init__(self, in_channels, conditon_dim):
        super().__init__()
        self.channels = in_channels
        self.bn = nn.BatchNorm2d(in_channels, affine=False)
        self.fc = nn.Linear(conditon_dim,
                            in_channels * 2)

        self.fc.weight.data[:, :in_channels] = 1
        self.fc.weight.data[:, in_channels:] = 0

    def forward(self, activations, condition):
        condition = self.fc(condition)
        gamma = condition[:, :self.channels]\
            .unsqueeze(2).unsqueeze(3)
        beta = condition[:, self.channels:]\
            .unsqueeze(2).unsqueeze(3)

        activations = self.bn(activations)
        return activations.mul(gamma).add(beta)

Discriminator part

GeNeVA-GAN은 이미지를 반복적으로 수정하면서 이미지를 생성하므로 각각의 시점에서 이미지의 real/fake 판별로는 충분한 학습이 이루어질 수 없다. 따라서 논문의 저자들은 기존의 discriminator들과 다르게 3가지 변화를 줬다.

1. image encoder $E_{D}$를 이용해 t-1 시점의 ground-truth 이미지 $x_{t-1}$과 t시점에 생성된 이미지 $\tilde{x}_{t}$를 인코딩 한 후 두 인코딩된 벡터를 fusion layer를 통과시킨다. fusion layer는 학습을 하는 layer가 아닌 인코딩 된 feature map들의 element-wise subtraction 또는 concatation을 수행한다. fusion layer를 이용하는 방법으로 discriminator는 이미지의 변화에 더 집중할 수 있다. 추가로 _projection discriminator_을 사용했다.
2. discrminator loss에 real/fake loss외에 (real image, wrong instruction)쌍을 통해 계산되는 wrong loss를 추가했다.
3. 해당 시점에 존재하는 객체(objects)들의 존재를 알기 위한 auxiliary objective를 사용했다.

Projection Discriminator

이미지 출처: cGANs with Projection Discriminator 논문

$$ f(x,y;\theta) := f_{1}(x,y;\theta) + f_{2}(x;\theta)=y^TV\phi(x;\theta_{\Phi}) + \psi(\phi(x;\theta_{\Phi});\theta_{\Psi}) $$ V: y(condition)에 대한 embedding vector $\phi$: 기존의 CNN layers discriminator $\psi$: scalar function 이미지 출처: cGANs with Projection Discriminator 논문

p : generated distribution q : true distribution r : log likelihood ratio

식(1)의 $D(x,y)$ = $A(f(x,y))$, A = activation function(주로 sigmoid) 식(2)는 기존의 loss function인 식(1)의 optimal solution $f^*(x,y)$을 두 개의 log likelihood ratio의 합으로 나타낸것이다. log linear model 식(4)를 이용해서 식(2)의 $r(y|x)$를 나타낸것이 식(5)이다. 같은 방법으로 식(2)의 $r(x)$ 또한 나타낼 수 있다. 이것들을 정리하면 식(7) $f(x,y)$를 정의할 수 있고, 이 식은 위의 식 $f(x,y;\theta)$와 같다.

위와 같이 정의된 $f(x,y;\theta)$를 이용한 discriminator를 사용하는 경우 기존의 condtional GAN들 보다 성능이 좋았다

[code]

https://github.com/Maluuba/GeNeVA/blob/master/geneva/models/networks/discriminator_factory.py (코드가 길어서 링크만 첨부) 위 주소의 코드 144~146줄을 보면 projection discriminator의 구현을 확인할 수 있다.

Loss

$c_{t}$: {$h_{t}$, $x_{t-1}$} $\hat{c}{t}$: t시점의 이미지 $x{t}$와 맞지 않는 instruction $\tilde{c}{t}$: {$h{t}$, $f_{G_{t-1}}$} Hinge Advesarial Loss를 사용했다.

Hinge Adversarial Loss

이미지 출처: Geometric-GAN

Discriminator의 마지막 활성화 함수는 identity function으로 sigmoid를 사용하지 않는다. real pair ($x_{t}$, $c_{t}$)에 대해 discriminator 출력값이 1 이하인 경우에만 학습하고, fake/wrong pair에 대해 discriminator 출력값이 -1이상인 경우에만 학습을 한다. hinge loss를 사용하면 기존의 gan loss보다 mode collapse 문제를 해결할 수 있다는 장점이 있다.

[code]

# https://github.com/Maluuba/GeNeVA/blob/master/geneva/criticism/losses.py

class HingeAdversarial():
    @staticmethod
    def discriminator(real, fake, wrong=None, wrong_weight=0.):

        l_real = F.relu(1. - real).mean()
        l_fake = F.relu(1. + fake).mean()

        if wrong is None:
            return l_real + l_fake
        else:
            l_wrong = F.relu(1. + wrong).mean()
            return l_real + wrong_weight * l_wrong + (1. - wrong_weight) * l_fake

Auxiliary Loss

t 시점 N개(dataset에 존재하는 모든 개체의 수)의 개체 각각에 대한 BCEloss를 계산한다. 뒤에 설명할 projection conditioning 이전의 discriminator layer에 N차원 linear layer를 추가하고, 활성화 함수로 sigmoid를 사용하여 각각의 $p_{i}$를 얻는다.

Zero-centered Gradient Panalty

학습의 안정성을 위해 discriminator의 parameters $\Phi$를 regularize 시킨다. gradient가 커지는 것을 막아준다. ($\gamma$:hyper parameter)

Implementation Details

model의 구조와 관련된 2가지

1. self-attention layer
2. spectral normalization

Self-Attention Layer

GeNeVA-GAN의 generator/discriminator의 layers 중간에 들어간다.

Self-Attention GAN(SAGAN)은 기존의 convolutional 연산만을 이용한 GAN은 CNN의 local receptive field로 인하여 Long-range dependence를 잘 고려하지 못하는 문제를 해결하기 위해 self-attention을 적용했다.

참고) Long-range dependence(LRD): is a phenomenon that may arise in the analysis of spatial or time series data. It relates to the rate of decay of statistical dependence of two points with increasing time interval or spatial dsitance between the points => 시간 간격/공간 거리가 증가함에 따라 두점의 통계적 의존성 붕괴율과 관련됨 이미지 출처: SA-GAN 논문

[code]

# https://github.com/Maluuba/GeNeVA/blob/master/geneva/definitions/self_attention.py

class SelfAttention(nn.Module):
    def __init__(self, C):
        super(SelfAttention, self).__init__()

        self.f_x = spectral_norm(
            nn.Conv2d(in_channels=C, out_channels=C // 8, kernel_size=1))
        self.g_x = spectral_norm(
            nn.Conv2d(in_channels=C, out_channels=C // 8, kernel_size=1))
        self.h_x = spectral_norm(
            nn.Conv2d(in_channels=C, out_channels=C, kernel_size=1))

        self.gamma = nn.Parameter(torch.zeros(1))

    def forward(self, x):
        B, C, H, W = x.size()
        N = H * W

        f = self.f_x(x).view(B, C // 8, N)
        g = self.g_x(x).view(B, C // 8, N)

        s = torch.bmm(f.permute(0, 2, 1), g)  # f(x)^{T} * g(x)
        beta = F.softmax(s, dim=1)

        h = self.h_x(x).view(B, C, N)
        o = torch.bmm(h, beta).view(B, C, H, W)

        y = self.gamma * o + x

        return y

Spectoral Normalization(SN)

GeNeVA-GAN의 discriminator의 모든 layer에 SN을 사용했다. SN은 다른 normalize와 같이 pytorch에 구현되있다. 이미지 출처: SN-GAN

$D(x,\theta)$ = $A(f(x,\theta))$, A: activation function $\nabla f$가 유계가 아니거나 심지어 계산이 불가능할 수 있다. 이러한 문제를 해결하기 위해 $||f||{Lip} \le K$ 즉 K-Lipschitz 제약을 준다. $||f||{Lip} \le M$은 $L_{2}$ norm을 이용해 정해진 구간에서 임의의 $x$,$x'$에 대해 $||f(x) - f(x')|| / ||x-x'||$ $\le$ M을 의미한다. 여기서 M은 립시츠 상수 이미지 출처 : https://velog.io/@tobigs-gm1/basicofgan

이와 같은 립시츠 제약은 WGAN에서 사용되었다. WGAN은 1-립시츠 제약을 위해 weight clipping을 사용했었다. 이미지 출처: SN-GAN

$\sigma$: spectral norm($L_{2}$ matrix norm) $\sigma(A)$ : $A^T$$A$의 eigen value 중 가장 큰 값을 $\lambda_{1}$일 때, $\sqrt{\lambda_{1}}$

식(7)을 보면 $||f||_{Lip}$의 립시츠 상수는 각 layer의 W들의 spectral norm의 곱들보다 작다. 따라서 각 layer의 W를 $\sigma$(W)로 normalize 하면 즉 W = $W/\sigma(W)$이면 립시츠 상수가 1이 된다.

SN은 각 layer의 transformation이 한 방향으로 민감(sensitive)해지는 것을 방지한다. 이러한 원리로 SN-GAN은 WGAN, WGAN-GP, Batch Norm, Layer Norm 등의 다른 방법들 보다 좋은 성능을 보였다.

Evaluation

성능 평가를 위해 Inception-v3 구조를 기반으로 한 object detector와 localizer를 만들었다. Inception-v3의 마지막 layer를 linear layer with sigmoid와 linear layer 두 부분으로 수정하여 첫 번째 부분은 object detect를 위한 분류기로 사용하고, 두 번째 부분은 localizer를 위해 개체의 좌표를 회귀한다.

GeNeVA-GAN의 성능평가는 기존의 GAN의 성능평가를 위한 Inception score와 FID가 부적절하여 object detecotor와 localizer를 이용해 precision,recall,F1-score를 구한다. 또한 object detector와localizer를 이용해 노드가 개체이고, 엣지가 위치관계(앞,뒤,좌,우)인 그래프를 생성한다. real/fake 이미지의 그래프를 비교해 개체들이 올바른 위치에 존재하는지 평가할 수 있다. 이 평가를 위해 Relational Similarity를 구한다.

Relational Similarity

관계 유사성으로 개체가 올바른 위치에 있는지 평가한다. $$ rsim(E_{G_{gt}},E_{G_{gen}}) = recall * \frac {\vert E_{G_{gen}} \cap E_{G_{gt}}\vert} {\vert E_{G_{gt}}|} $$

real/fake 이미지가 같은 개체들을 갖고 있는 경우 중 위치가 일치하는 비율에 recall을 곱해서 Relational Similarity를 구할 수 있다.

[code]

# https://github.com/Maluuba/GeNeVA/blob/master/geneva/metrics/inception_localizer.py

def get_graph_similarity(detections, label, locations, gt_locations, dataset):
    intersection = (detections & label).astype(bool)
    if not np.any(intersection):
        return 0

    locations = locations.data.cpu().numpy()[intersection]
    gt_locations = gt_locations.data.cpu().numpy()[intersection]

    genereated_graph = construct_graph(locations, dataset)
    gt_graph = construct_graph(gt_locations, dataset)

    matches = (genereated_graph == gt_graph).astype(int).flatten()
    matches_accuracy = matches.sum() / len(matches)
    recall = recall_score(label, detections, average='samples')

    graph_similarity = recall * matches_accuracy

    return graph_similarity

Conclusion

GeNeVA-GAN을 통해 주어진 instructions에 따라 반복적으로 합리적인 그림을 그릴 수 있는 것을 확인했다. 실험을 통해 비반복적 방법도 어느 정도 성능을 보일 수 있으나 반복적인 방법에 비해 낮은 성능을 확인했다. 또한 해당 모델을 위한 새로운 metric(Relational Similarity)을 제안했다. 마지막으로 실제 사진과 같은 이미지로 학습하기 위해 해당 모델에 맞는 주석이 달려있는 image sequence가 필요하다.

References

Geometric-GAN: Jae Hyun Lim and Jong Chul Ye, “Geometric GAN,” arXiv:1705.02894 [stat.ML], 2017.

SN-GAN: Takeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida, “Spectral normalization for generative adversarial networks,” in International Conference on Learning Representations (ICLR), 2018.

SA-GAN: Han Zhang, Ian Goodfellow, Dimitris Metaxas, and Augustus Odena, “Self-attention generative adversarial networks,” arXiv:1805.08318 [stat.ML], 2018.

projection discriminator: Takeru Miyato and Masanori Koyama, “cGANs with projection discriminator,” in International Conference on Learning Representations (ICLR), 2018.

zero-gentered gradient penalty: Lars Mescheder, Andreas Geiger, and Sebastian Nowozin, “Which training methods for GANs do actually converge?” in International Conference on Machine learning (ICML), 2018.

conditional batch normalization: Harm de Vries, Florian Strub, J´er´emie Mary, Hugo Larochelle, Olivier Pietquin, and Aaron C Courville. Modulating early visual processing by language. In NIPS, pp. 6576–6586, 2017.

Stack-GAN: Han Zhang, Tao Xu, Hongsheng Li, Shaoting Zhang, Xiaogang Wang, Xiaolei Huang, and Dimitris N. Metaxas, “StackGAN: Text to photo-realistic image synthesis with stacked generative adversarial networks,” in International Conference on Computer Vision (ICCV), 2017.

출처가 없는 이미지: GeNeVA-GAN 논문 내의 이미지

Image-to-Image Translation

지난 강의들에서 Image-to-Image Translation(pix2pix, CycleGAN), Multi-domain Image-to-Image Translation(StarGAN, RelGAN)을 다뤘습니다. 오늘은 Unsupervised Image-to-Image Translation을 주제로 UNIT, MUNIT, FUNIT 등의 논문들을 요약 정리해보며 Image-to-Image Translation에 대해 조금 더 이해해 보고자 합니다. (참고로 여기서 말하는 unsupervised는 unpaired dataset을 의미)

UNIT(Unsupervised Image-to-Image Translation)

Introduction

• 한 이미지가 다른 도메인으로 변환된 모습을 보여주는 paired 이미지 데이터가 없는 unsupervised 문제를 다룬다.
• 두 개의 도메인에 대해 두 개의 marginal distribution이 있을 때 joint distribution을 추론하는건 ill-posed problem이다.
• 이를 해결하기 위해 shared latent space assumption이 등장했다.

  Assumption - Shared Latent Space

  이는 서로 다른 도메인의 이미지 pair가 하나의 동일한 latent space로 mapping 될 수 있다는 가정으로 아래와 같은 식들로 표현할 수 있다. 위 식에서 shared latent space를 통해 cycle-consistency도 설명할 수 있다.

  Framework

  VAE{E, G}

  Encoder-Generator pair는 VAE를 구성하고 있다. Encoder를 통해 image를 latent space z에 mapping 시키고 Generator를 통해 z에서 image를 복원한다.

  Weight-sharing

  두 VAE를 연관시키기 위해서 weight-sharing을 사용한다. 위의 (b) 그림에서 점선에 해당하는 부분이다. 하나의 latent space z를 공유하기 위해서 두 Encoder의 last few layers와 두 Generator의 first few layers에서 weight를 공유한다. 이것만으로는 같은 latent space를 공유한다는 것을 보장할 수 없지만 여기에 adversarial training을 통해서 하나의 latent space를 공유하게 된다.

  GAN {G, D}

  Generator는 reconstruction stream에서의 이미지와 translation stream에서의 이미지를 생성하는데 reconstruction stream은 지도식으로 학습할 수 있기 때문에 translation stream에 대해서만 adversarial training을 한다.

  Learning

  E1, E2, G1, G2를 고정시키고 D1, D2를 학습하고 D1, D2를 고정시키고 E1, E2, G1, G2를 학습한다. 우리가 앞서 배웠던 GAN, VAE loss와 같다.

  Results

  

MUNIT(Multimodal Unsupervised Image-to-Image Translation)

Introduction

Multimodal을 위해 이미지에 대한 latent space가 content space와 style space로 decomposed 된다. 여기서 content space는 domain에 상관없이 공유하고 style space는 domain-specific 하다고 가정한다. 이를 통해 다양한 style을 입힌 결과를 보여줄 수 있다.

Related Works

GANs, Image-to-image translation, Style Transfer

앞의 강의에서 다룬 내용들..(생략)

Learning disentangled representations

content와 style에 대해 content-the underling spatial structure, style-the rendering of the structure 라고 말한다. 두 도메인이 같은 content distribution을 공유하지만 다른 style distributions을 가진다.

Model

(a) x1, x2 각각의 이미지가 style과 content로 나누어지고 다시 원래 이미지를 복구하는 Encoder, Decoder 구조
(b) x1에서 뽑아낸 content를 x2에서 뽑아낸 style을 입히면 x1->x2 image translation이 이루어진다.

Bidirectional reconstruction loss

한 domain 내에서 이미지가 content, style space로 mapping 되는 Encoder와 latent space가 다시 이미지로 mapping 되는 Decoder를 학습 시키기 위해 L1 reconstruction loss를 사용한다.

image reconstruction

image - latent - image

latent reconstruction

latent - image - latent

• content, style 각각에 대한 loss
• content reconstruction loss는 변환된 이미지가 input 이미지에 대한 의미적 content를 보존하도록
• style reconstruction loss는 주어진 다른 style code들에 대해 다양한 결과를 내도록

Adversarial loss

기존의 GAN loss와 동일

Total loss

여기서 λ 람다 값들은 reconstruction term의 중요도를 조절하는 weight이다.

Style-augmented Cycle Consistency

bidirectional reconstruction loss와 같은 내용이지만 어떤 데이터 셋에서는 이걸 명시적으로 사용했을 때 유용하다.

Implementation Details

Content encoder

several strided convolutional layers to downsample the input, several residual blocks to further process it
모든 convolutional layer들이 Instance Normalization(IN)을 한다. 즉 content 정보만 남긴다.

Style encoder

several strided convolutional layers, global average pooling layer and fully connected layer
Instance Normalization을 사용하지 않는다. IN 이 original feature의 평균, 분산 등 중요한 스타일 정보를 나타내는 것들을 없애기 때문에

Decoder

AdaIN을 통해 style 정보를 content에 입힌다 AdaIN Parameters = (N, ) Shape Vector, β = mean(AdaIN Params), γ = std(AdaIN Params)

Results

FUNIT(Few-Shot Unsupervised Image-to-Image Translation)

앞서 설명한 MUNIT에 기반해 few-shot을 가능하게 한 모델이다.

1. many source class images but few target class images
2. few target class images는 test time에만 존재하고 많은 다른 class로 이루어질수도 있다.

Model

Few-shot Image Translator

FUNIT의 목표는 source class의 image를 few target class image들로 본 적 없는 target class로 mapping 시키는 것이다. FUNIT을 학습시키기 위해서 object classes 이미지(class 간의 pair 등은 고려하지 않은 다양한 동물들의 이미지) 데이터를 사용했고 이를 source classes라고 한다. 그리고 test 때는 새로운 object class에 대한 few images를 target class로 한다.

어떤 source class든 target class의 이미지들에 맞게 변환되어야 한다.

conditional image generator G와 multi-task adversarial discriminator D로 이루어져 있다.

Generator의 경우 아래와 같이 content image x와 sef of K class images를 input으로 받는다. Training을 할 때는 source classes에서 겹치지 않게 random으로 두 개의 class를 뽑아서 학습시킨다.

few-shot image translator G의 구조는 MUNIT에서 봤던 것과 매우 유사한데, content encoder와 class encoder, decoder로 이루어져 있다.

content encoder는 input content image를 content latent code z로 mapping 시키고 class encoder는 각각의 class image 들에 대해 intermediate latent vector를 구한 후 mean을 구해 final class latent code z를 만든다.

Decoder에서는 역시 AdaIN을 사용한다. class image들은 global look(object appearance), content image는 local structure(locations of eyes)를 조절하도록 한다.

Generator가 더 많은 source classes(more species of animals)로 학습할수록 few-shot 성능이 더 좋아진다.

Multi-task Adversarial Discriminator

논문에 나와있는 Discriminator 구조!

Discriminator가 multiple adversarial classification을 하는데 각각이 binary classification task로 input image가 real인지 판단한다.

S개의 source class가 있을 때 Discriminator에서 S개의 output이 나오는데 real 이미지에 대해서는 해당 class의 output이 false일때만, translation fake 이미지에 대해서는 해당 class의 output이 true일때만 D를 penalize한다.

Generator도 해당 클래스의 output이 false일때만 update 된다.

Learning

GAN loss, content reconstruction loss, feature matching loss로 이루어져 있다.

GAN loss

GAN loss에서 D 위의 첨자는 object class를 의미하고 loss는 오직 class의 binary prediction score에 의해 계산된다.

content reconstruction loss

input content image와 input class image(K=1)로 같은 image를 사용해 input과 동일한 output image를 생성하도록 한다.

feature matching loss

Discriminator에서 마지막 prediction layer를 제거한 feature extractor Df로 translation output과 class image들 사이의 특징(feature map)의 차이가 최소화 되도록 학습한다.

Results

이외의 UNIT

여기서 더 다루지는 못했지만, 이후 NVIDIA에서 이어서 나온 COCO-FUNIT과 이외에도 TUNIT, DUNIT 등이 있다.

간단하게 그림으로만 소개하자면,

COCO-FUNIT

COCO-FUNIT(Few-Shot Unsupervised Image Translation with a Content Conditioned Style Encoder)은 style code를 뽑을 때 content에 대한 정보를 함께 줘서 input image의 구조를 더 잘 보존한다.

TUNIT

TUNIT(Rethinking the Truly Unsupervised Image-to-Image Translation)은 지금까지 unpaired의 의미를 가지고 있던 unsupervised의 정의를 다시해서 아무런 label도 없이(domain label도 없이) image-to-image translation 하는 모델이라고 소개한다. Guiding network E를 통해 pseudo label을 만들어(Mutual Information 기반) 같은 pseudo label 이미지들은 비슷한 이미지가 생성되도록 한다.

DUNIT

DUNIT(Detection-based Unsupervised Image-to-Image Translation)은 이미지 전체를 하나로 보지 않고 detection을 통해 해당 부분의 디테일을 보존한다.

지금까지 UNIT에 대해 다뤄봤습니다! 더 알아보고 싶다면 아래 논문들을 참고하세요~ [UNIT] https://arxiv.org/abs/1703.00848 코드 : https://github.com/mingyuliutw/UNIT
[MUNIT] https://arxiv.org/abs/1804.04732 코드 : https://github.com/NVlabs/MUNIT
[FUNIT] https://arxiv.org/abs/1905.01723 코드 : https://github.com/NVLabs/FUNIT
[COCO-FUNIT] https://arxiv.org/abs/2007.07431
[TUNIT] https://arxiv.org/abs/2006.06500
[DUNIT] https://openaccess.thecvf.com/content_CVPR_2020/html/Bhattacharjee_DUNIT_Detection-Based_Unsupervised_Image-to-Image_Translation_CVPR_2020_paper.html

1. Few-Shot Learning Introduction

Few-Shot Learning Problem

Few-Shot Learning Task?

• Training에 사용하는 support data / Test에 사용하는 query data
• N-way K-shot
• N : class의 수, K : class당 이미지의 수
• 일반적으로 성능은 N에 반비례, K에 비례
• 보통 N은 10이하로, K는 1이나 5로 설정

  기존의 Deep Neural Net의 한계

• Large-scale training dataset이 필요함
• 아래와 같은 적은 수(5-way 1-shot)의 training set으로 학습시키는 것은 불가능

Transfer Learning

• Few-shot task를 해결하고자 제안됨
• 1)Acuire knowledge : pre-trained된 network를 이용해, 2)Transfer knowledge : test phase에서 few-shot example들을 이용해 fine-tuning하고자 함
• 한계 : Few-shot 데이터에서 overfitting
• Few-shot learning의 목표 : Few-shot scenario에서도 잘 동작하는 transfer learning 알고리즘을 고안하는 것(ex. metric learning, meta-learning methods,...)

Few-Shot Meta Learning

• Input : support data(labeled), query data(unlabeled)

• Output : query 이미지에 대한 classification

• 학습 방식 Train "learning algorithm"

  • Meta-learner f_θ
  • f_θ를 few-shot classification task에 optimization (learn-to-learn) => Meta-learner를 few-shot task의 분포로 학습시키는 것

  

• Training episodes는 기존의 base class data에서 샘플링
• N classes x (K support examples + M query examples)
• Meta-learner $$ f_θ(S) = m_ψ $$
• Objective (query classification loss) $$ min_θ\displaystyle\sum_{(S,Q)}^{}L(f_θ(S),Q) $$
• Meta-learning routine
  1. Training episode(S,Q)를 샘플링
  2. Classification model(m_ψ = f _θ(S))를 생성
  3. Query의 label을 predict
  4. Query classification loss로 θ를 optimize

Matching networks for one-shot learning (2016'NIPS)

Few-Shot Learning vs Meta-Learning

• Few-shot learning : 제한된 데이터(few-shot data)로 transfer하는 것을 목표로 하는 transfer learning (ex. fine tuning, metric-learning, meta-learning)
• Meta-learning : learn to learn. few-shot learning에 이용되는 방식 중 하나

2. Main Types of Few-Shot Learning Algorithms

Few-Shot Learning 알고리즘의 종류

• Metric-based
• Model-based
• Optimization based

Metric Learning (Metric-Based)

Key Idea

• Support 데이터와 query 데이터 간의 거리 유사도를 측정하는 방식

• Efficient distance metric을 학습한다.

• 주어진 support 데이터를 feature space에 나타낸다. 같은 class의 데이터는 가깝게 두고, 다른 class의 데이터는 거리가 멀어지게 학습한다.

• Query 데이터를 유클리디안 거리(혹은 cosine 유사도)가 가까운 support 데이터의 class로 예측한다.

  Metric learning을 이용한 논문

• Siamese Neural network for one-shot image recognition (2015' ICML) : CNN 기반의 feature extractor 도입

  

• Prototypical networks for few-shot learning (2017' NIPS) : Prototype - class별 support 데이터의 평균 위치로, 각 class를 대표하는 역할 : Prototype과 query 데이터끼리의 거리 계산 -> 기존 방식보다 계산량 감소, 구조 단순화

Optimization Based Meta-Learning

Key Idea

• Few-shot task를 parameter optimization problem으로 생각
• 딥러닝 모델은 gradient의 backpropagation을 통해 학습한다. 그러나, gradient-based optimization은 few-shot task가 아닌 large-scale data를 위해 설계되었다.
• Optimization based meta-learning은 적은 수의 샘플에 대한 optimization 기법에 대해 다룬다.

MAML : Optimization based meta-learning

• Meta-learns θ -> fine-tuning을 통한 transfer learning으로 빠른 학습을 가능하게 한다.

• $$ min_θ\displaystyle\sum_{(S,Q)}^{}L(θ-α▽_θL(θ,S),Q) $$ 1) Support 데이터 S를 이용해 fine-tuning한다. 2) Query마다 classification score을 predict한다. 3) Query에 대한 loss를 이용해 θ를 optimize한다. $$ θ ← θ- β▽_θL(θ-α▽_θL(θ,S),Q) $$

• MAML은 약간의 업데이트로 서로 다른 task로 각각 최적화한 뒤(Adaptation), 이렇게 최적화된 각각의 모델로부터 gradient를 구해 서로 다른 task에 빠르게 최적화할 수 있는 공통의 초기 weight를 찾는 방식(meta-learning)으로 학습을 진행한다.

• 위 그림에서 adaptation을 의미하는 회색 실선은 각 task의 Loss(1, 2, 3)를 계산해 모델을 업데이트하는 것을 나타낸다. 이렇게 서로 다른 task로부터 업데이트함으로써 특정 task에 overfitting되는 것을 방지할 수 있다.

• Meta-Learning을 의미하는 검은 선은 위에서 각각 task에서 계산했던 gradient를 모아 gradient의 gradient를 계산해 모델을 업데이트하는 것을 의미한다. 이 과정에서 여러 task에 빠르게 최적화할 수 있는 공통의 weight로 점점 업데이트되고(검은 실선), 이렇게 찾은 weight로부터 다시 특정 task에 모델을 adaptation함(회색 점선)으로써 우리가 원하는 target task에 빠르게 최적화할 수 있다. 이러한 adaptation/meta-learning 과정을 최적의 weight를 찾을 때까지 반복함으로써, 우리가 원하는 target task에 빠르게 수렴하는 모델을 얻을 수 있다.

MAML의 단점

• 계산량이 많고 복잡하다.
• Large model일 경우 training하기 어렵다.
• Class별로 meta learner를 따로 학습해야 한다.

Optimization-based 논문

• Optimization as a model for few-shot learning (2016)
• On First-Order Meta-Learning Algorithms(2018)

Model-Based Meta-Learning

• 모델의 내부나 외부에 기억장치(memory)를 별도로 둠으로써, 모델 학습속도를 조절할 수 있게 한다.
• Meta Learning with Memory Augmented Neural Networks (2016)
• Meta Networks (2017)

  Usage in Generation Task

Few-Shot Adversarial Learning of Realistic Neural Talking Head Models (2019' ICCV)

Goal

• Target 이미지의 특징(표정)을 landmark로 나타내어, source 이미지의 스타일을 입힌다.

  Architecture

• Generater, Embedder, Discriminator

• Meta learning architecture

  • Meta-training 단계 : 모델은 face landmark를 realistic한 사진으로 변환하는 방법을 학습한다. 여기서, 다양한 인물(논문에서는 약 140,000명)을 하나의 모델에서 학습시켜 generalize하고자 한다.
  • Fine-tuning 단계 : 앞 단계에서 다양한 인물을 일반화하여 학습하기 때문에, fine-tuning 단계에서 few-shot의 이미지로 talking head를 빠른 시간에 학습할 수 있다. Fine-tuning 단계에서는 meta-learning에서 학습해 놓은 파라미터들로 시작하여 unseen한 데이터에 대해 빠르게 학습한다.

[Reference]

https://lilianweng.github.io/lil-log/2018/11/30/meta-learning.html#model-based https://www.youtube.com/watch?v=MaGudzppu3I&t=11567s https://www.youtube.com/watch?v=hE7eGew4eeg&t=687s http://dsba.korea.ac.kr/seminar/?mod=document&pageid=1&keyword=few&uid=63 https://openaccess.thecvf.com/content_ICCV_2019/html/Zakharov_Few-Shot_Adversarial_Learning_of_Realistic_Neural_Talking_Head_Models_ICCV_2019_paper.html https://www.kakaobrain.com/blog/106

(OP-GAN) Self-Supervised CycleGAN for Object-Preserving Image-to-Image Domain Adaptation

1. 요약

* 기존 GAN의 I2I에서의 한계

image-to-image translation에서 GAN 기반 방법(ex> CycleGAN, DiscoGAN 등)은 이미지의 object를 보존하는데 실패하는 경향이 있다.
따라서 domain adaptation 등의 task에 어려움이 있다.

• horse → zebra task에서 털 부분이 잘못 변환되거나 눈, 코같은 detail한 특징의 제거, blurry한 결과 등의 결과 발생하는 것을 볼 수 있다.

(출처 : Image-To-Image Translation Using a Cross-Domain Auto-Encoder and Decoder / https://www.mdpi.com/2076-3417/9/22/4780/htm)

(참고)

• domain adaptation?

• source domain : 학습에 사용되는 labeled data가있는 도메인

• target domain : 분포가 다른 target task가 수행되는 도메인
  => 위 그림의 source domain과 target domain 간의 데이터 분포가 다르다고 가정하면,
  domain adaptation은 주로 source 및 target domain에서 공통 특징을 학습하는 데 중점을 둔다.

(출처 : Multi-subject subspace alignment for non-stationary EEG-based emotion recognition)

* 제시된 해결 방안

content의 왜곡을 막기 위해 CycleGAN의 generator 부분에 (semantic) segmentation 네트워크를 적용하자는 아이디어 등장!

(참고)
(semantic) segmentation
: 이미지의 각 pixel이 어느 class에 속하는지 예측하는 것. pixel 단위의 annotation들이 같이 input으로 들어가야 한다.

출처: https://bskyvision.com/491

(한계)
CycleGAN이 content 인식 변환을 수행할 수는 있지만 pixel 단위의 annotation이 필요하다. → cost 증가 :(

* OP-GAN 제안

pixel 단위의 annotation 없이 CycleGAN의 content consistency(일관성)를 향상시키기 위해 self-supervised를 포함했다.

2. CycleGAN 의 문제

• CycleGAN의 구조 (night-to-day 예시)

(CycleGAN의 구체적인 내용은 재윤님이 강의를 참고 해주세요ㅎㅎ)

Source image A (저녁 사진) → Translated image B (낮 사진) → Reconstructed image A' (저녁 사진)로 생성할 때,
input인 A와 생성한 A'가 비슷한지를 보는 것이 cycle-consistency loss이다.
덧붙이자면 A 도메인 → B 도메인의 단순 매핑이 아니라, 다시 복구되는 것도 고려해 원본이 유지되게끔 제약을 추가하는 것이다.

이 cycle-consistency loss는 A → B (또는 B → A) 사이의 직접적인 reconstruction loss가 없기 때문에
한 도메인에서 다른 도메인으로 변환할 때 object의 왜곡이 발생한다.

(참고) Translating and Segmenting Multimodal Medical Volumes with Cycle- and Shape-Consistency Generative Adversarial Network

3. OP-GAN

• CycleGAN과 동일하게 unpaired I2I translation 하기 위해 adversarial loss와 cycle-consistency loss를 사용했다.
• CycleGAN과 동일한 generators ($G_{AB}, G_{BA}$)와 그에 상응하는 discriminators ($D_B, D_A$) 구조를 가진다.
• 이미지의 content를 보존하기 위해 multi-task self-supervised 샴 네트워크(S)를 추가했다.
• 샴 네트워크(S)의 input으로는 원래 이미지와 생성된 이미지를 받는다.

1) Self-supervised learning

(1) 먼저 원래 이미지와 생성된 이미지를 3 × 3 격자로 나눈다. (하나의 칸을 patch라고 한다.)

(2) training 동안 샴 네트워크의 input으로 할 2개의 patch 쌍을 random으로 선택한다.

• 이 논문에서는 2가지 가정을 한다.

1. C1 같이 원래 이미지와 생성된 이미지의 같은 위치에서 나온 patch는 consistent(일관된) content를 가져야 한다.
2. D1, D2 같이 같은 이미지에서 나온 patch는 비슷한 도메인 정보(ex> 빛의 밝기)를 가져야 한다.

따라서
두 patch의 상대적인 위치는 content 정보로 특징을 추출해내는 task를 supervision하는데 사용하고 (content registration)
두 patch의 출처 정보는 도메인 분류에 사용한다. (domain classification)

2) Network architecture

(참고)

<Siamese-Network(샴 네트워크) ?>

• 두 사진을 입력으로 받아서 두 이미지를 벡터화 시킨 이후, 두 벡터간의 유사도 (similarity in [0, 1]) 를 반환하는 네트워크
• 두 벡터 사이의 유사도는 보통은 유클리드 공간에서의 L2 거리를 이용하여 정의하는 경우가 많다.
• 입력을 받는 layer가 2개이고 각각 다른 이미지를 받는다.
• 특징을 학습하는 것보다는 두 이미지가 얼마나 다른지, 비교할 수 있는 능력을 가지게 됨.

(출처 : https://medium.com/mathpresso/%EC%83%B4-%EB%84%A4%ED%8A%B8%EC%9B%8C%ED%81%AC%EB%A5%BC-%EC%9D%B4%EC%9A%A9%ED%95%9C-%EC%9D%B4%EB%AF%B8%EC%A7%80-%EA%B2%80%EC%83%89%EA%B8%B0%EB%8A%A5-%EB%A7%8C%EB%93%A4%EA%B8%B0-f2af4f9e312a)

(샴네트워크는 weight를 공유하는 두 네트워크로 구성된다. https://tyami.github.io/deep%20learning/Siamese-neural-networks/)

<이제 진짜 architecture>

• 샴 네트워크는 [weight를 공유하는 2개의 encoder] / [content registration 부분] / [domain classification 부분]으로 구성된다.

• optimization을 위한 2개의 loss가 있다.
• encoder
  : input으로 들어간 patch(P)를 latent space(Z)로 임베딩하는 역할
  : content와 도메인 정보가 있는 feature들을 분리하는 역할
• $c_{A}, c_{B}$
  : content 정보가 있는 disentangled features
  : (11×11×512) feature map
  : (1 × 1) conv layer를 거치고 content consistency loss 계산을 위해 input patch의 원래 크기로 보간된다.
• $d_{A}, d_{B}$
  : 도메인 정보가 있는 disentangled features
  : (11×11×512) feature map
  : concat되어 (11×11×1024) discriminative feature map이 생성되고 도메인 정보를 추출한다.
• content registration 부분
  : I2I domain adaptation 과정동안 patch content를 유지하는 것이 목표
• $\tilde{p}{A}, \tilde{p}{B}$
  : 이미지의 object의 모양과 위치를 나타내는 content attention map

(참고)

• attention ?
  사람은 어떤 이미지를 볼 때, 전체를 보지않고 필요한 정보를 빠르게 얻기 위해 선택적으로 인지(selectively perceive)할 수 있는 능력이 있는데, 이를 attention이라고 한다.

• 그림에서 "어떤 게임을 하고있나?"라는 질문에 답을 하기 위해 이미지의 테니스 라켓 부분에 집중하고,
• "지면이 무엇인가?"라는 질문에 답을 하기 위해 이미지의 바닥 부분에 집중하는 것을 볼 수 있다.
• 같은 사진이 주어져도 질문에 따라 필요로 하는 정보가 다르기 때문에 집중하는 부분도 다른 것이다.

(출처 : [논문 요약 11/52] Human Attention in VQA: Do Humans and Deep Networks Look at the Same Regions?|작성자 hist0613)

3) Objective function

• 기존의 CycleGAN loss + self-supervised loss ($L_{S}$) 추가

1. [Content registration] → content consistency loss ($L_{cc}$)

: domain adaptation task에서 content 왜곡을 최소화 즉, object의 모양과 위치를 유지하기 위한 제약
: 2개의 content attention maps $\tilde{p}{A}, \tilde{p}{B}$를 L2 norm에 사용
: 원본 이미지와 변환된 이미지 간의 content 불일치에 대해 pixel 단위의 penalty를 부과하므로 OP-GAN이 왜곡 없이 사실적인 결과를 합성할 수 있다.

• M과 N
  : 각각 처리중인 patch의 width와 height
• (x, y)
  : attention maps $\tilde{p}{A}, \tilde{p}{B}$에서의 pixel 좌표

2. [Domain classification] → cross-entropy loss ($L_{dc}$)

: 3개의 class $D_1, D_2, C(C = {C_1, C_2})$로 구성된 1-K classification를 공식화 했다.
: domain classification 부분은 주로 feature로부터 domain 정보를 추출해서 content feature의 더 나은 disentanglement가 되도록 하는 것이 주 목표이다.

• $p_j$
  : class scores vecotor의 j번째 원소 (j ∈ [1, K], K는 class 수)
• $g_i$
  : i번째 input sample의 label

최종 Objective function

1. 샴 네트워크 (S)와 $D_B, D_A$는 먼저 $G_{BA}, G_{AB}$를 optimize한다.
2. 그 후 $G_{BA}, G_{AB}$를 고정해서 샴 네트워크 (S)와 $D_B, D_A$를 각각 optimize한다.
   → 그러므로 discriminator와 유사하게 샴 네트워크는 이미지 objects에 대한 정보를 generators에 직접 전달할 수 있다.
   → 이는 변환된 이미지의 object 보존이 잘 되게 한다.

4. 비교

• 기존 I2I adaptation frameworks는 원본 이미지와 변환된 이미지 간의 content 불일치에 대해 pixel 단위의 penalty가 없기 때문에 도로, 건물 등의 objects의 모양과 색상을 변경하는 등 이미지 content를 과도하게 수정하려 한다.
• 반면, OP-GAN은 이미지 objects를 보존하면서 cross domain adaptation이 잘 됐다.

5. 결론

• label로부터의 supervision 없이 image-to-image domain adaptation에서 objects를 보존하는 새로운 GAN인 OP-GAN을 제안했다.

MatchGAN: A Self-Supervised Semi-Supervised Conditional Generative Adversarial Network

1. 요약

* 기존 cGAN의 한계

cGAN은 합성 이미지의 생성과 조작 등에 유연함을 보이는 GAN이다.
그러나 많은 양의 annotated dataset이 요구된다. → 많은 cost (출처 : https://guimperarnau.com/blog/2017/03/Fantastic-GANs-and-where-to-find-them#cGANs)

* 제시된 해결 방안

cGAN을 training하는데 많은 양의 annotated dataset 요구를 줄이기 위해 많은 연구에서는 pretext task를 설계할 때 self-supervised 방법을 도입했다.
그리고 대부분의 연구는 input image space의 geometric augmentations(기하학적 증강)에 집중했다.

(출처 : https://blog.insightdatascience.com/automl-for-data-augmentation-e87cf692c366 )

(한계)
위의 예시에서처럼 class label은 변경되지 않으면서 data augmentation이 되었다.
즉, 각 class label의 새로운 data들을 만들어낼 수 없다는 한계가 있다.

* MatchGAN 제안

self-supervised learning pretext task에서 data augmentation 방법으로 image space가 아닌 label space를 활용하자!

2. MatchGAN

: labelled data가 아주 적은 semi-supervised 상황에서 많은 cGAN을 training하기 위해 self-supervised learning을 적용한 네트워크

* pretext task

• labelled data의 label space로부터 분별 있는 label들을 랜덤으로 샘플링해서 brown hair, black hair 같은 target labels를 추출했다.
• 이 target labels와 labelled data의 분포와 동일한 분포로부터 나온 unlabelled data를 generator의 input으로 넣어 (합성된) 새로운 이미지를 생성해낸다.

(참고) labelled data와 동일한 분포로부터 나온 unlabelled data가 주어지면 true source attribute label에 상관없이, 같은 target label이 할당된 경우 generator는 source image를 합성된 이미지 매니폴드의 비슷한 지역에 매핑해야 한다.(다른 target label이 할당된 경우에는 다른 지역으로 매핑한다.)

• generator에서 합성된 이미지는 target labels와 비교하여 동일한 label 정보를 공유하는 positive pairs와 다른 label 정보를 공유하는 negative pairs로 그룹화된다.
• positive, negative pairs 그룹을 분류하는 auxiliary match loss(triplet matching loss)를 최소화하는 것이 pretext task의 목적이다.

(참고) triplet 같은 제약 조건을 적용하면 generator가 변환된 attributes에 대한 consistency 를 유지하도록하여 궁극적으로 합성된 이미지에서 attributes를 더 잘 유지할 수 있다.

* framework

(본 논문에서는 starGAN을 baseline으로 했지만, 모든 cGAN에 적용될 수 있다고 한다.)

* Triplet Matching Objective as Pretext Task

• triplet 같은 제약 조건을 적용하면 generator가 변환된 attributes에 대한 consistency 를 유지하도록하여 궁극적으로 합성된 이미지에서 attributes를 더 잘 유지할 수 있다.
• 따라서 G와 D 모두에 대한 pretext task으로 label 정보를 기반으로 auxiliary match loss를 제안한다.
• triplet은 합성된 data ($x_a$) / $x_a$와 동일한 label 정보를 공유하는 positive example ($x_p$) / $x_a$와 다른 label을 공유하는 negative example ($x_n$)로 구성된다.

starGAN의 objective function

triplet matching objective

• standard triplet loss와 달리, 각각 channel 축을 따라 positive pair ($D_{emb}(x_a)$, $D_{emb}(x_p)$)와 negative pair ($D_{emb}(x_a)$, $D_{emb}(x_n)$)의 discriminator embeddings을 concat한다.
• 그리고 단일 convolutional layer을 통해 그들을 통과하고 각 pair에 대해 일치하는 label이 있는지 여부에 대한 확률 분포 $D_{mch}(x_a, x_p)$와 $D_{mch}(x_a, x_n)$을 생성한다.

최종 objective function

3. 비교

• 4번째 줄 surprised에서 남자 아이의 입 모양을 보면 MatchGAN의 결과가 baseline(starGAN)보다 덜 인위적이다.

• 4번째 줄 baseline(1%)에서 black hair 여성의 머리에 갈색의 점이 보인다.

=> MatchGAN이 덜 nosiy하며 덜 blurry하고 더 일관된 결과를 생성했다.

4. 결론

• MatchGAN은 합성된 이미지와 target labels를 추가적인 annotated data로 활용했고 pretext task로 triplet matching objective를 최소화했다.

Reference

• Self-Supervised CycleGAN for Object-Preserving Image-to-Image Domain Adaptation
• Image-To-Image Translation Using a Cross-Domain Auto-Encoder and Decoder
• https://www.mdpi.com/2076-3417/9/22/4780/htm
• Multi-subject subspace alignment for non-stationary EEG-based emotion recognition
• https://bskyvision.com/491
• Translating and Segmenting Multimodal Medical Volumes with Cycle- and Shape-Consistency Generative Adversarial Network
• https://medium.com/mathpresso/%EC%83%B4-%EB%84%A4%ED%8A%B8%EC%9B%8C%ED%81%AC%EB%A5%BC-%EC%9D%B4%EC%9A%A9%ED%95%9C-%EC%9D%B4%EB%AF%B8%EC%A7%80-%EA%B2%80%EC%83%89%EA%B8%B0%EB%8A%A5-%EB%A7%8C%EB%93%A4%EA%B8%B0-f2af4f9e312a
• https://tyami.github.io/deep%20learning/Siamese-neural-networks/
• [논문 요약 11/52] Human Attention in VQA: Do Humans and Deep Networks Look at the Same Regions?|작성자 hist0613
• https://guimperarnau.com/blog/2017/03/Fantastic-GANs-and-where-to-find-them#cGANs

1. Self-Supervised Learning (자기지도학습)

1-1. 필요성

레이블링의 단점

• Supervised learning(지도학습)은 강력하지만 많은 양의 레이블링된 데이터 필요
  1. 많은 양의 양질의 데이터만 있다면 좋은 성능을 낼 수 있음
  2. 하지만 이는 레이블링된 데이터가 없으면 사용 불가능하다는 문제가 있음
• 레이블링 작업자의 편향된 사전 지식 포함될 수 있음
• 레이블링에 매우 많은 시간 소요 (목적 태스크 복잡할수록)

GAN의 불안정성

• GAN은 높은 차원의 파라미터 공간의 non-convex한 문제에서 내쉬 균형을 찾기 때문에 학습이 어려움
• 자기지도학습을 사용하면 학습이 더 쉬워서 과거의 정보를 더 기억할 수 있음
  • 학습이 진행될수록 생성자는 점점 더 실제 데이터에 가까운 데이터 분포를 만들어내는 non-stationary한 환경
  • 뉴럴 네트워크는 학습 데이터의 도메인이 바뀌는 동적인 상황에서 과거의 데이터 잊음
  • ex) conditional model: real/fake를 구분하는 것뿐만 아니라 cat/dog도 구분하며 계속 학습하여, 새 데이터에 대하여 판별자가 구분해서 condition 습득 후 real/fake 구분을 진행하면 학습이 더 쉽고 안정적
• supervision signal이 학습에 불필요한 편향을 줄 수 있음

1-2. 정의

• 레이블링 된 데이터셋으로 모델을 학습하는 지도학습과 달리, 다량의 레이블이 없는 원데이터로부터 데이터 부분들의 관계를 통해 레이블을 자동으로 생성하여 지도학습에 이용 (비지도학습 기법 중 하나)
• 데이터의 일부분을 은닉하여 모델이 그 부분을 예측하도록 학습
• 프리텍스트 태스크(pretext task): 딥러닝 네트워크가 어떤 문제를 해결하는 과정에서 데이터 내의 semantic한 정보를 이해할 수 있도록 학습하게 하는 임의의 태스크 (사용자 임의대로 정의)
• 레이블이 없는 데이터를 이해하도록 프리텍스트 태스크를 위한 레이블을 직접 생성하여 모델을 학습하거나 데이터 간의 관계를 이용하여 학습
• 이렇게 사전학습된 모델을 데이터셋을 representation learning하여 다른 태스크로 전이시켜 사용

⇒ 새로운 태스크에서 소량의 데이터만으로 semantic representation을 찾게 하여 좋은 성능을 내는 전이학습(transfer learning)

Pipelines

1. 레이블링 없는 데이터를 프리텍스트 태스크로 학습

2-1. 학습된 특징들로 분류기를 학습하여 더 적은 레이블을 가진 새로운 데이터에도 적용 가능하게 학습

2-2. 더 적은 레이블의 새로운 데이터에도 적용 가능하도록 파인튜닝

• 원래 처음 모델을 고정하고, 그로부터 추출된 특징인 z를 사용하는 방식이나 실제로는 전체 네트워크를 파인 튜닝하고, 더 다양한 방식을 포함하여 다운스트림 태스크를 처리

1-3. 장점

• 각 태스크에 따른 새로운 데이터셋을 구축하는 비용과 시간을 줄일 수 있음 ex) 웹, 클라우드 상에 존재하는 다량의 비디오, 이미지, 텍스트 데이터들 별도 레이블링 없이 사전학습 가능
• 사람으로 인한 데이터셋 편향 현상 최소화
• 특정 태스크에서만 동작하는 모델이 아닌 범용성을 가지는 모델을 학습할 수 있음 (기존의 지도학습은 원데이터 목적에 따른 태스크에 알맞은 레이블을 할당하여 학습에 이용)

1-4. 연구의 분류

• 데이터의 부분 데이터나 손상된 부분으로부터 생성 및 재건
• 시각적 상식이나 문맥을 이용
• 대조 학습

2. 초창기의 GAN 기반 자기지도학습

• 재건 및 생성 기반 모델들은 픽셀 단위로 복원하거나 예측하기 때문에 계산 복잡도가 높다는 단점이 있음

2-1. 오토인코더

• 데이터에 대한 표현 학습을 위한 자기지도학습 기법
• 신경망을 통해 재건한 출력 데이터의 정답 레이블로 입력 데이터를 사용하여 입력과 출력의 결과가 같도록 학습
• 학습한 네트워크의 히든 레이어는 입력데이터보다 낮은 차원의 벡터로 압축되어 표현되는 이 벡터가 원본 데이터를 가장 잘 표현할 수 있는 특성 정보를 인코딩

example

1. 디노이징 모델: 원본 이미지에 노이즈를 삽입하여 신경망의 입력으로 사용한 다음, 원본 이미지으로 다시 복원
2. 색상화(Colorization): 이미지의 색상 정보 분리하여 흑백 채널을 네트워크에 입력 → 색상정보 예측

2-2. SSGAN (Self-Supervised GAN)

참조 논문: Ting Chen, Xiaohua Zhai, Marvin Ritter, Mario Lucic, Neil Houlsby, "Self-Supervised GANs via Auxiliary Rotation Loss", 2018

rotation-based 자기지도학습

rotation 기반 self-supervision의 판별자는 이미지의 real/fake 여부와 rotation degree 총 2가지를 구분합니다. real 이미지와 fake 이미지 모두 0, 90, 180, 270도로 회전되고, 화살표를 보면 회전되지 않은 이미지만 real/fake의 classification loss task에 쓰인다고 합니다! 또한 rotation loss에 대해서는 회전된 이미지를 회전된 각도에 따라 구분한다고 하네요.

• 생성자가 만든 이미지에 대해 rotation하고, rotation 얼마나 했는지 cross entropy loss로 만들어서 GAN loss에 더함
• identity한 이미지에 대해서 real/fake 구분, 나머지 이미지에 대해서는 rotation angle 학습

판별자 forgetting 방지

• ImageNet의 선형 분류 모델
• 500k번 넘어가면 Uncond-GAN의 정보 손실 일어남

• 1k번 반복할 때마다 클래스의 분포가 바뀔 경우 이미지 분류 문제의 정확성
• 동적인 환경에서는 분류기가 일반화 가능한 특징을 학습하기 어려울 수도 있음

rotation-based loss function

• 기존의 GAN loss function에 cross entropy loss와 hyper-parameter 곱해줌

• GAN value function

experiments

• Details

  1. dataset

     

  2. GAN: spectral normalization GAN with self-modulated batch normalization

  3. 하이퍼파라미터: Ir 0.0002, alpha 0.2, beta 1, Adam optimizer, Batch size 16 x 4 augmentation

• Result

  

  • gradient penalty
    • unconditional GAN: 같은 hyper-parameter이어도 결과의 질이 낮고 결과의 variation이 높음
    • self-supervision GAN: hyper-parameter가 같으면 같은 결과
  • spectral normalization: 성능이 더 좋아짐
  • FID: 이미지 생성 결과는 conditional GAN이 더 좋지만 그 다음으로 SSGAN이 좋음 (성능 비슷함) → conditional GAN은 각 이미지에 대한 label이 필요하지만 SSGAN은 데이터에 대한 label이 필요 없음
  • classification task → 좋은 representation 도출
    • Image → Trained Discriminator + classifier (training from zero to converge)
  • Rot-only: rotation만 사용하여 학습 (GAN 사용 안 함) → 협력하여 학습하므로 SSGAN이 더 성능 좋음
  • 학습을 하면 할수록 좋은 representation 도출

example

1. Image Completion: 이미지에서 일부분만 제거한 뒤 신경망의 입력으로 사용하고 제거한 영역을 복원

   → 오토인코더로 이미지 복원하며 복원된 데이터인지 실제 데이터인지를 판별하는 판별 네트워크를 두어 적대적으로 학습

2. 초해상도 복원 (Super-resolution): 원본 이미지를 해상도가 낮은 영상으로 변형한 뒤 다시 해상도를 높임

   ex) BigGAN(고해상도 이미지 생성 가능) + BiGAN(이미지로부터 유사도 추출) = BigBiGAN

3. 프리텍스트 태스크를 이용한 자기지도학습 방법

3-1. 구조 유추 (Inferring Structure)

1) 맥락 예측 (Context Prediction)

• 모델이 object의 부분을 인지하고 공간적 관계를 파악하는 것을 학습

• 과정

  1. 이미지 패치로 분할
  2. 중심 패치와 이웃에서 다른 패치 가져옴
  3. 각 패치를 같은 네트워크에 입력
  4. 특징을 concate하여 분류기에 넣음
  5. cross-entropy loss → 이웃 패치 파악

• 장점

  • 최초의 자기지도학습 방법
  • object의 부분에 대하여 학습하게 하는 직관적인 태스크

• 단점

  • 학습 이미지의 표준성 전제

    ex) 인공위성 사진

  • 이미지의 representation이 목적이지만 패치를 학습

  • 다른 이미지의 negative가 없기 때문에 충분히 fine-grained 하지 않음

  • output space가 작음: 8가지 선택지 밖에 없어서 출력에 대한 경우의 수가 너무 작음

2) Jigsaw puzzles

• 이미지를 패치로 분할하고 순서를 바꿈
• 네트워크가 순서를 예측하는 것이 목표
• 맥락 예측과 비슷하지만 더 어려움

3-2. 변환 예측 (Transformation Prediction)

1) 회전 예측 (Rotation prediction)

• 원래 이미지의 canonical한 orientation 잘 이해해야 함 → 이미지의 전반적 특징 잘 학습 가능

• 장점

  • 적용이 용이함

• 단점

  • 학습 이미지의 표준성 전제

  • train-eval gap: eval에는 회전된 이미지가 없음

  • 다른 이미지의 negative가 없기 때문에 충분히 fine-grained 하지 않음

  • output space가 작음

  • domain이 사소한 경우

    ex) 거리 사진에서 하늘만 인식

2) 상대적 변환 예측 (Relative transformation prediction)

⇒ 잘 매칭되기 위해서 좋은 feature 필요

• 장점

  • 고전파 컴퓨터 비전의 SIFT 등과 일치 (특징점 추출, 주 방향 결정, descriptor 생성)

• 단점

  • train-eval gap: eval에는 변환된 이미지가 없음

  • 다른 이미지의 negative가 없기 때문에 충분히 fine-grained 하지 않음

  • semantic의 중요성 vs. 낮은 수준의 특징

    → how much semantics do you need to solve this task? features are potentially not invariant to transformations

3-3. 재건 (Reconstruction)

• 재건을 통해 annotation 없이 이미지의 특징을 학습할 수 있음
• 이미지 복원 과정 → 네트워크가 영상 전반의 representation을 학습 할 수 있게 된다는 가정

1) 디노이징 오토인코더 (Denoising Autoencoders)

• 랜덤 노이즈가 섞인 원본 raw data에서 네트워크를 거쳐 원본 raw data를 복원하는 방법

• 장점
  • 간단하고 정통적인 방식: denoising 간편
• 단점
  • train-eval gap: 노이즈가 있는 데이터를 학습
  • 너무 간단해서 semantics가 필요 없음

2) 맥락 인코더 (Context Encoders)

• 영상 내 중간에 뚫린 부분을 추측/복원하는 방법

⇒ object를 인식하면 더 쉬움 (perceptual loss - 판별자)

• 자연어처리(NLP)

  • ex) BERT: 레이블이 없는 데이터셋을 먼저 훈련시킨 다음 작은 레이블이 있는 데이터셋에서 파인 튜닝하여 몇 가지 클래스 레이블로 좋은 결과 얻음

    All [MASK] have tusks. ⇒ All elephants have tusks.

• 장점

  • fine-grained 정보 보존하게 함

• 단점

  • train-eval gap: masking된 부분이 eval에는 없음

  • 재건 자체가 너무 어렵고 모호함

  • 불필요한 세부 사항에 소모적

    ex) 색, 경계

3) 색상화 (Colorization)

• 흑백 영상을 색을 입혀 컬러 영상으로 바꿔주는 방법

⇒ object가 무엇인지 인지하지 못하면 어려움

• 장점
  • fine-grained 정보 보존하게 함
• 단점
  • 재건 자체가 너무 어렵고 모호함
  • 불필요한 세부 사항에 소모적
  • 그레이스케일 이미지를 평가해야 하므로 정보 손실이 야기됨

4) Split-brain encoders

• 맥락 인코더 ⇒ Split-brain encoders
• 이미지의 절반을 잘랐을 때, 네트워크가 나머지 잘린 이미지 절반을 맞추도록 하는 방법

• 2개의 가지: 그레이스케일 이미지 → 컬러 이미지, 컬러 이미지 → 그레이스케일 이미지
• 장점
  • fine-grained 정보 보존하게 함
• 단점
  • 재건 자체가 너무 어렵고 모호함
  • 불필요한 세부 사항에 소모적
  • 입력을 독립적으로 처리

5) bag-of-words 예측 (Predicting bag-of-words)

• NLP에서 영감: 이산적 타겟인 단어들의 출현 빈도에 집중하는 텍스트 데이터의 수치화 표현 방법
• BoW (Bag-of-Words)
  1. 각 단어에 고유한 정수 인덱스 부여
  2. 각 인덱스의 위치에 단어 토큰의 등장 횟수를 기록한 벡터 만듦

Visualization of Clusters

• 과정
  1. 특징 추출
  2. 이미지를 BoW로 represent: visual words에 특징 부여
  3. 클러스터 → 중간 수준과 높은 수준의 개념을 인코딩
  4. 이미지 왜곡하여 BoWNet에 넣어 학습
  5. BoW representation 예측

• 장점

  • 왜곡된 이미지로부터 BoW 재건 → representation이 원하는 변환에 강건함
  • 맥락적 추론 학습 가능

• 단점

  • pre-trained 네트워크에서 부트스트래핑(bootstrapping) 필요

    → 더 fine-grained한 특징은 학습, 재발견 어려움

  • BoW로 집화(aggregate) → 공간 정보 손실

3-4. 인스턴스 분류 (Instance Classification)

1) Exemplar ConvNets

• 이미지에서 분할 추출하여 변형 → 같은 원본 이미지 고르기를 가진 분할 사진 고르기

• 수행된 기하학적이나 색상 관련 변환에 강건하면 쉬움

• 과정

  1. 96x96 크기의 영상 내에서 considerable한 gradient가 있는(객체가 존재할 만한 영역) 부분을 32x32 크기로 crop

  2. 하나의 이미지 당 이렇게 crop된 32x32 크기의 패치를 seed patch로 하고, 이 seed patch가 하나의 class를 의미하도록 함

  3. seed patch를 data augmentation에 사용하는 transformation들을 적용시켜 추가 영상을 만듦

  4. 하나의 seed image 여러 장 만들어 같은 class 가지도록 학습

     

• 장점

  • representations이 원하는 변환에 강건함
  • fine-grained 정보 보존하게 함

• 단점

  • exemplar 기반으로, 같은 클래스에서 생성된 이미지나 인스턴스가 negative로 쓰임

    (nothing prevents it from focusing on the background)

  • N개의 영상에 N개의 클래스 존재 → 학습 난이도가 올라가며 파라미터수도 매우 많아지게 됨

    ⇒ 큰 데이터셋에는 적합하지 않음 (number of classes = data size)

2) CPC (Contrastive Predictive Coding)

잘 구성된 representation은 data efficiency를 향상시킵니다. 하지만 실제 visual task에서는 그러한 representation을 찾는 것이 어렵다고 합니다. 대신 시공간 변동성을 인식하는 효율성 개선에 능력이 효과적이라고 밝혀졌는데, 이를 위해 representation의 predictability가 data efficiency의 중요한 역할이라 가정하고 contrastive predictive coding(CPC)이 제안되었습니다.

• 관찰이 시간적 또는 공간적 차원과 같이 순서에 따라 이루어지도록 요구하는 기술
• 고차원 데이터를 더 작은 임베딩 공간으로 압축하여 회귀 모델을 이용하여 예측 수행
  • 작업 자체와 관련이 적은 세부 사항은 한 걸음 물러나 노이즈로 간주하여 의미있는 맥락 학습
  • 압축된 representation & 현재 패치와 미래의 타겟 패치와의 공통 정보를 참조

1. 입력 이미지를 중복 패치 x_i,j로 나눔
2. 각 패치를 encoder network f_θ에 넣어 single vector z_i,j = f_θ(x_i,j)를 만듦
3. z 뭉치를 context network g_ϕ에 넣어 context vector c_i,j를 만듦
   • mask는 c_i,j의 receptive field가 {z_u,v}_u≤i,v가 되도록 함
4. prediction matrix W_k(prediction length k>0)를 이용하여 z^_i+k,j=W_kci,j 예측

5. c_i,j와 z_i+k,j의 상호 정보량이 최대가 되도록 L_CPC를 이용하여 학습

   

   (z_l: negative samples, 이미지의 다른 위치나 배치 안의 다른 이미지에서 무작위로 뽑은 feature vectors)

• InfoNCE loss 사용
  • NCE(Noise Contrastive Estimation)를 통해 상호 정보량을 최대화 → {predict, correct, negatives} 비교
  • 단순 cross-entropy를 이용하기에는 클래스 수가 너무 많아서 비효율적 → good/bad 판별하는 이진 분류 사용
  • 각각의 c_t마다 x_1, x_2, ..., x_n 중 실제 x를 예측해야 함
  • negatives: 이미지의 다른 위치나 배치 안의 다른 이미지에서 무작위로 뽑은 특징 벡터

• overview

  1. 비선형 인코더 g_enc가 입력 시퀀스 x_t를 latent representation의 시퀀스 z_t = g_enc(x_t)에 매핑

  2. 자동회귀모델 g_ar가 t 이전의 z로 맥락 c_t = g_ar 생성

  3. 이 때, 바로 x_t+3을 예측하는 것이 아니라 density ratio를 모델링함

     

  4. 인코더와 NCE, 중요도 샘플링을 통해 density ratio에서 무작위로 샘플링 된 negative와 target 비교

• 장점

  • 이미지, 영상, 음성, NLP 등에 쉽게 적용이 가능한 포괄적인 프레임워크
  • exemplar: fine-grained 정보를 보존하게 함
  • 맥락 예측: object의 부분에 대해 학습이 가능하게 함

• 단점

  • exemplar 기반: 같은 클래스 내의 이미지나 인스턴스가 negatives
  • train-eval gap: 학습은 패치로, 평가는 이미지로 함
  • 학습 이미지의 표준화 전제
  • 패치를 분할하기 때문에 학습 시간이 오래 걸림

3) Count

• 한 patch의 object의 특징들을 가상의 vector로 표현함

  ex) 각 패치 안에 코 2개, 눈 4개, 머리 1개 등

  → 이런 특징들은 각 패치나 전체 영상이 up/down sampling 되어도 유지가 되어야 함

• 각 패치의 특징 벡터들의 합은 원래 이미지의 특징 벡터의 합과 같다는 가설에서 제안

• 과정

  1. 이미지를 네트워크에 넣고, feature extractor를 통해서 최종 출력으로 위와 같은 패치별 특징 벡터를 구하도록 모델 구현
  2. 원본 이미지를 down scaling 했을 때 추론되는 특징 벡터 D의 합 = 패치별 네트워크를 지나서 얻은 T들의 합

• L2 loss 사용, 모든 특징 벡터를 0으로 출력하는 trivial loss 될 수도 있음

  → sample supervision 학습: 패치로 잘리는 영상 x와 완전히 다른 영상 y를 넣었을 때 다른 feature 벡터가 나오도록 하는 contrastive loss를 추가

3-5. 시간적 관계

• 영상에서 시간에 따른 일관성을 고려한 프레임의 재건 또는 생성을 이용하여 자기지도학습 수행

1) Optical Flow & SURF 특징점 기반의 추적 기법

• Optical Flow (광학 흐름): 2개의 연속된 영상 프레임 사이에 이미지 객체의 가시적 동작 패턴
• SURF 특징점: SIFT보다 빠르게 semantic한 특징 추출 가능한 특징점 기반 알고리즘 (Speed-Up Robust Feature)
• 영상 내 특정 패치를 단시간 추적하여 추적된 패치들과의 관계를 이용하여 학습에 이용
• 같은 패치로부터 추적된 패치들은 서로 positive 쌍, 다른 패치나 다른 영상으로부터 추출된 패치는 negative 쌍
• 양성 쌍 패치의 임베딩된 특징점 사이의 거리는 음성 쌍 패치의 거리보다 항상 작도록 triplet loss를 이용하여 학습 (대조 학습(Contrastive Learning))
  • baseline인 anchor를 positive, negative input과 비교
  • anchor input과 positive input 사이의 거리 최소화, negative input과의 거리 최대화 (유클리디안 거리)
  • 임베딩 학습의 목적으로 유사성을 학습하는 데 사용

2) 영상 내 프레임들의 시간적 순서 맞추기

• 영상 프레임들은 일반적으로 시간에 따른 순서를 따라 위치
• 프레임 사이의 움직임에 집중하도록 학습
• 과정
  1. 움직임이 많이 발생하는 구간에서 3개의 프레임을 고름
  2. 이들의 시간적 순서가 항상 증가하도록 나열된 튜플을 positive 튜플로, 시간 순서가 뒤섞인 튜플을 negative 튜플로 둠
  3. positive 튜플은 1, negative 튜플은 0으로 예측하도록 학습

3) 영상의 색상화

• 회색조로 변환한 영상 내의 두 프레임 사이의 자연스러운 시간적 연관성을 고려하여 이전 프레임에서 색상을 복사하여 다음 프레임의 색 예측
• 임베딩된 feature map의 유사도 비교 → 두 프레임 사이의 매칭을 구하여 이 관계를 통해 이전 프레임의 색상 정보를 다음 프레임으로 복사
• 복사를 통해 복원된 다음 프레임의 색상 정보를 그 프레임의 원래 색상값과 비교하여 손실 함수 계산

→ 레이블링이 매우 오래 걸리는 영상 분할과 사람 자세 예측 태스크에서 레이블링된 데이터 없이 자기지도학습만으로 잘 동작

3-6. 대조 학습 (Contrastive Learning)

• 2개의 샘플이 하나의 쌍을 이루어 네트워크의 입력으로 사용되며 그 데이터들이 서로 비슷한지 학습 (2006년 Yann Lecun)
• 두 샘플이 서로 다른 negative 쌍: 모든 negative 쌍을 고려하는 것은 불가능한 일이므로 학습에 도움이 되는 음성 쌍을 잘 골라내는 것이 대조 학습의 목표

1) MoCo (Momentum contrast for unsupervised visual representation learning)

• contrastive loss를 이용한 비지도학습

  1. 데이터를 인코더에 통과시켜 key와 query를 만듦

  2. query와 매칭되는 key와 유사하게, 매칭되지 않는 key와는 차별화되도록 학습

  3. 인코딩된 key들을 queue에 삽입하여 dictionary 구성

     ⇒ dictionary는 클수록, key는 consistent할수록 좋음

• Momentum Contrast

• 비교에 사용 되는 key dictionary를 queue로 사용
  • 미니배치 크기와 무관하게 커질 수 있음 → 더 많은 negative 쌍 고려 가능
  • 직전에 계산된 미니배치의 encoded representation이 queue에 들어오면 가장 오래된 representation 삭제하여 dictionary를 consistent하게 유지
• momentum update
  • queue로 dictionary를 크게 만들면 queue 안의 모든 샘플에 대해 gradient를 역전파해야 하므로 key를 학습시키기 어려움
  • key 인코더를 query 인코더와 분리 → query 인코더의 파라미터에 momentum 가중치를 주어 아주 천천히 업데이트 → 키 인코더의 표현이 천천히 일관되게 변화하도록 함

2) SimCLR (A simple framework for contrastive learning of visual representations)

• 과정
  1. 원본 데이터셋에서 예제를 무작위로 추출하여 두 번 변환 (random cropping & random color distortion)
  2. representation 계산
  3. representation의 비선형 투영 계산
• 동일한 이미지의 다른 변형을 식별하는 데 도움이 되고, 유사한 개념(ex. chairs vs dogs)의 표현 학습
• 비선형 투영 계산 → representation 자체에서 대조 손실을 구하는 것보다 성능 좋음
• 큰 배치 사이즈 & 오래 학습 → negative 쌍을 더 많이 고려하게 되어 지속적으로 성능 향상

3) BYOL (Bootstrap Your Own Latent: A New Approach to Self-Supervised Learning)

구조

• input: 같은 샘플로부터 다른 데이터 증강을 이용해 변형된 샘플

• 2개의 network (online network, target network)를 사용

• loss function: mean sqaured error function

  • 각각의 network는 encoder + projector + predictor로 구성
  • target network의 weight: online network의 weight의 exponential moving average(지수이동평균)에 의해 업데이트 → online network가 배울 regression target 생성 (expotential moving average의 coefficient 값은 0.996부터 1에 가깝게 감)
  • loss는 online network의 학습에만 사용

• 과정

  1. 2개의 network에 서로 다른 augmentation을 적용하여 feature vector(prediction)을 뽑기
  2. online network와 target network의 projection output에 l2 normalization (MSE)
  3. mean squared error를 최소화시키는 방향으로 online network를 학습 (online network와 target network의 output이 같아지도록 학습)
     4. loss의 대칭화를 위해 사용한 augmentation을 바꿔서 loss 한번 더 계산하여 두 loss의 합으로 학습

• 장점
  • negative 쌍을 사용하지 않고 positive 쌍만 이용하여 SimCLR보다 2% 성능 향상
    • 기존의 negative 쌍을 사용할 때 배치 크기가 매우 커야 학습이 잘 된다는 문제와 데이터 증강에 따른 성능 편차가 크다는 문제 해결
    • representation을 잘 배우는 것이므로 학습이 끝나면 onlline network의 encoder 제외 나머지는 사용 안함

⇒ 과거의 online netwrok들이 target network 속으로 스며드는 느낌

ImageNet에서 pre-training한 다양한 자기지도학습으로 학습된 representation에 대해 훈련된 linear classifierdml ImageNet 최고 정확도)

3-7. 멀티태스킹

• 맥락 예측 태스크인 Relative Patch Location + Colorization + Exemplar + Motion Segmentation을 1개의 네트워크에 학습
• 4개를 모두 적용했을 때의 결과가 가장 좋았음

4. 성능 측정

빨간 상자: pre-training을 self-supervise로 얻은 feature extractor

• 프리텍스트 태스크로 네트워크를 학습시키는 이유는 다음에 이어질 다운스트림 태스크를 잘 수행하기 위함

4-1. 태스크 일반화 (Task Generalization)

• 성능 측정을 위해 자기지도학습으로 네트워크를 pre-training 한 뒤 모든 가중치를 고정하고, 마지막 레이어에 linear classifier를 붙여 지도학습 방식으로 다운스트림 학습 진행

  ⇒ 가중치가 얼마나 특징을 잘 추출하고 representation을 잘 배웠는가?

  (단순한 선형 레이어 하나만 붙여 학습 했을 때 좋은 성능을 내기 위해서는 feautre extractor가 얼마나 성능이 좋은 간접적으로 확인할 수 있는 방법)

ImageNet : Classification

• Conv1, Conv2, ..: 는 AlexNet의 해당 레이어까지 파라미터를 고정하고 뒷부분을 학습
• ImageNet labels: 일반적인 지도학습으로 모델을 학습 후 Conv 레이어를 고정시킨 뒤 각 Conv 레이어 뒤에 linear 레이어를 붙여 학습한 결과
• Random & Random rescaled: Conv 레이어들을 random initialization 한 뒤 linear 레이어 붙여서 학습한 결과 ⇒ feature extractor 아무런 정보도 담고 있지 않기 때문에 오직 linear 레이어에 의존하여 학습하므로 linear layer를 사용할 때의 lower bound 성능임
• Self-supervised: Conv 레이어들을 pre-training 한 뒤 고정하고 linear 레이어를 붙여서 학습한 결과

4-2. 데이터셋 일반화 (Dataset Generalization)

• 자기지도학습으로 ImageNet 데이터셋으로 pre-training 후, 다운스트림 태스크로 PASCAL VOC의 classification, object detection, segmentation task 이용

  ⇒ feature extractor의 품질이 아니라 pre-training 후 파인 튜닝을 했을 때 얼마나 성능이 좋은가?

PASCAL VOC : Classification, Object Detection, Segmentation Task

• ImageNet labels: ImageNet pre-trained 가중치를 사용하여 다른 데이터셋에 학습한 결과

• Random & Random rescaled: random 가중치로부터 학습한 결과 (= scratch로부터 학습)

  → 적은 epoch 진행: pre-training 가중치의 이점인 빠른 학습의 빠른 수렴 강조 (30 epoch)

5. 결론

• 레이블링이 없는 데이터로 프리텍스트 태스크를 정의하여 높은 수준의 semantic 이해를 위해 학습
• feature extractor를 사전 학습하고, 다운스트림 태스크로 전이
• ImageNet으로 학습할 수 없는 다른 도메인의 경우 pre-training 시킬 데이터셋의 대안이 될 수 있음

Reference

https://arxiv.org/abs/1811.11212

http://www.kisdi.re.kr/kisdi/common/download?type=DR&file=1|14840

https://www.youtube.com/watch?v=MaGudzppu3I&t=11567s

https://abursuc.github.io/slides/2020_tutorial_cvpr//self_supervised_learning.html#1

https://annotation-efficient-learning.github.io/slides/relja_cvpr2020_self_supervised.pdf

https://hoya012.github.io/blog/Self-Supervised-Learning-Overview/

https://www.youtube.com/watch?v=eDDHsbMgOJQ&list=PLk4Qf8NdfVem3BKLdI_oWb0kHuRFYqxVy&index=8&t=3s

https://wikidocs.net/22650

https://openaccess.thecvf.com/content_ICCV_2017/papers/Doersch_Multi-Task_Self-Supervised_Visual_ICCV_2017_paper.pdf

https://openaccess.thecvf.com/content_CVPR_2019/papers/Chen_Self-Supervised_GANs_via_Auxiliary_Rotation_Loss_CVPR_2019_paper.pdf

https://creamnuts.github.io/paper/CPCv2/

https://brunch.co.kr/@synabreu/76

https://yann-leguilly.gitlab.io/post/2019-09-29-representation-learning-with-contrastive-predictive-coding/

http://blog.naver.com/PostView.nhn?blogId=samsjang&logNo=220662493920&parentCategoryNo=&categoryNo=&viewDate=&isShowPopularPosts=false&from=postView

https://m.blog.naver.com/PostView.nhn?blogId=laonple&logNo=220913997108&proxyReferer=https:%2F%2Fwww.google.com%2F

https://creamnuts.github.io/paper/MoCo/

https://tykimos.github.io/2019/07/29/Kears_BiGAN/

StarGAN :Unified Generative Adversarial Networks for Multi-Domain Image-to-Image Translation

1. 등장 배경

• 기존의 image-to-image translation 연구(Pix2Pix, CycleGAN, DiscoGAN 등)는 3개 이상의 도메인에서 안정적으로 동작하지 않습니다.
• 도메인수에 따라 Generator수가 증가하게 되는 단점이 있습니다.(k가 도메인의 개수이면 k(k-1)개의 generator를 학습)

2. StarGAN의 큰 특징

• 단일 모델만을 사용하여 여러가지의 domain들에대해 image-to-image translation이 가능합니다(한이미지에서 나이, 성별 등 여러개의 attribute를 한번에 바꾸기 가능)
• mask ventor를 이용하여 다른 domain을 가진 dataset들을 동시에 학습시킬수있다.

<용어 정리>
attribute : 이미지에 내재된 의미있는 feature(특징)를 말합니다. ex) gender, age, hair color,,
attribute value : attribute의 특정한 값입니다. ex) gender의 attribute values -> male/female, hair color -> balck/blond/brown/,,/
domain : 동일한 attribute value를 가지는 이미지 셋 입니다. ex) gender가 male인 image들이 하나의 domain이 됩니다.

3. Overview of StarGAN

(a) D : x → {Dsrc(x), Dcls(x)}, D는 real image나 fake image가 들어오면 real인지 fake인지 구분함과 동시에 real image일때 해당 domain으로 분류해내는 것을 학습합니다. 즉, D는 source와 domain labels에대한 확률분포를 만들어 냅니다.

(b) G의 input으로 {input image, target domain}이 들어갑니다. 여기서 target domain은 label(binary or one-hot vector의 형태)로 들어가게되고, ouput으로 fake 이미지를 생성합니다.

(c) G는 original doamin label(원래 내가 가지고 있던 image의 one-hot vector)을 가지고 fake image를 다시 original image로 reconstruction하려고 합니다. 그래서 output이 원래의 input image와 유사하게끔 만들어진 이미지라해서 Reconstructed image라고 부릅니다.

(d) D를 속이는 과정입니다. G는 real image와 구분불가능하고 D에의해 target domain으로 분류될수 있는 이미지를 생성하려 합니다.(real image처럼 보이려고 노력)

그림에서는 Generator가 2개인것처럼 보이지만 한개의 Generator를 다른 용도로 2번 사용된 것 입니다.

4. Loss

미리보는 full objective! 이제 하나하나씩 살펴보도록 하겠습니다

1. Adversarial Loss

• G는 x와 target domain label을 가지고 G(x,c)라는 이미지를 생성하고, D는 real and fake image들을 구분하려하는 loss입니다.
• 만약 D가 real로 분류 -> 1에 가까운 값으로 출력, fake로 분류 -> 0에 가까운값으로 출력될것입니다.(왜 0과 1? D는'source와 domain labels에대한 확률분포를 만들어 낸다')
• Loss는 작은게 좋은것! real image 인 x 에대해서 Dsrc(x)는 1을 가지도록, Dsrc(G(x,c))에서는 G가 real인 것처럼 학습을 진행해야하니 역시 1을 가지도록 학습한다면 Loss가 최소가 될 것입니다.(-log함수는 1에 가까우면 0으로 수렴, 0에 가까우면 ∞로 발산)

2. Domain Classification Loss

• input image x 와 target domain label c가 주어질때, x가 ouput image y로 변환되어 그것이 target doamin c로 분류되는 것이 목적입니다.
• 그렇기 떄문에 D와 G를 optimize할때 domain classification loss를 부과합니다.
• Domain Classification Loss 두개의 term으로 나눠질수 있습니다.

2-1 domain classification loss of real images used to optimize D real image가 들어오면 real image에 대한 original 도메인 값으로 분류되게하는 loss입니다. adversarial loss와 같고, 결국엔 이 Loss를 최소화시켜야 합니다.(D를 위해서 사용)

2-2 domain classification loss of fake image used to optimize G target 도메인으로 바뀌어 생성된 이미지가 target domain으로 분류될 수 있게 이 Loss를 최소화 시켜야 합니다.(G를 위해서 사용)

3. Reconstruction Loss

• 위의 Loss들 만으로는 input image의 target domain에 관련된 부분만을 변화시킬때 input image 본래 형태를 잘 보존 할 수 없기에 Generator에 한 가지 loss를 더 추가하였습니다.
• G는 G가 생성해낸 이미지와 original doamin label c'를 input으로 받아, target domain부분은 변화시키되 input image x의 형태를 유지하게끔 복원해내기 위해서 cycle consistence loss를 이용하였습니다.

4. 다시한번 full objective를 보자!

• λcls, λrec -> hyperparameter입니다. domain 분류와 reconstruction loss들 의 상대적인 중요도를 컨트롤합니다.
• D는 adversarial Loss를 maximize하길 원하기 때문에 마이너스가 붙은것이고, G는 minimize되길 원하기 때문에 마이너스가 붙지 않을것을 확인할 수 있습니다.(논문에서 λcls = 1로, λrec=10으로 설정)

5. Mask vector

• 논문에서 사용된 dataset은 facial attribute만 가지고 있는 CelebA와 facial expression만 가지고 있는 RaFD를 사용했습니다.
• 이는 서로 다른 도에인이기 때문에 저자는 mask vector, m이라는 개념을 도입하였습니다.
• m은 one-hot vector로 나타내어지고, 두 dataset을 합칠때는 concate하면 됩니다.

~c = [c1, ... , cn,m]

• ci : i번째의 dataset의 label들의 vector(ci는 binary attribute를 가진 binary vector 또는 categorical attribute를 가진 one-hot vector)
• CelebA와 RaFD를 교차시킴으로써 D는 두 dataset에서 차이를 구분짓는 모든 feature들을 학습하게 되고, G는 모든 label을 컨트롤하는것을 학습하게 됩니다.

6. StarGAN의 전체적인 구조

7. Result

• Celeb A와 RaFD를 128*128로 동일하게 맞춰준 후에 모델에 넣었으며 CelebA에서는 40개의 attribute중에 7개만 뽑아서 사용했고 RaFD는 작은 dataset이어서 모두 사용했습니다.
• starGAN single은 RaFD dataset만을 사용해서 뽑은 결과로 dataset 크기가 작아서 부자연스러운 부분이 있지만 StarGAN joint는 dataset을 모두를 사용하여 뽑아낸 결과로 확실히 좋은 성능을 보인다는 것을 알 수 있습니다.
• muptiple domains + multiple datasets 학습가능!

StarGAN v2 : Diverse Image Synthesis for Multiple Domains

1. StarGAN v1 -> StarGAN v2

• 각 domain에 대한 결정을 한번에 하나씩 직접해야합니다. -> 어떤 domain의 image 한개를 target domain의 여러 다양한 image로 변경 할 수 있습니다.
• 데이터 분포에 대한 다양한 특성을 반영하지 못합니다. -> 특정 도메인에 대한 다양한 style들을 표현할 수 있습니다.

2. KEY POINT!

• Mapping Network : 임의의 가우스 노이즈를 스타일 코드로 변환하는 것을 학습
• Style Encoder : 주어진 소스 이미지에서 스타일 코드를 추출하는 것을 학습

3. Framework

• X와 Y를 각각 이미지와 가능한 도메인의 집합이라고 부르겠습니다.
• X에 속하는 이미지 x와 Y에 속하는 임의의 도메인 y가 주어졌을 때 StarGAN v2의 목표는 하나의 Generator만으로 이미지 x를 도메인 y의 이미지로 변형하되, 다양한 스타일로 변형할 수 있도록 학습하는 것입니다.

(a) Generator : G의 역할은 다른 GAN과 유사하지만 input image x가 들어가면 output으로 G(x,s)가 나옵니다. style vector인 s는 AdaIN(Adaptive instance normalization)을 통해 주입됩니다. s는 도메인 y의 스타일을 대표하도록 밑에 나올 mapping network F나 style encoder E에 의해 만들어집니다.

(b) Mapping network : random latent vector z와 domain y가 주어졌을때 Mapping network인 F는 style vector s=Fy(z)를 만듭니다. 즉, domain y를 대표하는 latent vector z를 style vector s로 mapping해 줍니다. F는 다중출력 MLP로 구성됩니다.

(c) Style Encoder : image x와 domain y가 주어지면 E는 image x 에서 style information을 추출하는 역할을 합니다. s=Ey(x).

(d) Discriminator : D는 다중 출력 Discriminator입니다. D의 각 branch는 이미지 x가 real인지 fake인지 이진 분류할 수 있도록 학습합니다.

4. Training objectives

1. Adversarial objective

• StarGAN에서 봤던것이랑 똑같고, 특징은 latent vector z와 타깃 도메인 ~y를 랜덤하게 샘플링해, 타깃 스타일 벡터 ~s 를 input으로 넣어다는 것이 특징입니다.

2. Style reconstruction

• 스타일에 맞게 잘 변화시키기 위한 것입니다.
• s = Fy(z), fake image를 만드는데 사용한 style code와 만들어진 fake image를 단일인코더 E에 넣어 얻은 style code를 비교하는 것입니다.
• fake image에 우리가 원하는 스타일코드 ~s가 많이 적용되었을 수록 인코더를 통과한 fake image가 ~s랑 비슷해질것입니다. 즉, 얼마나 우리가 원하는 style에 기깝게 fake image가 생성되었는가를 판단해주는 loss라고 할 수 있습니다.

3. Style diversification

• 다양한 style을 생성할 수 있게 하기 위해 추가된 loss입니다. 여기서 s1,s2는 각각 다른 latent vector z에서 생성된 style vector입니다. 이 loss는 최적화 지점이 없기 때문에, 선형적으로 weight를 0으로 줄여가며 학습했다고 합니다.

4. Cycle consistency loss

• 위의 loss들만을 가지고는 생성된 이미지가 input image x에 대해 도메인에 해당하지 않는 속성들을 보존하고 있는지 확신할 수 없기 때문에 cycle consistence loss를 추가하였습니다. (s^은 Ey(x)로 input image x에 대해서 추출된 style vector)

5. Full objective

• λ는 하이퍼파라미터로 adversarial loss를 기준으로 각 loss의 중요도를 반영해 정해진다고 합니다.
• Style diversification에서 본것처럼 weight를 줄여가는 식으로 loss가 구성되었음을 알 수 있습니다.

5. Result

RelGAN: Multi-Domain Image-to-Image Translation via Relative Attributes

1. Abstract & Introduction

• 이전 method(StarGAN 등)는 input쌍으로 (image, target attribute)를 사용하고 원하는 속성으로 출력 이미지를 생성합니다.

  • 한계점1 : 이진값 속성을 가정 -> 세밀한 제어에 대해 만족스러운 결과를 얻을 수 없습니다.
  • 한계점2 : 대부분의 target attribute가 변경되지 않더라도 전체 target attribute 집합을 지정해야합니다.
    
    

• 해결방법 : multi-domain image-to-image translation인 RelGAN !

  • 선택한 attribute에 대해 원하는 변경을 설명하는 상대 속성(relative attribute)기반 방식을 사용합니다. RelGAN은 각 속성의 변경에 따라 입력 이미지의 전체 속성을 알 수 있습니다.(한계점2 극복)
  • 상대 속성(relative attribute)을 조건으로하는 G를 학습하기 위해 input-output 쌍이 상대 속성과 일치하는지 여부를 결정하는 matching-aware discriminator가 등장합니다.
  • 이진 속성을 가정하므로 속성 보간용으로 설계되지 X -> 보간 품질을 향상시키기 위해 interpolation discriminator(보간 판별기)를 제안 -> 편집 전후 사이의 부드럽고 사실적인 보간은 각 속성의 강도 (ex. 갈색 비율)를 세밀하게 제어할 수 있습니다.(한계점1 극복)
  • relative attribute
    • (x,a^) —→ (x,v), v(relative attributes) △= a^ - a
    • 상대 속성의 값은 각 속성을 변경하는 데 필요한 양을 직접 인코딩합니다. 특히, 0이 아닌 값은 관심있는 속성에 해당하고 0 값은 변경되지 않은 속성에 해당합니다.
    • a : original doamin(n-dim), a^ : target attribute vector(n-dim)

2. Overview of RelGAN

• RelGAN = 1개 Generator + 3개의 Discriminators, D = {DReal, DMatch, DInterp}
• G는 (1) realistic images, (2) accurate translations in terms of the relative attributes(상대 속성 측면에서 정확한 번역), (3) realistic interpolations(현실적인 보간)을 목표로 학습합니다.
• target image와 input image의 realtive attributes를 계산합니다.
• G가 facial attribute transfer이나 interpolation을 수행합니다. 여기서 G의 목표는 밑의 세가지의 D를 속이는것입니다.
• Dreal : real/fake구분, Dmatch : real triplets과 generated/wrong triplets을 구분, Dinterp : interpolation정도 예측

3. Method

• 목표: input image x를 ouput image y로 변환할때, y가 realistic하게 보이고, target attributes을 가지게 하는 것입니다.
• 도메인이 n-dimensional attribute vector a =[a(1),a(2),...a(n)]T로 특정지어지며, a(i)는 각 속성(age, gender, hair color)을 의미합니다.

3-1 Relative Attributes

• v(relative attributes) △= a^ - a
• relative attributes을 통한 facial attribute interpolation(얼굴 속성 보간) : x와 G (x, v) 사이의 보간을 수행하려면 G (x, αv)를 적용하기 만하면됩니다. 여기서 α ∈ [0, 1]은 보간 계수입니다.

3-2 Adversarial Loss

• 생성된 이미지와 실제 이미지를 구별할 수 없도록 하기 위한 loss로 G는 realistic한 이미지 생성, D는 real/fake 구분이 목적입니다.

3-3 Conditional Adversarial Loss

• 출력 이미지 G (x, v)가 realistic하게 보일뿐만 아니라 x와 G (x, v)의 차이가 상대 속성 v와 일치해야합니다.이 요구 사항을 달성하기 CGAN의 개념을 적용하고 이미지와 conditional variables (x, v)를 입력으로받는 conditional discriminator인 DMatch를 도입합니다.

• Dmatch는 real인 (x, v, x') 와 fake인 (x, v, G(x, v))를 구분하는것이 목적입니다.

• real triplet (x, v, x') : 2개의 이미지 (x,x')과 relative attribute vector(v = a'- a)

• 주의! x와 x '는 서로 다른 속성을 가진 서로 다른 identities, training data는 짝을 이루지 않습니다.

• wrong triplets을 추가함으로써 DMatch는 real triplet을 +1 (real&matched)로 분류하고 fake/wrong triplet을 모두 -1 (fake or mismatched)로 분류합니다.

3-4 Reconstruction Loss

• G (x, v)가 realistic하게 보이고 x와 G (x, v)의 차이가 상대 속성과 일치하도록 출력 이미지 G (x, v)를 생성하도록 G를 훈련시킬때, G가 low level에서 high level까지 다른 모든 측면을 보존하면서 해당 속성 관련 콘텐츠만 수정한다는 보장은 없습니다. 그래서 G의 정규화를 위해 cycle-reconstruction loss 와 self-reconstruction loss를 도입했습니다.
• Cycle-reconstruction loss : cycle consistency 개념을 적용하고 G(:, v), G(: ,−v)를 서로 inverse되어야 합니다.
• Self-reconstruction loss : 상대 속성 벡터가 0이면 속성이 변경되지 않았음을 의미하는 경우이고 출력 이미지 G (x, 0)는 가능한 한 x에 가까워야합니다.

3-5 Interpolation Loss

• G는 high-quality interpolation을 위해 보간 된 이미지 G (x, αv)가 realistic하게 보이도록 학습합니다. 이 loss는 G (x, αv)를 보간되지 않은 출력과 구별 할 수 없도록하는 정규화를 제안합니다.
• G와 경쟁하기 위해 세 번째 판별 자 DInterp가 등장합니다.
• DInterp의 목표 : 생성된 이미지를 input으로 가져 와서 αˆ = min (α, 1 − α)로 정의되는 보간 정도 αˆ를 예측하는 것입니다. 여기서 αˆ = 0은 보간 없음을 의미하고 αˆ = 0.5는 최대 보간을 의미합니다.
• (6) 첫번째 term : G (x, αv)에서 αˆ복구를 목표, 두/세번째 term : 보간되지 않는 이미지에 대해 0을 출력하도록 권장합니다.
• (7) G는 DInterp를 속여 G (x, αv)가 보간되지 않는다고 생각하게끔 만들고 싶어합니다.
• (8)과 같은 수정 된 손실이 적대적 훈련 과정을 안정화 시킨다는 것을 알게됩니다.I[·]는 인수가 참이면 1이고 그렇지 않으면 0 인 표시하는 함수입니다.

3-6 Full Loss

• 훈련 과정을 안정시키기 위해 우리는 손실 함수에 orthogonal regularization(직교 정규화)를 추가합니다. D = {DReal, DMatch, DInterp} 및 G에 대한 전체 손실 함수는 (9),(10)으로 표현됩니다.
• orthogonal regularization은 Overfitting에 의해 모델의 성능저하를 예방하는 정규화 방법 중 하나입니다. RelGAN저자는 BigGAN논문에서 쓰인 orthogonal regularization을 가져다 쓴것인데 그 논문에서 Generator에 직교 정규화를 적용하면 Generator input의 분산을 줄임으로써 샘플 fidelity와 variety 사이의 균형을 미세하게 제어 할 수있는 간단한 "truncation trick"을 사용할 수 있다고 말했습니다.
• "truncation trick"? 실제로 학습 데이터의 분포를 고려하면, density가 낮은 부분의 경우 학습 후 표현이 잘 되질 않습니다. 즉, 생성기가 제대로 학습을 하지 못합니다. 이러한 부분을 방지하기 위하여 쓰는 방법입니다. GAN model이 잘 학습하기 위한 것이 아니라, GAN model에서 generating된 이미지를 뽑아낼 때, 뽑아내는 것을 더 잘하기 위한 trick.

• (1) identity유지 X, (2) input image를 reconstruct하는 방법만 학습, (3) 위에 것들에 비해 reasonable한 결과, (4) 모든 loss 다 사용! -> 최상의 결과 도출

4. Network Architecture

• Generator : relative attribute를 사용하여 interpolation에 따른 다양한 이미지 생성
• Dmatch : real(l,v,l')과 fake(l,v,G(l,v))를 구분하는게 목적/ I, G(I,v)의 차이가 상대속성인 v와 일치하길 원하기에 도입된 판별기
  Dreal : real/fake 구분
  Dinterp : 생성된 image들을 input으로 받아 보간정도 예측

5. Code

• d_out1 = D_real, d_out2 = D_match, d_out3 = D_interp

6. Result

• 3개의 dataset을 이용하여 256*256으로 resize

• 얼굴속성변환

• 보간

Reference

starGAN : https://hichoe95.tistory.com/39
https://www.youtube.com/watch?v=-r9M4Cj9o_8
https://hichoe95.tistory.com/39

starGAN v2 : https://comlini8-8.tistory.com/13
https://www.youtube.com/watch?v=KO_mOGKdxOw
http://kozistr.tech/deep-learning/2020/02/10/StarGANv2.html
https://wingnim.tistory.com/96
https://skyil.tistory.com/90

RelGAN : 생성모델 컨퍼런스 신민정님 자료
코드 https://github.com/willylulu/RelGAN
https://github.com/elvisyjlin/RelGAN-PyTorch
truncation trick https://myeonghui-deep.tistory.com/6
https://jayhey.github.io/deep%20learning/2019/01/16/style_based_GAN_2/

이번에는 disentanglement에 대한 내용을 다루고자 합니다.

deeplearning.ai의 Build Basic Generative Adversarial Networks (GANs) 강의에서 짧게 disentanglement에 대해 알려주었는데, 많은 자료를 보여주진 않더라구요.

이번에는 해당 강의를 토대로, disentanglement와 관련된 몇 가지 페이퍼를 짧게 요약해보자 합니다.

이 글이 disentaglement의 완벽한 이해를 드리기는 힘들지만, 어떤 것을 하고자 하는지에 대  큰 그림을 얻어가셨으면 좋겠습니다. 오늘 다루는 페이퍼 이외에, 관련 페이퍼를 추가로 적어놓았으니, 관심있으시면 꼭 읽어보시길 바랍니다. :)

Let's Recap

[Figure 1] coursera - Build Basic Generative Adversarial Networks (GANs), 'Challenges with Controllable Generation'

데이터의 분포를 학습하기 위해 우리는 GAN을 사용했습니다. 어떤 노이즈 벡터를 생성하고 GAN의 입력으로 넣었을 때, 우리가 가진 학습 데이터와 비슷하지만 학습 데이터에는 존재하지 않았던 랜덤한 이미지를 만들어낼 수 있습니다.

그러나 우리가 원하는 특징을 가진 랜덤한 이미지를 만드는 것은 쉽지 않습니다. Figure 1을 살펴봅시다. 갈색머리를 가지고 있는 사람의 이미지를 파란머리를 가진 사진으로 변경한 것입니다. 지금까지 다룬 Vanilla GAN은 이렇게 하나의 피쳐만을 변경하는 것이 불가능합니다. 왜 그럴까요? 다른 예를 살펴보겠습니다.

[Figure 2] coursera - Build Basic Generative Adversarial Networks (GANs), 'Challenges with Controllable Generation'

Figure 2를 봅시다. 제가 랜덤 벡터($z$)로 생성한 이미지가 왼쪽의 수염이 없는 여성이라고 해봅시다. 저는 여기서 수염을 추가하고 싶고, $z_1$축을 조절하여 수염을 추가할 수 있는 랜덤 벡터($z'$)를 찾았다고 가정해보겠습니다. 이 여성의 그림에 수염을 추가할 수 있을까요? 물론 가능합니다. 그러나, 오랜쪽 아래의 수염을 가진 남성의 사진이 나오게 됩니다. 즉 수염을 추가한 것 뿐만 아니라 다른 피쳐들이 동시에 변한 것입니다.

[Figure 3] coursera - Build Basic Generative Adversarial Networks (GANs), 'Challenges with Controllable Generation'

이러한 결과가 나오는 것은 $z_1$축이 수염에 관련된 특징뿐만 아니라 다른 어떤 특징과도 연관이 되어있기 때문입니다. 이 예시로 볼 때는 머리 길이, 눈매, 그리고 눈썹 정도일 것 같습니다. 다시 말하면, 하나의 축이 하나의 특징을 의미하는 것이 아닙니다. 이를 entanglement (뒤얽힘, 꼬여있음)혹은 축이 entangle 되어있다. 라고 표현합니다. 축이 꼬여있는(entangle) 이유 중 한 가지는 일반적으로 $z$ 의 차수가 충분하지 않을 때 발생하지만, 이외에도 여러 가지 이유가 있습니다.

내가 원하는 피쳐들 외에 나머지는 고정한채로 이미지를 생성하고 싶다면 축을 disentagle되어있게 하면 되겠죠? disentanglement에 대한 해석을 그대로 인용하자면 다음과 같습니다.

[Figure 4] Takato Horii, Review "Info GAN"

Transforming from an uninterpretable space with entangled features to eigen spaces where features are independent.

자, 이제부터 disentanglement 관련 페이퍼를 다음 순서로 짧게 리뷰해보겠습니다.

• [1] Kulrarni, Tejas D., et. al. "Deep Convolutional Inverse Graphics Network" NIPS'15. 711 citations.
• [2] Chen, Xi, et al. "InfoGAN: Interpretable Representation Learning by Information Maximizing Generative Adversarial Nets" NIPS'16. 2219 citations.
• [3] Higgins, Irina, et al. "beta-VAE: Learning basic visual concepts with a constrained variational framework." ICLR'17. 1199 citations.

다음의 페이퍼는 이번 글에서는 다루지 않지만 읽어보면 큰 도움이 될 거라고 생각합니다. 몇 가지는 이곳에 짧게 정리되어 있습니다. 지금은 미루고 있지만 ☹️, 저도 나중에 꼭 페이퍼를 읽어보려구요 🙂!

• Alemi, Alexander A., et al. "Deep variational information bottleneck." ICLR'17, 411. citations.
• Burgress, Christopher P., et al. "Understanding disentangling in beta-VAE." NIPS'17, 266 citations.
• Chen, Ricky TQ, et al. "Isolating sources of disentanglement in variational autoencoders.", NIPS'18, 317 citations.
• Stoechr, Niglas, et al. "Disentagling interpretable generative parameters of random and real-world graphs." NIPS'19. 3 citations
• Hwang, HyeongJoo, et al. "Variational Interaction Information Maximization for Cross-domain Disentanglement." NIPS'20.

[1] Deep Convolutional Inverse Graphics Network (DC-IGN)

[Figure 4] DC-IGN 요약

특징

• out-of-plane rotations과 lighting variations과 같은 변형에 관하여 disentanglement를 시도함.
• 모델은 convoltion과 deconvolution의 몇 개의 레이어들로 구성되어 있음.
• Stochastic Gradient Variational Bayes를 옵티마이저로 사용함.
• 입력 값이 주어지면, 같은 object지만 pose와 lighting에 따라 새로운 이미지를 만들어냄.

Objective

[Figure 5]

컴퓨터 화상처리(Computer graphics)를 하기 위해서는 개발자들이 프로그래밍 언어를 사용해서 명령을 하겠죠? 그 명령(graphics code; $c$)은 매우 디테일 할 것입니다. 예를 들어 공의 위치는 어디이고, 밝기는 몇이고, 무슨 색깔을 가졌는가? 이렇게요. 이처럼 우리가 원하는 이미지 혹은 그래픽을 생성하기 위해서는 disentangled feature가 필요합니다.

해당 모델(DC-IGN)은 입력 값이 주어졌을 때, 같은 object지만 pose와 lighting에 따라 새로운 이미지를 만들어내는 것을 목표로 합니다.

Architecture

[Figure 6]

VAE(D. P. Kingma and M. Welling, 2013)를 변형한 형태의 모델 구조를 가고 있습니다. 따라서 크게 encoder와 decoder로 이루어졌으며, encoder는 {convolution layers+max-pooling}, decoder는 {convolution laysers+unpooling(upsampling using nearest neighbors)}로 구성됩니다.

Training

Input: data $x$

The posterior approximation: $Q(z_i|x)$, where $Q$~ $\mathcal{N}(\mu_{z_i}, \Sigma_{z_i})$

Graphics code: $Z$

encoder의 output ($encoder(x)$): $y_e$

[Figure 7]

$Q(z_i|x)$를 만들어내기 위해 데이터 $x$가 encoder를 통과합니다. $Q(z_i|x)$의 모수는 다음과 같이 만들어집니다.

$\mu_{z_i}=W_e*y_e$,

$\Sigma_{z_i}=diag(\exp(W_e*y_e))$

code $Z$가 different view를 가진 이미지를 생성하기 위해 decoder를 통과하고, $-\log(P(x|z_i))+KL(Q(z_i|x)||P(z_i))$ 를 object function으로 사용하여 학습하면 됩니다. 이 때, code $Z$는 Figure 7 처럼 disentaglement와 entaglement 파트가 섞여있는 벡터입니다.

[Figure 8]

여기까지는 다른 모델과 크게 다를 것이 없습니다. 그렇다면 어떻게 disentanglement를 할 수 있을까요?

DC-IGN은 mini-batch 를 이용하는 것입니다.

현재 우리가 여러 특징(feature)을 가진 학습데이터를 가지고 있다고 가정합시다. feature의 종류는 (방위각, 고도 각, 광원의 방위각, and intrinsic properties (shape, texture, etc)) 입니다. 앞의 3개의 feature를 각각 $z_1, z_2, z_3$라고 인코딩했다고 하겠습니다.

미리 mini-batch가 오직 한 개의 variable만 변하도록 데이터를 구성합니다. 예를 들어 elevation angle만 변할 수 있도록 구성하는 것입니다. 다음과 같은 procedure를 통해 모델은 학습됩니다.

[Figure 9]

1. {방위각, 고도 각, 광원의 방위각, 고유 속성} 중 하나에 해당하는 잠재 변수 $z_{train}$을 무작위로 선택합니다.
2. $z_{train}$에 해당하는 피쳐만 변하는 mini-batch 중에서 하나를 선택합니다.
3. mini-batch를 모델의 input으로 사용하여, 각각의 벡터 값을 알아냅니다.
4. 배치 전체에서 벡터들의 평균을 계산합니다.
5. Decoder로 들어가기 전에, 1번에서 결정한 $z_{train}$ 차원이 아닌 다른 차원의 값들($z_i\neq z_{train}$)은 4번에서 구한 평균값으로 대체합니다. 이것을 "clamped output"이라고 하겠습니다.
6. reconstruction error값을 계산하고, SGVB에 따라 decoder에 back-propagation 해줍니다.
7. $z_i\neq z_{train}$ 의 gradient값을 평균값과의 차이로 대체합니다. $z_{train}$의 gradient는 그대로 통과됩니다.
8. 수정된 gradient 값으로 encoder를 학습시킵니다.

intrinsic representation의 경우 $z_1, z_2, z_3$와 달리 매우 고차원이므로, 더 많은 학습이 요구됩니다. 따라서 논문의 저자들은 1:1:1:10의 비율로 모델을 학습했다고 합니다.

즉 한 번에 하나의 transfomation만 사용하여 학습함으로써, disentanglement를 시도하였습니다. 또한 하나의 변환을 보장하기 위해 선택된 차원을 제외하고는 평균과의 차이 값으로 하였습니다

Results

[Figure 10] *Kulrarni, Tejas D., et. al. 2015.*

[Figure 11] *Kulrarni, Tejas D., et. al. 2015.*

[2] InfoGAN: Interpretable Representation Learning by Information Maximizing Generative Adversarial Nets

[Figure 12] InfoGAN 요약

특징

• Mutual Information을 최대화하도록 학습함.
• GAN architecture를 사용함.

Objective

A disentangled representation should be helpful for the relevant but unknown tasks.

이에 따라 InfoGAN은 interpretable하고 meaningful representations을 만들어내기 위해 GAN의 구조를 사용하였습니다. 또한, 상호정보량(mutual information; MI)을 최대화하도록 하여 모델을 학습하였습니다.

InfoGAN 자체는 매우 간단하지만, 다양한 데이터셋에서 매우 효과적인 결과를 보여주었다고 합니다. 결과적으로 disentanglment 학습에 MI cost가 효과적이였음을 보여준 것이죠.

[Figure 13]

the generator distribution: $P_G(x)$

the real data distribution: $P_{data}(x)$

a generator: $G$

a discriminator: $D$

a noise variable: $z$

모델에 사용된 GAN을 간단하게 표현하자면 Figure 13과 같이 표현할 수 있습니다. 우리는 $P_G(x)$가 $P_{data}(x)$를 approximate하기를 원합니다. 따라서 $z\sim P_{noise}(z)$를 변형하여 $P_G$로부터 샘플 이미지를 생성할 수 있는 $G$를 학습시키게 됩니다. 이때, $G$는 $D$와 minmax game을 하며 경쟁적으로 모델을 학습하게 되며, $D$는 $P_G$와 $P_{data}$를 구별하기를 원합니다. 이를 수식으로 정리하자면 다음과 같습니다.

$\min_G \max_D V(D,G)=\mathbb{E}{x\sim P{data}}[\log D(x)]+\mathbb{E}_{z\sim noise}[\log(1-D(G(z))]$

위 식에서 볼 수 있듯이, GAN은 $z$에 아무런 제약조건을 주지 않습니다. 따라서 $z$는 entangled vector일 것입니다.

Key idea1

[Figure 14]

기존 GAN과 다르게, InfoGAN은 noise vector $z$ 뿐만 아니라 latent code $c$라는 벡터를 만들었습니다. 따라서 모델의 input은 Figure 14의 오른쪽 그림과 같이 두 개입니다. 이 때, latent codes를 $c_1, c_2, ..., c_L$이라고 표기하는데, 독립 가정을 하여 $P(c_1, c_2, ..., c_L)=\prod_{i=1}^{L}P(c_i)$가 성립합니다.

그러나 기존 GAN의 $c$만 추가한다고 해서 학습이 우리가 원하는 방향으로 이루어지는 것은 아닙니다. 모델이 $P_G(x|c)=P_G(x)$를 만들어 내기 위해 $c$를 무시하고 학습을 할 수 있기 때문입니다. 이를 위해 저자들은 information-theoretic regularization을 제안하였습니다. 이것은 latent codes c와 disribution G(z,c)의 상호정보량을 높이는 방식입니다. 즉, $I(c; G(z,c))$ 값을 높게 하는 것이죠.

[Figure 15] Mutual information From Wikipedia, the free encyclopedia

[Figure 16]

Figure 16를 보면, 두 개의 변수들이 독립이라면 상호정보량 $I=0$이 됩니다. 따라서 Info GAN은 이 값을 maximize하도록 목적함수를 설계한 것입니다.

이를 정리하면 다음과 같습니다.

$\min_G \max_D V_I (D,G)=V(D,G)-\lambda I(c;G(z,c))$ —— (1)

Training

[Figure 17] Chen, Xi, et al. 2016.

위의 식 (1)을 그대로 사용한다면, 한 가지 문제가 있습니다. 어떤 문제가 있을까요?

상호정보량은 이전 관측 $x$를 통해 새로운 관측 $y$의 불확실성이 얼마나 제거 되는가에 대한 척도라고 할 수 있습니다. 즉 Figure 16 에서 볼 수 있듯이 $P(c|x)$이 필요합니다. 따라서 저자들은 Variational Information Maximization 테크닉을 이용하여 $P(c|x)$를 approximate 하기 위한 lower bound를 구합니다.

Figure 17 에서 3번째→ 4번째는 trivial하기 때문에 생략하고, 1번째→2번째에 대해 살펴보겠습니다. 해당 내용은 InfoGAN의 Appendix에 있습니다. 이해를 돕기 위해 외부 자료를 참고하였습니다. 🙂

[Figure 18] 임성빈 박사님, [학부생의 딥러닝] GANs | InfoGAN : Information maximizing GAN, 하우론 브레인

(Wikipedia, *Fubini theorm: 이중 적분은 두 번의 일변수 적분을 통해 구할 수 있고, 이는 두 변수에 대한 적분의 순서와 무관하다는 정리)

따라서 최종 목적함수는 다음과 같습니다.

$\min_{G,Q} \max_D V_{InfoGAN} (D,G,Q)=V(D,G)-\lambda L_1(c;G(z,c))$

Results

[Figure 19] Chen, Xi, et al. 2016.

[Figure 20] Chen, Xi, et al. 2016.

[Figure 21] Chen, Xi, et al. 2016.

[Figure 22] Chen, Xi, et al. 2016.

[3] beta-VAE: Learning basic visual concepts with a constrained variational framework ($\beta$-VAE)

[Figure 23] Yong-min Shin, GNN-YYK, beta-VAEs

특징

• VAE 구조를 사용함.
• Adjustable hyperparameter인 $\beta$를 추가함.
• code vector 크기에 제한이 없음.
• Disentanglement의 정도를 quantitatively 비교하기 위한 프로토콜을 개발함.

Objective

disentanglemet의 대표적인 모델 중 한가지는 infoGAN이라고 할 수 있습니다. 그러나 infoGAN은 여러 한계점이 존재합니다. 저자가 언급한 info GAN의 단점은 (1) 다양하고 큰 데이터셋에는 적용하기 힘들다. (2) noize variables의 수에 민감하다. 등등이 있습니다.

이러한 문제를 해결하기 위해 저자들은 $\beta$-VAE를 제안하였습니다. 모델 하이퍼파라미터인 $\beta$를 조절함으로써 disentanglement의 정도를 조절할 수 있습니다.

Key idea

images: $x \in \mathbb{R}^N$

two sets of ground truth data generative factors: $v; and ;w$

conditionally independent factors: $v \in \mathbb{R}^K, where \log p(v|x)=\sum_k \log p(v_k|x)$

conditionally dependent factors: $w \in \mathbb{R}^H$

[Figure 23] Yong-min Shin, GNN-YYK, beta-VAEs

저자는 이미지를 생성하기 위한 모델을 Simulator라는 말로 표현하고 있는 것 같습니다. 따라서 우리는 image $x$가 $\mathbf{Sim}(v,w)$로 부터 생성되었다고 가정합니다.

기존 VAE와 어떻게 달라졌는지 살펴봅시다.

[Figure 24] Higgins, Irina, et al. 2017

(1) 모델은 data x와 latent factors z의 결합 분포를 학습할 수 있습니다. 이 때 z는 x를 생성할 수 있는 factor겠죠? 즉, $p(x|z) \approx p(x|v,w)=\mathbf{Sim}(v,w)$ 입니다. 따라서 수식(1)을 maximize하길 원합니다.

(2) VAE에서 공부했듯이, 우리는 $q_\phi (z|x)$로부터 $z$의 분포를 추정합니다.

중요한 것은, $q_\phi (z|x)$가 disentanglement part인 $v$를 잘 capture해야 합니다. v를 제외한 나머지 part가 w라고 생각할 수 있습니다. 이를 보장하기 위해, $q_\phi (z|x)$가 $p(z)$와 match 되게끔 constraint을 걸게 됩니다.

이렇게 제약조건을 걸면,

• latent information bottleneck의 capacity를 컨트롤할 수 있고,
• independent(disentaglement factor)를 실현할 수 있습니다.
• (v에 대한 직접적인 텀은 없다. 용량 제한을 주다보니, 그 공간 안에서 이미지를 잘 생성해내기 위한 파라미터를 학습하기 위해 disentanglement가 가능한 느낌이다.)*

이는 $p(z)\sim \mathcal{N}(0, I)$를 가정하면 조건부 최적화 문제로 풀 수 있습니다.

(3) 수식 (2)를 KKT 조건 하에 라그랑지안으로 풀면 (3)을 얻게 됩니다. (KKT 조건을 만족한다고 가정했기 때문에 (2)의 최적 솔루션이 (3)의 최적 솔루션을 구하는 것과 같음을 알 수 있습니다.)

눈치채셨겠지만, 논문 제목의 beta 파트가 여기서 등장하게 됩니다. 😉

여기서 KKT multiplier $\beta$는 latent information channel $z$를 통제하는 regularization coefficient가 됩니다.

(4) KKT 조건의 the complementary slackness(KKT 조건 중 하나)에 따라 $\epsilon$ ≥ 0이므로, 최종적으로 lower bound (4)가 나오게 됩니다.

beta의 효능 💪:

• Disentanglementd의 정도를 조절할 수 있음.
• beta = 1, Vanila VAE와 동일함.
• beta > 1, 더 효율적인 latent representation을 찾기 위해 학습함. (regularize term이 강화됨.)
• 학습이 비교적 안정적임.

최종 목적식 (4)에서도 알 수 있듯이, 실제로 v, w는 가정일 뿐 conditionally independent factors $v$, conditionally dependent factors $w$에 관여하는 텀은 없습니다.

결국 제약조건으로 인해 등장한 $\beta$ 텀을 잘 조절하며 학습하면, z가 v, w로 분해가 되는 것입니다. 이러한 이유로 InfoGAN의 한계점을 커버할 수 있다고 말한 것 같습니다.

따라서 전반적인 모델 구조에 대한 코드는 다음과 같이 심플합니다.

[Figure 25] 1Konny, "Pytorch implementation of β-VAE", Github.

Disentanglement의 Metric에 관하여 해당 논문의 section 3에서 소개하고 있습니다만, 생략하도록 하겠습니다. 😂

Results

[Figure 26] Higgins, Irina, et al. 2017

오늘 다룬 모델들을 베이스라인으로 하여 비교하고 있네요!

[Figure 27] Higgins, Irina, et al. 2017

1개의 latent 값을 바꿨을 때 1개의 특징만 변하고 있는 것을 볼 수 있습니다.

결론

최신 논문들을 다루지 않아 조금 아쉽지만, 어느정도 disentanglement와 친해지셨길 바라겠습니다. 🙂

읽어주셔서 감사합니다.

Reference

해당 글은 연세대학교 신용민님의 도움을 받아 작성하였습니다.

Image to Image Translation

image to image translation이란 이미지 데이터셋을 사용하여 input 이미지와 output 이미지를 mapping하는 것을 목표로 하는 생성모델의 한 분야입니다. 흑백 이미지에 컬러를 입힌다든지, 낮 사진을 밤 사진으로 만든다든지, 테두리만 주어진 사진을 실제 물건같이 만드는 것이 가능하죠.

이런 image to image translation은 크게 paired한 데이터셋을 사용하는 분야와 unpaired한 데이터셋을 사용하는 분야로 구분할 수 있습니다. 그리고 이 분야들을 대표하는 모델들이 오늘 볼 pix2pix과 cyclegan입니다.

Pix2Pix

그 당시 이미지 처리 문제의 대부분은 CNN을 사용해서 해결했습니다. 하지만 그 당시 CNN에는 큰 결점이 하나 있습니다. 특정 과업을 수행하기 위해서는 매번 특정 loss를 설계해야하기 때문에 포괄적인 작업을 할 수 없다는 것입니다. 실제 pix2pix에서 진행하는 실험들을 CNN으로 시도한 적 있으나 대부분의 결과는 blurry했습니다. 그래서 논문의 저자들은 CGAN이라는 조건부 생성모델을 바탕으로 포괄적인 작업을 수행할 수 있는 pix2pix을 만들었습니다. CGAN은 지난 번 민정님께서 잘 설명해주셨으니 넘어갈게요 :)

기본적으로 pix2pix은 생성모델이기 때문에 generator, discriminator가 필요합니다.

generator의 경우, CGAN과 굉장히 유사하게 작동합니다. 하지만 input으로 Noise vector와 class vector를 받는 CGAN과는 다르게 더 이상 Noise vector를 필요로 하지 않습니다. 오로지 이미지만을 input으로 받아 output을 생성하는 것입니다.

discriminator의 경우, 2가지를 input으로 받습니다. 기본적으로 generator에 넣었던 input 이미지, 이와 하나의 pair가 될 진짜 이미지나 생성된 이미지를 input으로 받습니다. 이 2가지를 동시에 discriminator에 넣었을 때, discriminator는 pair를 비교하여 생성된 이미지인지 진짜 이미지인지를 구분하는 것입니다. 이 일련의 과정으로 학습을 마치게 됩니다.

여기서 알아두셔야 할 점은 기존의 discriminator와 generator를 한 단계 발전시켰다는 점입니다. generator는 U-net구조와 skip connection을 사용했고, discriminator는 patchgan을 사용했다는 점입니다.

U - net

[출처 : https://taeoh-kim.github.io/blog/image2image/]

기본적으로 U-net은 encoder-decoder 구조를 skip-connection으로 발전시킨 구조입니다. 데이터가 인코더를 통하면 이미지의 feature들을 잘 추출해낼 수 있겠죠? 그리고 다시 디코더를 통하면 원하는 이미지를 만들 수 있을 것입니다. 그러나 이 과정에서 이미지의 형태나 해상도 등 정보의 손실은 어쩔 수 없이 발생하게 됩니다. 이러한 정보의 손실을 막기 위해서 skip - connection을 사용합니다. 이 뿐만 아니라 skip-connection을 사용하면 역전파 과정에서 vanishing gradient 문제도 해결할 수 있다는 장점이 있습니다.

[출처 : https://taeoh-kim.github.io/blog/image2image/]

모델의 구조는 위와 같습니다. 각각 8개의 block으로 구성되어 있으며, 유의하셔야 점은 decoder의 처음 3개의 block에서 Batch Normalizaion과 Dropout이 같이 진행되는 것입니다.

    def __init__(self, image_channels=3, inner_channels=64, n_layers=8, dropout=0.5, norm_layer=nn.InstanceNorm2d):
        super().__init__()
        assert n_layers >= 5

        block = UNetSkipConnectionBlock(inner_channels*8, inner_channels*8, 'innermost', norm_layer=norm_layer)
        for _ in range(n_layers-5):
            block = UNetSkipConnectionBlock(inner_channels*8, inner_channels*8, 'middle', block, dropout, norm_layer=norm_layer)
        block = UNetSkipConnectionBlock(inner_channels*4, inner_channels*8, 'middle', block, dropout, norm_layer=norm_layer)
        block = UNetSkipConnectionBlock(inner_channels*2, inner_channels*4, 'middle', block, dropout, norm_layer=norm_layer)
        block = UNetSkipConnectionBlock(inner_channels, inner_channels*2, 'middle', block, dropout, norm_layer=norm_layer)
        self.model = UNetSkipConnectionBlock(image_channels, inner_channels, 'outermost', block)

    def forward(self, x):
        return self.model(x)

generator 구조 코드 [출처 : https://www.secmem.org/blog/2020/07/19/pix2pix/]

    def __init__(self,
                 outer_channels,
                 inner_channels,
                 module_type,
                 submodule=None,
                 dropout=0.5,
                 norm_layer=nn.InstanceNorm2d
                 ):
        super().__init__()

        if module_type not in ['innermost', 'outermost', 'middle']:
            raise Exception('no such module type')

        if type(norm_layer) == functools.partial:
            use_bias = norm_layer.func == nn.InstanceNorm2d
        else:
            use_bias = norm_layer == nn.InstanceNorm2d

        down_conv = nn.Conv2d(outer_channels, inner_channels, kernel_size=4, stride=2, padding=1, bias=use_bias)
        down_relu = nn.LeakyReLU(0.2, True)
        down_norm = norm_layer(inner_channels)

        up_relu = nn.ReLU(True)
        up_norm = norm_layer(outer_channels)

        self.outermost = module_type == 'outermost'
        if module_type == 'innermost':
            up_conv = nn.ConvTranspose2d(inner_channels, outer_channels, kernel_size=4, stride=2, padding=1, bias=use_bias)
            modules = [down_relu, down_conv, up_relu, up_conv, up_norm]
        elif module_type == 'outermost':
            up_conv = nn.ConvTranspose2d(inner_channels*2, outer_channels, kernel_size=4, stride=2, padding=1)
            modules = [down_conv, submodule, up_relu, up_conv, nn.Tanh()]
        else:
            up_conv = nn.ConvTranspose2d(inner_channels*2, outer_channels, kernel_size=4, stride=2, padding=1, bias=use_bias)
            modules = [down_relu, down_conv, down_norm, submodule, up_relu, up_conv, up_norm, nn.Dropout(dropout)]

        self. model = nn.Sequential(*modules)

    def forward(self, x):
        if self.outermost:
            return self.model(x)
        return torch.cat([x, self.model(x)], 1)

skip-connection 구조 코드 [출처 : https://www.secmem.org/blog/2020/07/19/pix2pix/]

PatchGAN

pix2pix의 discriminator는 PatchGAN입니다. PatchGan이라고 대단한 구조는 아닙니다. 기존의 GAN의 discriminator는 Image 전체를 보고 진짜인지 아닌지를 판별한다면, PatchGAN은 이미지를 조각내서 부분부분을 보고 진짜인지 아닌지를 판별합니다. 아래와 같은 그림처럼 말이죠. 그러면 Patch 단위로 loss의 역전파가 진행되기 때문에 좀 더 detail한 image를 만들 수 있게 되는 것이죠.

이 때 대체로 patch의 크기는 70 x 70 사이즈를 사용합니다. 그 이유는 이미지의 크기와 동일한 286 x 286 사이즈의 patch를 사용해도 70 x 70 사이즈의 결과물과 다를 바가 없고, 오히려 parameter만 증가해 학습시간에 악영향을 미치기 때문이라고 합니다. 모델의 구조는 아래와 같습니다.

[출처 : https://taeoh-kim.github.io/blog/image2image/]

    def __init__(self,
                 input_channels=6,
                 inner_channels=64,
                 n_layers=3,
                 norm_layer=nn.InstanceNorm2d
                 ):
        super().__init__()

        if type(norm_layer) == functools.partial:
            use_bias = norm_layer.func == nn.InstanceNorm2d
        else:
            use_bias = norm_layer == nn.InstanceNorm2d

        modules = [nn.Conv2d(input_channels, inner_channels, kernel_size=4, stride=2, padding=1), nn.LeakyReLU(0.2, True)]
        for i in range(n_layers-1):
            modules += [
                nn.Conv2d(inner_channels*min(2**i, 8), inner_channels*min(2**(i+1), 8), kernel_size=4, stride=2, padding=1, bias=use_bias),
                norm_layer(inner_channels*min(2**(i+1), 8)),
                nn.LeakyReLU(0.2, True)
            ]
        modules += [
            nn.Conv2d(inner_channels * min(2 ** (n_layers-1), 8), inner_channels * min(2 ** n_layers, 8), kernel_size=4, stride=1,
                      padding=1, bias=use_bias),
            norm_layer(inner_channels * min(2 ** n_layers, 8)),
            nn.LeakyReLU(0.2, True),
            nn.Conv2d(inner_channels * min(2 ** n_layers, 8), 1, kernel_size=4, stride=1, padding=1)
        ]
        self.model = nn.Sequential(*modules)

    def forward(self, x):
        return self.model(x)

discriminator 구조 코드 [출처 : https://www.secmem.org/blog/2020/07/19/pix2pix/]

Loss

pix2pix의 기본적인 loss는 위와 같은 형식입니다. 굉장히 익숙한 앞부분과 생소한 뒷부분으로 구성되어 있죠.

pix2pix은 생성모델이므로 adversarial loss를 사용합니다. 이 때, loss는 주로 BCE loss를 사용한다고 합니다.

위의 adversarial loss만을 사용하면 생성된 이미지가 약간 흐리게 나온다고 합니다. 그래서 논문의 저자들은 조금이라도 개선된 이미지를 만들기 위해 L1 distance (Manhattan distance)를 사용합니다. 즉, 만들어진 이미지와 실제 이미지 사이의 픽셀간의 거리를 구해 이를 최소화하여 최대한 원래 이미지처럼 만들 수 있게 하는 것입니다.

그래서 최종적으로 제일 위의 loss function을 만들고, 람다라는 hyper parameter를 조절하여 최적의 loss function을 찾아갑니다.

CycleGAN

위에서 설명한 pix2pix 모델은 paired한 이미지 데이터셋을 가지고 학습을 진행했습니다. 하지만 paired 데이터셋은 실제로 구하기 굉장히 어렵고, 구한다고 하더라도 데이터셋에 들어가는 비용이 만만치 않습니다. 뿐만 아니라 아예 못구하는 데이터들도 수두룩합니다. 그래서 논문의 저자들은 짝지어진 예시 없이 X라는 도메인으로부터 얻은 이미지를 타겟 도메인 Y로 바꾸는 방법인 CycleGAN을 제시합니다.

paired dataset의 경우, X 이미지의 좌표값과 Y 이미지의 좌표값이 어떻게 대응되는지에 대한 정보들이 담겨있습니다. 그러나 unpaired dataset은 일대일로 매칭된 것이 아니기 때문에 이에 대한 정보가 존재하지 않습니다. 이를 개선하고자 저자들은 cycle consistency loss function을 사용한 것입니다.

구조

기본적으로 CycleGAN은 2개의 GAN을 필요로 합니다. X에서 Y의 이미지를 만들어주는 generator와 이 이미지가 진짜인지 판단하는 discriminator, 그리고 반대의 경우까지 고려한 것이죠.

기본적으로 discriminator는 pix2pix과 마찬가지로 patchGAN을 사용합니다. generator의 경우, pix2pix과 같은 U - net을 기반으로 발전시켰다. 아래와 같이 U-net에 DCGAN과 residaul connection을 추가한 방식을 사용했습니다. 이렇게 만들면서 확실히 정보의 손실량이 줄어, 고해상도 처리를 더 수월하게 만들었습니다.

    if netG == 'resnet_9blocks':
        net = ResnetGenerator(input_nc, output_nc, ngf, norm_layer=norm_layer, use_dropout=use_dropout, n_blocks=9)
    elif netG == 'resnet_6blocks':
                net = ResnetGenerator(input_nc, output_nc, ngf, norm_layer=norm_layer, use_dropout=use_dropout, n_blocks=6)
    elif netG == 'unet_128':
        net = UnetGenerator(input_nc, output_nc, 7, ngf, norm_layer=norm_layer, use_dropout=use_dropout)
    elif netG == 'unet_256':
        net = UnetGenerator(input_nc, output_nc, 8, ngf, norm_layer=norm_layer, use_dropout=use_dropout)
    else:
        raise NotImplementedError('Generator model name [%s] is not recognized' % netG)
    return init_net(net, init_type, init_gain, gpu_ids)

일반적으로 작동원리는 아래의 그림과 같습니다. 실제 이미지가 generator를 통하면 가짜 이미지를 생성합니다. 이 때, discriminator는 이 이미지가 진짜인지 가짜인지를 자신이 학습한 데이터를 토대로 판별하게 됩니다. output은 patchGAN을 사용했기 때문에 그림과 같이 각 부분마다 진짜인지 아닌지를 판별해서 구해집니다.

    # define networks (both Generators and discriminators)
    # The naming is different from those used in the paper.
    # Code (vs. paper): G_A (G), G_B (F), D_A (D_Y), D_B (D_X)
    self.netG_A = networks.define_G(opt.input_nc, opt.output_nc, opt.ngf, opt.netG, opt.norm,
                                    not opt.no_dropout, opt.init_type, opt.init_gain, self.gpu_ids)
    self.netG_B = networks.define_G(opt.output_nc, opt.input_nc, opt.ngf, opt.netG, opt.norm,
                                    not opt.no_dropout, opt.init_type, opt.init_gain, self.gpu_ids)

    if self.isTrain:  # define discriminators
        self.netD_A = networks.define_D(opt.output_nc, opt.ndf, opt.netD,
                                        opt.n_layers_D, opt.norm, opt.init_type, opt.init_gain, self.gpu_ids)
        self.netD_B = networks.define_D(opt.input_nc, opt.ndf, opt.netD,
                                        opt.n_layers_D, opt.norm, opt.init_type, opt.init_gain, self.gpu_ids)

def forward(self):
    """Run forward pass; called by both functions <optimize_parameters> and <test>."""
    self.fake_B = self.netG_A(self.real_A)  # G_A(A)
    self.rec_A = self.netG_B(self.fake_B)   # G_B(G_A(A))
    self.fake_A = self.netG_B(self.real_B)  # G_B(B)
    self.rec_B = self.netG_A(self.fake_A)   # G_A(G_B(B))

Loss

기본적으로 논문에서 제시한 loss function은 처음 이미지와 같습니다. GAN이 2개이기 때문에 각각의 adversarial loss와 cycle consistency loss를 고려한 것이죠. 이 후 이 function을 논문에서 차차 발전시켜서 두 번째 이미지와 같은 loss function을 만들게 됩니다. 이를 하나하나 살펴보겠습니다.

Cycle Consistency loss

Cycle Consistency를 사용하는 이유는 저희가 unpaired dataset을 사용하기 때문입니다. 위에서 언급했듯이 paired dataset의 경우, X와 Y의 이미지의 좌표값이 있어서 이 관계에 대한 정보가 있습니다. 반면 unpaired dataset은 이 정보가 없으며, 각 이미지간의 대응관계 너무 많기 때문에 사실상 만들어진 이미지가 실제와 pair라고 확정지을 수 없습니다. 즉, mapping의 제약이 적다는 의미이며 이는 결국 mode collapse를 야기할 수 있습니다. 이를 방지하기위해 Cycle consistency를 사용하는 것입니다.

단순 mapping이 아닌 돌아오는 mapping까지 고려하여, 최대한 mapping의 가능성을 줄여주는 것이죠. 그래서 아래의 loss function이 나오게 된 것입니다.

Adversarial Loss

CycleGAN 역시 생성모델이기에 adversarial loss를 사용합니다. 하지만 여기서 알아둬야할 점은 일반적인 GAN처럼 BCE loss를 사용하지 않고 Least Square loss를 사용한다는 점입니다.

논문에서는 이렇게 Least Sqaure loss를 사용했을 때, 좀 더 안정적으로 학습이 가능했고, 높은 퀄리티의 이미지를 생성했다고 합니다. 그리고 이 loss를 사용하면 BCE loss를 사용했을 때 나타나는 mode collapse나 vanishing gradient의 가능성을 줄여준다고 합니다.

Identity Loss

마지막으로 Identity Loss입니다. 논문의 저자들은 일부 작업에 이 loss를 적용했습니다. 일반적으로 모델은 X에서 Y로 가는 mapping을 학습합니다. 아래의 이미지가 대표적인 결과물입니다.

input은 모네의 그림인데요. 그림이 들어오면 마치 사진처럼 굉장히 잘 바꾼다는 것은 확실합니다. 하지만 색상이나 분위기를 완전히 바뀌었습니다. 이처럼 분위기나 색상을 유지하기 위해 Identity loss를 사용한 것입니다.

즉, Identity loss를 사용하는 이유는 Y에서 Y로 가는 mapping에 대한 제약을 걸어주는 것입니다. Y domain의 image가 input으로 들어왔을 때 그 특징을 유지하려면, 모델은 단순히 X를 Y로 만드는 단순 작업(?)을 하는 것이 아니라 들어온 input 이미지를 한 번 더 들여다 봐야한다는 것이죠.

그래서 위와 같은 identity loss를 만들어주는 것입니다.

    if gan_mode == 'lsgan':
        self.loss = nn.MSELoss()
    elif gan_mode == 'vanilla':
        self.loss = nn.BCEWithLogitsLoss()
    elif gan_mode in ['wgangp']:
        self.loss = None
    else:
        raise NotImplementedError('gan mode %s not implemented' % gan_mode)

        self.criterionGAN = networks.GANLoss(opt.gan_mode).to(self.device)  # define GAN loss.
        self.criterionCycle = torch.nn.L1Loss()
        self.criterionIdt = torch.nn.L1Loss()

한계

지금까지 본 CycleGAN은 굉장히 좋은 성능을 보여줬습니다. 하지만 이 모델 역시 한계는 존재했습니다. 우선 이미지의 모양을 바꾸진 못한다는 점입니다. CycleGAN은 주로 분위기나 색상을 바꾸는 것으로 스타일을 학습하여 다른 이미지를 생성합니다. 그러다보니 피사체의 모양 자체는 바꿀 수가 없었습니다. 그리고 데이터셋의 분포가 불안정하면 이미지를 제대로 생성할 수 없게 됩니다.

위의 예시처럼 사과를 오렌지로 바꾸는 작업은 모양을 바꾸지 못하는 오류입니다. 그리고 사람을 태운 말을 얼룩말로 바꿀 때, 사람까지 얼룩말이 되는 것은 데이터셋에 사람이 말을 탄 데이터가 없기 때문에 나타난 결과입니다.

Reference

CycleGAN, pix2pix 논문 : https://arxiv.org/abs/1611.07004 https://arxiv.org/abs/1703.10593 coursera 강의 : Apply Generative Adversarial Networks (GANs) pix2pix 관련 : https://taeoh-kim.github.io/blog/image2image/ https://greeksharifa.github.io/generative%20model/2019/04/07/Pix2Pix/ https://www.secmem.org/blog/2020/07/19/pix2pix/ CycleGAN 관련 : https://taeoh-kim.github.io/blog/image2image/ https://comlini8-8.tistory.com/9 https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix https://medium.com/curg/cyclegan-unpaired-%EB%8D%B0%EC%9D%B4%ED%84%B0%EB%A5%BC-%ED%95%99%EC%8A%B5%ED%95%98%EA%B3%A0-%EC%9D%B4%EB%AF%B8%EC%A7%80-%EB%B3%80%ED%99%98%ED%95%98%EA%B8%B0-6fca2f2cddd5

StyleGAN(스타일 갠) seminar 목차

1. gan 개선방안

2. style gan 활용

3. style gan의 사업적 측면

4. style gan의 의의

5. style gan의 구조 1) progressive growing 2) noise mapping network

   • z vector와 w vector의 차이점
   • style gan에서 w vector의 역할

   3) synthesis network

   • AdaIN
   • style mixing
   • stochastic variation

6. style gan이 제안한 latent space disentanglement 측정법

   • perceptual path length
   • linear separability

7. style gan 총 정리

8. style gan의 한계

9. style gan 2

1. gan의 개선 방안

_출처:cousera DeepLearning.AI <https://www.coursera.org/learn/build-better-generative-adversarial-networks-gans?utm_source=deeplearningai&utm_medium=institutions&utm_campaign=DLWebGANsMain_>

위의 사진은 gan의 발전과정이다. 흑백, 저화질의 사진에서 컬러 고화질의 사진으로 2014년부터 2018년까지 4년사이 놀라운 발전이 이루어졌다.
Gan이 많이 발전해왔지만 여전히 개선점이 존재한다. 2주차 강의에서부터 계속 강조해왔던

1. stability(안정성)
2. capacity(gan의 능력)
3. diversity(다양성) 이다.

_출처:cousera DeepLearning.AI <https://www.coursera.org/learn/build-better-generative-adversarial-networks-gans?utm_source=deeplearningai&utm_medium=institutions&utm_campaign=DLWebGANsMain_>

왼쪽이미지는 잘 학습된 생성 이미지/ 오른쪽 이미지는 local minimum에 빠진 mode collapse 생성 이미지이다. 즉, 왼쪽이미지는 샘플 전체의 표준편차가 높고. 오른쪽 이미지는 샘플 전체의 표준 편차가 낮다.

이 모델의 stability를 개선하기 위한 방법으로

1. minibatch

2. Wasserstein loss 2주차 신민정님 자료:(https://velog.io/@tobigs-gm1/basicofgan)

3. spectral normalization

4. exponential averaging (style gan)

   _출처:cousera DeepLearning.AI <https://www.coursera.org/learn/build-better-generative-adversarial-networks-gans?utm_source=deeplearningai&utm_medium=institutions&utm_campaign=DLWebGANsMain_>

5. progressive growing (style gan)

   _출처:cousera DeepLearning.AI <https://www.coursera.org/learn/build-better-generative-adversarial-networks-gans?utm_source=deeplearningai&utm_medium=institutions&utm_campaign=DLWebGANsMain_>

   
   1,2번은 이미 배웠으니 넘어가도록 하고 4,5번은 stlye gan에서 자세히 설명하도록하겠다
   
   spectral normalization에 대해 설명하자면 batch normalization과 매우 비슷하다.
   hyper-parameter에서 Lipschitz constant만 조정하면 되기때문에 실행이 간단하고 추가적인 계산량이 적다는 장점이있다.
   pytorch와 tensor flow는 구현이 되어 있어서 그냥 사용하면된다.
   

pytorch : TORCH.NN.UTILS.SPECTRAL_NORM()_ tensorflow : tfa.layers.SpectralNormalization()_

![spectral normalization 논문]: (https://arxiv.org/abs/1802.05957/) ![spectral normalization 설명]: (https://hichoe95.tistory.com/60?category=783893/) ![spectral normalization 구현 코드]: (https://github.com/christiancosgrove/pytorch-spectral-normalization-gan/)

_출처:cousera DeepLearning.AI <https://www.coursera.org/learn/build-better-generative-adversarial-networks-gans?utm_source=deeplearningai&utm_medium=institutions&utm_campaign=DLWebGANsMain_>

gan 자체의 capacity를 올리기 위해서

1. 하드웨어 GPU 성능 개선
2. 고해상도의 data set사용

위 2가지 방법이 capacity 개선방법이다.

_출처:cousera DeepLearning.AI <https://www.coursera.org/learn/build-better-generative-adversarial-networks-gans?utm_source=deeplearningai&utm_medium=institutions&utm_campaign=DLWebGANsMain_>

Diversity를 개선하기 위해서 더 많은 범위의 data set을 사용해야한다.
** gan의 개선 방안 ** stability는 longer training and better images일때 개선 capacity는 lager models and higher resoulution image일때 개선 diversity는 increasing variety in generated images일때 개선

style gan은 stability, capacity, diversity를 개선한 모델이다.

2. style gan의 활용

style gan을 활용하여 이미지, text를 생성하는 사이트들이 있다.

• 얼굴 생성 사이트 https://thispersondoesnotexist.com/
• 실존하지 않는 text, image 생성 사이트 https://github.com/paubric/thisrepositorydoesnotexist

3. style gan의 사업적 측면

실제로 style gan 어떤 사업에 활용을 할 수 있을지 살펴보자.

• 의류피팅 모델 가상 피팅모델 예시 https://www.instagram.com/lilmiquela/

  
  

• 현실에 존재하지 않는 세련된 피팅 모델을 생성한다. 다양한 핏을 가진 피팅 모델을 생성하여 옷에 맞는 모델을 이용하거나 자신과 비슷한 핏을 가진 모델을 생성하여 옷이 자신의 핏과 맞는지 비교. 이는 모델을 많이 고용할 수 없는 중소규모의 쇼핑몰의 경우 다양하게 생성된 피팅 모델을 활용할 수 있다.
  

• 가상의공간 생성 제품을 팔때 생성된 수백 가지의 가상의 공간에 물건을 배치하여 다양한 공간에 따라 제품을 보여주어 다양한 느낌으로 제품을 보여줄 수 있다.

  
  

• AI앵커가 전하는 뉴스 앵커 대신 AI앵커가 뉴스를 대신 전달하게 된다. https://www.youtube.com/watch?v=IZg4YL2yaM0

  
  
  

4. stlye gan의 의의

• 기존 PGGAN의 구조 개선

• image 합성 과정에서 scale-spcific control 가능

  • scale-specific control이란? 이미지 합성과정에서 specific한 scale로 자유롭게 조절가능하다는 의미

• 이미지를 합쳐보니 새로운 이미지를 잘 생성해내는것을 발견

• Latent space의 disentanglement 측정방법 제안 (perseptual path length, linear separability)

• 고화질이고 다양한 사람 얼굴을 포함하는 FFHQ 데이터셋 공개

5. style gan의 구조

1) progressive growing

style gan의 구조를 살펴보자

출처: A Style-Based Generator Architecture for Generative Adversarial Networks 
<https://arxiv.org/abs/1812.04948>

style gan의 progressive growing은 PGGAN을 base로 한다.

출처: PROGRESSIVE GROWING OF GANS FOR IMPROVED QUALITY, STABILITY, AND VARIATION
 <https://arxiv.org/abs/1710.10196>

<PGGAN의 progressive growing 구조>

기존의 gan 모델은 고해상도 이미지를 생성하기 어렵다는 문제점이 있었다.
gan 모델이 고해상도 이미지를 생성하기 어려운 이유는 고해상도 일수록 fake image를 구분하기 쉬워지고 큰 메모리를 생성할때 메모리 문제가 있기 때문에 작은 크기의 mini-batch를 사용할 수 밖에 없다. 이렇게 mini-batch의 크기가 작아지면 mode collapse 문제가 발생한다.그래서 Gan의 고해상도 이미지 생성 문제를 해결하기 위한 모델이 PGGAN이다.

PGGAN의 progressive growing을 먼저 보면 알겠지만 PGGAN은 한 번에 전체 크기의 이미지 feature를 학습시키는게 아니라 4X4 저해상도 이미지에서부터 시작해서 점진적으로 layer를 추가하며 1024X1024의 고해상도 이미지를 만든다.

출처: PROGRESSIVE GROWING OF GANS FOR IMPROVED QUALITY, STABILITY, AND VARIATION
<https://arxiv.org/abs/1710.10196>

<PGGAN의 upsampling 구조>

PGGAN을 upsampling 할때 1-a 부분은 학습된 파라메터 없이 upsampling만 하는 부분이고 a부분은 학습된 파라메터를 가지고 있습니다. 점차 학습된 파라메터에 의존하게끔 upsampling을 한다

여기서 PGGAN 문제가 발생하게 되는데 PGGAN은 latent vector z가 normalization을 거쳐 모델에 input value로 들어간다. 이렇게 latent vector z가 input으로 들어가게 되면, latent space는 반드시 traning data의 probability density를 따라야한다.

그렇기 때문에 PGGAN은 progressive growing 구조를 따라 고해상도의 이미지를 생성하지만 생성된 이미지의 feature들이 entanglement하게 만들어진다

다시말하면, input을 조금이라도 조정하게 되면 동시에 여러 특징이 영향을 받는다.

출처: https://velog.io/@chy0428/StyleGAN-A-Style-Based-Generator-Architecture-for-Generative-Adversarial-Networks-%EB%85%BC%EB%AC%B8-%EC%A0%95%EB%A6%AC

위 사진은 PGGAN의 latent space interpolation 결과이다. 압축한 정보를 복원하기위해 알려진 지점 값 사이에 중간에 위치한 값으로 추정하는 interpolation과정에서 상당히 어색한 이미지가 생성되는 것을 볼 수 있다.

그 이유는 feature들이 entanglement하기 때문이다.

interpolation 설명: <https://darkpgmr.tistory.com/117>
PGGAN 설명: <https://sensibilityit.tistory.com/508>

출처: A Style-Based Generator Architecture for Generative Adversarial Networks 
<https://arxiv.org/abs/1812.04948>

synthesis network 부분에 progressive growing이 적용되었다.

2) mapping network

• z vector와 w vector의 차이점

오른쪽 그림의 1. mapping network를 보시면 input vector가 직접 convolution으로 들어가지 않고 fully connected layer로 구성된 mapping network를 통과하여 비선형 w vector로 변화 시킨다.

mapping network를 사용하여 입력 z vector를 각각의 요소가 다른 visual feature를 control하게 만드는 intermediate vector로 변환시킨다. 이때 intermediate vector w는 정규분포를 따를 필요가 없다. 그래서 data set을 훨씬 유동적인 공간(intermediate latent space)에 mapping 할 수 있게 된다.

• w vector의 역할
• • 정규분포를 따르지 않는 intermediate vector w를 이용하면 visual attribute와 stochastic variation을 조절하기 훨씬 용이해진다. **

intermediate vector w는 데이터 간 상관관계를 줄여 z vector보다 더 disentanglement한 latent vector를 만든다.

z, w vector disentanglement
출처: A Style-Based Generator Architecture for Generative Adversarial Networks 
<https://arxiv.org/abs/1812.04948>

출처 : https://www.coursera.org/lecture/build-better-generative-adversarial-networks-gans/noise-mapping-network-Udixn

intermediate vector w는 synthesis network가 이미지를 생성하는 과정에서 style을 입히는데 사용된다.

** mapping network code **

def G_mapping(
    latents_in,                             # First input: Latent vectors (Z) [minibatch, latent_size].
    labels_in,                              # Second input: Conditioning labels [minibatch, label_size].
    latent_size             = 512,          # Latent vector (Z) dimensionality.
    label_size              = 0,            # Label dimensionality, 0 if no labels.
    dlatent_size            = 512,          # Disentangled latent (W) dimensionality.
    dlatent_broadcast       = None,         # Output disentangled latent (W) as [minibatch, dlatent_size] or [minibatch, dlatent_broadcast, dlatent_size].
    mapping_layers          = 8,            # Number of mapping layers.
    mapping_fmaps           = 512,          # Number of activations in the mapping layers.
    mapping_lrmul           = 0.01,         # Learning rate multiplier for the mapping layers.
    mapping_nonlinearity    = 'lrelu',      # Activation function: 'relu', 'lrelu'.
    use_wscale              = True,         # Enable equalized learning rate?
    normalize_latents       = True,         # Normalize latent vectors (Z) before feeding them to the mapping layers?
    dtype                   = 'float32',    # Data type to use for activations and outputs.
    **_kwargs):                             # Ignore unrecognized keyword args.

    act, gain = {'relu': (tf.nn.relu, np.sqrt(2)), 'lrelu': (leaky_relu, np.sqrt(2))}[mapping_nonlinearity]

    # Inputs.
    latents_in.set_shape([None, latent_size])
    labels_in.set_shape([None, label_size])
    latents_in = tf.cast(latents_in, dtype)
    labels_in = tf.cast(labels_in, dtype)
    x = latents_in

    # Embed labels and concatenate them with latents.
    if label_size:
        with tf.variable_scope('LabelConcat'):
            w = tf.get_variable('weight', shape=[label_size, latent_size], initializer=tf.initializers.random_normal())
            y = tf.matmul(labels_in, tf.cast(w, dtype))
            x = tf.concat([x, y], axis=1)

    # Normalize latents.
    if normalize_latents:
        x = pixel_norm(x)

    # Mapping layers.
    for layer_idx in range(mapping_layers):
        with tf.variable_scope('Dense%d' % layer_idx):
            fmaps = dlatent_size if layer_idx == mapping_layers - 1 else mapping_fmaps
            x = dense(x, fmaps=fmaps, gain=gain, use_wscale=use_wscale, lrmul=mapping_lrmul)
            x = apply_bias(x, lrmul=mapping_lrmul)
            x = act(x)

    # Broadcast.
    if dlatent_broadcast is not None:
        with tf.variable_scope('Broadcast'):
            x = tf.tile(x[:, np.newaxis], [1, dlatent_broadcast, 1])

    # Output.
    assert x.dtype == tf.as_dtype(dtype)
    return tf.identity(x, name='dlatents_out')

출처: https://github.com/NVlabs/stylegan/blob/master/training/networks_stylegan.py#L300

mapping_layer 보시면 8개이고 latent_size=512이다. 따라서 8개의 fully connected layer를 지난 정규화된 z vector는 1X512 size의 w mapping network를 만드는 것을 볼 수 있다.

3) synthesis network

• ADAIN(Adaptive Instance Normalization)

출처: A Style-Based Generator Architecture for Generative Adversarial Networks 
<https://arxiv.org/abs/1812.04948>

이제 synthesis network 부분을 살펴보자

synthesis nework를 보면 w vector(style을 변화시키는)가 들어가는 AdaIn이 있다.

AdaIn 활용
출처:https://m.blog.naver.com/PostView.nhn?blogId=tlqordl89&logNo=221536378926&proxyReferer=https:%2F%2Fwww.google.com%2F

사진을 보면 알듯이 AdaIn은 사진에 스타일을 입혀서 새로운 그림을 그리는 기능을한다

AdaIN 수식 출처: https://sensibilityit.tistory.com/510

w vector를 학습된 2개의 affine Transformation(벡터의 직선, 길이(거리)의 비, 평행성(parallelism)을 보존) FC를 통과 시켜 y_s, y_b를 얻는다 y_s는 style, y_b는 style bias이다. 여기서 X는 counvolution output이고 각 채널의 정규화를 통해 채널들에 원하는 스타일을 입힐 수 있다.

ADAIN을 통해 scale-specific control이 가능하게된다.

** ADIN code **

# Apply bias to the given activation tensor.

def apply_bias(x, lrmul=1):
    b = tf.get_variable('bias', shape=[x.shape[1]], initializer=tf.initializers.zeros()) * lrmul
    b = tf.cast(b, x.dtype)
    if len(x.shape) == 2:
        return x + b
    return x + tf.reshape(b, [1, -1, 1, 1])

# Instance normalization.

def instance_norm(x, epsilon=1e-8):
    assert len(x.shape) == 4 # NCHW
    with tf.variable_scope('InstanceNorm'):
        orig_dtype = x.dtype
        x = tf.cast(x, tf.float32)
        x -= tf.reduce_mean(x, axis=[2,3], keepdims=True)
        epsilon = tf.constant(epsilon, dtype=x.dtype, name='epsilon')
        x *= tf.rsqrt(tf.reduce_mean(tf.square(x), axis=[2,3], keepdims=True) + epsilon)
        x = tf.cast(x, orig_dtype)
        return x

# Style modulation.

def style_mod(x, dlatent, **kwargs):
    with tf.variable_scope('StyleMod'):
        style = apply_bias(dense(dlatent, fmaps=x.shape[1]*2, gain=1, **kwargs))
        style = tf.reshape(style, [-1, 2, x.shape[1]] + [1] * (len(x.shape) - 2))
        return x * (style[:,0] + 1) + style[:,1]

출처: https://github.com/NVlabs/stylegan/blob/master/training/networks_stylegan.py#L300

여기서 apply_bias는 w vector를 y_s, y_b 구하는 과정 instance_norm은 X를 정규화 시키는 코드 style modulation은 ADAIN을 보여준다.

AdaIN 설명: https://blog.naver.com/PostView.nhn?blogId=tlqordl89&logNo=221536378926&parentCategoryNo=&categoryNo=20&viewDate=&isShowPopularPosts=true&from=search AdaIN 논문: https://arxiv.org/abs/1703.06868 AdaIN 코드: https://github.com/xunhuang1995/AdaIN-style Affin Transformation: https://darkpgmr.tistory.com/79

• style mixing

출처: https://towardsdatascience.com/explained-a-style-based-generator-architecture-for-gans-generating-and-tuning-realistic-6cb2be0f431

4X4X512 크기의 초기 네트워크(constant tensor)에 AdaIN에 이용하여 레이어에 이미지와 style을 결합하고 progressive growing에 적용하여 1024X1024X3 이미지로 변환시킨다.

gan 모델의 다양성을 높이기 위하여 각기 다른 vector w를 혼합하여 이미지의 변화를 줄 수 있다. 그리고 다른 vector w를 혼합하여 모델을 만들면 인접한 layer간 style correlate 현상을 방지 할 수 있다.

*다른 vector w를 혼합하여 이미지를 형성하는 것을 style mixing이라한다. *

출처: A Style-Based Generator Architecture for Generative Adversarial Networks 
<https://arxiv.org/abs/1812.04948>

이렇게 각 layer 마다 다른 style mixing 할 수 있다. 4X4/ 8X8 layer에서 style mixing하면 coarse style (pose, hair style, face shape 등)
16X16, 32X32 layer에서 style mixing하면 middle style (facial features, hair style, eyes open/closed 등)
64X64, 1024X1024 layer에서 style mixing하면 fine style (color scheme) 등을 나타내서 각부분에 다른 W를 넣어서 style 조절을 가능하게 한다.

** 2개 이상의 w vector를 사용한 style mixing을 통해 Dropout과 비슷한 작용을 하게되었다고 볼 수 있고 저해상도layer는 전체적인 이미지 스타일을 반영하고 고화질 layer로 갈수록 세부적인 구조를 담당하는 것을 볼 수 있다. **

** style mixing code **

 # Things to do at the end of each layer.
    def layer_epilogue(x, layer_idx):
        if use_noise:
            x = apply_noise(x, noise_inputs[layer_idx], randomize_noise=randomize_noise)
        x = apply_bias(x)
        x = act(x)
        if use_pixel_norm:
            x = pixel_norm(x)
        if use_instance_norm:
            x = instance_norm(x)
        if use_styles:
            x = style_mod(x, dlatents_in[:, layer_idx], use_wscale=use_wscale)
        return x

출처: https://github.com/NVlabs/stylegan/blob/master/training/networks_stylegan.py#L300

apply_noise를 보면 노이즈를 넣어주고

ADAIN을 적용하는 것을 볼 수 있다.

• stochastic variation

하지만 아무리 고화질 layer에 style을 적용해도
짧은 수염, 주근깨, 주름 등 세세한것들을 바꿀 수 없다.

출처: A Style-Based Generator Architecture for Generative Adversarial Networks 
<https://arxiv.org/abs/1812.04948>

여기서 노이즈 부분이 주근깨, 짧은 수염, 머리카락 한올 등 세세한 것들을 바꾸는데 영향을 미친다.

정규분포에서 가져온 sample noise를 convolution layer에 더하여 이미지를 보다 세세하게 만든다.
** AdaIN이 이미지의 큼직한 부분(style)을 바꾸는 방법이면 stochastic variation 세세한 부분을 바꾸는 방법이다. **

** stochastic variation code **

# Noise input.

def apply_noise(x, noise_var=None, randomize_noise=True):
    assert len(x.shape) == 4 # NCHW
    with tf.variable_scope('Noise'):
        if noise_var is None or randomize_noise:
            noise = tf.random_normal([tf.shape(x)[0], 1, x.shape[2], x.shape[3]], dtype=x.dtype)
        else:
            noise = tf.cast(noise_var, x.dtype)
        weight = tf.get_variable('weight', shape=[x.shape[1].value], initializer=tf.initializers.zeros())
        return x + noise * tf.reshape(tf.cast(weight, x.dtype), [1, -1, 1, 1])

# Noise inputs.
    noise_inputs = []
    if use_noise:
        for layer_idx in range(num_layers):
            res = layer_idx // 2 + 2
            shape = [1, use_noise, 2**res, 2**res]
            noise_inputs.append(tf.get_variable('noise%d' % layer_idx, shape=shape, initializer=tf.initializers.random_normal(), trainable=False))

출처: https://github.com/NVlabs/stylegan/blob/master/training/networks_stylegan.py#L300

noise를 입히는 과정이다. append를 통해 노이즈를 더해 준것을 볼 수 있다.

출처: A Style-Based Generator Architecture for Generative Adversarial Networks 
<https://arxiv.org/abs/1812.04948>

6. style gan이 제안한 latent space disentanglement 측정법

• perceptual path length latent space로 부터 2개의 random한 입력간에 interpolation 하는 과정에서 얼마나 이미지가 급격하게 변하는지 측정한다. interpolation을 했을때 non-linear한 변화가 이미지에서 일어난다면 latent space가 entangled할 수 있다는 뜻이다.
   ~~~ 출처: A Style-Based Generator Architecture for Generative Adversarial Networks ~~~

각각 z와 w 일 경우의 distance를 구하는 공식이고, z는 spherical interpolation을 하고, w는 linear interpolation을 하는데, w를 linear interpolation하는 이유는 w 벡터들은 normalized 되어있지 않기 때문이다.

기존에 pretrained된 2개의 VGG-16 모델을 사용하여 위의 식에다 어떠한 latent vector z1값과 z2을 넣고 각각의 이미지를 VGG-16모델에 각각 embedding을 시켰을때 feature 값들의 distance를 구합니다.

따라서 E의 변화가 있었을 때, feature가 많이 변하면 distance도 커지고 interpolation이 제대로 안되는 entanglement라는 뜻이다.

• linear separability

  출처:물공's의 딥러닝<https://sensibilityit.tistory.com/510>

  latent space가 충분히 disentangle되었다면 stochastic variation을 설명할 수 있는 latent vector z의 direction vector(ex, 성별, 머리카락 길이, 머리색 등)을 정확하게 찾아낸다. 입력값을 이진분류해서 분류가 잘 될 수록 disentangled는 뜻이다.

7. style gan 총 정리

출처: https://towardsdatascience.com/explained-a-style-based-generator-architecture-for-gans-generating-and-tuning-realistic-6cb2be0f431

Style gan의 이미지 생성과 학습과정을 정리하면

*1X512의 latent z vector를 mapping network에 넣어서 더 dis entanglement한 w vector를 만든다.
constant tensor 4X4X512의 이미지에 각기 다른 w vector를 AdaIn에 넣어서 style을 입힌다.
세세한 사항을 바꾸기 위해 noise를 더한다.
그렇게 해서 1024X1024의 이미지를 만든다. 이 synthesis network는 progressive growing 구조이다.
그리고 proGan discriminator로 Gan을 학습시킨다. *
** discriminator code **

# Discriminator used in the StyleGAN paper.

def D_basic(
    images_in,                          # First input: Images [minibatch, channel, height, width].
    labels_in,                          # Second input: Labels [minibatch, label_size].
    num_channels        = 1,            # Number of input color channels. Overridden based on dataset.
    resolution          = 32,           # Input resolution. Overridden based on dataset.
    label_size          = 0,            # Dimensionality of the labels, 0 if no labels. Overridden based on dataset.
    fmap_base           = 8192,         # Overall multiplier for the number of feature maps.
    fmap_decay          = 1.0,          # log2 feature map reduction when doubling the resolution.
    fmap_max            = 512,          # Maximum number of feature maps in any layer.
    nonlinearity        = 'lrelu',      # Activation function: 'relu', 'lrelu',
    use_wscale          = True,         # Enable equalized learning rate?
    mbstd_group_size    = 4,            # Group size for the minibatch standard deviation layer, 0 = disable.
    mbstd_num_features  = 1,            # Number of features for the minibatch standard deviation layer.
    dtype               = 'float32',    # Data type to use for activations and outputs.
    fused_scale         = 'auto',       # True = fused convolution + scaling, False = separate ops, 'auto' = decide automatically.
    blur_filter         = [1,2,1],      # Low-pass filter to apply when resampling activations. None = no filtering.
    structure           = 'auto',       # 'fixed' = no progressive growing, 'linear' = human-readable, 'recursive' = efficient, 'auto' = select automatically.
    is_template_graph   = False,        # True = template graph constructed by the Network class, False = actual evaluation.
    **_kwargs):                         # Ignore unrecognized keyword args.

    resolution_log2 = int(np.log2(resolution))
    assert resolution == 2**resolution_log2 and resolution >= 4
    def nf(stage): return min(int(fmap_base / (2.0 ** (stage * fmap_decay))), fmap_max)
    def blur(x): return blur2d(x, blur_filter) if blur_filter else x
    if structure == 'auto': structure = 'linear' if is_template_graph else 'recursive'
    act, gain = {'relu': (tf.nn.relu, np.sqrt(2)), 'lrelu': (leaky_relu, np.sqrt(2))}[nonlinearity]

    images_in.set_shape([None, num_channels, resolution, resolution])
    labels_in.set_shape([None, label_size])
    images_in = tf.cast(images_in, dtype)
    labels_in = tf.cast(labels_in, dtype)
    lod_in = tf.cast(tf.get_variable('lod', initializer=np.float32(0.0), trainable=False), dtype)
    scores_out = None

    # Building blocks.
    def fromrgb(x, res): # res = 2..resolution_log2
        with tf.variable_scope('FromRGB_lod%d' % (resolution_log2 - res)):
            return act(apply_bias(conv2d(x, fmaps=nf(res-1), kernel=1, gain=gain, use_wscale=use_wscale)))
    def block(x, res): # res = 2..resolution_log2
        with tf.variable_scope('%dx%d' % (2**res, 2**res)):
            if res >= 3: # 8x8 and up
                with tf.variable_scope('Conv0'):
                    x = act(apply_bias(conv2d(x, fmaps=nf(res-1), kernel=3, gain=gain, use_wscale=use_wscale)))
                with tf.variable_scope('Conv1_down'):
                    x = act(apply_bias(conv2d_downscale2d(blur(x), fmaps=nf(res-2), kernel=3, gain=gain, use_wscale=use_wscale, fused_scale=fused_scale)))
            else: # 4x4
                if mbstd_group_size > 1:
                    x = minibatch_stddev_layer(x, mbstd_group_size, mbstd_num_features)
                with tf.variable_scope('Conv'):
                    x = act(apply_bias(conv2d(x, fmaps=nf(res-1), kernel=3, gain=gain, use_wscale=use_wscale)))
                with tf.variable_scope('Dense0'):
                    x = act(apply_bias(dense(x, fmaps=nf(res-2), gain=gain, use_wscale=use_wscale)))
                with tf.variable_scope('Dense1'):
                    x = apply_bias(dense(x, fmaps=max(label_size, 1), gain=1, use_wscale=use_wscale))
            return x

출처: https://github.com/NVlabs/stylegan/blob/master/training/networks_stylegan.py#L300

discriminator는 upscale된 이미지를 downscale하는것을 볼 수 있다.

stlye gan의 의의

• 기존 PGGAN의 구조 개선

• PGGAN의 feature들이 entanglement문제 해결

• image 합성 과정에서 scale-spcific control 가능

• w vector를 사용한 ADIN으로 scale-spcific control 가능

• 이미지를 합쳐보니 새로운 이미지를 잘 생성해내는것을 발견

• style mixing으로 새로운 이미지 생성

• Latent space의 disentanglement 측정방법 제안 (perseptual path length, linear separability)

• 고화질이고 다양한 사람의 얼굴을 포함하는 FFHQ 데이터셋 공개

• 나이와 민족 시선, 밝기 그리고 이미지 배경이 다양한 FFHQ dataset 공개

8. style gan의 한계

출처: Analyzing and Improving the Image Quality of StyleGAN <https://arxiv.org/abs/1912.04958>

<water droplet artifacts 문제>

AdaIn으로 인해 feature map에 노이즈가 발생한다. 원래 feature type의 값이 작은데 AdaIn으로 정규화하여 인해 값이 커지고 이게 noise를 발생시킨다.

출처: Analyzing and Improving the Image Quality of StyleGAN <https://arxiv.org/abs/1912.04958>

<phase artifacts 문제> 다음은 일부 feature들이 얼굴의 움직임을 따르지 않는 문제이다. 얼굴이 움직임에도 이는 움직이지 않는 것을 볼 수 있다 이 문제는 progressive growing으로 인해 발생하는데 각각의 코드블록마다 독립적으로 이미지가 생성되기때문에 이러한 특징이 자주 나타난다.

9. style gan2

그래서 style gan의 water droplet artifacts 문제와 phase artifacts문제를 해결한 style gan2가 나왔다. style gan2에서는 water droplet artifacts를 제거하기 위해 AdaIn 대신 CNN의 가중치를 정규화하였다.

<water droplet artifacts 개선>

출처: Analyzing and Improving the Image Quality of StyleGAN <https://arxiv.org/abs/1912.04958>

출처: https://prowiseman.tistory.com/entry/StyleGAN-StyleGAN2

출처: https://prowiseman.tistory.com/entry/StyleGAN-StyleGAN2

progressive growing을 제거하여 phase artifacts 문제를 개선하였다.

style gan2 논문: https://arxiv.org/abs/1912.04958 style gan2 코드: https://github.com/NVlabs/stylegan2 style gan2 설명: https://iamseungjun.tistory.com/6?category=881965

references

style gan 강의 https://www.coursera.org/lecture/build-better-generative-adversarial-networks-gans/welcome-to-week-3-oe097

style gan 관련 https://velog.io/@chy0428/StyleGAN-A-Style-Based-Generator-Architecture-for-Generative-Adversarial-Networks-%EB%85%BC%EB%AC%B8-%EC%A0%95%EB%A6%AC

https://sensibilityit.tistory.com/510 https://www.kakaobrain.com/blog/55 https://towardsdatascience.com/explained-a-style-based-generator-architecture-for-gans-generating-and-tuning-realistic-6cb2be0f431 https://jayhey.github.io/deep%20learning/2019/01/14/style_based_GAN_1/ https://jayhey.github.io/deep%20learning/2019/01/16/style_based_GAN_2/ https://nuguziii.github.io/paper-review/PR-001/ https://blog.lunit.io/2019/02/25/a-style-based-generator-architecture-for-generative-adversarial-networks/

style gan 논문 : https://github.com/NVlabs/stylegan style gan 코드 : https://github.com/NVlabs/ffhq-dataset

AdaIn관련: https://github.com/xunhuang1995/AdaIN-style

style gan2 관련: https://iamseungjun.tistory.com/6?category=881965 https://prowiseman.tistory.com/entry/StyleGAN-StyleGAN2

질문1. stochastic variation이 feature들을 조절하는 것인지?

These are single-channel images consisting of uncorrelated Gaussian noise, and we feed a dedicated noise image to each layer of the synthesis network. The noise image is broadcasted to all feature maps using learned per-feature scaling factors and then added to the output of the corresponding convolution …

A Style-Based Generator Architecture for Generative Adversarial Networks, 2018.

를 보면 노이즈 이미지는 학습된 기능별 스케일링 요소를 사용하여 모든 feature map에 broadcasted 된 다음 해당 convolution의 출력에 추가된다고 말한다. 이는 stochastic variation가 지정된 세부 수준에서 feature 변형을 위해 사용한다 볼 수 있다.

질문 2. Entanglement latent vector z를 Fully connected layer부분에서 disentanglement로 바뀌는 것인지? AdaIn 부분에서 disentanglement로 바뀌는 것인지?

Style Modules (AdaIN) The AdaIN (Adaptive Instance Normalization) module transfers the encoded information ⱳ, created by the Mapping Network, into the generated image. The module is added to each resolution level of the Synthesis Network and defines the visual expression of the features in that level:

1. Each channel of the convolution layer output is first normalized to make sure the scaling and shifting of step 3 have the expected effect.
2. The intermediate vector ⱳ is transformed using another fully-connected layer (marked as A) into a scale and bias for each channel.
3. The scale and bias vectors shift each channel of the convolution output, thereby defining the importance of each filter in the convolution. This tuning translates the information from ⱳ to a visual representation.

출처: https://towardsdatascience.com/explained-a-style-based-generator-architecture-for-gans-generating-and-tuning-realistic-6cb2be0f431

Vector Z를 8개의 Fully connected layer에 통과 시킨 결과 disentanglement한 결과가 나오고 ADAIN layer는 style_scale, style_bias로 변환시키는 역할을 한다. 이때 style_scale, style_bias는 convolution layer를 통과하여 defining the importance of each filter의 역할을 한다.

Evaluation of GANs

Evaluation

GAN model을 평가하기 어렵다. why? Universal gold-standard discriminator가 존재하지 않는다.

생성된 이미지 평가의 중요한 두 가지 지표

1. Fidelity : quality of images
2. Diversity : variety of images

Comparing Images

1. Pixel distance 각 픽셀값의 차이를 절대값을 이용해서 구한다. 쉽게 값을 구할 수 있다는 장점이 있지만 위상변화에 매우 취약하다는 단점이 존재하므로 사용하지 않는다.

2. Feature distance 이미지들을 픽셀 단위로 비교하는 것이 아니라 특징들을 추출해서 비교한다. 따라서 pixel distance보다 위상변화에 대해 믿을만한 값을 얻을 수 있다.

Feature Extraction

위의 Feature distance를 구하기 위해서는 특징을 나타내는 벡터(연산을 위해)가 필요하다. 특징벡터를 구하기 위해 pre-trained CNN 모델을 이용한다 이미지 분류에서 CNN은 특징을 추출하는 convolutional layers와 분류를 하는 fully connected layers로 구성된다. 따라서 convolutional layers에 이미지의 특징을 표현하는 feature layer가 존재하고 이를 이용해서 이미지를 embedding할 수 있다. 대부분의 경우 fc층 전의 마지막 pooling layer를 feature layer로 사용하나 필요(primitive information)에 따라 앞 부분의 layer를 사용하는 경우도 있다. ImageNet dataset을 이용해 pre-trained된 CNN을 사용한다.

Inception-v3 and Embeddings

Feature extraction을 수식으로 표현하면 $\phi$: Embedding function, $x$: input image $\phi(x) = (x_{1},x_{2},...,x_{n})^{T}$, $x_{i}$ : 어떠한 특징의 값

Embedding function을 ImageNet으로 학습된 Inception-v3모델의 convolutional layers를 이용한 함수로 정의한다.

이렇게 얻어진 벡터$\phi(x)$를 이용해서 Euclidean/Cosine distance등을 이용해서 feature distance를 구할 수 있다.

Inception-v3참고: https://static.googleusercontent.com/media/research.google.com/ko//pubs/archive/44903.pdf

Fréchet Inception Distance(FID)

두 일변량 정규분포의 FID는 위와 같이 정의된다.

두 다변량 정규분포의 FID는 위와 같이 정의된다. (일변량의 확장버전)

FID의 기본 가정: embedding vector가 다변량 정규분포를 따른다. 정확하게 따른다기 보다는 계산의 편의를 위해서 가정한다.

낮은 FID -> 두 분포의 거리가 가깝다 -> 진짜와 가짜가 유사하다

FID의 단점

1. ImageNet data로 pre-trained된 경우 ImageNet data 이미지의 class와 다른 이미지를 다룰 경우 원하는 특징을 포착하지 못할 수 있다
2. pre-trained가 아닌 경우, 많은 수의 sample로 학습시키지 않으면 biased feature layer가 생겨서 좋지 못한 FID score를 얻게 된다
3. pre-trained가 아닌 경우, 학습을 시키기 위해 시간이 오래 걸린다
4. 표본의 분포가 정규분포가 아닐 경우 제한적인 통계량(평균,분산)만으로는 분포의 차이를 잘못 설명할 수 있다.

Inception Score(IS)

FID 이전 많이 사용되던 evaluation metric

Entropy? 정보이론의 대표적인 개념으로 무작위성으로 볼 수 있다 랜덤 변수 X의 값이 예측가능하면 엔트로피가 낮음 예측하기 어렵다면 엔트로피는 높음

Inception Score 이해하기

수식을 보기 전 Inception-v3 model이 어떻게 사용되는지 확인하자 IS: classifier => fc층 사용 FID: feature extractor => fc층 사용 안함

IS는 KL divergence의 expectation의 지수제곱(exp의 역할은 사람이 값을 이해하기 쉽게한다)

KL divergence 내의 두 분포 p(y|x): 주어진 input x에 대해 label y의 확률분포 p(y): label들의 확률분포

위 이미지의 왼쪽은 p(y|x)를 나타내고 한 곳에서 peak한 분포를 보이므로 entropy가 낮다 => Fidelity

위 이미지의 오른쪽은 p(y)를 나타내고 골고루 퍼진 분포(uniform)를 보이므로 entropy가 높다 => Diversity

Fidelity와 Diversity를 나타내는 분포들의 차이를 KL divergence의 기대값을 이용해서 구한 후 지수 제곱을 해주면 Inception Score가 된다.

예시) fidelity와 diversity 모두 우수한 생성모델을 가정하자 해당 모델에서 생성한 이미지들은 fidelity가 높기 때문에 classifier가 잘 분류해낼 것이다. 따라서 p(y|x)가 한 곳에서 높은 값을 갖는 분포를 갖게 된다. 또한 diversity가 높기 때문에 다양한 label의 이미지를 생성할 것이다. 따라서 p(y)가 uniform distribution과 비슷한 형태의 분포를 갖게 된다. 두 분포의 차이가 크므로 KL divergence가 크다. KL divergence가 커지면 IS가 커진다. 따라서 IS가 큰 값을 갖으면 fidelity와 diversity가 우수한 생성모델이라 할 수 있다.

IS의 단점

1. 생성자가 각 label마다 하나의 이미지만 반복해서 생성하는 경우 IS가 높지만 이는 inner diversity를 고려하지 못한 좋지 못한 생성모델
2. fake image만을 이용한다 -> real image와 비교하지 못 한다.
3. FID와 마찬가지로 ImageNet data로 pre-trained된 경우 ImageNet data 이미지의 class와 다른 이미지를 다룰 경우 원하는 특징을 포착하지 못할 수 있다

Sampling and Truncation

GAN을 평가할때 letent vector z의 사전 분포에 맞게 sampling 한다. $\mu$ 근처에서 sampling된 z들을 이용해서 fidelity에 집중해서 평가할 수 있다. 반대로 $\mu$와 먼 곳까지 포함에서 sampling된 z들을 이용해서 diversity에 집중해서 평가할 수 있다.

truncation trick을 이용해서 z 분포의 양 끝부분을 잘라낸 곳에서 sampling을 한 후 평가를 진행할 수 있다. 잘라내는 지점은 hyperparameter로 사람이 경험에 의해 직접 지정한다.

우수한 fidelity를 원하는 경우 양 끝부분을 많이 잘라내서 sampling을 하면 되고, 우수한 diversity를 원하는 경우 양 끝부분을 적게 잘라내서 sampling하면 된다. fidelity와 diversity의 trade-off 관계에 맞게 잘라내는 지점을 지정하면 된다.

HYPE(Human eYe Perceptual Evaluation)

• 지각 심리학의 심리 물리학 방법에서 영감을 받은 근거가 있는 방법을 통해 생성 모델 출력의 지각 현실성을 측정
• 신뢰할 수 있고, 일관된 측정기
• 크라우드소싱 기술을 통해 비용과 시간 효율적인 방법을 보장
• Fidelity(realism)에 대해 평가할 수 있지만 다른 지표들(diversity, overfitting, train stability)은 평가하지 못 한다.

HYPE(time)

• 사람이 진짜로부터 가짜를 구별하는데 필요한 시간 제한적인 인지 임계값을 결정하기 위해 시간 제약을 조정하며 이미지들을 보여준다.
• HYPE(time) score는 최소의 시간으로 여겨진다. 여기서의 시간은 사람이 모델의 결과를 진짜인지 가짜인지 구분하는데 필요한 시간

HYPE(time)의 방법

• 150개 이미지(5:5 real/fake)들을 노출시간을 500ms으로 시작해서 가짜 진짜를 판별시킨다. 맞추면 노출시간을 30ms 줄이고 틀리면 10ms 늘린다
• 각각의 평가자의 마지막 값을 계산해서 평균을 구하면 점수가 된다
• 높은 점수는 진짜와 가짜를 구분하는데 더 긴 시간이 필요하다는 것을 의미한다. 즉, 좋은 생성 모델

HYEP(inf)

• time 버전의 신뢰도를 유지하면서 첫번째 방법을 더욱 간단하고 빠르고 비용 저렴하게 이용한다.
• 무한한 시간(시간 제약이 없음)이 주어질 때, 사람들이 가짜와 진짜를 착각하는 비율로 해석
• 점수가 50%인 경우 사람들은 생성된 결과를 진짜와 가짜를 우연의 확률로 구별한다. 50% 이상인 경우 생성된 결과가 진짜보다 더욱 현실적이라는걸 나타낸다.

HYEP(inf)의 방법

• 100개의 이미지들을 (5:5 real/fake) 각각의 평가자에게 보여주고 잘못 평가한 이미지들의 비율을 계산하여 총 n명의 평가를 종합한다
• 높은 점수가 나올수록 좋은 생성모델

Precision and Recall

precision = 생성된 이미지 중 실제 이미지 분포에 들어가는 이미지들/생성된 이미지들

precision은 fidelity와 연관

recall = 실제 이미지 중 생성된 이미지 분포에 들어가는 이미지들/실제 이미지들

recall은 diversity와 연관

대부분의 경우 recall이 precision보다 높음. 따라서 truncation trick을 이용해서 precision을 높이다.

'Improved Precision and Recll Metric for Assessing Generative Models'논문에서 발전된 precision and recall을 정의했다 식(1): 함수 f에서 특정 벡터 $\phi$가 해당 분포의 특정 cluster에 들어가는지 여부를 k-nearest neighbors를 이용해서 정의했다. 이를 통해서 특정 feature 벡터가 실제 이미지 분포에 포함되는지 혹은 생성된 이미지 분포에 포함되는지를 판단할 수 있다 식(2): 함수 f를 통해 얻은 값을 통해 recall과 precision을 정의한다. recall과 precision의 원래 정의와 같다.

정리

• GAN (생성 모델)을 평가하는 것은 어렵다
• 평가 방법으로 FID, IS, HYPE, precision and recall 등이 있다
• 해당 평가 방법들 모두 완벽한 방법은 아니고, 장단점이 존재한다
• 생성 모델의 evaluation metric에 대한 연구가 계속 진행되고 있다.

GAN Disadvantages and Bias

Disadvantages of GANs

Advantages of GANs

1. 높은 수준의 이미지 생성
2. 이미지 생성 시간이 빠르다.

Disadvantages

1. 본질적인 evaluation metrics 부족
2. 학습의 불안정성 -> 어느정도 해결됨
3. 명시적인 확률 밀도를 알 수 없다.
4. latent vector로 역변환이 어렵다.

Alternatives to GANs

Variational Autoencoder(VAE)

encoder와 decoder로 이루어진 생성 모델로 자세한 설명은 이전 강의 https://velog.io/@tobigs-gm1/Variational-Autoencoder 참조

장점

1. 확률 밀도를 알 수 있다
2. 역변환이 가능하다
3. 학습의 안정성

단점

1. blurry한 생성 결과물

Autoregressive Model

RNN처럼 sequence를 이용해서 이미지를 생성한다. 따라서 GAN이나 VAE와 다르게 latent vector가 존재하지 않는다. pixelRNN, pixelCNN, GatedpixelCNN 등이 존재한다.

Flow based generative model

다른 모델과 다르게 letent vector z가 input vector x와 같은 차원을 갖는다. 같은 차원을 갖으므로 정보의 손실이 적다. z의 분포를 표준정규분포로 시작하여 변수변환과 야코비안을 이용해 x의 분포처럼 복잡한 분포로 만든다. 이때 변환에 사용되는 함수는 역함수가 존재해야하고, 야코비안 행렬식 계산이 간단하게 이뤄져야 한다. 이러한 과정을 통해 구한 함수 f를 이용해 생성 결과물을 얻는다.

Intro to Machine Bias

COMPAS Algorithm 이 알고리즘은 미래에 범죄를 저지를 확률에 따라 점수를 주는 알고리즘이다. ProPublica는 기사에서 해당 알고리즘에 인종차별적 요소가 들어가 있다고 문제를 제기했다.

왼쪽의 백인 남성은 Home Depot에서 대략 $86 가치의 물건을 절도했다. 또한 그는 무장절도 경험과 수감 경험이 있다. 오른쪽의 흑인 여성은 $80 가치의 자전거와 스쿠터 절도를 시도했고, 현장에서 물건을 두고 도주했다. 다른 전과 기록은 없었다. 하지만 흑인 여성의 COMPAS점수가 더 높았다.

이 알고리즘의 사전 질문에 인종에 대한 질문은 존재하지 않지만 인종차별적인 결과가 발생하고 있다. 하지만 알고리즘의 계산과정은 공개되지 않아서 알고리즘 설계에서 인종차별적 결과를 의도했는지 확인하기 어렵다.

알고리즘의 점수는 판사의 판단에 영향을 미쳐 수감 기간에 영향을 준다. 또한 이 수감 기간으로 인해 수감 생활 이후의 삶에 안 좋은 영향을 미친다.

Fairness Definitions

'Fairness Definitions Explained'논문에서 예시를 통해 여러 fairness definitions를 설명하고 있다. 해당 논문에서 German Credit Dataset으로 학습된 로지스틱 회귀 분류기를 사용해 남성과 여성으로 그룹간의 신용 점수 분류 결과의 차이를 확인한다. 이 분류기를 이용해 여러 fairness definition을 각각 설명하고, 어떻게 적용되는지를 확인한다. 이 과정에서 fairness를 무엇으로 정의하냐에 따라 분류기의 fairness는 달라진다.

definitions of fairness 위 표에서 Lilliputian과 Brobdingnagian그룹으로 나뉜다. Qualified/Unqualified는 ground-truth로 실제 자격인 있는 없는가에 대한 값이다 Admiited/Rejected는 분류의 결과로 예측값이다.

• demographic parity: A fairness metric that is satisfied if the results of a model's classification are not dependent on a given sensitive attribute. Ground-truth에 상관없이 그룹에 따른 분류결과(Admitted/Rejected)의 비율이 같으면 된다. 위의 예시에서 두 그룹의 total percentage of admitted가 다르므로 demographic parity을 만족하지 못 한다.

• equality of opportunity: equality of opportunity measures whether the people who should qualify for an opportunity are equally likely to do so regardless of their group membership. 그룹에 상관없이 실제 자격이 있는(qualified)한 학생은 선호되는 결과인 Admitted로 분류될 확률이 같아야 한다.위의 예시에서 두 그룹의 percentage of qulified students admitted가 같으므로 equality of opportuniy가 만족한다.

• equality of odds: if, for any particular label and attribute, a classifier predicts that label equally well for all values of that attribute. 그룹에 상관없이 자격이 있는(qualified)한 학생은 Admitted로 분류될 확률이 같고, 또한 자격이 없는(unqualified)한 학생은 rejected로 분류될 확률이 같아야 한다. 즉, equality of opportunity에서 부정적인 결과에 대한 확률도 같아햐 하는 제약조건이 추가된 fairness이다. 위의 예시에서 두 그룹 각각 percentage of qualified students admitted와 percentage of unqualified students가 같으므로 equality of odds를 만족한다.

• fairness through unawareness: A model is fair if the protected attribute differentiating Class A and Class B is not given to the model. 그룹 조건이 포함되지 않았을 때 분류 결과 비율이 같으면 만족한다.

Machine Learning Glossary: Fairness (2020):https://developers.google.com/machine-learning/glossary/fairness 에서 더 많은 정의 확인할 수 있다.

A Survey on Bias and Fairness in ML

'A Survey on Bias and Fairness in Machine Learning' 논문에서는 Bias와 Fairness의 정의에 대해 상세히 나와있다. 또한 Bias문제가 없는 fair machine learning methods에 대해서 소개하고 있다.

여기서는 fair한 생성모델을 하나 소개한다. 위 그림은 FairGAN의 구조이다. FairGAN은 한 개의 생성자와 두 개의 구별자로 이루어진다. 생성자는 이산적이고 연속적인 데이터 둘 다 생성하기 위해 medGAN의 생성자를 수정해서 사용한다. 구별자1과 생성자의 적대적 관계는 conditionalGAN과 유사한 형태를 갖고 있다. 또한 구별자2와 생성자의 적대적 관계는 생성된 샘플이 proteced속성(s)의 값을 예측하기 위해 지원하는 정보를 인코딩하지 않도록 하는 것이 목표로 한다. FairGAN 논문: https://arxiv.org/pdf/1805.11202.pdf

Ways Bias in Introduced

Training Bias

• 데이터를 수집하는 과정에서 변동(분산)이 없는 데이터를 수집하는 경우가 있다.
• 데이터가 한 장소 또는 한 웹사이트에서 수집되는 경우가 있다.
• 데이터를 라벨링할때 다양한 라벨링하는 사람이 필요하다. 적은 수의 라벨러는 데이터에 편향을 줄 수 있다.

Evaluation Bias

• 모델이 평가될 때 주요 문화의 특성에서의 correctness가 반영되어 편향이 생길 수 있다.
• 'Does Object Recognition Work for Everyone?'논문에서는 household detection 모델에서 income에 따른 평향이 존재한다는 것을 밝혔다. 해당 모델에서 이와 같은 편향이 생긴 이유는 데이터의 대부분이 income이 높은 국가들에서 수집되었고, 데이터 수집시 기본 언어로 영어를 사용했다는 것이다.
• 생성 모델을 평가할 때 FID가 사용된다. FID의 Inception-v3는 ImageNet dataset을 이용해 pre-train된다. 밑의 그림과 같은 ImageNet dataset의 편향으로 인해 편향된 평가를 얻게 될 수 있다.

Model Architecture Bias 모델의 구조 만들거나 최적화 코드를 만드는 코딩하는 사람에게 영향을 받아 편향될 수 있다.

PULSE styleGAN을 이용해서 pixelated blurry image에서 high resolution image을 생성한다.

왼쪽사람 부터 former president of U.S.A Barack Obama(African-American), politician Alexandria Ocasio Cortez(Hispanic), actress Lucy Liu(Asian-American)

이들은 모두 유색인종이다. 하지만 생성된 이미지를 보면 백인의 특성을 많이 갖는 이미지들이 생성되었다. 이를 통해서 해당 모델에 bias가 존재함을 알 수 있다. 해당 프로그램 개발자는 모델 적용시의 주의사항을 명시하였다.

머신러닝 알고리즘을 개발할 때 데이터 수집부터 평가 및 활용 등 개발 전과정에서 bias가 생길 수 있다. bias에 관한 문제는 현재 ML community에서 뜨거운 논쟁거리이다. 따라서 이를 극복하기 위한 연구도 진행되고 있다.

정리

• GAN은 장점과 단점이 존재한다.
• GAN이외에 VAE, AR, FLOW 등 생성 모델들이 존재한다.
• 머신러닝 모델에는 bias가 존재할 수 있다.
• bias를 평가하기 위한 여러가지 fairness가 정의된다.
• 머신러닝 개발자는 개발 및 적용 등 모델 전과정에서 bias가 일어날 수 있다는 점을 명심해야한다.

references

• Build Better GANs coursera강의 및 첨부된 논문들https://www.coursera.org/learn/build-better-generative-adversarial-networks-gans/home/welcome
• Inception-v3 논문: https://static.googleusercontent.com/media/research.google.com/ko//pubs/archive/44903.pdf
• Inception Score 관련: https://medium.com/octavian-ai/a-simple-explanation-of-the-inception-score-372dff6a8c7a ,https://m.blog.naver.com/chrhdhkd/222013835684
• 투빅스 12기 김태한님 VAE 수업자료: https://velog.io/@tobigs-gm1/Variational-Autoencoder
• Autoregressive model 관련: https://towardsdatascience.com/generating-high-resolution-images-using-autoregressive-models-3683f9af0db4
• Flow based generative model 관련: https://medium.com/@sunwoopark/slow-paper-glow-generative-flow-with-invertible-1x1-convolutions-837710116939
• FairGAN 논문: https://arxiv.org/pdf/1805.11202.pdf

Generative Modeling

생성모델링은 가지고있는 데이터 분포에서 sampling한 것 같은 새로운 데이터를 만드는 것입니다. 생성모델링은 판별모델링과 비교하면 이해하기 쉽습니다. 판별모델링은 label y가 필요한 supervised learning이고, 생성모델링은 label y가 필요없는 unsupervised learning입니다. [label y가 있는 경우도 존재]

• 판별모델링 : Sample x가 주어졌을 때, label y의 확률 $P(y|x)$를 추정
  • 생성모델링 : Sample x의 $P(x)$를 추정, [ label이 있는 경우(with condition vector)는 $P(x|y)$를 추정(아래 CGAN에서 설명) ]

생성모델링의 목적 : Want to learn $P_{model}(x)$ similar to $P_{data}(x)$ [출처 : 미술관에서 GAN 딥러닝 실전프로젝트 ] [출처 : NaverD2 "Generative adversarial Networks" 최윤제님 강의자료]

GAN의 구조

GAN이란 Generativ Adversarial Network의 약자입니다. 한국어로 풀어쓴다면 '생성적 적대 신경망'이고, 단어 그대로를 해석한다면 새로운 데이터를 생성하기 위해 뉴럴네트워크로 이루어진 생성자(Generator)와 판별자(Discriminator)가 서로 겨루며 훈련한다는 뜻입니다. 생성자(Generator,이하 G)와 판별자(Discriminator,이하 D)의 역할과 동작을 알아보겠습니다. GAN의 원본 논문에서는 판별자와 생성자를 경찰과 위조지폐범으로 표현했습니다. 판별자 D는 진짜 화폐(dataset의 x)와 생성자가 만들어낸 가짜 화폐를 "real"or"fake"를 잘 구분해야 합니다. 생성자 G는 진짜 화폐같은 가짜 화폐를 만듭니다.

판별자 Discriminator를 먼저 학습합니다. 진짜 이미지x가 들어가면 진짜(1)로 구분, 가짜이미지(생성자가 random code를 받아 만들어낸 G(z))를 입력으로 받으면 가짜(0)로 구분해야합니다. output layer에는 sigmoid를 activation function으로 사용합니다.(0.5를 가준으로 real or fake binary classification) 생성자 Gernerator는 random code z를 입력으로 받아 진짜 이미지 x와 유사한 이미지를 생성합니다. 생성자 G가 잘 학습된다면 D(G(z))가 1에 가까운 값이 나오게됩니다.

LOSS

GAN의 판별자 D는 real or fake를 판단하기 때문에, Binary Cross Entropy(이하BCE)를 사용합니다 [real일 때 y = 1, fake일 때 y = 0인 이진분류] 아래의 식은 BCE를 GAN에 적용했을 때의 Loss입니다. x~P_{data}(x) : 실제 데이터 분포에서 온 sample x z~P_{x}(x) : Gaussian 분포(예)에서 온 Sample latent code z

• 판별자 D는 loss를 최대화 하는 것을 목표로합니다.
• 생성자 G는 loss를 최대화 하는 것을 목표로 합니다. 생성자의 입력은 x와 관련 없기 때문에, $E_{x~P_{data}(x)}[log(D(x))]$항은 고려하지 않습니다.

DCGAN

DCGAN(Deep Convolutional GAN,2015)는 CNN구조로 판별자 D와 생성자 G를 구성한 GAN입니다. 판별자 D는 이미지(예 28x28x3)를 입력으로 받아 binary classification을 수행하므로 CNN구조를, 생성자 G는 random vector z(예 (100,1))를 입력으로 받아 이미지(28x28x3)을 생성해야므로 deconvolutional network구조를 갖게됩니다. 또한 pooling layer를 사용하지 않고 stride 2이상인 convolution,deconvolution을 사용하였습니다. DCGAN의 논문에서, Z space의 연산이 가능하다는 내용을 언급합니다. 예를 들어, "안경 쓴 남자"에 해당하는 z-vector에서 "안경을 쓰지 않은 남자"에 해당하는 z-vector를 빼고, "안경을 쓰지 않은 여자"에 해당하는 z-vector를 더한다면 그 z-vector로 생성한 이미지는 "안경을 쓴 여자"라는 겁니다. (vector space arithmetic) [하지만, "안경 쓴 남자"-"안경 쓰지 않은 남자"에 해당하는 z-vector로 이미지를 생성한다고 "안경"의 이미지가 나오는 것은 아닙니다. ]

Wasserstein GAN(WGAN)

BCE Loss의 문제점

1. Mode Collapse (모드 붕괴)

Mode collapse는 GAN에 BCE loss를 사용할 때 생기는 문제 중 하나입니다. 생성자가 다양한 이미지를 만들어내지 못하고 비슷한 이미지만 계속해서 생성하는 경우를 뜻합니다. 이는 생성자가 판별자를 속이는 적은 수의 샘플을 찾을 때 일어납니다. 따라서 한정된 이 샘플 이외에는 다른 샘플을 생성하지 못합니다. 즉, 생성자가 local minimum에 빠지게 된것입니다.

mode란? 데이터 분포에서 Mode란, 관측치가 높은 부분을 의미합니다. 정규분포에서는 평균이 분포의 Mode입니다.Mode가 1개이면 single mode 2개인 경우는 bimodal이라고 하고, 2개이상인 경우를 multimodal,mulitple modes라고 합니다. MNIST dataset의 경우 숫자마다 1개의 mode, 총 10개의 모드가 있는 multiple modes분포로 나타나게 됩니다. [출처 : deeplearning.ai "Build Basic Generative Adversarial Networks (GANs)" 강의자료]

2. Vanishing Gradient (기울기 소실)

BCE loss는 아래 수식과 같습니다. GAN에 적용될 때에는 다음과 같이 나타낼 수 있습니다. 생성자는 BCE를 줄이는 방향으로, 판별자는 BCE를 최대화 하는 방향으로 학습을 진행하고 이를 minimaxgame이라고 합니다. minimaxgame을 하면서 $P_{model}(x)$을 $P_{data}$와 유사하게 만듭니다. 이때 판별자와 생성자중에, 생성자를 학습하는 것이 더 어렵습니다. 예를들어, 판별자는 real/fake(1/0)를 구분하면 되지만, 생성자는 28x28x3이미지를 생성해야하기 때문입니다. 즉 판별자 D가 생성자 G보다 학습이 쉽다는 것입니다.

하지만, 학습 초기에는 판별자의 성능이 좋지 않기 때문에 크게 문제가 되지 않습니다.(아래 그래프) 이런 경우에는 0이 아닌 gradient값이 생성자에게 유용한 피드백을 줄 수 있습니다. [출처 : deeplearning.ai "Build Basic Generative Adversarial Networks (GANs)" 강의자료]

그러나 판별자 D의 학습이 잘 될수록 생성되는 분포 $P_{model}(x)$와 $P_{data}(x)$를 훨씬 더 구별하게 됩니다. 실제 데이터 분포$P_{data}(x)$는 에 가까이 위치하고, 생성되는 분포 $P_{model}(x)$는 0에 근접하게됩니다. 결과적으로 판별자 D가 잘 학습될수록 0에 가까운 gradient를 넘겨주게 되고, 이는 생성자G입장에서 유익하지 않은 피드백입니다. 결국 생성자는 학습을 종료하게됩니다.

[출처 : deeplearning.ai "Build Basic Generative Adversarial Networks (GANs)" 강의자료]

결론적으로 D가 학습중에 잘 개선될 때 cost function의 flat한 영역에 위치하게 되고 이는 $P_{model}(x)$와 $P_{data}(x)$가 서로 너무 달라서 D가 real과 fake를 너무 잘 구분할 수 있는것을 의미한다. cost funtion의 flat한 영역에 위치하게되어 gradient vanishing문제에 빠진다.

Wasserstein Loss

WGAN paper

위에서 말한 GAN에서의 BCE loss의 문제(mode collapse, vanishing gradient)를 개선하기 위해 새로운 loss Wasserstein loss(와서스테인 로스)를 사용합니다. WGAN에서는 새로운 loss를 사용하는 판별자 D를 비평자 C(Critic)라고합니다.(GvsC)

Earth Mover's Distancce

GAN의 목표인 "$P_{data}(x)$와 동일하도록 $P_{model}(x)$을 학습"은 $P_{data}(x)$와 $P_{model}(x)$ 두 분포사이의 거리를 줄이는것으로 생각 할 수 있습니다. Earth Mover's Distance는 두 분포가 얼마나 다른지를 나타내는 수치입니다. $P_{model}(x)$을 $P_{data}(x)$와 동일하게 만들기 위해 이동해야하는 거리와 양을 의미합니다.

BCE loss의 문제는 판별자 D가 sigmoid를 사용하여 real/fake의 확률값을 출력으로하여, 판별자가 좋아짐에 따라 두 분포의 차이가 심해져서 cost funtion의 기울기가 0값인 영역에 위치해 vanishing gradient문제가 생긴다는 것이었습니다. 하지만, Earth Mover's Distance의 결과는 0과 1의 한계가 없습니다. 분포가 얼마나 멀리 떨어져 있든 상관없이 의미있는 gradient(0이 아닌 기울기)를 전달할 수 있습니다. Earth Mover's Distance를 loss에 사용하면 결과적으로 Vanishing Graident해결할 수 있고, Model collapse가능성을 감소시킵니다!

두 확률 분포간의 거리를 나타내는 지표중 왜 Earth Mover's Distance일까? 두 확률 분포간의 거리를 나타내는 지표 1.Total Variation(TV) 2.Kullback-Leibler(KL) Divergence 3.Jensen-Shannon(JS) Divergence 4.Earth Mover's Distance EM distance(=Wasserstein 거리)의 경우 추정하는 모수에 상관없이 일정한 수식을 가지고 있으나, 다른경우 모수에 따라 거리가 달라질 뿐만 아니라 그 값이 상수 또는 무한대의 값을 가지게됩니다. TV,KL/JS Divergence는 두 분포가 서로 겹치는 경우에 0, 겹치지 않는 경우에는 무한대 또는 상수로 극단적인 값을 가지게됩니다. 결론적으로 TV,KL/JS Divergence을 loss로 사용한다면 gradient가 제대로 전달되지 않아 학습이 어려워집니다. 더 많은 정보 : Wassertein GAN 수학 이해하기

그럼 Earth Mover's Distance을 사용한 Wasserstein loss를 알아봅시다. Kantorovich-Rubinstein Duality Theorem을 이용하여 Earth Mover's Distance를 다음과 같이 나타낼 수 있습니다. 학습시키기 위해 parameter가 추가된 f 로 수식을 바꾸고, Pθ를 g(θ)에 대한 식으로 바꾸면 아래와 같은 수식이 됩니다. 오잉! GAN의 로스와 비슷한 형태군요!$f_{w}$를 비평가 C(판별자 D)로 바꾸면!!Wasserstein Objective function 완성! (Wasserstein loss = $-1/n*∑{i=1}^ny{i}p_{i}$, real x -> $y_{i} = 1$ fake $D(G(x))$ -> $y_{i} = -1$

WGAN조건

Earth Mover's Distance의 출력이 [0, 1]로 제한되지 않아 loss에 사용하는것이 적적하다는 것을 알아보았는데, 일반적으로 신경망에서 너무 큰 숫자는 피해야 하기 때문에 Lipshitz 제약이라는 제약조건을 걸어줍니다. 비평자 C (판별자 D)가 1-Lipshitz continuous function(1-립시츠 연속합수)이어야 합니다. 아래식을 만족하면 됩니다.$|D_{x_{1}}-D_{x_{2}}|$는 비평자C예측 간의 차이의 절댓값이고, $x_{1}-x_{2}$는 두 이미지의 픽셀의 평균값 차이의 절댓값입니다. 1-립시츠 연속함수의 경우 기울기의 절댓값의 최대는 1입니다. 함수 위 어느 점에 원뿔을 놓더라도 하얀색 원뿔에 들어가는 영역이 없습니다. 다른 말로 하면 아래 직선은 어느 지점에서나 상승하거나 하강하는 비율이 한정되어있습니다. 가중치 클리핑 (weight clipping)을 통해 립시츠 제약을 부과할 수 있습니다. WGA 논문에서는 비평자 C의 가중치를 [-0.01, 0.01]안에 놓이도록, 훈련 배치가 끝난 후 가중치 클리핑을 통해 립시츠 제약을 부과하는 방법을 보였습니다. (0.01은 논문에서 실험을 통해 얻은 값입니다.)

WGAN구조

    def train_one_step(self,batch_images):
        batch_z = np.random.uniform(-1, 1,[self.batch_size, self.z_dim]).astype(np.float32)
        real_images = batch_images
        with tf.GradientTape() as g_tape, tf.GradientTape() as d_tape:
            fake_imgs = self.g(batch_z, training=True)
            d_fake_logits= self.d(fake_imgs, training=True)
            d_real_logits= self.d(real_images, training=True)
            critic_loss=tf.reduce_mean(d_fake_logits-d_real_logits)
            g_loss = self.g_loss_fun(d_fake_logits)               

        gradients_of_d = d_tape.gradient(critic_loss, self.d.trainable_variables)

        # for WGAN model all the gradients should clip to (-0.01,0.01)
        for idx,grad in enumerate(gradients_of_d) :
            gradients_of_d[idx]=tf.clip_by_value(grad,-0.01,0.01)
        gradients_of_g = g_tape.gradient(g_loss, self.g.trainable_variables)
        self.d_optimizer.apply_gradients(zip(gradients_of_d, self.d.trainable_variables))
        self.g_optimizer.apply_gradients(zip(gradients_of_g, self.g.trainable_variables))
        self.g_loss_metric(g_loss)
        self.critic_loss_metric(critic_loss)

바닐라맛 GAN은?

    # train for one batch
    @tf.function
    def train_one_step(self,batch_images):
        batch_z = np.random.uniform(-1, 1,[self.batch_size, self.z_dim]).astype(np.float32)
        real_images = batch_images
        with tf.GradientTape() as g_tape, tf.GradientTape() as d_tape:
            fake_imgs = self.g(batch_z, training=True)
            d_fake_logits = self.d(fake_imgs, training=True)
            d_real_logits = self.d(real_images, training=True)
            d_loss = self.d_loss_fun(d_fake_logits, d_real_logits)
            g_loss = self.g_loss_fun(d_fake_logits)
        gradients_of_d = d_tape.gradient(d_loss, self.d.trainable_variables)
        gradients_of_g = g_tape.gradient(g_loss, self.g.trainable_variables)
        self.d_optimizer.apply_gradients(zip(gradients_of_d, self.d.trainable_variables))
        self.g_optimizer.apply_gradients(zip(gradients_of_g, self.g.trainable_variables))
        self.g_loss_metric(g_loss)
        self.d_loss_metric(d_loss)

Conditional GAN(CGAN)

Conditional GAN과 Unconditional GAN의 차이는 다음과 같습니다.

Conditional	Unconditional
Exaples from the classes you want	Examples from random classes
Training dataset needs to be labeled	Training dataset doesn't need to be labeled
Conditional GAN(이하CGAN)은 생성자와 판별자가 훈련하는 동안 추가 정보를 사용해 조건이 붙는 생성적 적대 신경망입니다. CGAN을 이용하면 우리가 원하는 class가 담긴 데이터를 생성할 수 있습니다. 생성자와 판별자를 훈련하는 데 모두 label을 사용합니다. 아래 그림은 CGAN의 구조입니다.

판별자의 입력

판별자에는 label(one-hot vector)와 이미지가 입력으로 들어갑니다. label vector를 embedding layer에 통과시켜 이미지와 동일한 사이즈로 만들고, Concate합니다. 이렇게 one-hot vecotr인 labe과 이미지를 한번에 입력합니다.

생성자의 입력

생성자의 입력으로 들어가는 random noise z는 생성되는 이미지의 다양성이 보장되도록 합니다. 랜덤벡터(랜덤노이즈)와 레이블이 동시에 들어가게됩니다. 단, 그냥 vector concate의 형식 [random vector z,label y]은 아닙니다. z-dim에 맞게 label vector크기 변환(ex keras embedding층)해서 원소곱(Multiply)해서 들어가게됩니다.

아래는 CGAN말고 seimi-supervised 형식의 GAN의 구조를 표현한 그림입니다.

SGAN

ACGAN

Controllable Generation

학습 중 라벨을 활용하는 CGAN과 달리, 학습 후에 원하는 기능을 조절하도록 할 수도 있습니다. Controllable은 class를 조절할 수 있는 CGAN과는 다릅니다.

즉, random vector z를 조절하여 feautre를 변화시킬 수 있다는것입니다.

Disentanglement에 관한 자세한 내용은 4주차 이예지님의Disenstanglement를 참고하시기 바랍니다.

[reference] 투빅스 14기 정규세션 10주차 강의자료 : https://drive.google.com/file/d/1syOw-5YZPfHlVAdQJiLnkBXbD39262Kq/view CS231n 13rkd Generative Model : https://www.youtube.com/watch?v=5WoItGTWV54 미술관에 GAN 딥러닝 실전 프로젝트 - 데이비드 포스터(한빛미디어) GAN 인 액션 - 야쿠프 란그르,블라디미르 보크(한빛미디어) Deeplearning.ai "Generative Adversarial Networks (GANs) Specialization" Course1 Basic of GANs : https://www.coursera.org/learn/build-basic-generative-adversarial-networks-gans?utm_source=deeplearningai&utm_medium=institutions&utm_campaign=DLWebGANsMain WGAN : https://ahjeong.tistory.com/7

Prior Knowledge

1. What is MAP, MLE?

1) Bayes' rule

두 확률 변수의 사전 확류로가 사후 확률 사이의 관계를 나타내는 정리입니다.

$P(A|B) = {P(B|A)P(A) \over p(B)}$

$P(A|B)$ - posterior $P(B)$ - evidence $P(A)$ - prior $P(B|A)$ - likelihood

A는 관심있는 변수에 해당하며 B는 그러한 A를 추측하기 위한 수단입니다.

2) MAP, MLE

MAP - Maximum A Posterior MLE - Maximum Likelihood Estimation

$P(w|y,X) = {P(y|X,w)P(w) \over P(y|X)}$ 여기서 일반적인 모델링이란 확률분포 P의 형태를 정하고(ex. gaussian distribution), 해당 확률분포의 모수를 추정하는 w의 형태(ex. linear regression)를 정하는 것을 말합니다.

여기서 일반적인 linear regression을 기준으로 MAP와 MLE의 차이점에 대해 알아보겠습니다.

Linear regression에서는 P의 분포를 gaussian distribution, 그리고 해당 P의 모수 $\mu$를 독립변수의 선형결합 즉, $a_0+a_1x_1+a_2x_2+...+a_nx_n$의 형태로 나타내는 모델링을 의미합니다. 이때 w는 $a_0, a_1, ... , a_n$를 말합니다.

• MLE Likelihood 즉 우도를 최대화 하는 방식으로 변수 X와 y의 관계를 찾아가는 방법입니다.
  Convex function을 만들기 위하여 negative log likelihood의 최솟값을 찾아가는 형태로 학습이 이루어지게 됩니다.
  이때 negative log likelihood는 $-log(P(y|X,w))$에 해당이 되고, 확률분포 $P(y|X,w)$는 $(2\pi\sigma)^{-{1\over2}}{exp^{-{1\over2}(y-\mu)^{T}{\sigma^{-{1\over2}}}(y-\mu)}}$로 표현됩니다. Target variable인 y가 일반적으로 연속적인 하나의 값이므로 ${\sigma}$는 상수값이 되고 $(y-\mu)^{T}(y-\mu)$는 MSE(mean square error)와 동일한 값이 됩니다. 따라서 negative log likelihood를 하게되면 지수항에 해당하는 MSE부분이 유도되어 linear regression의 objective function은 MSE가 됩니다.

• MAP Posterior 즉 사후확률분포를 최대로 하는 방식으로 변수 X와 y의 관계를 찾아가는 방법입니다. 여기서 말하는 사후분포에 해당하는 변수는 y가 아닌 y와 X의 관계를 나타내어주는 w를 말하며 따라서 식의 형태는 bayes' rule에 의하여 다음과 같습니다. $P(w|y,X) = {P(y|X,w)P(w) \over P(y|X)}$ 여기서 evidence에 해당하는 분모부분은 w가 없으므로 w에 영향을 받지 않는 값으로 상수 취급을 할 수 있으며 해당 값은 전체확률의 법칙을 이용하면 구할 수 있습니다. 이제 분자부분만 계산하면 되는데 위의 MLE에서와 마찮가지로 $P(y|X,w)$는 gaussian distribution으로 형태를 정하므로 우리에게 필요한 것은 $P(w)$의 형태만이 남게 됩니다. 따라서 이를 한번 standard normal distribution으로 가정해 보겠습니다. MLE와 마찮가지로 convex function을 만들어준 후 이를 optimization하기 위하여 negative log posterior를 구하여 보면 $-log(P(y|X,w)P(w))$가 됩니다. 이때 로그의 성질에 의하여 해당 식은 $-logP(y|X,w)-log(P(w))$으로 나뉘어 질 수 있으며 앞의 $-logP(y|X,w)$부분은 MLE와 마찮가지로 MSE값이 됩니다. 이때 뒷부분의 $-log(P(w))$의 경우 standard normal distribution으로 가정하였으므로 이를 풀어주면 $C({a_0}^2+{a_1}^2+...+{a_n}^2)$의 형태가 됩니다. 이를 다시 보게되면 MSE+$C({a_0}^2+{a_1}^2+...+{a_n}^2)$의 형태로 우리가 일반적으로 알고있는 ridge regularization인 것을 알 수 있습니다.

즉 MLE는 MAP의 $P(w)$를 uniform distribution이라는 조건의 특수한 케이스 임을 알 수 있습니다. 따라서 모델링을 하여 y를 추정하는 것은 결국 내가 가지고 있는 train set을 얼마나 잘 맞추는 것이 아니라 trains set을 근거로 y와 X의 올바른 관계를 도출하는 것이므로 $P(w)$를 안다면 이를 이용한 MAP로 접근하는 것이 올바른 방법입니다. 하지만 대부분의 경우 $P(w)$를 알지 못하는 경우이므로 어쩔 수 없이 uniform distribution으로 가정한 후 MLE로 학습을 진행하게 됩니다.

2. Kullback Leibler Divergence

1) Information Theory

정보의 가치의 정도를 측정하기 위한 응용수학의 한 갈래

정보의 성질 3가지

1) 자주 발생하는 사건은 낮은 정보량을 가진다. 2) 독립사건은 추가적인 정보량을 가진다 - 정보량이 더해진다.

ex) 투빅이는 사실 여우입니다....!?!?!?

이를 수학적인 값으로 표현을 하게 되면 특정 사건이 일어날 확률을 $P(X)$라고 하면 해당 사건의 정보량은 $I(X) = -log_2{P(X)}$이 됩니다.

2) Kullback Leibler Divergence

이러한 정보량 $I(X)$를 토대로 기댓값을 구하게 되면 그것이 바로 엔트로피(entropy) 값이 됩니다. $H(X)=-\Sigma{P(x)log_2{P(X)}}=E(I(X))$ 이를 토대로 P(X)의 정보량을 다른 확률분포 Q(X)에 대해 기댓값을 구하면 cross entropy를 구할 수 있습니다. $H(P,Q)=-\Sigma{P(x)log_2{Q(X)}}=E_P{(I_Q{(X)})}$ 그리고 마지막으로 이러한 cross entropy와 entropy간의 차이가 바로 kullback leibler divergence값이 됩니다. $KL(P||Q)=H(P,Q)-H(P)$ 이러한 kullback leibler divergence값은 P와Q라는 분포의 차이를 나타내주는 지표로 다음의 두 가지 특징이 있습니다.

• $KL(P||Q)!=KL(Q||P)$이므로 거리 값이 아니다.
• 항상 0보다 크거나 같다. by jensen's inequality

VAE

1. VAE와 AE?

AE(Auto Encoder): 단순히 차원을 축소하는 것이 목적입니다.

input 변수 X에 대하여 label 값인 y를 예측하는 모델에서 label 값인 y와 X가 같은 값을 가지게 되었을 때 neural network 도중의 hidden variable값이 label인 y(즉 X)에 대한 정보를 담고있다는 점을 토대로 차원을 축소하는 방법입니다. MLE와 유사합니다.

VAE(Variational Auto Encoder): AE와 마찮가지로 label 값과 input 값이 같은 것과 더불어 축소된 차원 값인 latent vector의 분포를 가정하고 해당 가정된 분포의 형태내에서 해당 모델이 label을 잘 맞추도록 학습하는 방법입니다. MAP와 유사합니다.

이러한 VAE가 AE와 다르게 가질 수 있는 장점은 아래의 그림으로 알 수 있습니다. 위의 그림에서 (b)그림은 (a)의 일부분 값이 손실된 그림이고 (c)그림은 (a)그림을 한 픽셀시 오른쪽으로 이동한 그림입니다. 이때 MSE값을 (a)를 기준으로 (b)와 (c)에 대해 구하여 보면 숫자 2의 모습은 (c)가 더 유사함에도 불구하고 (b)의 MSE값이 더 작게 나옵니다. 이러한 문제로 인하여 AE는 latent vector의 값이 변화하였을 때 (b)그림이 나올 확률이 높지만 VAE의 경우 latent vector의 분포안에서 특징을 추출하게되는 성질이 있어 (c)가 나올 확률이 상대적으로 AE보다 높아집니다.

2. ELBO Loss

ELBO Loss 즉 evidence lower bound loss는 VAE의 loss function입니다. 이는 다음의 유도과정을 통해 유도가 됩니다. 여기서 $log(P(X))$의 ELBO부분(빨간색)과 KL(파란색) 부분으로 나뉘어 지게 되는데 이때 파란색 부분은 실제로는 구하려면 한번 gradient를 update하는데 많은 계산을 하게되어 실질적으로 구하기 어려우므로 ELBO부분의 loss function을 이용하여 학습이 이루어집니다. 이때 실제값을 구할 수는 없지만 최저 한도는 계산이 가능하므로 이를 높여 optimization에 근사하게 됩니다. 그리고 그러한 ELBO Loss function은 위의 식으로 최종 계산됩니다. 여기서 regularization부분의 경우 gaussian distribution간의 KL값은 풀어보면 어느정도 간단하게 정리가 되는 것을 볼 수 있습니다. 또한 reconstruction부분의 경우 continuous variable이면 gaussian, discrete variable이면 cross entropy가 되는 것을 볼 수 있습니다.

3. Mnist training result review

Tensorflow 2.0 공식 홈페이지에서 제공하고있는 VAE 샘플 코드를 통해 학습을 한 결과입니다. 이때 VAE는 사전에 정해둔 분포에 복원시키는 데이터의 특징이 투영되므로 가장 평균적으로 잘 복원시키는 이미지가 gaussian distribution의 평균에 위치하도록 학습이 진행되게 됩니다. 아래의 그림은 mnist training dataset 6000장의 이미지들을 모두 더한후 평균을 취한 이미지로써 학습하여 나타낸 위의 그림의 한 가운데 그림과 유사해 보이는 것을 알 수 있습니다. 이를 좀더 수치화 하여 각 이미지들과의 차이의 평균을 나타내면 아래의 값처럼 나오게 되고 가운데 즉 평균에 가까울 수록 그 값이 작아짐을 볼 수 있습니다. 따라서 결국 VAE도 학습시 네트워크보다는 train dataset이 얼마나 내가 내포시키고 싶은 특징을 가지느냐에 따라 성능이 굉장히 차이가 나게 됩니다.

AAE & CVAE

1. AAE

기존 VAE의 구할 수 없던 KL divergence값을 GAN의 discriminator를 이용하여 찾아가도록 하는 방법입니다. 기본적인 네트워크의 구성은 아래의 그림과 같습니다.

2. CVAE

함축시키고 싶은 정보가 discrete한 class로 label되어 질 수 있다면 이를 이용하여 해당 특징을 학습시키는 방법으로 네트워크의 구조는 다음과 같습니다.

Reference

• 이활석님의 오토인코더 강의
• tobigs' 13기 신민정님 강의자료
• https://ratsgo.github.io/generative%20model/2018/01/28/VAEs/
• https://datascienceschool.net/view-notebook/c5248de280a64ae2a96c1d4e690fdf79/
• http://egloos.zum.com/incredible/v/7480854

투빅스 13&14기 생성모델 세미나는 총 7주동안 진행되며 VAE, GAN, Image Translation, Self-supervised Learning, Few-shot Learning, Cros Domain을 다룰 예정입니다.

*커리큘럼📒 *

총 7회 세미나를 진행합니다.

2~3주차 세미나는 deeplearning.ai의 Generative Adversarial Networks Specialization 커리큘럼을 따라진행됩니다. deeplearning.ai의 강의는 참고 자료이며, 단순한 강의리뷰가 아닌 심화세미나를 진행합니다.

*Course1 : Build Basic Generative Adversarial Networks (GANs) * week1. Intro to GANs week2. Deep Convolutional GANs week3. Wasserstein GANs with Gradient Penalty week4. Conditional GAN & Controllable Generation -> 2주차 GAN의 기초(GAN,DCGAN,WGAN,CGAN) week4. Conditional GAN & Controllable Generation -> 4주차 Disentanglement *Course2 : Build Batter Generative Adversarial Networks (GANs) * week1. Evaluation of GANs week2. GAN Disadvantages and Bias -> 2주차 GAN의 평가와 편향
week3. StyleGAN and Advancements -> 3주차 StyleGAN
*Course : Apply Generative Adversarial Networks (GANs) * week1. GANs for Data Augmentation and Privacy week2. Image-to-Image Translation with Pix2Pix week3. Unpaired Translation with CycleGAN -> 3주차 Image Translation (pix2pix & CycleGAN)

해당 세미나 내용은 Velog에 업데이트 됩니다.

*멤버소개👩‍💻 *