エンコーダ（変オートエンコーダ）からの変化量に

著者：SnowYuan

1.VAEプロフィール

エンコーダからの変化（変オートエンコーダ、VAE）は生成モデルである（生成モデル）Aは、他の一般的な生成モデルは、ネットワーク（ジェネレーティブ敵対ネットワーク、GAN）に対する式で、ここでは、VAEを紹介します原則、および実装Keras。
変分オートエンコーダのクール。彼らは私たちは、複雑なデータモデルの生成を設計し、その大規模なデータセットのためにしましょう。彼らはフィクションのイメージと高解像度デジタルアートの有名人の顔を生成することができます。また、最先端の機械学習の成果を生み出し学習の画像生成・強化の観点からこれらのモデル。次の図に示す顔モデル生成VAEと架空の有名人

自動エンコーダの変動が仮想面セレブを生成し、図1

2. VAE原則

確率の観点から、我々は、任意のデータセットが分布Pからサンプリングされることを前提とし（X | z）は、Zは、手書きのデジタル画像Xのような特定の内部機能を表す隠れ変数であり、Zは、フォントサイズを表すことができ、スタイル、太字、イタリックおよびその他の設定を書いて、それは事前分布と一致して、特定の隠された変数zが与えられたとき、私たちは一連のサンプルを生成するために、サンプルの分布から学ぶことができ、これらのサンプルは、zを持っています共通の表現。
知らP（Z）で（それは、このようなN（0,1）の条件下として知られているディストリビューションと一致していると仮定することができ、私たちの目的は、（Xを確率モデルPを生成するために学ぶことです|。我々は、最大を採用することができZ）尤推定（最尤推定）：良いモデルは、農産物サンプルに高い確率が私たちの世代は、モデルをパラメータ化するために使用されている場合∈Dが観察されているxはいるはず、例えば、我々はニューラルネットワークデコーダで学び、。これはなど、B、W右デコーダ値は、ニューラルネットワークを最適化する私たちの目標はされています

zは連続変数であるため残念ながら、積分が離散的な形に変換することができない、式を直接リード最適化することは困難です。

の|（Z x）が（| | Z x）が、最適化のqに、すなわち必要性（Z x）とPおおよそPへ|（X、Z）変分推論を使用して、思考の行を変更します（変分推論）の考え方は、我々は分布qを採用しました間の距離：

：KLダイバージェンスがpの分布の尺度であり、Q間のギャップの測定は、と定義され

、我々は世代モデルではなく、漠然としたデータ構造を構築しようとしている、あなたが絵を「思い出す」ことができます。別に画像符号化から、我々は潜在的なベクトルを作成する方法を知らないので、我々はまた、何かを生成することはできません。ここでは簡単な解決策です。我々は、潜在的なベクトルユニットは、一般的にガウス分布に従う生成するためにそれを強制的に、ネットワーク符号化に制約を追加しました。これは、エンコーダからの標準から分離エンコーダからのこの変分制約です。新しい画像を生成する非常に簡単になりました：私たちが行う必要があるすべては、ユニットからの潜在的なベクトルzをサンプリングし、そのガウスマトリクスデコーダーによってされます。
実際には、私たちのネットワークとどのように正確に潜在変数ガウス分布の単位を表現するために、我々はネットワークを聞かせすることを決定するためにどのくらい近いか比較検討する必要があります。ネットワーク平均二乗誤差の再構成画像の精度の尺度である世代の損失、およびKLダイバージェンスである潜在的損失、測定値の潜在変数と単位ガウス分布：私達の損失項目については、我々は、2つの別個の損失を要約しますマッチング度。
generation_loss =平均（スクエア（generated_image - real_image））
latent_loss = KL-発散（latent_variable、unit_gaussian）
損失= generation_loss + latent_loss
KLダイバージェンスを、私たちは、単純な再パラメータ化技術を適用する必要が最適化するために：実際の値を生成しないエンコーダベクトル、それは平均ベクトルと標準偏差ベクトルを生成します。

KL散度计算如下：
#z_meanとz_stddevエンコーダネットワークによって生成された2つのベクトルで
latent_loss = 0.5 * tf.reduce_sum（tf.square（z_mean）+ tf.square（z_stddev） - tf.log（tf.square（z_stddev）） - 1,1）

我々は、損失デコーダネットワークを計算するとき、私たちは私たちのように、その後の和とベクトルポテンシャルの標準偏差、からサンプリング

サンプル= tf.random_normal（[BATCHSIZE、n_z]、0,1、DTYPE = tf.float32）
sampled_z = z_mean +（z_stddev *サンプル） *

私たちは潜在的に超えた確率変数を生成するためにできることに加えて、この制約は、ネットワークの私達の汎化能力を向上させました。

3.ネットワーク定義

（| X z）は、前P（z）は、デコーダP（x | z）はエンコーダQ：VAEは、3つの部分から構成されています。

図2 VAEネットワーク構造

4.VAE MNIST戦闘

潜在的なスペースをサンプリングすることにより、我々はデコーダネットワークを使用して生成することができるモデルを形成することができ、モデルは、新しいトレーニング期間に観測されたデータと同様に生成することができます。具体的には、我々は、サンプリングされた事前分布p（z）は、ガウス分布に従う単位であると仮定されます。図3は、デコーダネットワーク生成にエンコーダから手書きMNISTトレーニング変化を介してデジタルデータのデータセット。ここでは、グリッド値の二次元ガウス関数からサンプリングし、そしてショーデコーダの出力は、私たちのネットワーク。

図3 VAEデジタルモデル生成手書き

