✱ 핸즈온 머신러닝 17장 오토인코더, GAN 그리고 확산 모델 ✱

오토인코더 : 지도 방식을 사용하지 않고도(레이블되어 있지 않은 훈련 훈련 데이터를 사용해서) 잠재 표현 또는 코딩이라 부르는 입력 데이터의 밀집 표현을 학습할 수 있는 인공신경망이다. 

코딩은 일반적으로 입력보다 훨씬 낮은 차원을 가진다.

따라서 오토인코더는 차원 축소, 특히 시각화에 유용하게 사용된다.

오토인코더가 강력한 특성 추출기처럼 작동하므로 심층 신경망의 비지도 사전 훈련에 사용될 수 있다.

생성 모델 : 일부 오토인코더는 훈련 데이터와 매우 비슷한 새로운 데이터를 생성할 수 있다.

예) 얼굴 사진으로 오토인코더를 훈련하면 이 모델은 새로운 얼굴을 생성할 수 있게 된다.

 

생성적 적대 신경망(GAN)도 데이터를 생성할 수 있다.

 

지금 생성 학습 분야에서 주목할 만한 것은 확산 모델이다. 

GAN보다 다양하고 고품질의 이미지를 생성하면서도 훨씨 ㄴ더 쉽게 훈련할 수 있게 되었지만 실행 속도가 훨씬 느리다.

 

오토인코더, GAN, 확산 모델은 모두 비지도 학습이며, 모두 잠재 표현을 학습하고 생성 모델로 사용될 수 있다.

 

오토인코더는 단순히 입력을 출력으로 복사하는 방법을 배운다.

네트워크에 제약을 가해(잠재 표현 크기 제한, 입력에 잡음 추가 등) 오토인코더가 단순히 입력을 출력으로 바로 복사하지 못하도록 막고 데이터를 효율적으로 표현하는 방법을 배우게 한다. 

코딩은 이정 제약 조건하에서 항등 함수를 학습하려는 오토인코더의 노력으로 생겨난 부산물이다.

 

GAN은 신경망 두 개로 구성된다.

생성자는 훈련 데이터와 비슷하게 보이는 데이터를 생성하고 판별자는 가짜 데이터와 진짜 데이터를 구별한다.

적대적 훈련 : 이 구조는 신경망이 훈련하는 동안 생성자와 판별자가 서로 경쟁한다.

 

잡음 제거 확산 모델(DDPM)은 이미지에서 아주 작은 잡음을 제거하도록 훈련된다.

그 다음 가우스 잡음으로 가득찬 이미지에서 확산 모델을 반복적으로 실행하면 훈련 이미지와 유사한 (하지만 동일하지 않은) 고품질 이미지가 서서히 드러난다.

---

17.1 효율적인 데이터 표현

오토인코더가 입력을 받아 효율적인 내부 표현으로 바꾸고 입력과 가장 가까운 어떤 것을 출력한다.

오토인코더는 항상 입력을 내부 표현으로 바꾸는 인코더(인지 네트워크)와 내부 표현을 출력으로 바꾸는 디코더(생성 네트워크)의 두 부분으로 구성된다. 

출력 층의 뉴런 수가 입력 개수와 동일하다는 것을 제외하면 일반적으로 오토인코더는 다층 퍼셉트론(MLP)와 구조가 동일하다.

위 사진에서는 뉴런 두 개로 구성된 하나의 은닉 층이 있고(인코더) 뉴런 세 개로 구성된 출력 층이 있다.(디코더)

오토인코더가 입력을 재구성하기 떄문에 출력을 종종 재구성이라고 부른다.

비용 함수는 재구성이 입력과 다를 때 모델에 벌점을 부과하는 재구성 손실을 포함한다. 

 

내부의 표현이 입력 데이터보다 저차원이기 때문에 과소완전이라고 한다. 

입력을 코딩으로 간단히 복사할 수 없으며, 입력과 똑같은 것을 출력하기 위한 다른 방법을 찾아 입력 데이터에서 가장 중요한 특성을 학습하도록 만든다. (중요하지 않은 것은 버린다.)

---

17.2 과소완전 선형 오토인코더로 PCA 수행하기

오토인코더가 선형 활성화 함수만 사용하고 비용 함수가 평균 제곱 오차(MSE)라면, 이는 결국 주성분 분석(PCA)를 수행하는 것이다.

 

import tensorflow as tf

encoder = tf.keras.Sequential([tf.keras.layers.Dense(2)])
decoder = tf.keras.Sequential([tf.keras.layers.dense(3)])
autoencoder = tf.keras.Sequential([encoder, decoder])

optimizer = tf.keras.optimizers.SGD(learning_rate=0.5)
autoencoder.compile(loss="mse", optimizer=optimizer)

3D 데이터셋에 PCA를 적용해 2D에 투영하는 선형 오토인코더이다.

 

오토인코더를 인코더와 디코더 두 개 컴포넌트로 구성한다. 둘 다 하나씩 Dense 층을 가진 일반적인 Sequential 모델이다. 오토인코더는 인코더 다음에 디코더가 뒤따르는 Sequential 모델이다.

오토인코더의 출력 개수가 입력의 개수와 동일하다. 

PCA를 수행하기 위해서는 활성화 함수를 사용하지 않으며(모든 뉴런이 선형이다.) 비용함수는 MSE이다. ← PCA가 선형 변환인 이유

 

X_train = [...] # 3D 데이터셋을 생성한다.
history = autoencoder.fit(X_train, X_train, epochs=500, verbose=False)
codings = encoder.predict(X_train)

이 모델을 가상의 3D 데이터셋에 훈련한다.

이 모델을 사용해 동일한 데이터셋을 인코딩한다. (2D로 투영한다.)

 

X_train이 입력과 타깃에도 사용된다. 

왼쪽은 원본 3D 데이터셋이고 오른쪽은 오토인코더의 은닉 층 출력(코딩 층)이다.

오토인코더는 PCA처럼 데이터에 있는 분산이 가능한 한 많이 보존되도록 데이터를 투영할 최상의 2D 평면을 찾는다.

---

17.3 적층 오토인코더

적층 오토인코더(심층 오토인코더) : 다른 신경망과 마찬가지로 오토인코더도 은닉 층을 여러 개 가질 수 있다. 

층을 더 추가하면 오토인코더가 더 복잡한 코딩을 학습할 수 있다. 

그러나 오토인코더가 너무 강력해지지 않도록 주의해야 한다. 훈련 데이터를 완벽하게 재구성하겠지만 이 과정에서 유용한 데이터 표현을 학습하진 못한다.

 

적층 오토인코더의 구조는 전형적으로 가운데 은닉 층(코딩 층)을 기준으로 대칭이다. 

17.3.1 케라스로 적층 오토인코더 구현하기

stacked_encoder = tf.keras.Sequential([
    tf.keras.layers.Flatten().
    tf.keras.layers.Dense(100, activation="relu"),
    tf.keras.layers.Dense(30, activation="relu"),
])
stacked_decoder = tf.keras.Sequential([
    tf.keras.layers.Dense(100, activation="relu"),
    tf.keras.layers.Dense(28 * 28),
    tf.keras.layers.Reshape([28, 28])
])
stacked_ae = tf.keras.Sequential([stacked_encoder, stacked_decoder])

