Tensorflow: 使いやすいバッチノルムレイヤー。

私はそのいくつかの部分に取り組んでいます。

batch_normレイヤーがあります：
https://github.com/tensorflow/tensorflow/blob/b826b79718e3e93148c3545e7aa3f90891744cc0/tensorflow/contrib/layers/python/layers/layers.py#L100

このレイヤーに何か問題があると思います。 トレーニングではすべてがOKで、損失は非常に少なくなります。 しかし、テストでは精度がゼロになります。
ちなみに、is_training = Falseを使用した場合のテストでは、accがゼロになります。
バッチ正規化は、トレーニング時とテスト時にように、トレーニングフェーズとテストフェーズで異なる動作をすることを知って--Quora 。 この実装は不明確だと思います

ここでも同じですが、is_training = Falseで予期しない動作が発生しました。 このフラグを変更する正しい方法は何ですか？ tf.placeholdersを単独で使用しないため、現在tf.condを使用しています。

@pawni is_trainingはPythonブール値を使用する必要があります。 tf.condにすることはできません。

@ppwwyyxxよく私はtf.cond(placeholder, batch_norm(.., is_training = True), batch_norm(.., is_training = False))をやっていますか、それともbatch_norm(.., is_training=variable)をやって、必要に応じてグラフの外でそれを変更することになっていますか？

ああ、あなたはbatch_norm(.., is_training=tf.cond(placeholder))をやっていると思いましたが、これは正しくありません。
あなたの現在の方法にも問題があるかもしれません。 作成した2つのbatch_norm opが同じスコープを共有していることを再確認する必要があります。そうしないと、基礎となる平均/分散統計が共有されません。

これを行うには、 reuse引数が役立つ場合がありますが、独自のバージョンのbnレイヤーを使用しているためわかりません。

同じスコープとreuse=Trueます。 時々動作するようですが、よくわかりません。 トレーニングからテストへの変更を最適に処理する方法を簡単に説明したレイヤーをドキュメントに追加できれば素晴らしいと思います。

@sguada FYI

現在、batch_normにはpythonブール値が必要ですが、Tensorを渡すオプションの追加に取り組んでいます。

@pawnimoving_meanとmoving_varianceの更新について心配したくない場合はupdates_collections = Noneを設定して、それらが適切に更新されていることを確認してください。そうでない場合は、トレーニング中にtf.GraphKeys.UPDATE_OPSに追加されたupdate_opsが実行されていることを確認する必要があります。

テンソルフローには、トーチのように、モデルの状態を変更する2つのハイパーメソッドが必要だと思います。 モデルの状態を変更します。 とても簡単だと思います。

この「公式」BNレイヤーを使用する適切な方法を示す非常に単純なNNの小さなスクリプトはありますか？ 本当にありがたいです。

これが少し繰り返される場合は申し訳ありませんが、APIは別のインターフェースでBNについて話しているようです： https ：

それはBNを使用する公式の方法ではありませんか？ 私はそれを使用する方法について混乱していて、SOが古くなっているようで、APIとは異なるリンクにレイヤーがありますが、これをどのように正確に行うのですか？ SOに行くのか、ここで尋ねるのかわかりません。

スパムについては申し訳ありませんが、次のようなものを使用するだけで何が問題になりますか。

def standard_batch_norm(l, x, n_out, phase_train, scope='BN'):
    """
    Batch normalization on feedforward maps.
    Args:
        x:           Vector
        n_out:       integer, depth of input maps
        phase_train: boolean tf.Varialbe, true indicates training phase
        scope:       string, variable scope
    Return:
        normed:      batch-normalized maps
    """
    with tf.variable_scope(scope+l):
        #beta = tf.Variable(tf.constant(0.0, shape=[n_out], dtype=tf.float64 ), name='beta', trainable=True, dtype=tf.float64 )
        #gamma = tf.Variable(tf.constant(1.0, shape=[n_out],dtype=tf.float64 ), name='gamma', trainable=True, dtype=tf.float64 )
        init_beta = tf.constant(0.0, shape=[n_out], dtype=tf.float64)
        init_gamma = tf.constant(1.0, shape=[n_out],dtype=tf.float64)
        beta = tf.get_variable(name='beta'+l, dtype=tf.float64, initializer=init_beta, regularizer=None, trainable=True)
        gamma = tf.get_variable(name='gamma'+l, dtype=tf.float64, initializer=init_gamma, regularizer=None, trainable=True)
        batch_mean, batch_var = tf.nn.moments(x, [0], name='moments')
        ema = tf.train.ExponentialMovingAverage(decay=0.5)

        def mean_var_with_update():
            ema_apply_op = ema.apply([batch_mean, batch_var])
            with tf.control_dependencies([ema_apply_op]):
                return tf.identity(batch_mean), tf.identity(batch_var)

        mean, var = tf.cond(phase_train, mean_var_with_update, lambda: (ema.average(batch_mean), ema.average(batch_var)))
        normed = tf.nn.batch_normalization(x, mean, var, beta, gamma, 1e-3)
    return normed

次に、次のようにフィードディクショナリでどちらを使用するかをテンソルフローに指示するのは簡単です。

feed_dict = {x: Xminibatch, y_: Yminibatch, phase_train: True}
sess.run(fetches=[merged,train_step], feed_dict=feed_dict)

実装が変更されるかどうかが不明なため、提案をしたいと思いました（畳み込みなど、コードを貼り付けなかったものに簡単に拡張できることに注意してください）。

@pawni @ppwwyyxxスコープの問題を解決するために、再利用をtrueに使用する必要があるかどうかを判断しましたか？

@ brando90現在、私は次のようなことをしています。

def BatchNorm(inputT, is_training=True, scope=None):
    return tf.cond(isTraining,
                lambda: batch_norm(inputT, is_training=True,
                                   center=False, updates_collections=None, scope=scope),
                lambda: batch_norm(inputT, is_training=False,
                                   updates_collections=None, center=False, scope=scope, reuse = True))

しかし、＃3265は基本的にこのように実装したいと思います。 ここでのドロップアウト実装を参照できます： https ：

update_collections = Noneの場合、更新はインプレースで行われ、tf.cond（）を使用して、is_trainingをTensorにする方が簡単です。これは、更新が遅れてupdate_opsが後で実行される場合です。
私はすぐに最初の部分を取得しようとします。

@ brando90 @pawni彼のコードはうまく機能しますが、以下のように変更する必要があります

def BatchNorm(inputT, is_training=True, scope=None):
    # Note: is_training is tf.placeholder(tf.bool) type
    return tf.cond(is_training,  
                lambda: batch_norm(inputT, is_training=True,  
                                   center=False, updates_collections=None, scope=scope),  
                lambda: batch_norm(inputT, is_training=False,  
                                   updates_collections=None, center=False, scope=scope, reuse = True))  

そして、トレーニングやテストの時間に実行すると、

# when training 
sess.run([opt, loss], feed_dict={x: bx, y: by, is_training=True})  

# when test 
sess.run([opt, loss], feed_dict={x: bx, y: by, is_training=False})  

このコードは機能しますが、 ＃3265が言うように、 tf.contrib.layers.batch_normがis_training変数をtf.plcaeholerとして取得すると素晴らしいでしょう。

@ nmhkahn @ pawniコードスニペットをありがとう。 これらは、畳み込みネットワークにバッチ正規化を追加するのに非常に役立ちました。 トレーニングは非常にうまく機能しているようです。 テストはそうではありません。 コードトレーニングの精度の一部のバージョンでは、テストの精度よりもはるかに高いため、バッチ正規化パラメーターを共有していない可能性があります。 他のバージョンのコードでは、「ValueError：変数conv1 / betaはすでに存在し、許可されていません。VarScopeでreuse = Trueを設定するつもりでしたか？」というメッセージが表示されます。 これは、パラメータを再学習しようとしていることを示しているようです...再利用しようとしたとき。

変数の共有が正しく行われるように、トレーニングおよびテスト中に「defBatchNorm」関数を呼び出す方法の例を誰かが提供できますか。

助けてくれてありがとう。

2016年7月25日更新：

@ nmhkahn @ pawniコメントありがとうございます。 contribのコードを詳しく調べた後、私は自分の問題が何であるかを理解しました。 トレーニングとテスト中に、4つの変数（ベータ、ガンマ、移動平均、移動平均）を更新または再利用します。 それらをユニークにするために、レイヤーごとにスコープを設定する必要がありました。 私はこのようにしました：

conv1 = tf.nn.relu（batch_norm_layer（conv2d_stride2_valid（data、W_conv1）+ b_conv1、train_phase、scope = "conv1"））

ここで、batch_norm_layerは@nmhkahn @pawniの例に似ており、conv2d_stride2_validは畳み込み層を定義するための単なる定義であり、W_conv1とb_conv1は重みとバイアスを保持する変数です。 バッチ正規化を使用しているため、バイアス項を削除できる可能性があります。

