web-dev-qa-db-ja.com

テンソルフローの重みの初期化

TensorFlow Webサイトの MNISTチュートリアル について、実験（ Gist ）を実行して、さまざまな重みの初期化が学習に与える影響を確認しました。人気のある [Xavier、Glorot 2010]論文 で読んだものとは対照的に、重みの初期化に関係なく学習はうまくいくことに気付きました。

Learning curves for different weight initializations averaged over 3 runs

異なる曲線は、畳み込み層と完全に接続された層の重みを初期化するためのwの異なる値を表します。 wのすべての値は、0.3および1.0はパフォーマンスが低下し、一部の値はより速くトレーニングされます-特に、0.03および0.1は最速です。それにもかかわらず、プロットはwのかなり広い範囲を示しています。これは機能し、「ロバストネス」w.r.tを示唆しています。重量の初期化。

def weight_variable(shape, w=0.1):
  initial = tf.truncated_normal(shape, stddev=w)
  return tf.Variable(initial)

def bias_variable(shape, w=0.1):
  initial = tf.constant(w, shape=shape)
  return tf.Variable(initial)

質問：なぜこのネットワークは勾配問題の消失または爆発に悩まされないのですか？

実装の詳細についてはGistを読むことをお勧めしますが、参照用のコードは次のとおりです。 Nvidia 960mでは約1時間かかりましたが、CPUで合理的な時間内に実行できると思います。

import time
from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf
from tensorflow.python.client import device_lib

import numpy
import matplotlib.pyplot as pyplot

mnist = input_data.read_data_sets('MNIST_data', one_hot=True)

# Weight initialization

def weight_variable(shape, w=0.1):
  initial = tf.truncated_normal(shape, stddev=w)
  return tf.Variable(initial)

def bias_variable(shape, w=0.1):
  initial = tf.constant(w, shape=shape)
  return tf.Variable(initial)


# Network architecture

def conv2d(x, W):
  return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

def max_pool_2x2(x):
  return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
                    strides=[1, 2, 2, 1], padding='SAME')

def build_network_for_weight_initialization(w):
    """ Builds a CNN for the MNIST-problem:
     - 32 5x5 kernels convolutional layer with bias and ReLU activations
     - 2x2 maxpooling
     - 64 5x5 kernels convolutional layer with bias and ReLU activations
     - 2x2 maxpooling
     - Fully connected layer with 1024 nodes + bias and ReLU activations
     - dropout
     - Fully connected softmax layer for classification (of 10 classes)

     Returns the x, and y placeholders for the train data, the output
     of the network and the dropbout placeholder as a Tuple of 4 elements.
    """
    x = tf.placeholder(tf.float32, shape=[None, 784])
    y_ = tf.placeholder(tf.float32, shape=[None, 10])

    x_image = tf.reshape(x, [-1,28,28,1])
    W_conv1 = weight_variable([5, 5, 1, 32], w)
    b_conv1 = bias_variable([32], w)

    h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
    h_pool1 = max_pool_2x2(h_conv1)
    W_conv2 = weight_variable([5, 5, 32, 64], w)
    b_conv2 = bias_variable([64], w)

    h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
    h_pool2 = max_pool_2x2(h_conv2)

    W_fc1 = weight_variable([7 * 7 * 64, 1024], w)
    b_fc1 = bias_variable([1024], w)

    h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
    h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)

    keep_prob = tf.placeholder(tf.float32)
    h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

    W_fc2 = weight_variable([1024, 10], w)
    b_fc2 = bias_variable([10], w)

    y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2

    return (x, y_, y_conv, keep_prob)


# Experiment

def evaluate_for_weight_init(w):
    """ Returns an accuracy learning curve for a network trained on
    10000 batches of 50 samples. The learning curve has one item
    every 100 batches."""
    with tf.Session() as sess:
        x, y_, y_conv, keep_prob = build_network_for_weight_initialization(w)
        cross_entropy = tf.reduce_mean(
            tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y_conv))
        train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
        correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1))
        accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
        sess.run(tf.global_variables_initializer())
        lr = []
        for _ in range(100):
            for i in range(100):
                batch = mnist.train.next_batch(50)
                train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})
            assert mnist.test.images.shape[0] == 10000
            # This way the accuracy-evaluation fits in my 2GB laptop GPU.
            a = sum(
                accuracy.eval(feed_dict={
                    x: mnist.test.images[2000*i:2000*(i+1)],
                    y_: mnist.test.labels[2000*i:2000*(i+1)],
                    keep_prob: 1.0})
                for i in range(5)) / 5
            lr.append(a)
        return lr


ws = [0.0001, 0.0003, 0.001, 0.003, 0.01, 0.03, 0.1, 0.3, 1.0]
accuracies = [
    [evaluate_for_weight_init(w) for w in ws]
    for _ in range(3)
]


# Plotting results

pyplot.plot(numpy.array(accuracies).mean(0).T)
pyplot.ylim(0.9, 1)
pyplot.xlim(0,140)
pyplot.xlabel('batch (x 100)')
pyplot.ylabel('test accuracy')
pyplot.legend(ws)
tensorflowdeep-learningmnist
10
Herbert

ウェイトの初期化戦略は、モデルを改善する上でしばしば見落とされがちな重要なステップである可能性があります。これがGoogleのトップの結果であるため、より詳細な答えが必要だと考えました。

一般に、各レイヤーのアクティベーション関数の勾配、着信/発信接続の数（fan_in/fan_out）、および重みの分散の合計積は1に等しくなければなりません。この方法では、ネットワークを逆伝播するときに、入力勾配と出力勾配の分散が一定に保たれ、勾配が爆発したり消失したりすることはありません。 ReLUは勾配の爆発/消滅に対してより耐性がありますが、それでも問題が発生する可能性があります。

oPが使用するtf.truncated_normalはランダムな初期化を行い、重みを「異なる」更新を促しますが、notは上記の最適化戦略を考慮します。小規模なネットワークではこれは問題にならないかもしれませんが、より深いネットワークやより速いトレーニング時間が必要な場合は、最近の調査に基づいた重み初期化戦略を試してみることをお勧めします。

ReLU関数に先行する重みの場合、次のデフォルト設定を使用できます。

tf.contrib.layers.variance_scaling_initializer

タン/シグモイド活性化層の場合、「xavier」の方が適切な場合があります。

tf.contrib.layers.xavier_initializer

これらの関数と関連する論文の両方の詳細については、次を参照してください。 https://www.tensorflow.org/versions/r0.12/api_docs/python/contrib.layers/initializers

重みの初期化戦略を超えて、さらに最適化することでバッチの正規化を検討できます。 https://www.tensorflow.org/api_docs/python/tf/nn/batch_normalization

12
Shane

ロジスティック関数は勾配がすべて<1であるため、勾配が消失する傾向があります。そのため、逆伝播中に乗算するほど、勾配は小さくなります（RelUは正の勾配が1になります）。一部なので、この問題はありません。

また、あなたのネットワークは、それに苦しむほど深くはありません。

4
gdelab