stacked_ae.compile(loss="mse", optimizer="nadam")
history = stacked_ae.fit(X_train, X_train, epochs=20,
                         validation_data=(X_valid, X_valid))

인코더는 28x28 픽셀의 흑백 이미지를 받는다. 그다음 각 이미지를 784 크기의 벡터로 표현하기 위해 펼친다. 이 벡터를 크기가 점점 줄어드는 Dense 층 두 개에 통과시킨다. 두 층은 모두 ReLU 활성화 함수를 사용한다. 각 입력 이미지에 대해 인코더는 크기가 30인 벡터를 출력한다. 

디코더는 인코더가 출력한 크기가 30인 코딩을 받는다. 그다음 크기가 점점 커지는 Dense 층 두 개에 통과시킨다. 최종 벡터를 28x28 배열로 변경하여 디코더의 출력이 인코더의 입력과 동일한 크기가 되도록 만든다.

적층 오토인코더를 컴파일할 때 평균 MSE 손실과 Nadam 옵티마이저를 사용한다.

마지막으로 X_train을 입력과 타깃으로 사용해 모델을 훈련한다. 비슷하게 X_valid를 검증 입력과 검증 타깃으로 사용한다.

17.3.2 재구성 시각화

오토인코더가 적절히 훈련되었는지 확인하는 한 가지 방법은 입력과 출력을 비교하는 것이다. 입력과 출력의 크기가 너무 크지 않아야 한다. 

import numpy as np

def plot_reconstructions(model, images=X_valid, n_images=5):
    reconstructions = np.clip(model.predict(images[:n_images]), 0, 1)
    fit = plt.figure(figsize=(n_images * 1.5, 3))
    
    for image_index in range(n_images):
        plt.subplot(2, n_images, 1 + image_index)
        plt.imshow(images[images_index], cmap="binary")
        plt.axis("off")
        plt.subplot(2, n_images, 1 + n_images + image_index)
        plt.imshow(reconstructions[image_index], cmap="binary")
        plt.axis("off")
        
plot_reconstructions(stacked_ae)
plt.show()

17.3.3 패션 MNIST 데이터셋 시각화

적층 오토인코더를 훈련했으므로 이 모델을 사용해 데이터셋의 차원을 축소할 수 있다.

오토인코더의 장점이 샘플과 특성이 많은 대용량 데이터셋을 다룰 수 있다는 점이기 때문에, 오토인코더를 사용해 적절한 수준으로 차원을 축소한 후 다른 차원 축소 알고리즘을 사용해 시각화할 수 있다.

from sklearn.manifold import TSNE
X_valid_compressed = stacked_encoder.predict(X_valid)
tsne = TSNE(init="pca", learning_rate="auto", random_state=42)
X_valid_2D = tsne.fit_trainsform(X_valid_compressed)

적층 오토인코더의 인코더 모델을 사용해 차원을 30으로 줄인다.

그다음 t-SNE 알고리즘을 구현한 사이킷런 클래스로 시각화를 위해 차원을 2까지 줄인다.

plt.scatter(X_valid_2D[:, 0], X_valid_2D[:, 1], c=y_valid, s=10, cmap="tab10"))
plt.show()

이 데이터셋을 그래프로 그릴 수 있다. 

17.3.4 적층 오토인코더를 사용한 비지도 사전 훈련

레이블된 훈련 데이터가 많지 않은 복잡한 지도 학습 문제를 다루어야 한다면 비슷한 문제를 학습한 신경망을 찾아 하위 층을 재사용하는 방법이 있다.

저수준의 특성을 학습할 필요가 없으니 적은 훈련 데이터를 사용해 고성능 모델을 훈련할 수 있다.

기존의 네트워크에서 학습한 특성 감지 기능을 재사용한다.

 

비슷하게 대부분의 데이터가 레이블되지 않은 대량의 데이터셋이 있다면 먼저 전체 데이터를 사용해 적층 오토인코더를 훈련한다.

그런 다음 오토인코더의 하위 층을 재사용해 실제 문제를 해결하기 위한 신경망을 만들고 레이블된 데이터를 사용해 훈련할 수 있다.

분류기를 훈련할 때 레이블된 훈련 데이터가 많지 않으면 사전 훈련된 층 가장 하위에 있는 층 하나 이상을 동결하는 것이 좋다.

모든 훈련 데이터를 사용해 오토인코더를 훈련하고 인코더 층을 재사용하여 새로운 신경망을 만들면 된다.

17.3.5 가중치 묶기

오토인코더가 완벽하게 대칭일 땐 디코더의 가중치와 인코더의 가중치를 묶는 것이 일반적인 방법이다.

→ 모델에 있는 가중치의 수가 절반으로 줄어들어 훈련 속도가 증가하고 과대적합의 위험이 줄어든다.

class DenseTranspose(tf.keras.layers.Layer):
    def __init__(self, dense, activation=None, **kwargs):
        super().__init__(**kwargs)
        self.dense = dense
        self.activation = tf.keras.activations.get(acitvation)
    
    def build(self, batch_input_shape):
        self.biases = self.add_weight(name="bias",
                                      shape=self.dense.input_shape[-1],
                                      initializer="zeros")
        super().build(batch_input_shape)

    def call(self, inputs):
        Z = tf.matmul(inputs, self.dense.weights[0], transpose_b=True)
        return self.activation(Z + self.biases)

이 사용자 정의 층은 일반적인 Dense 층과 다른 Dense 층의 전치된 가중치를 사용한다.

독자적인 편향 벡터를 사용한다.

dense_1 = tf.keras.layers.Dense(100, activation="relu")
dense_2 = tf.keras.layers.Dense(30, activation="relu")

tied_encoder = tf.keras.Sequential([
    tf.keras.layers.Flatten(),
    dense_1,
    dense_2
])

tied_decoder = tf.keras.Sequential([
    DenseTranspose(dense_2, activation="relu"),
    DenseTranspose(dense_1),
    tf.keras.layers.Reshape([28, 28])
])

tied_ae = tf.keras.Sequential([tied_encoder, tied_decoder])

이전과 비슷하게 새로운 적층 오토인코더를 만든다.

이 디코더의 Dense 층은 인코더의 Dense 층과 묶여있다.

17.3.6 오토인코더 한 개씩 훈련하기

한 번에 전체 오토인코더를 훈련하는 대신 오토인코더를 하나씩 훈련하고 이를 쌓아올려서 한 개의 적층 오토인코더를 만들 수 있다.

단계 1에서 첫 번째 오토인코더는 입력을 재구성하도록 훈련된다.

그다음 이 오토인코더를 사용해 전체 훈련 세트를 인코딩하여 압축된 새 훈련 세트를 만든다. 

이 새로운 훈련 세트에서 두 번째 오토인코더를 훈련한다. (단계 2)

마지막으로 모든 오토인코더를 사용해 전체 네트워크를 만든다. (각 오토인코더의 은닉 층을 먼저 쌓고 출력 층을 반대로 쌓는다.)