ネットは今うまく機能しています。 トレーニングモードとテストモードで精度をプロットした後、トレーニング精度の後にテスト精度が上昇し始めることに気付きました。 振り返ってみると、テスト用のデータセット統計を収集しているので、それは理にかなっています。 しかし、最初のテストで何か間違ったことをしているように見えました。 コメントをいただき、コミュニティでバッチ正規化を利用できるようにしていただきありがとうございます。

@nmhkahn pawniの提案とどう違うのですか？

@ brando90 nmhkahnによって修正されたバージョンで小さなエラーが発生しました（ isTrainingをis_training ）

@diegoAtAlpine私は同じ問題を見つけました-しかし、なぜこれが

@nmhkahn @pawni @あなたがするとき：

sess.run([opt, loss], feed_dict={x: bx, y: by, is_training=True})

is_trainingをプレースホルダーとして使用しているという意味ではありませんか？ 人々はis_trainingをプレーサーホルダーにしたいとコメントしていますが、それは私のバージョンのそれです。

def batch_norm_layer(x,train_phase,scope_bn):

    bn_train = batch_norm(x, decay=0.999, center=True, scale=True,
    is_training=True,
    reuse=None, # is this right?
    trainable=True,
    scope=scope_bn)
    bn_inference = batch_norm(x, decay=0.999, center=True, scale=True,
    is_training=False,
    reuse=True, # is this right?
    trainable=True,
    scope=scope_bn)
    z = tf.cond(train_phase, lambda: bn_train, lambda: bn_inference)
    return z

それは正しくありませんか？

is_trainingのテンソルまたはプレースホルダーを渡すことができるようにtf.contrib.layers.batch_normを既に拡張しました。 間もなくTFcontribに統合されます。

で利用可能になりました
https://github.com/tensorflow/tensorflow/commit/9da5fc8e6425cabd61fc36f0dcc1823a093d5c1d#diff -94bbcef0ec8a5cdef55f705e99c2b2ed

それは私だけですか、それともこのBNレイヤーを追加すると、単一のエポックのトレーニングが著しく遅くなりますか？

@ brando90それは私にとってもトレーニングを遅くしますが、いくつかの統計を計算する必要があるので、これは予想されると思います。 そして、あなたのバージョンは私には良さそうです。

BatchNormは現在（計算されたすべての統計のために）非常に遅いですが、ここで述べます。

@nmhkahn簡単な質問。 あなたが書いたとき（テスト用）：

sess.run([opt, loss], feed_dict={x: bx, y: by, is_training=False})

理論的には、bxは任意のデータセットにすることができますか？ つまり、トレーニングをしていなくても、

@ brando90その通りです。

is_trainingフラグと再利用フラグについても混乱しています。 CIFARの例に従ってプログラムを作成しました。ここで、コードはCIFARのように構造化されています。

• 推論
• 損失
• 列車

そして、私はそれをマルチGPU方式で実行しています（トレーニング用）。
したがって、トレーニング用のスクリプト（cifar10_multigpu.pyと同様）とテスト用のスクリプト（cifar10_eval.pyと同様）が1つずつあります。
そう

for ii in xrange(2):  # Num of GPU
  with tf.device('/gpu:%d' % ii):
    with tf.name_scope('device_%d' % ii) as scope:

      data_batch, label_batch = factory.GetShuffleBatch(batch_size)

      unnormalized_logits = factory.MyModel(dataBatch=data_batch, numClasses=numClasses,
                                                 isTraining=True)

      More stuff happening
      tf.get_variable_scope().reuse_variables()

推論は関数MyModelで発生します。 （以下は関数の例です。実際には、より多くのレイヤーとニューロンを使用しています）。

def MyModel(data_batch, num_classes, feature_dim):

  # Hidden Layer 1
  with tf.variable_scope('hidden1') as scope:
    weights = variable_on_cpu('weights',[feature_dim, 256], tf.truncated_normal_initializer(stddev=0.04))
    biases = variable_on_cpu('biases', [256], tf.constant_initializer(0.001))
    hidden1 = tf.nn.relu(tf.matmul(data_batch, weights) + biases, name=scope.name)

  # Hidden Layer 2
  with tf.variable_scope('hidden2') as scope:
    weights = variable_on_cpu('weights',[256, 256], tf.truncated_normal_initializer(stddev=0.04))
    biases = variable_on_cpu('biases', [256], tf.constant_initializer(0.001))
    hidden2 = tf.nn.relu(tf.matmul(hidden1, weights) + biases, name=scope.name)

  # output, unnormalized softmax
  with tf.variable_scope('softmax_unnorm') as scope:

    weights = variable_on_cpu('weights', [256, num_classes], tf.truncated_normal_initializer(stddev=1/num_classes))
    biases = variable_on_cpu('biases', [num_classes], tf.constant_initializer(0.0))
    softmax_un = tf.add(tf.matmul(hidden2, weights), biases, name=scope.name)

  return softmax_un

バッチノマライズを実行したい。 だから私がしたとき：

def MyModel(data_batch, num_classes, feature_dim, isTraining):

  with tf.variable_scope('bnormalization') as scope:
    norm_data_batch = tcl.batch_norm(inputs=dataBatch, epsilon=0.0001, is_training=isTraining, 
                                      reuse=True, scope=scope)

  # Hidden Layer 1
  with tf.variable_scope('hidden1') as scope:
    weights = variable_on_cpu('weights',[feature_dim, 256], tf.truncated_normal_initializer(stddev=0.04))
    biases = variable_on_cpu('biases', [256], tf.constant_initializer(0.001))
    hidden1 = tf.nn.relu(tf.matmul(data_batch, weights) + biases, name=scope.name)

トレーニングフェーズで次のエラーが発生しました。
可変bnormalization / betaは存在せず、許可されていません。 VarScopeでreuse = Noneを設定するつもりでしたか？

トレーニングフェーズでこのスレッドで読んだことから、reuse = Noneを使用する必要があります。 この部分は正しいですか？ これが当てはまる場合、2つのGPUを使用しているので、最初のGPUでreuse = Noneを実行し、2番目のGPUでreuse = Trueを実行する必要がありますか？ または、tf.get_variable_scope（）。reuse_variables（）を実行しているので、それ自体が処理されますか？

最後に、テストフェーズでは、is_training = Falseおよびreuse = Trueにする必要がありますか？

どんな助けでも大歓迎です。

これで、tf.contrib.layers.batch_normは、テンソル、変数、またはプレースホルダーをis_trainingとして受け入れます。

https://github.com/tensorflow/tensorflow/commit/9da5fc8e6425cabd61fc36f0dcc1823a093d5c1d#diff -94bbcef0ec8a5cdef55f705e99c2b2ed

バッチ正規化によって実験が悪化するのは正常ですか？ MNIST初心者向けチュートリアルに基づいて2層のNNネットワークで試してみましたが、BNが存在する場合は一貫して悪い結果が得られます。 0.9477。

私のスクリプトはここにありますhttps://github.com/brando90/tensor_flow_experiments/blob/master/tf_tutorials/beginner_tutorial_MNIST_BN.py

誰かがこれらの問題を経験したことがありますか、それともBNはこのようなものであり、それを機能させるために何か他のことをする必要がありますか？

tf.contrib.layers.batch_normの最新バージョンは、

ただし、重要なのは、 updates_collections = Noneを渡して、moving_meanとmoving_varianceがインプレースで更新されるようにすることです。そうしないと、update_opsを収集して、それらが実行されていることを確認する必要があります。

tf.contrib.layersまたはtf.contrib.slimを使用してモデルを構築することをお勧めします。

slim = tf.contrib.slim

def build_NN_two_hidden_layers(x, is_training):
 batch_norm_params = {'is_training': is_training, 'decay': 0.9, 'updates_collections': None}
 with slim.arg_scope([slim.fully_connected], 
    activation_fn=tf.nn.relu,
    weigths_initializer=tf.contrib.layers.xavier_initializer(),
    biases_initializer=tf.constant_initializer(0.1),
    normalizer_fn=slim.batch_norm,
    normalizer_params=batch_norm_params):
   net = slim.fully_connected(x, 50, scope='A1')
   net = slim.fully_connected(net, 49, scope='A2')
   y = slim.fully_connected(net, 10, activation_fn=tf.nn.softmax, normalizer_fn=None, scope='A3')
 return y

@sguada（tf.condに基づいて）手動でトレーニングするかどうかを指示する古いものを変更しましたが、精度は再び最大95になっているようです。 updates_collectionsをNoneに変更する必要があったのはなぜですか？ なぜこんなに大きな精度の違いが出たのか説明してもらえますか？ それは重要な変更のように思われます（それがそれほど重要な場合は、Noneをデフォルト値にする必要がありますか？）。 ありがとう！ :)

また、プレースホルダーであり、手動で行う必要はないとおっしゃっていました。 ただし、is_trainingのプレースホルダーを渡すと、

TypeError: Using a tf.Tensor as a Python bool is not allowed. Use tがNoneでない場合： instead of tの場合： to test if a tensor is defined, and use the logical TensorFlow ops to test the value of a tensor.

