TensorFlow とオートエンコーダーモデルを使用して手書き数字を生成する方法

[[209419]]

オートエンコーダーは、入力データを効率的にエンコードする方法を学習するために使用できるニューラルネットワークです。ニューラルネットワークは、何らかの入力が与えられると、まず一連の変換を使用してデータを低次元空間にマッピングします。ニューラルネットワークのこの部分はエンコーダーと呼ばれます。

次に、ネットワークはエンコードされた低次元データを使用して入力を再構築しようとします。ネットワークのこの部分はデコーダーと呼ばれます。エンコーダーを使用して、データをニューラルネットワークが理解できる形式に圧縮できます。ただし、通常はより効率的な手書きのアルゴリズム (jpg 圧縮など) があるため、オートエンコーダーがこの目的で使用されることはほとんどありません。

さらに、オートエンコーダはノイズ除去タスクを実行するためによく使用され、元の画像を再構築する方法を学習できます。

変分オートエンコーダとは何ですか?

オートエンコーダに関連する興味深いアプリケーションは数多くあります。

そのうちの 1 つは変分オートエンコーダと呼ばれます。変分オートエンコーダを使用すると、単にデータを圧縮するだけでなく、オートエンコーダがこれまでに遭遇した新しいオブジェクトを生成することもできます。

一般的なオートエンコーダを使用する場合、ネットワークによって生成される特定のエンコーディングが何であるかはわかりません。異なるエンコーディングオブジェクトを比較することはできますが、内部的にどのようにエンコードされているかを理解することはほぼ不可能です。つまり、エンコーダーを使用して新しいオブジェクトを生成することはできません。入力がどのようになるかさえわかりません。

変分オートエンコーダを使用した逆のアプローチを使用します。潜在ベクトルの分布に注意を払う必要はなく、ネットワークにどのような分布を望むかを伝えるだけで済みます。

通常、単位正規分布特性を持つ潜在ベクトルを生成するようにネットワークを制約します。次に、データを生成するときに、この分布からサンプルを採取し、そのサンプルをデコーダーに渡すだけで、ネットワークのトレーニングに使用したオブジェクトとまったく同じ新しいオブジェクトが返されます。

以下では、Python と TensorFlow を使用してこれを行う方法について説明します。ネットワークに MNIST 文字を描画するように教えます。

最初のステップはトレーニングデータをロードすることです

まず、いくつかの基本的なインポート操作を実行しましょう。 TensorFlow には、MNIST データセットに簡単にアクセスできる非常に便利な関数があります。

 tensorflow をtfimportとしてインポートし、numpy を npiimportとしてインポートし、matplotlib.pyplotをpltとしてインポートします。 
 
 %matplotlib インラインから tensorflow.examples.tutorials.mnist インポート input_data 
 
 mnist = input_data.read_data_sets( 'MNIST_data' )

入力データと出力データの定義

MNIST 画像の寸法は 28 x 28 ピクセルで、モノクロチャネルのみです。入力データ X_in は MNIST 文字のバッチであり、ネットワークはそれらを再構築する方法を学習します。次に、入力と同じ次元を持つ出力で、プレースホルダー Y にそれらを出力します。

Y_flat は後で損失関数を計算するときに使用され、keep_prob はドロップアウトを適用するときに（正規化方法として）使用されます。トレーニング中は、その値は 0.8 に設定されます。新しいデータを生成するときは、ドロップアウトを使用しないため、その値は 1 になります。

TensorFlow には定義済みの Leaky ReLU 関数がないため、lrelu 関数を独自に定義する必要があります。

 tf.reset_default_graph() 
 
 batch_size = 64 X_in = tf.placeholder(dtype=tf.float32, shape=[None, 28, 28], name = 'X' )
 Y = tf.placeholder(dtype=tf.float32, shape=[なし, 28, 28],名前= 'Y' )
 Y_flat = tf.reshape(Y, 形状=[-1, 28 * 28])
 keep_prob = tf.placeholder(dtype=tf.float32, shape=(), name = 'keep_prob' ) です。 
 
 dec_in_channels = 1n_latent = 8reshaped_dim = [-1, 7, 7, dec_in_channels]
 inputs_decoder = 49 * dec_in_channels / 2def lrelu(x, alpha=0.3): return tf.maximum(x, tf.multiply(x, alpha))

エンコーダの定義

入力は画像なので、畳み込み変換を使用する方が合理的です。最も注目すべき点は、エンコーダーはガウス分布に従うオブジェクトを作成する必要があるため、エンコーダー内に 2 つのベクトルを作成することです。

1つは平均ベクトル
1つは標準偏差ベクトルである

後で、エンコーダーが正規分布に従うデータポイントを実際に生成するように「強制」する方法を説明します。デコーダーに入力されるエンコードされた値は、z として表すことができます。損失関数を計算するときは、選択した分布の平均と標準偏差が必要になります。