이렇게 해서 최종 적층 오토인코더를 만든다. 이런 방식으로 더 많은 오토인코더를 훈련해 아주 깊은 적층 오토인코더를 만들 수 있다.

---

17.4 합성곱 오토인코더

이미지를 다루는 경우에는 오토인코더가 좋은 성능을 내지 못하기 떄문에 합성곱 신경망이 밀집 네트워크보다 훨씬 잘 맞는다. 

따라서 비지도 사전 훈련이나 차원 축소를 위해 이미지에 대한 오토인코더를 만드려면 합성곱 오토인코더를 만들어야 한다. 

인코더는 합성곱 층과 풀링 층으로 구성된 일반적인 CNN이다. 

인코더는 전형적으로 입력에서 공간 방향의 차원(높이와 너비)을 줄이고 깊이(특성 맵의 개수)를 늘린다. 

디코더는 거꾸로 작동하며, 이미지의 스케일을 늘리고 깊이를 원본 차원으로 되돌린다.

이를 위해선 전치 합성곱 층을 사용한다. (또는 합성곱 층과 업샘플링 층을 연결할 수 있다.)

conv_encoder = tf.keras.Sequential([
    tf.keras.layers.Reshape([28, 28, 1]),
    tf.keras.layers.Conv2D(16, 3, padding="same", activation="relu"),
    tf.keras.layers.MaxPool2D(pool_size=2), # 출력: 14 x 14 x 16
    tf.keras.layers.Conv2D(32, 3, padding="smae", activation="relu"),
    tf.keras.layers.MaxPool2D(pool_size=2), # 출력: 7 x 7 x 32
    tf.keras.layers.Conv2D(64, 3, padding="same", activation="relu"),
    tf.keras.layers.MaxPool2D(pool_size=2), # 출력: 3 x 3 x 64
    tf.keras.layers.Conv2D(30, 3, padding="same", activation="relu"),
    tf.keras.layers.GlobalAvgPool2D() # 출력: 30
])
conv_decoder = tf.keras.Sequential([
    tf.keras.layers.Dense(3 * 3 * 16),
    tf.keras.layers.Reshape((3, 3, 16)),
    tf.keras.layers.Conv2DTranspose(32, 3, strides=2, activation="relu"),
    tf.keras.layers.Conv2DTranspose(16, 3, strides=2, padding="same",
                                    activation="relu"),
    tf.keras.layers.Conv2DTranspose(1, 3, strides=2, padding="same"),
    tf.keras.layers.Reshape([28, 28])
])
conv_ae = tf.keras.Sequential([conv_encoder, conv_decoder])

 

오토인코더가 흥미로운 특성을 학습하도록 강제하기 위해 코딩 층의 크기를 제한하여 과소완전으로 만들었다. 

사용할 수 있는 다른 종류의 제약도 많다.

입력 크기만큼 또는 입력보다 큰 코딩 층을 두어 과대완전 오토인코더를 만들 수 있다. 

잡음 제거 오토인코더, 희소 오토인코더, 변이형 오토인코더와 같은 종류도 있다.

---

17.5 잡음 제거 오토인코더

오토인코더가 유용한 특성을 학습하도록 강제하기 위해 입력에 잡음을 추가하고 잡음이 없는 원본 입력을 복원하도록 훈련한다.

적층 잡음 제거 오토인코더

 

잡음은 입력에 순수한 가우스 잡음을 입력에 추가하거나 드롭아웃처럼 랜덤으로 입력을 꺼서 발생시킬 수 있다. 

dropout_encoder = tf.keras.Sequential([
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dropout(0.5),
    tf.keras.layers.Dense(100, activation="relu"),
    tf.keras.layers.Dense(30, activation="relu")
])
dropout_decoder = tf.keras.Sequential([
    tf.keras.layers.Dense(100, activation="relu"),
    tf.keras.layers.Dense(28 * 28),
    tf.keras.layers.Reshape([28, 28])
])
dropout_ae = tf.keras.Sequential([dropout_encoder, dropout_decoder])

인코더의 입력에 적용한 Dropout 층이 있는(또는 GaussianNoise 층을 사용한) 일반적인 적층 오토인코더이다.

Dropout 층은 훈련하는 동안에만 활성화된다. (GaussianNoise 층도 마찬가지이다.)

---

17.6 희소 오토인코더

비용 함수에 적절한 항을 추가하여 오토인코더가 코딩 층에서 활성화되는 뉴런 수를 감소시키도록 만든다.

→ 오토인코더가 적은 수의 활성화된 뉴런을 조합하여 입력을 표현해야 한다. 코딩 층의 각 뉴런은 유용한 특성을 표현하게 된다.

sparse_l1_encoder = tf.keras.Sequential([
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(100, activation="relu"),
    tf.keras.layers.Dense(300, activation="sigmoid"),
    tf.keras.layers.ActivityRegularization(l1=1e-4)
])
sparse_l1_decoder = tf.keras.Sequential([
    tf.keras.layers.Dense(100, activation="relu"),
    tf.keras.layers.Dense(28 * 28),
    tf.keras.layers.Reshape([28, 28])
])
sparse_l1_ae = tf.keras.Sequential([sparse_l1_encoder, sparse_l1_decoder])

ActivityRegularization 층은 입력을 그대로 반환하면서 훈련 손실에 입력의 절댓값을 더한다. (이 층은 훈련하는 동안에만 작동한다.)

ActivityRegularization 층을 제거하고 이전 층에서 activity_regularier=tf.keras.regularizers.l1(1e-4)로 지정해도 동일하다.

이 규제는 신경망이 0에 가까운 코딩을 만들도록 유도하지만 입력이 올바르게 재구성하지 못하면 벌칙을 받기 때문에 적어도 0이 아닌 값이 조금은 출력되어야 한다. 

l2 노름 대신 l1 노름을 사용하면 신경망이 모든 코딩을 감소시키는 대신 입력 이미지에서 불필요한 것을 제거하고 가장 중요한 코딩을 보전하도록 만든다. 

 

훈련 반복마다 코딩 층의 실제 희소 정도를 측정하고 측정된 희소 정도가 타깃 희소 정도와 다르면 모델에 벌칙을 부과하는 방법도 있다.

이를 위해 전체 훈련 배치에 대해 코딩 층에 있는 각 뉴런의 평균적인 활성화를 계산한다.

배치 크기는 너무 작지 않아야 하며 그렇지 않으면 평균값이 정확하지 않을 것이다. 

 

각 뉴런에 대한 평균 활성화 정도를 알면 비용 함수에 희소 손실을 추가하여 너무 활성화되거나 충분히 활성화되지 않은 뉴런에 벌칙을 가할 수 있다.  비용 함수에 제곱 오차를 추가하는 방법이 있다. 

→ 실전에서 더 좋은 방법은 평균 제곱 오차보다 훨씬 강한 그레이디언트를 가질 쿨백-라입르러 발산을 사용하는 것이다. 

 

두 개의 이산 확률 분포 P와 Q가 주어졌을 때, 이 두 분산 사이의 쿨백-라이블러 발산의 식이다.