そしてbatch_normコードを指しています。 おそらく、このプレースホルダーがどのように使用されるべきかを示すのは良いことかもしれません。なぜなら、それがどのように使用されるのか理解していないようだからです。 ありがとう！ :)

@ brando90
コードの関連部分はここL227-256です。

お気づきのように、更新を強制するwith ops.control_dependenciesステートメントがあります。 「箱から出してすぐに」使用されるコードのデフォルトはNoneである必要があると思います。

1122の上の私のコメントに関しては、tf.get_variable_scope（）。reuse_variables（）が問題を処理することがわかったので、トレーニングフェーズではbatch_normの引数の再利用はNoneである必要があります。 それはステートメントvariable_op_scopeと関係があります（tensorflowでそのドキュメントを読んでください）

tf.placeholderでのbatch_normの使用

x = tf.placeholder(tf.float32, [None, 784])
is_training = tf.placeholder(tf.bool, [], name='is_training')
y = build_NN_two_hidden_layers(x, is_training)

# For training
sess.run(y, {is_training: True, x: train_data})

# For eval
sess.run(y, {is_training: False, x: eval_data})

以前の問題は、各ステップの後にmoving_meanとmoving_variance更新していなかったことmoving_meanた。updates_collectionsがNoneの場合、計算の一部として更新が強制されます。
ただし、ネットワークに多数のbatch_normレイヤーがある場合は、すべての更新操作を収集して一緒に実行する方が効率的であるため、各レイヤーは更新が完了するのを待つ必要はありません。

y = build_model_with_batch_norm(x, is_training)
update_ops = tf.group(tf.get_collection(tf.GraphKeys.UPDATE_OPS))

sess.run([y, update_ops])

バッチ基準の高速化に進展はありましたか？

自動エンコードのタスクのために、（フラット化された）MNIST（およびreluユニット）データセットを使用して、2層の密に接続されたNNでバッチノルムを使用しようとしましたが、NaNエラーが発生し続けます。 なぜこれがそうなのか誰か知っていますか？ これはBNで可能ですか？ 怪しげなように見えますが、それは私の学習設定やレートなどではありませんでした（しかし、BNはこれに対して一種の頑固なはずなので、そうすべきではないと思います）

@sguada特にフラグupdates_collectionsに関して、 batch_normの正しい使用方法を理解していません。 フラグがNoneあるかどうかを正しく理解した場合、ネットワークは効率的ではないため、 updates_collections=tf.GraphKeys.UPDATE_OPSを許可してから、すべてのbatch_norm更新を収集して一緒に実行する必要があります。

update_ops = tf.group(tf.get_collection(tf.GraphKeys.UPDATE_OPS))実行して、batch_normsの更新を収集します。

異なるbatch_normレイヤーを使用する多くの異なるモデルがありますが、これは正しく機能しませんか？：

#model 1
y1 = build_model_with_batch_norm(x, is_training)
update_ops1 = tf.group(tf.get_collection(tf.GraphKeys.UPDATE_OPS))
sess.run([y1, update_ops1])
#model 2
y2 = build_model_with_batch_norm(x, is_training)
update_ops2 = tf.group(tf.get_collection(tf.GraphKeys.UPDATE_OPS))
sess.run([y2, update_ops2])

この部分をもう少し詳しく説明していただけますか？ どうもありがとうございました。

別のコレクションキーに入れるだけです：

# While building your 1st model...
tf.contrib.layers.batch_norm(..., updates_collection="updates-model1")

# same for 2nd model with key "updates-model2"

#model 1
y1 = build_model_with_batch_norm(x, is_training)
update_ops1 = tf.group(tf.get_collection("updates-model1"))
sess.run([y1, update_ops1])
#model 2
y2 = build_model_with_batch_norm(x, is_training)
update_ops2 = tf.group(tf.get_collection("updates-model1"))
sess.run([y2, update_ops2])

それにもかかわらず、ドキュメントは時代遅れになっています。 次のことを行うように指示します。

update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
if update_ops:
    updates = tf.group(update_ops)
    total_loss = control_flow_ops.with_dependencies([updates], total_loss)

だが：

• _tf.group（）_はリストを受け入れません。 _tf.tuple（）_に置き換えました
• _control_flow_ops.with_dependencies（）_にアクセスする方法がわかりません。 tf.with_dependecies（）を使用した他の例を見たことがありますが、Tensorflow0.10ではそれを行うことができません。 私はここでそれを見つけました：_tf.python.control_flow_ops.with_dependencies（）_

編集：

ドキュメントをs.thに更新する必要があります。 このような：

from tensorflow.python import control_flow_ops

update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
if update_ops:
    updates = tf.tuple(update_ops)
    total_loss = control_flow_ops.with_dependencies(updates, total_loss)

編集2：

ネットワークでいくつかの実行を行った後、グラフの作成中に_tf.GraphKeys.UPDATE_OPS_を手動でフェッチするのとは対照的に、_updates_collections = None_を使用してもパフォーマンスの違いは見られないと言わざる

編集：私の結果が正しければ言うのは難しいですが、ネットワーク全体は確かに1.5倍高速になります。 私の知る限り、BN統計はGPUではなくCPUで計算されます。

誰かがパフォーマンス上の利点も見ることができますか？ 結果を共有してください:)

パフォーマンスの問題に戻りますが、現在のバッチ標準レイヤーはGPUの使用からまったくメリットがありますか？ このバッチノルムの実装でGPUのメリットを経験した人はいますか？

あなたはあなた自身のためにテストすることができます：
https://github.com/tensorflow/tensorflow/blob/4addf4b5806cd731949c6582a83f5824599cd1ef/tensorflow/python/ops/batch_norm_benchmark.py

スパムについては申し訳ありませんが、ドキュメントには、このBNを畳み込みで使用する方法が実際には説明されていません（おそらくどこかに提供する必要がありますか？）。 要するに、（アクティベーションごとではなく）機能ごとに同じパラメーターを適用して学習する必要があることをどのように理解するのでしょうか？

（これを行うためのコードスニペットは少なくともありますか？）

スリムなbatch_normラッパーは、入力テンソルの最後の次元を正規化します。 したがって、完全に接続されたレイヤーからの2D入力テンソルの場合、バッチで正規化されるため、アクティブ化ごとの正規化が実行されます。 畳み込みに由来する4Dテンソルの場合、最初の3つの次元（バッチ、幅、深さ）で正規化されるため、機能ごとの正規化が実行されます。 @sguadaは、これについてもう少し説明的であるかもしれません。

@nmhkahnコードスニペットに関して、 is_training=TrueときにreuseがNoneに設定されているのはなぜですか？ これにより、スケーリングパラメータgammaとオフセットパラメータbetaがすべてのトレーニングステップで再初期化されませんか？ 元の論文では、 betaとgammaは「元のモデルパラメータとともに学習された」と思いました。 そのためには、一度だけ初期化してから、すべてのトレーニングステップで再利用するべきではありませんか？

tf.cond(is_training, lambda: batch_norm(inputT, is_training=True, updates_collections=None, scope=scope), lambda: batch_norm(inputT, is_training=False, updates_collections=None, scope=scope, reuse = True))

batch_normを利用可能で効果的にするために、TFチームがここに投入した作業に大いに感謝します。 私の検索から、このスレッドはそれを使用する方法についての最良のリソースです。 この辺りにはさまざまな問題やアイデアが飛び交っています。batch_normレイヤーの使用方法の最も単純な標準ケースについてのコンセンサスアドバイスを理解するのは困難です。 ドキュメントを拡張して正確な推奨使用法を指定することには、多くの価値があると思います。

それを理解するための最善の試みは、私を次のコードに導きました：

is_training_ph = tf.placeholder(tf.bool)
...
with tf.variable_scope('bn_test_layer') as vs:
    layer_output = tf.cond(is_training_ph,
        lambda: tf.contrib.layers.batch_norm(layer_input, is_training=True, center=True, scale=True, activation_fn=tf.nn.relu, updates_collections=None, scope=vs),
        lambda: tf.contrib.layers.batch_norm(layer_input, is_training=False, center=True, scale=True, activation_fn=tf.nn.relu, updates_collections=None, scope=vs, reuse=True))

次に、is_training_phをトレーニングの場合はTrueに、テストの場合はFalseに設定します。 これは私にはうまくいきません。 鉄道模型はうまく訓練されますが、テストのパフォーマンスはひどいです。 対照的に、テスト時にis_training_ph = Trueを維持すると、うまく機能します。 したがって、適切な既存の変数が見つからないように、まだスコープの問題があると思います。

@ davek44私はあなたが使用しているのと同じコードフレームワークを使用していますが、同じことを観察しました。トレーニングフェーズでis_training=Trueオンにし、検証および/またはテストフェーズでis_training=Falseをオフにすると、モデルは説明した論文と同じようにトレーニングします（モデルはより速く収束し、より大きな学習率を使用できました）が、テストのパフォーマンスはひどいものです。 is_training=True常にオンにすると、モデルはバッチノルムレイヤーを挿入しない場合と同じようにトレーニングします。 何が悪かったのかわかりません。TensorBoardを使用してパラメーターを監視する予定です。 この動作の原因を診断した場合、更新していただけますか？