あなたは、潜在的な空間の異なる領域に異なる数の存在のそれぞれを見て、スムーズに他のデジタル数に1から変更することができたよう。あなたは2回の観察の間でデータを挿入したい場合は、この円滑な移行には、このような最近の例として、非常に便利であるGoogleがモデルを確立するために2つの音楽サンプルの間に挿入されます。

次のようにサンプルコードは次のとおりです。

import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
import tensorflow.keras as kr
from keras import backend as K
%matplotlib inline

# MNIST Dataset parameters.
num_features = 784 # data features (img shape: 28*28).

# Training parameters.
batch_size = 128
epochs = 50

# Network Parameters
hidden_1 = 128 # 1st layer num features.
hidden_2 = 64 # 2nd layer num features (the latent dim).

from tensorflow.keras.datasets import mnist, fashion_mnist


def load_data(choice='mnist', labels=False):
    if choice not in ['mnist', 'fashion_mnist']:
        raise ('Choices are mnist and fashion_mnist')

    if choice is 'mnist':
        (X_train, y_train), (X_test, y_test) = mnist.load_data()
    else:
        (X_train, y_train), (X_test, y_test) = fashion_mnist.load_data()

    X_train, X_test = X_train / 255., X_test / 255.
    X_train, X_test = X_train.reshape([-1, 784]), X_test.reshape([-1, 784])
    X_train = X_train.astype(np.float32, copy=False)
    X_test = X_test.astype(np.float32, copy=False)

    if labels:
        return (X_train, y_train), (X_test, y_test)
    return X_train, X_test

def plot_digits(X, y, encoder, batch_size=128):
    # display a 2D plot of the digit classes in the latent space
    z_mean, _, _ = encoder.predict(X, batch_size=batch_size)
    plt.figure(figsize=(12, 10))
    plt.scatter(z_mean[:, 0], z_mean[:, 1], c=y)
    plt.colorbar()
    plt.xlabel("z[0] Latent Dimension")
    plt.ylabel("z[1] Latent Dimension")
    plt.show()


def generate_manifold(decoder):
    """Generates a manifold of MNIST digits from a random noisy data.
    """
    # display a 30x30 2D manifold of digits
    n = 30
    digit_size = 28
    figure = np.zeros((digit_size * n, digit_size * n))

    # linearly spaced coordinates corresponding to the 2D plot
    # of digit classes in the latent space
    grid_x = np.linspace(-4, 4, n)
    grid_y = np.linspace(-4, 4, n)[::-1]

    for i, yi in enumerate(grid_y):
        for j, xi in enumerate(grid_x):
            z_sample = np.array([[xi, yi]])
            x_decoded = decoder.predict(z_sample)
            digit = x_decoded[0].reshape(digit_size, digit_size)
            figure[i * digit_size: (i + 1) * digit_size,
            j * digit_size: (j + 1) * digit_size] = digit

    plt.figure(figsize=(10, 10))
    start_range = digit_size // 2
    end_range = n * digit_size + start_range + 1
    pixel_range = np.arange(start_range, end_range, digit_size)
    sample_range_x = np.round(grid_x, 1)
    sample_range_y = np.round(grid_y, 1)

    plt.xticks(pixel_range, sample_range_x)
    plt.yticks(pixel_range, sample_range_y)
    plt.xlabel("z[0] Latent Dimension")
    plt.ylabel("z[1] Latent Dimension")
    plt.imshow(figure, cmap='Greys_r')
    plt.show()

def sampling(args):
    z_mean, z_log_var = args
    # eps = K.random_normal(tf.shape(z_log_var), dtype=tf.float32, mean=0., stddev=1.0, name='epsilon')
eps = K.random_normal(tf.shape(z_log_var), dtype=tf.float32, mean=0., stddev=1.0)
z = z_mean + tf.exp(z_log_var / 2) * eps
return z

# Encoder
inputs = kr.layers.Input(shape=(num_features, ), name='input')
x = kr.layers.Dense(hidden_dim, activation='relu')(inputs)
z_mean = kr.layers.Dense(latent_dim, name='z_mean')(x)
z_log_var = kr.layers.Dense(latent_dim, name='z_log_var')(x)

### Use reparameterization trick to push the sampling out as input
z = kr.layers.Lambda(sampling, name='z')([z_mean, z_log_var])

### instantiate encoder model
encoder = kr.Model(inputs, [z_mean, z_log_var, z], name='encoder')
encoder.summary()

# Decoder
latent_inputs = kr.layers.Input(shape=(latent_dim), name='z_sampling')
x = kr.layers.Dense(hidden_dim, activation='relu')(latent_inputs)
outputs = kr.layers.Dense(num_features, activation='sigmoid')(x)

#### instantiate decoder model
decoder = kr.Model(latent_inputs,outputs, name='decoder')
decoder.summary()
## VAE model = encoder + decoder
outputs = decoder(encoder(inputs)[2]) # select the Z value from outputs of the encoder
vae = kr.Model(inputs, outputs, name='vae')

# Define VAE Loss
# Reconstruction loss
reconstruction_loss = tf.losses.mean_squared_error(inputs, outputs)
reconstruction_loss = reconstruction_loss * num_features

# KL Divergence loss
kl_loss = 1+z_log_var - tf.square(z_mean)- tf.exp(z_log_var)
kl_loss = -0.5 * tf.reduce_sum(kl_loss, axis=-1)
vae_loss = tf.reduce_mean(reconstruction_loss + kl_loss )

vae.add_loss(vae_loss)
vae.compile(optimizer='adam')
vae.summary()

# Train Model
(X_train, _), (X_test, y) = load_data('mnist', labels=True)
vae.fit(X_train, epochs=epochs, batch_size=batch_size, validation_data=(X_test, None))

# Predict and Visualization
generate_manifold(decoder)
plot_digits(X_test, y, encoder) # y for label color