코딩 층에서 뉴런이 활성화될 목표 확률 p와 실제 확률 q(훈련 배치에 대한 평균 활성화) 사이의 발산을 측정한다.

 

코딩 층의 각 뉴런에 대해 희소 손실을 계산했다면 이 손실들을 모두 합해서 비용 함수의 결과에 더한다.

희소 손실과 재구성 손실의 상대적 중요도를 제어하기 위해 희소 손실에 희소 가중치 하이퍼파라미터를 곱한다.

이 가중치가 너무 크면 모델이 목표 희소에 가깝게 되겠지만 입력을 적절히 재구성하지 못해서 쓸모없는 모델이 될 수 있다.

반대로 가중치가 너무 작으면 희소 목표를 거의 무시할 것이므로 어떤 흥미로운 특성도 학습하지 못할 것이다. 

 

kl_divergence = tf.keras.losses.kullback_leibler_divergence

class KLDivergenceRegularizer(tf.keras.regularizers.Regularizer):
    def __init__(self, weight, target):
        self.weight = weight
        self.target = target
        
    def __call__(self, inputs):
        mean_activities = tf.reduce_mean(inputs, axis=0)
        return self.weight * (
            kl_divergence(self.target, mean)activities) +
            kl_divergence(1. - self.target, 1. - mean_activities))

KL 발산 규제를 적용하기 위한 사용자 정의 규제이다.

kld_reg = KLDivergenceRegularizer(weight=5e-3, target=0.1)
sparse_kl_encoder = tf.keras.Sequential([
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(100, activation="relu"),
    tf.keras.layers.Dense(300, activation="sigmoid",
                          activity_regularizer=kld_reg)
])
sparse_kl_decoder = tf.keras.Seqeuntial([
    tf.keras.layers.Dense(100, activation="relu"),
    tf.keras.layers.Dense(28 * 28),
    tf.keras.layers.Reshape([28, 28])
])
sparse_kl_ae = tf.keras.Sequential([sparse_kl_encoder, sparse_kl_decoder])

코딩 층의 활성화에 KLDivergenceRegularizer를 적용해 희소 오토인코더를 만든다.

---

17.7 변이형 오토인코더

확률적 오토인코더이다. 훈련이 끝난 후에도 출력이 부분적으로 우연에 의해 결정된다. ↔ 잡음 제거 오토인코더는 훈련 시에만 무작위성을 사용한다.

생성 오토인코더이다. 훈련 세트에서 샘플링된 것 같은 새로운 샘플을 생성할 수 있다.

 

이런 두 속성이 변이형 오토인코더를 RBM과 유사하게 만들지만 훈련이 더 쉽고 샘플링 과정이 훨씬 빠르다.

변이형 오토인코더는 효율적인 근사 베이즈 추론 방식인 변분 베이즈 추론을 수행한다.

베이즈 추론은 베이즈 정리에서 유도된 방정식을 사용하여 새로운 데이터를 기반으로 확률 분포를 업데이트한다.

원래 분포를 사전 분포라고 하고 업데이트된 분포를 사후 분포라고 한다. 

데이터 분포의 좋은 근삿값을 찾는 것이 목적이며 근삿값을 찾으면 이로부터 샘플을 추출할 수 있다.

왼쪽은 변이형 오토인코더이다. 오토인코더의 기본 구조인 인코더와 그 뒤를 따르는 디코더가 있다.

주어진 입력에 대한 코딩을 바로 만드는 대신 인코더는 평균 코딩 μ와 표준 편차 σ를 만든다.

실제 코딩은 평균이 μ이고 표준 편차가 σ인 가우스 분포에서 랜덤하게 샘플링된다.

그 후 디코더가 샘플링된 코딩을 보통처럼 디코딩한다.

 

오른쪽 그림은 이 오토인코더를 통과하는 훈련 샘플을 보여준다.

인코더가 μ와 σ를 만들면 코딩이 랜덤하게 생성된다. 마짐가으로 이 코딩이 디코딩되어 훈련 샘플을 닮은 최종 출력을 만든다. 

 

변이형 오토인코더는 입력이 매우 복잡한 분포를 가지더라도 간단한 가우스 분포에서 샘플링된 것처럼 보이는 코딩을 만드는 경향이 있다.

훈련한느 동안 비용 함수가 코딩을 가우스 샘플들의 군집처럼 보이도록 코딩 공간(잠재 공간) 안으로 점진적으로 이동시킨다.

→ 훈련이 끝난 뒤 새로운 샘플을 매우 쉽게 생성할 수 있다. 가우스 분포에서 랜덤한 코딩을 샘플링해 디코딩하면 된다. 

 

비용 함수는 두 부분으로 구성된다.

오토인코더가 입력을 재생산하도록 만드는 일반적인 재구성 손실(이전처럼 MSE를 사용할 수 있다.)과 단순한 가우스 분포에서 샘플링된 것 같은 코딩을 가지도록 오토인코더를 강제하는 잠재 손실이다. 

목표 분포(가우스 분포)와 실제 코딩 분포 사이의 KL 발산을 사용한다. 

희소 인코더보다 수식이 조금 더 복잡하다. 코딩 층으로 전달될 수 있는 정보량을 제한하는 (→오토인코더가 유용한 특성을 학습) 가우스 잡음 때문이다. 이 식을 간소화하여 잠재 손실을 간단하게 계산할 수 있다.

 

class Sampling(tf.keras.layers.Layer):
    def call(self, inputs):
        mean, log_var = inputs
        return tf.random.normal(tf.shape(log_var)) * tf.exp(log_var / 2) + mean

 

μ와 γ가 주어졌을 때 코딩을 샘플링하는 사용자 정의 층이다. 

이 Sampling 층은 mean(μ)와 log_var(γ)를 입력으로 받는다.

tf.random_normal() 함수를 사용해 평균이 0이고 표준 편차가 1인 정규 분포에서 랜덤한 벡터를 샘플링한다. 

그다음 (σ에 해당하는) exp(γ / 2)를 곱하고 μ를 더한 결과를 반환한다.

이는 평균이 μ이고 표준 편차가 σ인 정규 분포에서 코딩 벡터를 샘플링한다.

codings_size = 10

inputs = tf.keras.layers.Input(shape=[28, 28])
Z = tf.keras.layers.Flatten()(inputs)
Z = tf.keras.layers.Dense(150, activation="relu")(Z)
Z = tf.keras.layers.Dense(100, activation="relu")(Z)
codings_mean = tf.keras.layers.Dense(codings_size)(Z)
codings_log_var = tf.keras.layers.Dense(codings_size)(Z)
codings = Sampling()([codings_mean, codings_log_var])
variational_encoder = tf.ekras.Model(
    inputs=[inputs], outputs=[codings_mean, codings_log_var, codings])

이 모델은 완전히 순차적이지 않기 때문에 함수형 API를 사용해 인코더를 만든다.

codings_mean(μ)와 codings_log_var(γ)를 출력하는 두 Dense 층이 동일한 입력(두 번째 Dense 층의 출력)을 사용한다.

그다음 codings_mean과 codings_log_var를 Sampling 층으로 전달한다.