tf.contrib.layers.batch_normはテンソルをis_trainingと見なすことができるため、特別なことをする必要はありません。

is_training_ph = tf.placeholder(tf.bool)

outputs = tf.contrib.layers.batch_norm(layer_input, is_training=is_training_ph, center=True, scale=True, activation_fn=tf.nn.relu, updates_collections=None, scope='batch_norm'),

そのコードでも同じようにテストパフォーマンスが低下します。

詳細を知ることは不可能ですが、私の推測では、トレーニングは数回の反復でしか行われないため、moving_meanとmoving_averageはまだ収束していません。

テスト中にbatch_sizeを変更して、バッチを小さくするとパフォーマンスがどのように低下​​するかを確認できます。

そのコードでも同じようにテストパフォーマンスが低下します。

tf.slim batchnormまたはtf.condのいずれかで、プレースホルダーとしてis_trainingを入力してもまったく同じ問題が発生しました。
前者の場合、訓練されたモデルを調査したところ、移動平均と移動分散がすべてゼロで構成されていることがわかりました。
後者の場合、移動平均と分散は（異なる値で）より合理的に見えますが、テスト時にis_training = Falseを使用すると、パフォーマンスも非常に悪くなります。 is_training = Trueを使用すると、より適切に機能しますが、テストバッチ内の移動平均と分散のみを使用すると思います。

@nmduc @ davek44トレーニングとテスト中にtf.contrib.layers.batch_norm計算された移動平均と移動分散を追跡するコードを作成しました。 decayの値は非常に重要であり（指数関数的減衰を使用して移動平均と移動分散を計算します）、 decay設定を1.0に近づけます（つまり、 decay=.999 ）、移動平均は0に近い値に低下します。まったく同じコードで2回のテスト実行を行いましたが、 tf.contrib.layers.batch_norm decay設定が異なり、検証/テストの精度がより合理的であるように見えました。

decay=0.9のテスト実行結果

decay=0.999使用したテスト実行結果（ decay=0.999はtf.contrib.layers.batch_normのデフォルト設定です）

（また、減衰値が大きいほど、検証精度の変化を確認するためにモデルをより長くトレーニングする必要があるようです）

うん、それを修正した。 @zhongyukで分析を共有していただきありがとうございます。

開発者には、decay = 0.9をデフォルトにすることを検討することをお勧めします。 0.99でさえ私にはうまくいきません。 これは、Torchの実装のデフォルト値でもあります。 https://github.com/torch/nn/blob/master/BatchNormalization.luaの運動量パラメーターを参照して

@zhongyuk共有していただきありがとうございます。 それは今私のために働きます。

これは重要なようです。 @sguada 1.0より前に、ここで正しい行動decay大幅に下げる必要がある可能性があるという事実を文書化したPRを送ってくれますか？ そのパラメーターを微調整する必要はなかったと確信していますが、分散設定の副作用である可能性があります。

デフォルトを0.9に変更するか、より小さなデータセットまたは少数の更新でその影響をより適切に文書化することができます。
分散設定の@vincentvanhouckeは通常、数百万の更新を行うので問題ありませんが、数百の更新のみを行うここのような他の場合には、大きな違いがあります。
たとえば、decay = 0.999を使用すると、1000回の更新後に0.36のバイアスが発生しますが、そのバイアスは10000回の更新後に0.000045に低下し、50000回の更新後に0.0に低下します。

特に小さなバッチサイズを使用すると、テストのパフォーマンスが低下するという問題もあることに注意してください（トレーニングに使用した200ではなく10より小さいものは、テストの精度を低下させます）。 tf.placeholderを使用して、テスト/トレーニングモードを切り替えました。

このバッチ正規化レイヤーがトレーニングの収束を改善するために機能することは素晴らしいことですが、モデルを本番環境に適用できない場合は、それを使用してもあまり意味がありません。 このバッチノルムレイヤーを使用して、小さなデータサンプルまたは単一のデータサンプルで良好なテストパフォーマンスを確認できる人はいますか？

is_training = Falseを小さなバッチで使用し、batch_size = 1でも使用すると、バッチからの統計を使用せず、トレーニング中に学習した統計を使用するため、テストのパフォーマンスが良好であることを確認できます。 統計がデフォルトのdecay = 0.999に収束していることを確認する必要があります。これは、少なくとも50kの更新を意味します。

TF開発者の確認をフォローアップするために、2つの異なるdecay設定（およびトレーニングbatch_size = 1）を使用して統計の収束を追跡します。 decay=0.99と、550〜600ステップの学習/更新後に統計が収束します（バイアス<0.001）。 decay=0.9と、学習/更新の100ステップ以内で統計が収束します（バイアス<0.001）。

@sguadaありがとう、それは出力が実際にバッチサイズに依存しないことも意味しますか？ 精度に大きな影響を与える非常にわずかな変化に気付いているからです（おそらく、パフォーマンスの定義は、このわずかな変化の影響を受けやすくなっています）。 正確には、128次元の出力テンソルのすべての値が増加するため、ベクトルの全長はバッチサイズにほぼ直線的に比例します。 値ごとに、これはそれほど大きな違いではありませんが、潜在空間のベクトル距離を計算するときに大きな影響を与えます。

@zhongyukありがとうdecay=0.9で約5kの更新を実行したので、収束するはずであり、大きなバッチサイズを使用したパフォーマンスのテストは問題ありません。 しかし、そうでなかったとしても、テストのトレーニングに違いが生じるでしょうか？ 収束していなかったとしたら、トレーニング

さらに調査して、別のタスクで問題を再現できるかどうかを確認します。 これまでの迅速なフィードバックに感謝します！

@dominikandreas統計が収束しないことが原因でテストのパフォーマンスが低下する場合は、トレーニングのパフォーマンスはかなり良好ですが、テストのパフォーマンスは不良です。 トレーニング中、バッチの正規化はトレーニングバッチ統計のみを使用して行われるためです。 ただし、テスト時間中は、すべてのトレーニングバッチの移動平均統計を使用して、入力テンソルを正規化します。

コードにエラーが見つかりました。バッチ正規化は正常に機能しています:-)サポートに感謝します

こんにちは@zhongyuk 、移動平均と分散をどのように追跡しましたか？
ありがとう！

@rogertrullo通常、移動平均と分散を追跡するようにTensorBoardを設定します。 それ以外に、バイアスを監視するためのトレーニングと参照中に、スコープ内のtf.get_variable("moving_mean")を介して統計をフェッチしようとしました。

こんにちは、
他の説明と同じ問題があり、トレーニング結果は良好ですが、batch_normを使用した後の検証/テストが不良です。
私は次のような関数を使用します：
conv_normed1 = tf.contrib.layers.batch_norm（conv1 + block1_layer3_1_biases、updates_collections = None、scale = True、decay = batch_norm_decay、center = True、is_training = is_training）
減衰値は0.9です
再利用フラグを設定する必要がありますか？
助けていただければ幸いです。

このスレッドで説明されているようにbatch_normを使用しており（トレーニング用のtf.bool、およびops.GraphKeys.UPDATE_OPSを使用）、すべてが機能します。

以下を使用して保存および復元する場合：
セーバー= tf.train.Saver（）
できます、

ただし、以下を使用して保存する場合：
セーバー= tf.train.Saver（tf.trainable_variables（）+ [global_step]）
（グラデーションなどを保存しないことで）ストレージスペースを節約できるように
復元時にエラーが発生します：
「初期化されていない値unpool4 / convc / bn / moving_mean」

明らかに、これは、moving_mean（およびmoving_variance）がどのレイヤーにも保存されていないためです。 私はそれらをたくさん持っているので（多くのレイヤーにネストされています）-保存する値のリストにそれらを追加する最も効率的な方法は何ですか？ また、これらはトレーニング可能な変数であるため、trainable_variablesコレクションに追加されないのはなぜですか？

@mshunshinの移動平均と分散は、トレーニング可能な変数ではありません。勾配はありません。これらは、例のミニバッチ全体で統計を蓄積しているだけです。
それらを保存/復元するには、tf.global_variables（）を使用できます。

私にとって、このラッパーを使用すると、物事が機能し始めました。
def batch_norm_wrapper(x, phase, decay, scope, reuse): with tf.variable_scope(scope, reuse=reuse): normed = tf.contrib.layers.batch_norm(x, center=True, scale=True, decay=decay, is_training=phase, scope='bn',updates_collections=None, reuse=reuse) return normed
私の意見では、スコープの使用と再利用全体は、このスレッドでは明確ではありません。

どうもありがとう。 tf.global_variables（）を使用すると、グラデーションが含まれていると思うので、保存ファイルははるかに大きくなります。 結局私は使用しました：

saver = tf.train.Saver（[x for x in tf.global_variables（）if'Adam 'not in x.name]）

そして、セッションマネージャのinitがそれらを適切に初期化しないため：

sess.run（tf.variables_initializer（[x for x in tf.global_variables（）if'Adam 'in x.name]））

（tf.train.AdamOptimizerを使用）

