작성자 : 서울시립대학교 경제학부 박준영

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.SPECTRALNORM()
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>

이제 style gan에 적용된 progressive growing을 알아보자
style gan의 구조는 다음과 같다.

출처: 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 
<https://arxiv.org/abs/1812.04948>

각각 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의 역할을 한다.