마지막으로 variational_encoder 모델은 출력 세 개를 마든다.

필요한 것은 codings뿐이지만 조사 목적으로 codings_mean과 codings_log_var도 출력한다.

decoder_inputs = tf.keras.layers.Input(shape=[codings_size])
x = tf.keras.layers.Dense(100, activation="relu")(decoder_inputs)
x = tf.keras.layers.Dense(150, activation-"relu")(x)
x = tf.keras.layers.Dense(28 * 28)(x)
outputs = tf.keras.layers.Reshape([28, 28])(x)
variational_decoder = tf.keras.Model(inputs=[decoder_inputs], outputs=[outputs])

디코더는 함수형 API 대신 시퀀셜 API를 사용할 수 있다.

지금까지 만들었던 여러 디코더와 동일하게 층을 쌓은 것이기 때문이다.

_, _, codings = variational_encoder(inputs)
reconstructions = variational_decoder(codings)
variational_ae = tf.keras.Model(inputs=[inputs], outputs=[reconstructions])

마지막으로 변이형 오토인코더 모델을 만든다.

인코더의 처음 두 개 출력을 무시한다. (코딩에 디코더만 주입한다.) 마지막으로 잠재 손실과 재구성 손실을 추가한다.

latent_loss = -0.5 * tf.reduce_sum(
    1 + codings_log_var - tf.exp(codings_log_var) - tf.square(codings_mean),
    axis=-1)
variational_ae.add_loss(tf.reduce_mean(latent_loss) / 784.)

오토인코더의 잠재 손실 식을 적용해 마지막 축을 따라 더해서 배치에 있는 각 샘플의 잠재 손실을 계산한다.

그다음 배치에 있는 모든 샘플의 평균 손실을 계산하고 재구성 손실에 비례해 적절한 크기가 되도록 나눈다.

실제로 변이형 오토인코더의 재구성 손실은 픽셀마다 재구성 오차의 합이다. 

하지만 케라스가 mse 손실을 계산할 때 합이 아니라 n개 전체 픽셀의 평균을 계산한다. -> 필요한 것보다 재구성 손실이 n배 작다. 

variational_ae.compile(loss="mse", optimizer="nadam")
history = variational_ae.fit(X_train, X_train, epochs=25, batch_size=128,
                             validation_data=(X_valid, X_valid))

오토인코더를 컴파일하고 훈련한다.

17.7.1 패션 MNIST 이미지 생성하기

codings = tf.random.normal(shape=[3 * 7, codings_size])
images = variational_decoder(codings).numpy()

변이형 오토인코더를 사용해 패션 의류처럼 보이는 이미지를 생성한다.

가우스 분포에서 랜덤한 코딩을 샘플링하여 디코딩한다.

 

변이형 오토인코더는 시맨틱 보간을 수행할 수 있다. 

두 이미지가 겹쳐 보이는 것 같은 픽셀 수준의 보간 대신 코딩 수준에서 두 이미지를 보간할 수 있다.

예) 잠재 공간에 있는 임의의 선분을 따라 몇 개의 코딩을 선택하여 디코딩하면, 점진적으로 바뀌는 연속된 이미지를 얻을 수 있다. 

codings = np.zeros([7, codings_size])
codings[:, 3] = np.,inspace(-0.8, 0.8, 7)
images = variational_decoder(codings).numpy()

---

17.8 생성적 적대 신경망

생성자 : 랜덤한 분포(일반적으로 가우스 분포)를 입력으로 받고 이미지와 같은 데이터를 출력한다. 

랜덤한 입력은 생성할 이미지의 잠재 표현(코딩)으로 생각할 수 있다.

생성자는 변이형 오토인코더의 디코더와 같은 기능을 제공한다.

→ 동일한 방식으로 새로운 이미지를 생성할 수 있다.(가우스 잡음을 주입하여 완전히 새로운 이미지를 출력한다.)

판별자 : 생성자에서 얻은 가짜 이미지나 훈련 세트에서 추출한 진짜 이미지를 입력으로 받아 입력된 이미지가 가짜인지 진짜인지 구분한다.

 

훈련하는 동안 생성자와 판별자의 목표는 반대이다.

판별자는 진짜 이미지와 가짜 이미지를 구분하고 생성자는 판별자를 속일 만큼 진짜 같은 이미지를 만든다.

GAN은 다른 목표를 가진 두 개의 네트워크로 구성되므로 일반적인 신경망처럼 훈련할 수 없다.

 

먼저 판별자를 훈련한다. 훈련 세트에서 실제 이미지 배치를 샘플링하고 생성자에서 생성한 동일한 수의 가짜 이미지를 합친다. 가짜 이미지의 레이블은 0으로, 진짜 이미지는 1로 설정한다. 판별자는 이진 크로스 엔트로피를 사용해 한 스텝 동안 이렇게 레이블된 배치로 훈련된다. 이 단계에서 역전파는 판별자의 가중치만 최적화한다.

그다음 생성자를 훈련한다. 먼저 생성자를 사용해 다른 가짜 이미지 배치를 만든다. 다시 판별자를 사용해 이미지가 진짜인지 가짜인지 판별한다. 배치에 진짜 이미지를 추가하지 않고 레이블을 모두 1(진짜)로 설정한다. 생성자가 판별자가 진짜라고 믿을 만한 이미지를 만들어야 한다. 이 단계 동안에는 판별자의 가중치를 동결하는 것이 중요하며 역전파는 생성자의 가중치에만 영향을 미친다. 

 

codings_size = 30

Dense = tf.keras.layers.Dense
generator = tf.keras.Sequential([
    Dense(100, activation="relu", kernel_initializer="he_normal"),
    Dense(150, activation="relu", kernel_initializer="he_normal"),
    Dense(28 * 28, activation="sigmoid"),
    tf.keras.layers.Reshape([28, 28])
])

discriminator = tf.keras.Sequential([
    tf.keras.layers.Flatten(),
    Dense(150, activation="relu", kernel_initializer="he_normal"),
    Dense(100, activation="relu", kernel_initializer="he_normal"),
    Dense(1, activation="sigmoid")
])
gan = tf.keras.Sequential([generator, discriminator])

생성자와 판별자를 만들어야 한다.

생성자는 오토인코더의 디코더와 비슷하며 일반적인 이진 분류기이다.

(이미지를 입력으로 받고 하나의 유닛과 시그모이드 활성화 함수를 사용한 Dense 층으로 끝난다.)

각 훈련 반복의 두 번째 단계에서 생성자와 판별자가 연결된 전체 GAN 모델이 필요하다. 

discriminator.compile(loss="binary_crossentropy", optimizer="rmsprop")
discriminator.trainable = False
gan.compile(loss="binary_crossentropy", optimizer="rmsprop")

이 모델들을 컴파일한다.

판별자는 이진 분류기이므로 이진 크로스 엔트로피 손실을 사용한다.

gan 모델도 이진 분류기이므로 이진 크로스 엔트로피 손실을 사용한다.

하지만 생성자는 gan 모델을 통해서만 훈련되기 때문에 따로 컴파일할 필요가 없다.

두 번째 단계에서 판별자를 훈련하면 안 된다. (중요)