モデルの変数を含むtf.model_variables（）、つまり移動平均を使用することもできます。

@sguadaご迷惑を

私はslim.batch_normを使用していますが、トレーニングのパフォーマンスが高く、検証/テストのパフォーマンスが低くなっています。 reuseやscopeなどのパラメータの不適切な使用が原因だと思います。 バッチ正規化には多くの問題がありますが、それを使用する方法に関する完全なコードスニペットを見つけるのは困難です。 さまざまなフェーズでさまざまなパラメータを渡す方法について。

たとえば、 tf.GraphKeys.UPDATE_OPSを使用して依存関係を制御し、 is_trainingをプレースホルダーとして設定したとします。 しかし、{is_training：False}をフィードすると、検証パフォーマンスは依然として低下します。

公式で完全な（つまり、トレーニング、検証、テストがすべて含まれている）バッチ正規化の例があれば、大いに感謝します。

前もって感謝します！

こんにちは、
バッチノルムを使用するたびに異なるスコープを設定し、私に適したトレーニング/テストフェーズ（テストの場合はTRUE、トレーニングの場合はFALSE）に従って再利用入力を与える必要があります。

@ishaybee助けてくれてありがとう。 問題が見つかりました==これはmoving_mean / moving_varianceのコールドスタートが原因です。

十分なステップをトレーニングしていないため、推定移動平均/分散はそれほど安定していません。 結果は次のようになります。モデルはミニバッチのトレーニングでかなりうまく機能しますが（最初は損失が急速に減少することを知っています）、検証パフォーマンスは不安定です（推定された母集団の平均/分散が十分に安定していないため）。

モデルをより長くトレーニングすると、検証の精度も高くなります。

もう1つの重要なことは、必ずslim.learning.create_train_opを使用してtrainopを作成することです。 tfネイティブtf.train.GradientDescentOptimizer(0.1).minimize(loss)は使用しないでください。

したがって、答えは、バッチ正規化を正しく使用していますが、トレーニング中のダイナミクスを完全には理解していません。

================
そのうえ：

1. これは、 MNISTデータセットでBNレイヤーを使用する方法の
2. 小さい減衰値を使用すると、ウォームアップフェーズが加速されます。 デフォルトの減衰は0.999です。MNISTなどの小さなデータセットの場合、0.99または0.95を選択でき、短時間でウォームアップします。

@soloice 、注意、コメントについては、batch_normを呼び出すために次のパラメーターがレイヤー内に渡されます。

batch_norm_params = {'is_training'：is_training、 'decay'：0.9、 'updates_collections'：なし}

updates_collectionsがNoneに設定されていない場合（つまり、BatchNorm内で平均更新が行われる）、BatchNormレイヤーが移動平均を更新するために必要なtf.GraphKeys.UPDATE_OPSを何らかの方法で実行することは期待できません（例：conv2d）。したがって、後でテストデータを実行できます。

または、ここでUPDATE_OPSを明示的に実行してみて

    update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
    if update_ops:
        updates = tf.group(*update_ops)
        cross_entropy = control_flow_ops.with_dependencies([updates], cross_entropy)

更新-私はあなたのコードを正確に引用し、あなたはUPDATE_OPSを使用していることがわかりました。

「コールドスタート」については、上記の説明で見たように、BatchNormの移動平均減衰（入力パラメーター）をデフォルトの0.999から0.95のような値に減らすと、起動を高速化できます。

@pavelbulanovこれを手伝ってくれてありがとう！ decay小さい値を試して、これがどのように役立つかを確認します。

================
更新：小さな減衰（たとえば、0.9または0.95）を使用すると大いに役立ちます。 decayを0.9に設定すると、検証損失はすぐに減少します。 ただし、小さな減衰の欠点は、その有効範囲が小さいことです。結果は、最近のいくつかのサンプルによって支配されているため、母平均/分散の適切な推定ではありません。 クイックスタート（小さな減衰）とより長い有効範囲（大きな減衰）のバランスをとる必要があります。

こんにちは、
この問題の提案を利用してバッチ正規化レイヤーを実装しようとしましたが、検証とテストで70％を超えるエラーが発生します...トレーニング以外の呼び出しの減衰は低くなります...

これが私のコードです：

def BatchNorm(inputT, is_training=False, scope=None):
  return tf.cond(
    is_training,
    lambda: tf.contrib.layers.batch_norm(inputT, is_training=True,  reuse=None, decay=0.999, epsilon=1e-5, center=True, scale=True, updates_collections=None, scope=scope),
    lambda: tf.contrib.layers.batch_norm(inputT, is_training=False, reuse=True, decay=0.900, epsilon=1e-5, center=True, scale=True, updates_collections=None, scope=scope)
    )

前もって感謝します。

@Alexivia 2つの異なるバッチ正規化レイヤーを使用しているようですか？ BNレイヤーは1つだけ使用する必要があります（もちろん、 is_trainingパラメーターが異なります）。

@soloiceにアドバイスありがとうございます。
is_trainingとreuseパラメーターを変えてみました。

lambda: tf.contrib.layers.batch_norm(inputT, is_training=True,  reuse=None, decay=0.9, epsilon=1e-5, center=True, scale=True, updates_collections=None, scope=scope),
lambda: tf.contrib.layers.batch_norm(inputT, is_training=False, reuse=True, decay=0.9, epsilon=1e-5, center=True, scale=True, updates_collections=None, scope=scope)

それでも良い検証とテスト結果が得られません...> 70％...

こんにちは、
上記の私のラッパーを参照してください。
「withtf.variable_scope（scope、reuse = reuse）：」を使用する必要があると思います。

こんにちは@ishaybee 、
私はあなたのアドバイスに従いました、今私のコードは次のとおりです：

def BatchNorm(inputT, is_training=False, reuse=True, scope=None):
  with tf.variable_scope(scope, reuse=reuse):
    return tf.contrib.layers.batch_norm(inputT, is_training=is_training, reuse=reuse, scope=scope, updates_collections=None, decay=0.9, center=True, scale=True)

そして、feed_dictを介してis_trainingとreuseをフィードしますが、エラーValueError("The reuse parameter must be True or False or None.")

再利用をPython変数（モデルの入力）およびプレースホルダーとしてフィードしてみてください。

試してみたところ、値についての文句はなくなりました...しかし、値をbatch_norm関数に強制しても変化が見られず、TensorBoardでは変化が見られないため、プレースホルダー値は使用されていないと思います。グラフに接続しています...（添付画像を参照）

私のコードは今このようになっています：
バッチ正規化ラッパー

def BatchNorm(inputT, is_training=False, reuse=None, scope=None):
  with tf.variable_scope(scope):
    return tf.contrib.layers.batch_norm(inputT, is_training=is_training, reuse=reuse, scope=scope, updates_collections=None, decay=0.9, center=True, scale=True)

モデル定義