エンコーダの定義(X_in、keep_prob):
    activation = lrelu 、 tf.variable_scope( "encoder" 、reuse=None):
        X = tf.reshape(X_in、形状=[-1、28、28、1])
        x = tf.layers.conv2d(X、フィルター=64、カーネルサイズ=4、ストライド=2、パディング= 'same' 、アクティベーション=アクティベーション)
        x = tf.nn.dropout(x, keep_prob)
        x = tf.layers.conv2d(x, フィルター=64, カーネルサイズ=4, ストライド=2, パディング= 'same' , アクティベーション=アクティベーション)
        x = tf.nn.dropout(x, keep_prob)
        x = tf.layers.conv2d(x, フィルター=64, カーネルサイズ=4, ストライド=1, パディング= 'same' , アクティベーション=アクティベーション)
        x = tf.nn.dropout(x, keep_prob)
        x = tf.contrib.layers.flatten(x)
        mn = tf.layers.dense(x, 単位=n_latent)
        sd = 0.5 * tf.layers.dense(x, 単位=n_latent)
        イプシロン = tf.random_normal(tf.stack([tf.shape(x)[0], n_latent]))
        z = mn + tf.multiply(イプシロン、tf.exp(sd))
 z、mn、sdを返す

デコーダーの定義

デコーダーは、入力値が定義した特定の分布からサンプリングされたかどうかを気にしません。単純に入力画像を再構築しようとします。最後に、一連の転置畳み込みを使用します。

 def デコーダー(sampled_z, keep_prob): tf.variable_scope ( "デコーダー" 、reuse=None):
        x = tf.layers.dense(sampled_z、単位=inputs_decoder、アクティベーション=lrelu)
        x = tf.layers.dense(x, 単位 = inputs_decoder * 2 + 1, アクティベーション = lrelu)
        x = tf.reshape(x, reshaped_dim)
        x = tf.layers.conv2d_transpose(x、フィルター=64、カーネルサイズ=4、ストライド=2、パディング= 'same' 、アクティベーション=tf.nn.relu)
        x = tf.nn.dropout(x, keep_prob)
        x = tf.layers.conv2d_transpose(x、フィルター=64、カーネルサイズ=4、ストライド=1、パディング= 'same' 、アクティベーション=tf.nn.relu)
        x = tf.nn.dropout(x, keep_prob)
        x = tf.layers.conv2d_transpose(x、フィルター=64、カーネルサイズ=4、ストライド=1、パディング= 'same' 、アクティベーション=tf.nn.relu) 
         
        x = tf.contrib.layers.flatten(x)
        x = tf.layers.dense(x, 単位=28*28, 活性化=tf.nn.sigmoid)
        img = tf.reshape(x, shape=[-1, 28, 28])画像を返す

ここで、2 つの部分を接続します。

サンプリング、mn、sd = エンコーダ(X_in、keep_prob) 
 
 dec = デコーダー(サンプリング、keep_prob)

損失関数を計算し、ガウス隠れ分布を実装する

画像再構成の損失関数を計算するために、単純に二乗差を使用しました (これにより、画像が少しぼやけることがあります)。この損失関数には KL ダイバージェンスも組み込まれており、これにより、隠し値が標準分布からサンプリングされることが保証されます。このトピックについて詳しく知りたい場合は、この記事 (https://jaan.io/what-is-variational-autoencoder-vae-tutorial/) をご覧ください。

再形成しない = tf.reshape( dec , [-1, 28*28])
 img_loss = tf.reduce_sum(tf.squared_difference(未整形, Y_flat), 1)
潜在損失 = -0.5 * tf.reduce_sum(1.0 + 2.0 * sd - tf.square(mn) - tf.exp(2.0 * sd), 1)
損失 = tf.reduce_mean(img_loss + latent_loss)
オプティマイザー = tf.train.AdamOptimizer(0.0005).minimize(損失)
 sess = tf.Session()
 sess.run(tf.global_variables_initializer())

ネットワークのトレーニング

これで、ついに VAE をトレーニングできるようになりました。

200 ステップごとに、現在の再構築がどのようになっているかを確認します。約 2000 回の反復の後、ほとんどの再構築は妥当なものに見えました。

 iが範囲(30000)内にある場合:
    バッチ = [np.reshape(b, [28, 28])、 bの場合、mnist.train.next_batch (batch_size=batch_size)[0]]
    sess.run(オプティマイザー、feed_dict = {X_in: バッチ、Y: バッチ、keep_prob: 0.8})
    そうでない場合i % 200:
        ls、d、i_ls、d_ls、mu、sigm = sess.run([loss、 dec 、img_loss、dst_loss、mn、sd]、feed_dict = {X_in: batch、Y: batch、keep_prob: 1.0})
        plt.imshow(np.reshape(バッチ[0]、[28, 28])、cmap= 'グレー' )
        plt.show()
        plt.imshow(d[0], cmap= '灰色' )
        plt.show()
        print(i, ls, np.mean(i_ls), np.mean(d_ls))

新しいデータを生成する

最も驚くべきことは、新しいキャラクターを生成できるようになったことです。最後に、単位正規分布から値をサンプリングし、それをデコーダーに入力します。生成された文字のほとんどは人間の手書き文字と同一です。

ランダム = [np.random.normal(0, 1, n_latent) _が範囲(10)]
 imgs = sess.run( dec 、 feed_dict = {sampled: randoms、 keep_prob: 1.0}) です。
 imgs = [np.reshape(imgs[i], [28, 28])、 i がrange(len(imgs))内にある場合、 img がimgs内にある場合:
    plt.figure(図サイズ=(1,1))
    plt.axis( 'オフ' )
    plt.imshow(画像、cmap= 'グレー' )