→ gan 모델을 컴파일하기 전에 판별자가 훈련되지 않도록 설정해야 한다.

batch_size = 32
dataset = tf.data.Dataset.from_tensor_slices(X_train).shuffle(buffer_size=1000)
dataset = dataset.batch(batch_size, drop_remainder=True).prefetch(1)

훈련이 일반적인 반복이 아니므로 fit() 메서드를 사용할 수 없다.

대신 사용자 정의 훈련 반복문을 만들어야 하며 먼저 이미지를 순회하는 Dataset을 만들어야 한다.

def train_gan(gan, dataset, batch_size, codings_size, n_epochs):
    generator, discriminator = gan.layers
    
    for epoch in range(n_epochs):
        for X_batch in dataset:
            # 단계 1 - 판별자 훈련
            noise = tf.random.normal(shape=[batch_size, codings_size])
            generated_images = generator(noise)
            X_fake_and_real = tf.concat([generated_images, X_batch], axis=0)
            y1 = tf.constant([[0.]] * batch_size + [[1.]] * batch_size)
            discriminator.train_on_batch(X_fake_and_real, y1)
            # 단계 2 - 생성자 훈련
            noise = tf.random.normal(shape=[batch_size, codings_size])
            y2 = tf.constant([[1.]] * batch_size)
            gan.train_on_batch(noise, y2)
            
train_gan(gan, dataset, batch_size, codings_size, n_epochs=50)

각 반복마다 두 단계가 있다. 

가우스 잡음을 생성자에 주입하여 가짜 이미지를 생성한다. 이와 동일한 개수의 진짜 이미지를 합쳐서 배치를 완성한다. 타깃 y1는 가짜 이미지일 경우 0, 진짜 이미지는 1로 설정한다. 이 배치에서 판별자를 훈련한다. 이 단계에서는 판별자만 훈련된다.

GAN에 가우스 잡음을 주입한다. 생성자가 먼저 가짜 이미지를 생성하고 판별자가 이 이미지가 가짜인지 진짜인지 추측한다. 이 단계에서 생성자를 향상시켜야 한다. 즉, 판별자가 실패해야 한다. 이 때문에 타깃 y2를 1로 지정한다. 이 단계에서는 판별자가 훈련되지 않으므로 gan 모델에서 향상되는 부분은 생성자뿐이다.

codings = tf.random.normal(shape=[batch_size, codings_size])
generated_images = generator.predict(codings)

훈련이 끝난 후에 가우스 분포에서 랜덤하게 코딩을 샘플링하여 생성자에 주입하면 새로운 이미지를 얻을 수 있다.

17.8.1 GAN 훈련의 어려움

훈련이 진행됨에 따라 내시 균형이라 부르는 상태에 다다를 수 있다.

다른 플레이어가 전략을 수정하지 않을 것이므로 어떤 플레이어도 자신의 전략을 수정하지 않으려는 상태를 말한다.

GAN을 충분히 오래 훈련하면 완벽한 생성자를 만들어 이 균형에 도달할 것이지만 어떤 것도 이 균형에 도달할 것이라 보장하지 않는다.

생성자의 출력의 다양성이 줄어들 때 모드 붕괴가 발생한다. 

생성자와 판별자가 지속적으로 서로에게 영향을 주기 때문에 파라미터 변동이 크고 불안정해질 수 있다.

 

경험 재생 기법은 매 반복에서 생성자가 만든 이미지를 (오래된 이미지는 삭제하면서) 재생 버퍼에 저장하고 실제 이미지와 (현재 생성자가 만든 가짜 이미지가 아니라) 이 버퍼에서 뽑은 가짜 이미지를 더해서 판별자를 훈련한다. 

이는 판별자가 생성자의 가장 최근 출력에 과대적합될 가능성을 줄인다. 

미니배치 판별 기법은 배치 간에 얼마나 비슷한 이미지가 있는지 측정하여 판별자에게 제공한다. 

판별자는 다양성이 부족한 가짜 이미지 배치 전체를 쉽게 거부할 수 있다. -> 모드 붕괴 위험을 줄인다.

17.8.2 심층 합성곱 GAN

[안정적인 합성곱 GAN을 구축하기 위해 제안된 주요 가이드라인]

판별자에 있는 풀링 층을 스트라이드 합성곱으로 바꾸고 생성자에 있는 풀링 층은 전치 합성곱으로 바꾼다.

생성자와 판별자에 배치 정규화를 사용한다. 생성자의 출력 층과 판별자의 입력 층은 제외한다.

층을 깊게 쌓기 위해 완전 연결 은닉 층을 제거한다.

tanh 함수를 사용해야 하는 출력 층을 제외하고 생성자의 모든 층은 ReLU 활성화 함수를 사용한다.

판별자의 모든 층은 LeakyReLU 활성화 함수를 사용한다.

17.8.3 ProGAN

훈련 초기에 작은 이미지를 생성하고 점진적으로 생성자와 판별자에 합성곱 층을 추가해 갈수록 큰 이미지를 만든다.

이전에 훈련된 층은 그대로 훈련 가능하게 두고 생성자의 끝과 판별자의 시작 부분에 층을 추가한다.

생성자의 출력을 4x4에서 8x8로 크게 하려면 기존 합성곱 층(합성곱 층 1)에 (최근접 이웃 필터링을 사용한) 업샘플링 층을 추가하여 8x8 크기 특성 맵을 출력한다.

이 특성 맵이 새로운 합성곱 층(합성곱 층 2)으로 주입되고 다시 새로운 출력이 합성곱 층으로 주입된다.

합성곱 층 1의 훈련된 가중치를 잃지 않기 위해 두 개의 새로운 합성곱 층을 점진적으로 페이드-인하고 원래 출력 층을 페이드-아웃한다.

이렇게 하기 위해 새로운 출력(가중치 α)과 원래 출력(가중치 1 - α)의 가중치 합으로 최종 출력을 만든다.

비슷한 페이드-인/페이드-아웃 기버이 판별자에 새로운 합성곱 층을 추가할 때 사용된다. (다운샘플링을 위해 평균 풀링 층이 뒤따른다.)

모든 합성곱 층은 "same" 스트라이드 1을 사용하므로 입력의 높이와 너비를 보존한다.

원래 합성곱 층도 마찬가지이다.

따라서 8x8 출력을 만든다.

출력 층의 커널 크기는 1이다. 이를 사용해 입력을 필요한 컬러 채널 수로 투영한다. 

 

미니배치 표준 편차 층

판별자의 마지막 층 근처에 추가한다.

S = tf.math.reduce_std(inputs, axis=[0, -1]))

입력에 있는 모든 위치에 대해 모든 채널과 배치의 모든 샘플에 걸쳐 표준편차를 계산한다.

 

v = tf.reduce_mean(S))

이 표준 편차를 모든 픽셀에 대해 평균하여 하나의 값을 얻는다.

tf.concat([inputs, tf.fill([batch_size, height, width, 1], v)], axis=-1)

추가적인 특성 맵이 모든 샘플에 추가되고 앞서 계산된 하나의 값으로 채워진다. 

 