def model(data, train=False, is_training=False, reuse=None):
  # 1st conv layer
  with tf.name_scope('conv1') as scope:
    conv = tf.nn.conv2d(
    <...>
    norm = BatchNorm(pool, is_training=is_training, reuse=reuse, scope=scope)

トレーニング

feed_dict = {train_data_node: batch_data,
      train_labels_node: batch_labels,
      is_training: True,
      reuse: None}
  # Run the optimizer to update weights.
  sess.run(optimizer, feed_dict=feed_dict)

検証

batch_predictions = sess.run(eval_prediction, feed_dict={eval_data: data[-EVAL_BATCH_SIZE:, ...], is_training: False, reuse: True})

is_traningは可能ですが、プレースホルダーの再利用はブール値である必要があり、テンソルでもプレースホルダーでもありません。

何をしようとしているのかわかりません。ほとんどの場合、静的な値を使用すると問題が解決します。 たとえば、このパターンはうまく機能します。

def model(data, is_training=False, reuse=None, scope='my_model'):
  # Define a variable scope to contain all the variables of your model
  with tf.variable_scope(scope, 'model', data, reuse=reuse):
    # 1 layer
    net = tf.contrib.layers.conv2d(data, ....)
    ....
    net = tf.contrib.layers.batch_norm(net, is_training)
   return net

train_outputs = model(train_data, is_training=True)
eval_outputs = model(eval_data, is_training=False, reuse=True)

eval_predictions = sess.run(eval_outputs, feed_dict={eval_data: data[-EVAL_BATCH_SIZE:, ...]})

モデルの動作を動的に変更する必要がない限り、is_trainingにプレースホルダーを使用する必要はありません。 秘訣は、モデルを2回作成し、2回目に変数を共有することです。

ありがとう@sguada ！ あなたの提案を適用した後、私はついにそれを機能させることができました！

API 1.0のドキュメントに、グラフに更新操作を手動で追加する必要があることが反映されていると便利です。 新しいtfユーザーである私は、テストエラーがおかしいことに気づき、バッチの正規化が問題であることに気付くまで、グラフのデバッグにかなりの時間を費やさなければなりませんでした。 次に、最適化にcontrib関数を使用しない限り、デフォルトでモーメントを追跡する変数が更新されないことを理解するために、より多くの時間を費やす必要がありました。 1.0では、update_collectionsをNoneに設定するオプションがないため、これが問題になる可能性があることを示すインジケーターはドキュメントからありません。 さらに、トレーニングケースで実行される操作に制御フローの依存関係を追加するパラメーターがあることは理にかなっているようです。

@danrscその通り。 BNレイヤーの使用法はかなり混乱しています。 バッチ正規化に関するドキュメントまたは完全な公式チュートリアルを追加することを提案しましたが、残念ながら応答がありません= =

完全に同意します。 BNの使用法は非常にトリッキーであり、ドキュメントは現在不十分ではないと思います。 これは、このような一般的に使用されるレイヤーでは修正する必要があります。

ドキュメントの問題を可視化するために再度開きます。

@sguadaがトリアージのためにあなたに割り当てます。 ケースについてテクニカルライターを雇う価値があるかもしれません。

先週この問題に混乱し、3日間のトレーニングを無駄にしました...ドキュメントがすぐに修正され、公式のバッチ正規化の例がAPIドキュメントに追加されることを願っています。

@sguada 「tf.contrib.layers.batch_normはテンソルをis_trainingとして使用できるため、特別なことをする必要はありません」とおっしゃっていました。
しかし、コード内のコメントは
is_trainingがTensorであるために定数値を持たない場合、
＃ VariableまたはPlaceholder場合、is_training_valueはNoneになり、
＃ needs_momentsが真になります。
is_trainingをプレースホルダーとして設定した場合、テストフェーズでもnees_momentsがtrueになるということですか？
私の知る限り、テスト中の瞬間は必要ありません。

したがって、 is_trainingがVariableまたはPlaceholder場合、変更できることを意味するため、モーメントを計算するグラフが必要になるため、レイヤーがそれを構築します。
次に、実行時に、値がTrueまたはFalse Trueかどうかに応じて、バッチmomentsまたはmoving_meanとmoving_varianceます。

したがって、テスト中に値をFalseと、 momentsは使用されません。

@sguada @ brando90

def batch_norm_layer(self, x,train_phase, scope_bn):
        bn_train = batch_norm(x, decay=0.9, center=False, scale=True,
        updates_collections=None,
        is_training=True,
        reuse=None,
        variables_collections= [UPDATE_OPS_COLLECTION],
        trainable=True,
        scope=scope_bn)
        bn_inference = batch_norm(x, decay=0.9, center=False, scale=True,
        updates_collections=None,
        is_training=False,
        reuse=True,
        variables_collections= [UPDATE_OPS_COLLECTION],
        trainable=True,
        scope=scope_bn)
        z = tf.cond(train_phase, lambda: bn_train, lambda: bn_inference)
        return z

このようにbatchnormを作成しましたが、移動平均と移動変数がテスト中に更新され、理由がわかりません。

@sguadaが言ったように、2つのモデルを作成しようとしましたが、is_training = Falseのモデルがクラッシュします。

W tensorflow/core/framework/op_kernel.cc:993] Not found: Key fully_connected_5/weights not found in checkpoint
W tensorflow/core/framework/op_kernel.cc:993] Not found: Key fully_connected_6/weights not found in checkpoint
W tensorflow/core/framework/op_kernel.cc:993] Not found: Key fully_connected_7/biases not found in checkpoint
W tensorflow/core/framework/op_kernel.cc:993] Not found: Key fully_connected_6/biases not found in checkpoint
W tensorflow/core/framework/op_kernel.cc:993] Not found: Key fully_connected_7/weights not found in checkpoint
W tensorflow/core/framework/op_kernel.cc:993] Not found: Key history_embeddings_1 not found in checkpoint
W tensorflow/core/framework/op_kernel.cc:993] Not found: Key global_step_1 not found in checkpoint

完全に接続されたネットとCNNを使用してバッチノルムを実行する方法の具体的な例があるはずだと思います。 誰もがこの機能を使おうとしているのを見る前に、物事がうまくいくことを期待して何日もモデルを訓練してきたのはうんざりです。

興味深いことに、batch_normでトレーニングした後、モデルを復元するには数十億年かかります。 ほとんどの場合、TF2.0までこのようなことを再試行するのを待ちます。

@MisayaZ 2つのbatch_normレイヤーを作成する必要はなく、train_phase（tf.boolであると想定）をbatch_normに渡すだけです。 また、UPDATE_OPS_COLLECTION変数_collectionsを渡します。これにより、追加される変数であるコレクションが変更されます。

以下が機能するはずです。

z = batch_norm(x, decay=0.9, center=False, scale=True, updates_collections=None, 
                             is_training=train_phase, scope=scope_bn)

@OktayGardenerは、作成しようとしているモデルがわからないため、変数がチェックポイントに保存されていないようです。

batch_normは、完全に接続されたレイヤーでも機能します。

slim = tf.contrib.slim
def model(data, is_training=False, reuse=None, scope='my_model'):
  # Define a variable scope to contain all the variables of your model
  with tf.variable_scope(scope, 'model', data, reuse=reuse):
    # Configure arguments of fully_connected layers
    with slim.arg_scope([slim.fully_connected],
                        activation_fn=tf.nn.relu,
                        normalizer_fn=slim.batch_nom):
      # Configure arguments of batch_norm layers
      with slim.arg_scope([slim.batch_norm],
                          decay=0.9,  # Adjust decay to the number of iterations
                          update_collections=None, # Make sure updates happen automatically
                          is_training=is_training, # Switch behavior from training to non-training):
        net = slim.fully_connected(data, 100, scope='fc1')
        net = slim.fully_connected(net, 200, scope='fc2')
        ....
        # Don't use activation_fn nor batch_norm in the last layer        
        net = slim.fully_connected(net, 10, activation_fn=None, normalizer_fn=None, scope='fc10')
       return net

@sguadaありがとう、私はあなたが上で述べたように実装されているbathnormでネットワークを構築します

z = batch_norm(x, decay=0.9, center=False, scale=True, updates_collections=None, 
                             is_training=train_phase, scope=scope_bn)

速度が遅いので、テンソルフローベンチマークを使用して次のように計算時間を取得します。
I tensorflow / core / util / stat_summarizer.cc：392]==============================計算時間でトップ=== ===========================
I tensorflow / core / util / stat_summarizer.cc：392] [ノードタイプ] [開始] [最初] [平均ms] [％] [cdf％] [mem KB] [名前]
I tensorflow / core / util / stat_summarizer.cc：392] Conv2D 106.164 51.354 51.004 23.145％23.145％692.224 conv8 / Conv2D
I tensorflow / core / util / stat_summarizer.cc：392] Conv2D 85.187 19.115 19.283 8.750％31.896％692.224 conv7 / Conv2D
I tensorflow / core / util / stat_summarizer.cc：392] SquaredDifference 11.967 15.105 14.331 6.503％38.399％11075.584 conv1 / batch_norm / moments / success_statistics / SquaredDifference
I tensorflow / core / util / stat_summarizer.cc：392] Mul 11​​.970 14.162 13.495 6.124％44.523％11075.584 conv1 / batch_norm / batchnorm / mul_1
I tensorflow / core / util / stat_summarizer.cc：392] Conv2D 3.948 8.170 7.986 3.624％48.146％11075.584 conv1 / Conv2D
I tensorflow / core / util / stat_summarizer.cc：392] Sub 11.960 10.176 7.943 3.604％51.751％11075.584 conv1 / batch_norm / moments / success_statistics / Sub
I tensorflow / core / util / stat_summarizer.cc：392] SquaredDifference 45.570 5.908 7.177 3.257％55.007％5537.792 conv2 / batch_norm / moments / success_statistics / SquaredDifference
I tensorflow / core / util / stat_summarizer.cc：392] Mul 45.574 7.755 6.902 3.132％58.140％5537.792 conv2 / batch_norm / batchnorm / mul_1
I tensorflow / core / util / stat_summarizer.cc：392] Conv2D 40.692 5.408 4.845 2.199％60.338％5537.792 conv2 / Conv2D
I tensorflow / core / util / stat_summarizer.cc：392] Sub 45.563 6.067 4.784 2.171％62.509％5537.792 con

conv1 / batch_norm / moments / success_statistics / SquaredDifferenceのように、テスト中に瞬間的にいくつかの操作が実行され、多くの時間がかかる理由がわかりません。

テストではその瞬間は必要ありませんが、なぜ瞬間の下でいくつかの操作が実行されるのですか？

こんにちは、

contrib.layersの上記のbatch_normレイヤーを使用すると、トレイングラフがシームレスに実行されている間、検証グラフの出力としてnanを取得しています。 足りないものはありますか？

私が使用しているもの：

def batchnormlayer(inputs, numout, train_model):
    with tf.variable_scope("batch_norm") as scope_bn:
        epsilon = 1e-3
        return tf.contrib.layers.batch_norm(inputs, decay=0.9, updates_collections=None,
                                            scale=True, scope=scope_bn,
                                            is_training=train_model, epsilon=epsilon,
                                            fused=True, reuse=scope_bn.reuse)

ありがとう

フォローアップとして、batch_normの16レイヤーを再利用しています。
しかし、4つのレイヤーを再利用することでうまくいくことがわかりました。

テンソルフロープロセスを強制終了して再起動すると、エラーが数エポックの間悪化する（つまり、最後のチェックポイントでのエラーよりも悪化する）ことに気付いたばかりです。 また、batch_normを削除すると、この問題が解消されることもわかりました。 しばらくコードを見た後、移動平均を管理するためにExponentialMovingAveragesクラスが使用された場合のように、変数の値がシャドウ変数から復元されなかったことが原因である可能性があります。 これは、別のプロセスを使用して評価すると、移動平均ではなく、変数の最後の値が取得されることも意味します。 私はこれを正しく解釈していますか？これは意図された動作ですか？ シャドウ変数の値を復元したいようです...

私は問題を見つけました、私の場合の移動分散はいくつかの反復の後に負になります。

テンソルの出力： Model/clip_logits/batch_norm/moving_variance:0存在するtf.model_variables()は

Moving variance (shape = (101,)) = 
[ 214.70379639   95.36338043    0.57885742  189.49542236  102.72473145
  137.14886475  286.57333374  111.06427002  154.98750305  167.75219727
  207.83955383  211.14007568  158.23495483  171.61665344  116.81361389
  115.77380371   43.59399796  137.75064087  181.75245667  161.37339783
  215.21934509   92.88521576  191.23846436  336.3946228   259.85919189
  299.47039795  186.23222351  165.19311523  262.82446289  170.11567688
  233.56843567  209.35050964  115.96807861  154.34109497  295.5770874
  123.6055603   295.76187134  296.88583374  240.88217163  247.32983398
   87.15661621  217.69897461  133.00698853   -4.80375671  344.77462769
  291.50601196  117.77174377  265.83712769  207.90093994  194.186203
  220.21418762  178.03738403  115.27571869  196.62184143  228.8089447
  191.53205872  331.36807251  151.55435181  197.2951355   179.67504883
  181.09727478   90.09922791  173.30133057  102.6836853   160.9434967
  236.59512329  168.05305481  403.36340332   41.14326096  185.93409729
  130.57434082  266.31509399  101.44387817  163.88059998  290.25015259
  244.52597046  229.86647034  158.14352417  202.68774414  187.78227234
  248.78218079  126.0978241   171.41891479  274.40740967  119.84254456
  202.53045654  200.20608521  214.04730225  111.53284454  222.03184509
  244.81187439  172.23052979  187.09806824  194.62802124  255.26345825
  293.63598633  307.91036987  210.86982727  308.88919067  144.94792175
  229.69013977]

ご覧のとおり、ディメンションの1つに負の分散があります。 これはどうして可能ですか？
PSバッチノルム層は、ネットワークの最後の完全に接続された層の直後で、softmaxの前に使用されます。

@ raghavgoyal14 fused = Trueで使用していますか？ 同様の問題があり、融合バージョンを使用すると問題が解決しました

@abred ：はい、 fused=True 、同じ問題です。

@sguadaこんにちは、sguada、問題があります。
tensorflowでのcontrib.layers.batch_normの定義：
def batch_norm（inputs、
減衰= 0.999、
center = True、
scale = False、
イプシロン= 0.001
Activation_fn =なし、
param_initializers =なし、
param_regularizers =なし、
updates_collections = ops.GraphKeys.UPDATE_OPS、
is_training = True、
再利用=なし、
variables_collections = None、
output_collections =なし、
trainable = True、
batch_weights = None、
fused = False、
data_format = DATA_FORMAT_NHWC、
zero_debias_moving_mean = False、
scope =なし、
renorm = False、
renorm_clipping =なし、
renorm_decay = 0.99）：
スケール：Trueの場合、ガンマを掛けます。 Falseの場合、ガンマは
使用されていない。 次の層が線形である場合（たとえば、nn.relu）、これは次のようになります。
スケーリングは次のレイヤーで実行できるため、無効になっています。

tf.contrib.layers.batch_norm（input、scale = False）を使用する場合、「scale = False」は、トレーニング中に「y = gamma * x + beta」でガンマがゼロかどうかを意味します。 どうもありがとうございました。

scale = Falseの場合、ガンマは定数1です。

@ppwwyyxxご
どうもありがとうございました。

@MisayaZ 「is_training」のプレースホルダーを指定してBatchnormを使用しても同じ動作をしていました。 トレースでは、テスト時でもモーメントが計算されていることがわかります。そのため、ソースコードに入ると、次のことがわかりました。

    # If `is_training` doesn't have a constant value, because it is a `Tensor`,
    # a `Variable` or `Placeholder` then is_training_value will be None and
    # `needs_moments` will be true.
    is_training_value = utils.constant_value(is_training)
    need_moments = is_training_value is None or is_training_value
    if need_moments:
        # here it defines the moments

「is_training」が変数またはプレースホルダーの場合、プレースホルダーを「False」に設定した場合でも、モーメントが定義され、実行時にそれらが計算されるように見えます。 グラフを再定義せずにトレーニング中に定期的なテストを実行できるため、プレースホルダーのままにしておくことをお勧めしますが、定数として使用し、トレーニングとテストの異なる動作を定義することにしました。現在、モーメントは計算されていません。テスト時に。

@ tano297ありがとうございます。 'is_training'も定数として使用するようになりました。 プレースホルダーのままにして、定期的なテストを行うと、移動平均と移動分散の値が変更されます。 また、入力の平均と分散を計算し、移動平均と移動分散を更新するため、推論時間は長くなります。 テストを行う正しい方法は、前述のようにトレーニングとテストのさまざまな動作を定義することです。

@ tano297 @MisayaZ
しかし、「smart_cond」は

is_training_value = utils.constant_value(is_training)
need_updates = is_training_value is None or is_training_value
if need_updates:
  ...
  outputs = utils.smart_cond(is_training, _force_updates, no_updates)

is_trainingがTrueと評価された場合にのみ、更新が計算および適用されることを確認してください。

@abredはい、確かにそうですが、391行目を参照しています。ここでは、_fused_batch_norm（）内の移動平均の更新が行われます。

    # If `is_training` doesn't have a constant value, because it is a `Tensor`,
    # a `Variable` or `Placeholder` then is_training_value will be None and
    # `need_updates` will be true.
    is_training_value = utils.constant_value(is_training)
    need_updates = is_training_value is None or is_training_value
    if need_updates:
        ...
        outputs = utils.smart_cond(is_training, _force_updates, no_updates)
        ...

私はbatch_norm（）内の753行目について話している：

    # If `is_training` doesn't have a constant value, because it is a `Tensor`,
    # a `Variable` or `Placeholder` then is_training_value will be None and
    # `needs_moments` will be true.
    is_training_value = utils.constant_value(is_training)
    need_moments = is_training_value is None or is_training_value
    if need_moments:
        ...
        mean, variance = utils.smart_cond(is_training,
                                          _force_updates,
                                          moving_vars_fn) 
        ...

その場合のスマート条件（私に関する限り）は、移動平均を更新するかどうかを決定しますが、モーメントは計算されます。

@ tano297あなたはそれについて正しいです、私は間違った場所にいました、しかしそれでも：
行755-770はモーメントを計算しますが、モーメントは_force_updatesでのみ使用され、is_trainingがTrueと評価された場合にのみ実行されますね。
したがって

mean, variance = utils.smart_cond(is_training, _force_updates, moving_vars_fn) 

行804と同等である必要があります。

mean, variance = moving_mean, moving_variance

is_trainingがFalseに評価され、したがって「モーメント」の場合-グラフの一部は使用されないため、実行しないでください

しかし、私はテストしていないので、それについて間違っているかもしれません:)

@ tano297 @abred youright 。 次のようにbatchnormを使用すると、移動平均と移動分散が変更されます。

def batch_norm_layer(self, x,train_phase, scope_bn):
        bn_train = batch_norm(x, decay=0.9, center=False, scale=True,
        updates_collections=None,
        is_training=True,
        reuse=None,
        variables_collections= [UPDATE_OPS_COLLECTION],
        trainable=True,
        scope=scope_bn)
        bn_inference = batch_norm(x, decay=0.9, center=False, scale=True,
        updates_collections=None,
        is_training=False,
        reuse=True,
        variables_collections= [UPDATE_OPS_COLLECTION],
        trainable=True,
        scope=scope_bn)
        z = tf.cond(train_phase, lambda: bn_train, lambda: bn_inference)
        return z

次のように使用する場合：

z = batch_norm(x, decay=0.9, center=False, scale=True, updates_collections=None, 
                         is_training=train_phase, scope=scope_bn)

移動平均と移動分散はテスト中に変更されませんが、速度は非常に遅いです。

こんにちは@zhongyuk 、

また、トレーニングと推論の両方にis_training = Trueを使用すると良い結果が得られるが、推論中にis_training = Falseを設定すると悪い結果が得られるという問題も発生しました（is_training = Trueを使用する場合よりも悪い）。 あなたの分析によると、私が正しく理解していれば、BNでdecay = 0.9を設定するだけで、この問題を解決できます。 私は正しいですか？