이 층 덕분에 판별자는 이러한 통계를 쉽게 얻을 수 있고 다양성이 아주 적은 이미지를 만드는 생성자에게 속을 가능성이 줄어든다.

 

동일한 학습 속도

He 초기화 대신 평균이 0이고 표준 편차가 1인 가우스 분포를 사용해 모든 가중치를 초기화한다.

하지만 런타임에(층이 실행될 때마다) He 초기화에 있는 동일한 인자로 가중치의 스케일을 낮춘다.

옵티마이저들은 각자 추정한 표준 편차로 그래이디언트 업데이트를 정규화한다.

→ 다이내믹 레인지가 큰 파라미터는 훈련하는 데 시간이 오래 걸리고, 작은 파라미터는 너무 빠르게 업데이트되어 불안정해질 수 있다. 

가중치 초기화에서 스케일을 맞추지 않고 모델의 한 부분으로 가중치를 조절함으로써 훈련 내내 모든 파라미터의 다이내믹 레인지를 동일하게 만든다.

따라서 모든 가중치가 동일한 속도로 학습된다.

 

픽셀별 정규화 층

생성자의 합성곱 층 뒤에 추가한다.

동일한 이미지의 동일 위치에 있는 모든 활성화를 채널에 대해 정규화를 수행한다. (활성화의 제곱 평균의 제곱근으로 나눈다.)

inputs / tf.sqrt(tf.reduce_mean(tf.square(X), axis=-1, keepdims=True) + 1e - 8)

생성자와 판별자 사이의 과도한 경쟁으로 활성화 값이 폭주하는 것을 막는다. 

 

생성된 이미지의 다양성을 자동으로 평가할 수 있지만 품질을 판단하는 것은 훨씬 까다롭고 주관적인 문제이다.

생성된 이미지와 훈ㄹ녀 이미지의 국부적인 구조 사이의 유사도를 여러 규모로 측정하는 방법이 제안되었다.

17.8.4 StyleGAN

생성자에 스타일 트랜스퍼 기법을 사용해 생성된 이미지가 훈련된 이미지와 같은 다양한 크기의 국부적인 구조를 갖도록 만들어졌다.

판별자와 손실함수는 그대로 구도 생성자만 변경했으며, 생성된 이미지의 품질을 크게 높여준다. 

네트워크 두 개로 구성된다.

 

매핑 네트워크

8개의 MLP가 잠재 표현 z(코딩)를 벡터 w로 매핑한다.

이 벡터는 여러 아핀 변환으로 전달되어 벡터 여러 개를 생성한다. 

이 벡터는 미세한 텍스처부터 고수준 특성까지 각기 다른 수준으로 생성된 이미지의 스타일을 제어한다.

코딩을 여러 스타일 벡터로 매핑한다. 

합성 네트워크

이미지 생성을 책임진다.

일정하게 학습된 입력을 받는다. (훈련이 끝난 후에 입력이 일정해지고 훈련하는 동안에는 역전파에 의해 계속 바뀐다.)

이 입력을 합성곱 층 여러 개와 업샘플링 층에 통과시킨다.

입력과 활성화 함수 전에 있는 모든 합성곱 층의 출력에 잡음이 조금 섞인다.

잡음이 섞인 다음에 적응적 인스턴스 정규화(AdaIN) 층이 따른다.

각 특성 맵을 독립적으로 표준화한 다음 스타일 벡터를 사용해 각 특성 맵의 스케일과 이동을 결정한다

스타일 벡터에는 특성 맵마다 하나의 스케일과 하나의 편향이 포함된다.

 

[StyleGAN의 생성자 구조]

 

코딩과 독립적으로 잡음을 추가하는 게 중요하다.

초기 GAN에서는 이런 무작위성이 코딩이나 생성자 자체에서 만든 랜덤한 잡음에서 왔다.

잡음이 코딩에서 온다는 것은 생성자가 코딩의 표현 능력의 상당 부분을 잡음을 저장하는 데 할애한다는 것을 의미한다. (손해)

이 잡음이 네트워크를 통과하여 생성자의 마지막 층에 도달할 수 있어야 한다. (훈련 속도를 느리게 하는 불필요한 제약 사항)

각기 다른 수준에서 동일한 잡음이 사용되기 때문에 일부 인공적인 요소가 나타날 수 있다.

생성자가 랜덤한 잡음을 스스로 만들어낸다면 실제처럼 보이지 않고 더욱 인공적으로 보일 것이다. (네트워크 능력 낭비)

→ 별도의 잡음 입력을 추가하면 모든 이슈가 사라진다.

GAN은 추가된 잡음을 사용하여 이미지의 각 부분에 정확한 양의 무작위성을 추가할 수 있다. 

 

추가된 잡음은 각 수준마다 다르다.

잡음 입력은 하나의 특성 맵을 채우는 가우스 잡음으로 구성되며 해당 수준의 모든 특성 맵으로 브로드캐스팅된다.

그런 다음 추가되기 전에 학습된 특성별 스케일링 인자로 조정된다.

 

StyleGAN은 일정 비율의 이미지를 두 개의 다른 코딩으로 생성하는 믹싱 규제(스타일 믹싱) 기법을 사용한다. 

코딩 c_1과 c_2가 매핑 네트워크를 통과하여 두 스타일 벡터 w_1과 w_2를 만든다.

그다음 합성 네트워크가 첫 번째 단계에서는 스타일 w_1, 나머지 단계에서는 스타일 w_2를 바탕으로 이미지를 생성한다.

변경되는 단계는 랜덤하게 선택된다.

→ 네트워크가 인접한 수준의 스타일이 상관관계를 가진다고 가정하지 못하도록 막는다.

각 스타일 벡터가 생성된 이미지에 있는 제한된 개수의 속성에만 영향을 미치는 StyleGAN의 국지성을 촉진시킨다.

---

17.9 확산 모델

잡음 제거 확산 확률 모델(DDPM)은 GAN보다 훈련하기 훨씬 쉽고 생성되는 이미지가 더 다양하고 품질이 훨씬 더 높다.

하지만 GAN이나 VAE에 비해 이미지를 생성하는 데 시간이 매우 오래 걸린다.

타임 스텝 t마다 평균이 0이고 분산이 β_t인 가우스 잡음을 이미지에 조금씩 추가한다. 이 잡음음 각 픽셀마다 독립적이다. (등방성)

x_1, x_2 등으로 시작해서 고양이가 잡음에 완전히 가려져 보이지 않는 이미지를 얻는다. 마지막 타임 스텝은 T로 나타낸다.

즉, 점진적으로 고양이를 잡음으로 뒤덮는다. (정방향 과정)

 

정방향 과정에서 가우스 잡음을 점점 더 많이 추가하면 픽셀값이 점점 더 가우스 분포가 된다.

매 단계마다 픽셀값이 root_(1 - β_t) 비율로 조금씩 조정된다.

스케일링 계수가 1보다 약간 작기 때문에 픽셀값의 평균이 점차 0에 가까워진다.

또한 분산이 점차 1에 수렴하도록 보장한다.

픽셀값의 표준 편차가 root_(1 - β_t)로 스케일 조정되므로 분산은 1 - β_t(스케일링 계수의 제곱)로 스케일 조정된다.

각 단계에서 분산 β_t를 갖는 가우스 잡음을 추가하기 떄문에 분산은 0으로 줄어들 수 없다. 

 

[정방향 확산 과정의 확률 분포 q]

x_0이 주어지면 x_1, x_2, ..., x_t-1을 계산할 필요 없이 이미지 x_t를 샘플링할 수 있다.

여러 가우스 분포의 합도 가우스 분포이기 때문에 모든 잡음을 한 번에 추가할 수 있다.

 

x_t에서 x_(t - 1)로 가는 역방향 과정을 수행할 수 있는 모델을 훈련시켜야 한다. 

그런 다음 이 모델을 사용하여 이미지에서 작은 잡음을 제거하고 모든 잡음이 사라질 때까지 이 작업을 여러 번 반복한다.

고양이 이미지가 많이 포함된 데이터셋에서 모델을 훈련시킨 다음 가우스 잡음으로 가득 찬 사진을 제공하면 모델이 점차 새로운 고양이가 나타나게 만들 것이다. 

 

정방향 과정을 만들기 위해선 분산 스케줄을 구현해야 한다.

def variance_schedule(T, s=0.008, max_veta=0.999):
    t = np.arrange(T + 1)
    f = np.cos((t / T + s) / (1 + s) * np.pi / 2) ** 2
    alpha = np.clip(f[1:] / f[:-1], 1 - max_beta, 1)
    alpha = np.append(1, alpha).astype(np.float32)
    beta = 1 - alpha
    alpha_cumprod = np.cumprod(alpha)
    return alpha, alpha_cumprod, beta
    
T = 4000
alpha, alpha_cumprod, beta = variance_schedule(T)

def prepare_batch(X):
    X = tf.cast(X[..., tf.newaxis]. tf.float32) * 2 - 1
    X_shape = tf.shape(X)
    t = tf.random.uniform([X_shape[0]], minval=1, maxval=T + 1, dtype=tf.int32)
    alpha_cm = tf.gather(alpha_cumprod, t)
    alpha_cm = tf.reshape(alpha_cm, [X_shape[0]] + [1] * (len(X_shape) - 1))
    noise = tf.random.normal(X_shape)
    return {
        "X_noisy": alpha_cm ** 0.5 * X + (1 - alpha_cm) ** 0.5 * noise,
        "time": t,
    }, noise

채널 축을 추가해야 한다. 픽셀값을 -1에서 1로 스케일 조정하여 평균이 0이고 분산이 1인 최종 가우스 분포에 가깝게 만든다.

배치의 각 이미지에 대해 1에서 T 사이의 임의의 타임 스텝을 포함하는 벡터 t를 생성한다.

tf.gather()를 사용하여 벡터 t의 각 타임 스텝에 대한 alpha_cumprod 값을 추출한다. 각 이미지에 대해 짝대기 α_t 값이 하나씩 포함된 벡터 alpha_cm이 만들어진다.

alpha_cm을 [배치 크기]에서 [배치 크기, 1, 1, 1]로 크기를 바꾼다. (배치 X에 alpha_cm을 브로드캐스팅하기 위해)

평균이 0이고 분산이 1인 가우스 잡음을 생성한다.

위의 식을 사용하여 이미지에 확산 과정을 적용한다. 이 함수는 입력과 타깃을 포함하는 튜플을 반환한다. 입력은 잡음 이미지와 이미지 생성에 사용된 타임 스텝이 포함된 파이썬 딕셔너리로 표현된다. 타깃은 각 이미지를 생성하는 데 사용된 가우스 잡음이다. 

 

이런 설정으로 모델은 원본 이미지를 얻기 위해 입력 이미지에서 빼야 하는 잡음을 예측한다.

 

def prepare_dataset(X, batch_size=32, shuffle=False):
    ds = tf.data.Datase.from_tensor_slices(X)
    if shuffle:
        ds = ds.shuffle(buffer_size=10_000)
    return ds.batch(batch_size).map(prepare_batch).prefetch(1)

train_set = prepare_dataset(X_train, batch_size=32, shuffle=True)
valid_set = prepare_dataset(X_valid, batch_size=32)

훈련 데이터셋과 검증 데이터셋을 만들고 모든 배치에 prepare_batch() 함수를 적용한다.

이전처럼 X_train과 X_valid에는 픽셀값이 0에서 1 사이인 패션 MNIST 이미지가 담겨있다.

def build_diffusion_model():
    X_noisy = tf.keras.layers.Input(shape=[28, 28, 1], name="X_noisy")
    time_input = tf.keras.layers.Input(shape=[], dtype=tf.int32, name="time")
    [...]
    outputs = [...]
    return tf.keras.Model(inputs=[X_noisy, time_input], outputs=[outputs])

확산 모델을 만들 수 있다. 잡음 이미지와 타임 스텝을 입력으로 받고 입력에서 뺄 잡음을 예측할 수 있다면 어떤 모델이든 가능하다.

model = build_deffusion_model()
model.compile(loss=tf.keras.losses.Huber(), optimizer="nadam")
history = model.fit(train_set, validation_data=valid_set, epochs=100)

모델을 훈련할 수 잇다.

 

모델을 훈련하고 나면 이를 사용하여 새로운 이미지를 생성할 수 있다.

역방향 확산 과정에는 지름길이 없다.

평균이 0이고 분산이 1인 가우스 분포에서 x_T를 랜덤으로 샘플링한 다음 모델에 전달하여 잡음을 예측한다.

그다음 식을 이용하여 이미지에서 잡음을 뺀다.

x_0가 될 때까지 과정을 반복한다.

이 식에서 ε_θ(x_t, t)는 입력 이미지 x_t와 타임 스텝 t가 주어졌을 때 모델이 예측한 잡음을 나타낸다. 

θ은 모델 파라미터를 나타낸다. z는 평균이 0이고 분산이 1인 가우스 잡음이다.

 

def generate(model, batch_size=32):
    X = tf.random.normal([batch_size, 28, 28, 1])
    for t in range(T, 0, -1):
        noise = (tf.random.normal if t > 1 else tf.zeros)(tf.shape(X))
        X_noise = model({"X_noisy": X, "time": tf.constant([t] * batch_size)})
        X = (
            1 / alpha[t] ** 0.5
            * (X - beta[t] / (1 - alpha_cumprod[t]) ** 0.5 * X_noise)
            + (1 - alpha[t]) ** 0.5 * noise
        )
    return X

X_gen = generate(model)

모델을 여러 번 호출해야 하므로 이미지 생성 속도가 느리다. 

 

잠재 확산 모델 : 강력한 오토인코더를 사용하여 훈련 이미지를 훨씬 더 작은 잠재 공간으로 압축하여 확산 과정을 수행한다.

그다음 오토인코더를 사용하여 최종 잠재 표현의 압축을 풀고 출력 이미지를 생성한다.

이미지 생성 속도가 상당히 빨라지고 훈련 시간과 비용이 크게 줄어들며 생성된 이미지의 품질이 아주 뛰어나다.