ところで、decay = 0.9を使用してモデルを最初から再トレーニングする必要がありますか？ または、チェックポイントからトレーニングを再開する（つまり、decay = 0.999のときにトレーニングする）こともできますか？

ありがとう！

@nmduc @ davek44

こんにちは。トレーニングと推論の両方にis_training = Trueを使用すると良い結果が得られるが、推論中にis_training = Falseを設定すると悪い結果が得られるという問題も発生しました（is_training = Trueを使用する場合よりも悪い）。 あなたたちはこの問題を解決しましたか？ ありがとう！

@tyshiwobatch_normにdecay = 0.9を設定したところ、これまでのところうまく機能しています。

バッチノルムを適切に使用する方法についてのこれらすべてのコメントの後で私は混乱しました：それで私が持っているものはここにあります。 私が間違っている場合は私を訂正してください。

batch_norm = tf.contrib.layers.batch_norm(conv, center=True, scale=True, reuse=phase_train_py, scope='bn', is_training=is_training)

ここで、phase_train_pyはPythonのブール変数であり、is_trainingはブール変数を受け取るプレースホルダーです。 tf.condの使用は間違っていると思います。そうでない場合、関数にはブールパラメーターが付属していました。 言い換えると、 tf.condが真の場合、トレーニング用にbatch_norm関数を使用し、テスト用に別の関数を使用する必要があります。 したがって、開発者は、関数の動作を変更するために、これらのブール変数を変更することを許可します。 つまり、私が行っているのは、トレーニング中にis_training phase_train_pyをFalseに設定し、 is_trainingをTrueに設定することです。 そして、テスト中はその逆です。 テンソルまたはプレースホルダーはsess.runでしか変更できないため、グラフを実行する前に意図的にphase_train_pyを変更しました。 例：

if condition: phase_train_py = False sess.run(to_run_list, feed_dict={phase_train: True}) else: phase_train_py = True sess.run(to_run_list, feed_dict={phase_train: False})

++++++++++++++++++++++++++++++++++++++++++++++++++++ +++++++++++++++++++++++++++++
たぶんあなたはこれを読む必要があります
++++++++++++++++++++++++++++++++++++++++++++++++++++ +++++++++++++++++++++++++++++

TFv1.3にはまだ問題があるようです。 私は次の詳細に注意していると確信していますが、それでも公式のtf.contrib.layers.batch_normを使用できず、評価中にis_training=Falseれました（ただし、評価中にis_training=True変更しないと、 OK）：
1. decay 、指数移動平均は実際には信号処理のアルファフィルターであり、収束する時間は列車の約1 /（1減衰）ステップです。 減衰= 0.999の場合、収束するには1 / 0.001 = 1000ステップが必要です。 したがって、トレーニングステップ数に適切な減衰を設定します。

1. プレースホルダーを使用してトレーニングとテストの評価を切り替える
2. update opのコントロール依存関係をtrain_opに追加したくない場合は、 updates_collections=None使用します
3. reuseを適切な値に設定します。

公式のbatch_normを使用する唯一の方法は、2つのグラフを作成することです。1つは電車用、もう1つは評価用で、それぞれis_training=Trueとis_training=Falseです。 このように、トレーニングと評価を動的に切り替える必要はありません。 しかし、複数のグラフを作成する必要があるため、これはばかげた方法です。

最後に、私は自分で移動平均を書きます、そしてそれがうまくいったことがわかります！ それは次のとおりです（Web上のコードに基づいており、自分で変更しています）

def bn_layer(x, scope, is_training, epsilon=0.001, decay=0.99, reuse=None):
    """
    Performs a batch normalization layer

    Args:
        x: input tensor
        scope: scope name
        is_training: python boolean value
        epsilon: the variance epsilon - a small float number to avoid dividing by 0
        decay: the moving average decay

    Returns:
        The ops of a batch normalization layer
    """
    with tf.variable_scope(scope, reuse=reuse):
        shape = x.get_shape().as_list()
        # gamma: a trainable scale factor
        gamma = tf.get_variable("gamma", shape[-1], initializer=tf.constant_initializer(1.0), trainable=True)
        # beta: a trainable shift value
        beta = tf.get_variable("beta", shape[-1], initializer=tf.constant_initializer(0.0), trainable=True)
        moving_avg = tf.get_variable("moving_avg", shape[-1], initializer=tf.constant_initializer(0.0), trainable=False)
        moving_var = tf.get_variable("moving_var", shape[-1], initializer=tf.constant_initializer(1.0), trainable=False)
        if is_training:
            # tf.nn.moments == Calculate the mean and the variance of the tensor x
            avg, var = tf.nn.moments(x, np.arange(len(shape)-1), keep_dims=True)
            avg=tf.reshape(avg, [avg.shape.as_list()[-1]])
            var=tf.reshape(var, [var.shape.as_list()[-1]])
            #update_moving_avg = moving_averages.assign_moving_average(moving_avg, avg, decay)
            update_moving_avg=tf.assign(moving_avg, moving_avg*decay+avg*(1-decay))
            #update_moving_var = moving_averages.assign_moving_average(moving_var, var, decay)
            update_moving_var=tf.assign(moving_var, moving_var*decay+var*(1-decay))
            control_inputs = [update_moving_avg, update_moving_var]
        else:
            avg = moving_avg
            var = moving_var
            control_inputs = []
        with tf.control_dependencies(control_inputs):
            output = tf.nn.batch_normalization(x, avg, var, offset=beta, scale=gamma, variance_epsilon=epsilon)

    return output


def bn_layer_top(x, scope, is_training, epsilon=0.001, decay=0.99):
    """
    Returns a batch normalization layer that automatically switch between train and test phases based on the 
    tensor is_training

    Args:
        x: input tensor
        scope: scope name
        is_training: boolean tensor or variable
        epsilon: epsilon parameter - see batch_norm_layer
        decay: epsilon parameter - see batch_norm_layer

    Returns:
        The correct batch normalization layer based on the value of is_training
    """
    #assert isinstance(is_training, (ops.Tensor, variables.Variable)) and is_training.dtype == tf.bool

    return tf.cond(
        is_training,
        lambda: bn_layer(x=x, scope=scope, epsilon=epsilon, decay=decay, is_training=True, reuse=None),
        lambda: bn_layer(x=x, scope=scope, epsilon=epsilon, decay=decay, is_training=False, reuse=True),
    )

グラフの作成中にbn_layer_top関数を使用するだけで、is_trainingパラメーターはtf.placeholder
。 次に、 feed_dict 、トレーニング中にプレースホルダーをTrueに、評価中にFalseに自由に切り替えることができます。

それがコミュニティに役立つことを願っています。

Slim.batch_normを使用する場合は、「tf.train.GradientDecentOptimizer（lr）.minimize（loss）」やその他のオプティマイザーではなく、必ず「slim.learning.create_train_op」を使用してください。 それが機能するかどうかを確認してみてください！

@vincentvanhouckeあなたはこのスレッドの別の投稿に書いています：

スリムなbatch_normラッパーは、入力テンソルの最後の次元を正規化します。 したがって、完全に接続されたレイヤーからの2D入力テンソルの場合、バッチで正規化されるため、アクティブ化ごとの正規化が実行されます。 畳み込みに由来する4Dテンソルの場合、最初の3つの次元（バッチ、幅、深さ）で正規化されるため、機能ごとの正規化が実行されます。 @sguadaは、これについてもう少し説明的であるかもしれません。

「スリムbatch_normラッパー」で関数tf.contrib.layers.batch_normを意味しますか？ もしそうなら、私はこの情報をこの関数のドキュメントテキストに追加することをお勧めします。 したがって、この関数は、FC-LayerとConv2D-Layerの両方について、このペーパーで説明されているのとまったく同じようにバッチ正規化を実行することが非常に明確になります。 現時点では、「conv2dおよびfull_connectedのノーマライザー関数として使用できます。」というテキストのみがあり、これが正規化軸のトピックに関連しているかどうかは不明です。

@ZahlGrafドキュメントを明確にするPRを喜んで検討します。 私たちは長い間これに取り組んできたので、何が明白であるかどうかがよくわかりません。このトピックについて新鮮な視点を持つ人のために、ドキュメントを明確にすることを歓迎します。

@vincentvanhoucke
主にこのスレッドでのあなたの声明に基づいて、より詳細な説明を含むPRを作成しました。
https://github.com/tensorflow/tensorflow/pull/15653

この問題は外部からの貢献を招いているため、譲受人を削除してください。 それ以外の場合は、 contributions welcomeラベルを削除します。 ありがとうございました。

この問題は外部からの貢献を招いているため、譲受人を削除してください。 それ以外の場合は、 contributions welcomeラベルを削除します。 ありがとうございました。

バッチノルムレイヤーを追加するという元のリクエストが解決されたため、このバグを解消します。 ドキュメントに関する最近の問題のいくつかには、独自のPRがあるようです
batch_normに問題がある場合は、StackOverflowで質問するか、別の問題を開いてください。