Tensorflow: बैच मानक परत का उपयोग करना आसान है।

मैं उस के कुछ हिस्सों पर काम कर रहा हूँ।

अब एक batch_norm परत है:
https://github.com/tensorflow/tensorflow/blob/b826b79718e3e93148c3545e7aa3f90891744cc0/tensorflow/contrib/layers/python/layers/layers.py#L100

मुझे लगता है कि इस परत के साथ कुछ गलत है। प्रशिक्षण में हर चीज ठीक है और नुकसान बहुत अच्छा है। लेकिन परीक्षण में मुझे शून्य सटीकता मिलती है।
परीक्षण के तरीके से जब मैं is_training = गलत का उपयोग करता हूं, मुझे शून्य एसीसी मिलता है।
मुझे पता है कि ट्रेन और परीक्षण चरण में बैच सामान्यीकरण अलग-अलग व्यवहार करता है , जैसा कि वर्णन - Quora । मुझे लगता है कि यह कार्यान्वयन अस्पष्ट है

यहाँ भी, मैंने is_training = गलत के साथ कुछ अप्रत्याशित व्यवहार का अनुभव किया है। इस झंडे को बदलने का सही तरीका क्या है? मैं वर्तमान में tf.cond का उपयोग कर रहा हूं क्योंकि यह tf.placeholders स्वयं नहीं लेता है।

@ पावनी आपको is_training लिए पायथन बूलियन का उपयोग करना होगा। यह tf.cond नहीं हो सकता है।

@ppwwyxx अच्छी तरह से मैं 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)) कर रहे थे, जो कि गलत है।
आपके वर्तमान तरीके में भी समस्याएं हो सकती हैं। आपको यह जांचने की आवश्यकता होगी कि आपके द्वारा बनाए गए दो batch_norm op एक ही गुंजाइश साझा करते हैं, अन्यथा वे अंतर्निहित माध्य / विचरण आँकड़े साझा नहीं करेंगे।

ऐसा करने के लिए reuse तर्क मदद कर सकता है, लेकिन मुझे यकीन नहीं है क्योंकि मैं bn परत के अपने संस्करण का उपयोग करता हूं।

मैं उसी दायरे और reuse=True का उपयोग कर रहा हूं। यह कभी-कभी काम करने लगता है लेकिन मुझे यकीन नहीं है। यह बहुत अच्छा होगा यदि परत को एक छोटी व्याख्या के साथ प्रलेखन में जोड़ा जा सकता है कि प्रशिक्षण से परीक्षण तक के बदलाव को कैसे सबसे अच्छा संभालना है।

@sguada FYI करें

वर्तमान में बैच_नॉर्म को एक अजगर बूलियन की आवश्यकता होती है, लेकिन हम एक टेन्सर पारित करने के विकल्प को जोड़ने में काम कर रहे हैं।

@pawni अगर आप मूविंग_मैंन और मूविंग_वेरियन सेट अपडेट्स_कोलेक्शन = अपडेट करने के बारे में चिंता नहीं करना चाहते हैं, तो सुनिश्चित करने के लिए कोई भी नहीं है कि वे जगह में अपडेट किए गए हैं, अन्यथा आपको यह सुनिश्चित करने की आवश्यकता है कि प्रशिक्षण के दौरान अपडेट किया गया tf.GetKeys.UPDATE_OPS चलाए जाएं।

मुझे लगता है कि टेंसरफ़्लो को 2 हाइपर तरीकों की ज़रूरत है जो मॉडल की स्थिति को बदलते हैं, कुछ मशाल की तरह। मॉडल स्थिति बदलें । मुझे लगता है कि यह बहुत सीधा है।

क्या एक बहुत ही सरल एनएन के साथ एक छोटी स्क्रिप्ट है जो यह दिखाती है कि इस "आधिकारिक" बीएन परत का उपयोग करने का उचित तरीका क्या है? मैं वाकई इसकी सराहना करूंगा।

खेद है कि अगर यह थोड़ा दोहरावदार है, लेकिन ऐसा लगता है कि एपीआई बीएन के बारे में एक अलग इंटरफ़ेस में बात करता है: https://www.tensorflow.org/versions/r0.9/api_docs/python/nn.html#batch_news

क्या बीएन का उपयोग करने का आधिकारिक तरीका नहीं है? मैं इस पर उलझन में हूं कि इसका उपयोग कैसे किया जाए और एसओ पुराना लग रहा है और फिर एपीआई से एक अलग लिंक में एक परत है, बस यह कैसे करता है? एसओ के यहां जाने या पूछने पर मैं अस्पष्ट हूं।

स्पैमिंग के लिए खेद है, लेकिन इस तरह से कुछ का उपयोग करने में क्या गलत है:

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 @ppwwyxx क्या आप लोगों ने फैसला किया कि अगर आपको री यूज़ टू ट्रू का इस्तेमाल करना पड़ा?

@ 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://github.com/tensorflow/tensorflow/blob/master/tensorflow/contrib/layers/python/layers/layers.py#L433 -L435

जब updates_collections = फिर कोई नहीं होता है, तो अपडेट इन-प्लेस हो जाता है और tf.cond () का उपयोग करना आसान होता है, यह अनुमति देने के लिए is_training एक Tensor होने के नाते थोड़ा और जटिल होता है, जब अपडेट में देरी हो जाती है और बाद में अपडेट्स चलाए जाते हैं।
मैं जल्द ही पहला भाग पाने की कोशिश करूंगा।

@ 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 ।

कोड स्निपेट के लिए @nmhkn @pawni धन्यवाद। वे मेरे कनवल्शन नेटवर्क में बैच सामान्यीकरण जोड़ने में बहुत उपयोगी थे। प्रशिक्षण बहुत अच्छा लगता है। परीक्षण नहीं है। कोड प्रशिक्षण के कुछ संस्करणों में एक्यूरेसी, परीक्षण सटीकता की तुलना में बहुत अधिक होती है, जिसका अर्थ है कि मैं बैच सामान्यीकरण मापदंडों को साझा नहीं कर रहा हूं। कोड के अन्य संस्करणों में मुझे "ValueError: Variable conv1 / Beta पहले से ही मौजूद है, अस्वीकृत है। क्या आपका मतलब था Reuse = True in VarScope सेट करना?" जो इंगित करता है कि मैं पैरामीटर को फिर से भरने की कोशिश कर रहा हूं ... जब मैं पुन: उपयोग करने की कोशिश कर रहा था।

क्या कोई प्रशिक्षण और परीक्षण के दौरान "डिफ बेटचॉर्म" फ़ंक्शन को कॉल करने का एक उदाहरण प्रदान कर सकता है ताकि चर साझाकरण सही ढंग से हो सके।

किसी भी मदद के लिए धन्यवाद।

25 जुलाई 2016 को अद्यतन:

@nmhkahn @pawni आपकी टिप्पणियों के लिए धन्यवाद। कंट्रिब में कोड पर करीब से देखने के बाद मुझे एहसास हुआ कि मेरी समस्या क्या थी। प्रशिक्षण और परीक्षण के दौरान हम या तो चार वेरिएबल्स (बीटा, गामा, मूविंग_मीन और मूविंग_वरियन) को अपडेट या पुन: उपयोग कर रहे हैं। उन अद्वितीय को बनाने के लिए मुझे प्रति परत एक गुंजाइश निर्धारित करनी थी। मैंने इसे इस तरह किया:

conv1 = tf.nn.relu (बैच_norm_layer (conv2d_stride2_valid (डेटा, W_conv1) + b_conv1, train_phase, गुंजाइश = "conv1_"))

जहाँ बैच_ norm_layer @nmhkahn @pawni के उदाहरणों के समान है, conv2d_stride2_valid एक लेयर को परिभाषित करने के लिए सिर्फ एक डिफेंस है, और W_conv1 और bconv1 वेरिएबल्स वेट और बायसेस को पकड़े हुए हैं। मैं शायद पूर्वाग्रह शब्द को हटा सकता हूं क्योंकि हम बैच सामान्यीकरण का उपयोग कर रहे हैं।

नेट अब अच्छी तरह से काम कर रहा है। मैंने प्रशिक्षण और परीक्षण मोड में सटीकता की साजिश रचने के बाद ध्यान दिया कि प्रशिक्षण सटीकता के बाद परीक्षण सटीकता शुरू होती है। रेट्रोस्पेक्ट में यह समझ में आता है क्योंकि हम परीक्षण के लिए डेटासेट आँकड़े एकत्र कर रहे हैं। लेकिन ऐसा प्रतीत हुआ जैसे मैं अपने शुरुआती परीक्षणों के दौरान कुछ गलत कर रहा था। आपकी टिप्पणियों और समुदाय के लिए बैच सामान्यीकरण उपलब्ध कराने के लिए धन्यवाद।

@nmhkn यह पावनी के सुझाव से कैसे अलग है?

@ brando90 मेरे संस्करण में एक छोटी सी त्रुटि थी जो nmhkahn द्वारा तय की गई थी ( isTraining से is_training ) बदलना

@diegoAtAlpine मुझे वही समस्याएं मिलीं - निश्चित नहीं कि यह मामला क्यों है। हालाँकि, ValueError को कोड स्निपेट द्वारा हल किया जाना चाहिए। निश्चित नहीं है कि आप यह देखना चाहते हैं कि इसे nhhkahn के उदाहरणों के रूप में कैसे काम करना है?

@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

क्या यह सही नहीं है?

मैंने पहले से ही tf.contrib.layers.batch_norm को विस्तारित कर दिया है, जो is_training के लिए एक Tensor या प्लेसहोल्डर पास करने की अनुमति देता है। इसे जल्द ही TF कॉन्ट्रिब में मर्ज कर दिया जाएगा।

अब इसमें उपलब्ध है
https://github.com/tensorflow/tensorflow/commit/9da5fc8e6425cabd61fc36f0dd1823a093d5c1d#diff -94bbceffec8a5cdef55f705e99c2b2ed2ed2

यह सिर्फ मुझे है या इस बीएन परत को जोड़ने से एक एकल प्रशिक्षण के प्रशिक्षण को धीमा कर देता है?

@ brando90 यह मेरे लिए प्रशिक्षण को धीमा कर देता है लेकिन मुझे लगता है कि यह अपेक्षित है क्योंकि इसे कुछ आंकड़ों की गणना करने की आवश्यकता है। और आपका संस्करण मुझे अच्छा लग रहा है।

बैचनॉर्म वर्तमान में बहुत धीमा है (क्योंकि सभी आँकड़ों की गणना की गई है), लेकिन वे यहाँ पर कहा गया है कि एक कुडन बैटचनॉर्म ऑप को जोड़ने पर काम कर रहे हैं ।

@nmhkahn त्वरित प्रश्न। जब आपने लिखा (परीक्षण के लिए):

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

सिद्धांत रूप में, bx और किसी भी डेटा सेट द्वारा किया जा सकता है? हालांकि, यह अभी भी प्रशिक्षण सेट हो सकता है, भले ही हम प्रशिक्षण नहीं कर रहे हैं? (यानी ट्रेन की त्रुटि को ट्रैक करने के लिए)

@ ब्रांडो 90 आप सही कह रहे हैं।

मैं झंडे और पुन: उपयोग करने के संबंध में भी भ्रमित हूं। मैंने CIFAR उदाहरण के बाद एक प्रोग्राम बनाया है, जहाँ मेरा कोड CIFAR में संरचित है:

• अनुमान
• हानि
• रेल गाडी

और मैं इसे मल्टी-जीपीयू फैशन (प्रशिक्षण के लिए) में चला रहा हूं।
इसलिए मेरे पास प्रशिक्षण के लिए एक स्क्रिप्ट है (cifar10_multigpu.py के समान) और एक परीक्षण के लिए (cifar10_eval.py के समान)।
इसलिए

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 / बीटा मौजूद नहीं है, अस्वीकृत। क्या आपके पास पुन: सेट करने का कोई मतलब नहीं है = कोई भी वरस्कोप में नहीं है?

प्रशिक्षण चरण में मैं इस सूत्र में जो पढ़ रहा हूं, उसका पुन: उपयोग करना चाहिए = कोई नहीं। क्या मुझे यह हिस्सा सही लगा है? यदि यह सच है, तो जब से मैं दो GPUS का उपयोग कर रहा हूं, क्या मुझे पुन: उपयोग करना चाहिए = पहले GPU में कोई नहीं और पुन: उपयोग करें = दूसरे में सच? या जब से मैं tf.get_variable_scope ()। Reuse_variables () कर रहा हूँ, यह स्वयं का ख्याल रखता है?

अंत में, परीक्षण के चरण में, मेरे पास is_training = गलत और पुन: उपयोग करना चाहिए = सही?

कोई भी मदद बहुत ही सराहनीय होगी।

अब tf.contrib.layers.batch_norm टेंसर, वैरिएबल या प्लेसहोल्डर को आइसिंग के रूप में स्वीकार करता है

https://github.com/tensorflow/tensorflow/commit/9da5fc8e6425cabd61fc36f0dd1823a093d5c1d#diff -94bbceffec8a5cdef55f705e99c2b2ed2ed2

क्या यह सामान्य है कि बैच सामान्यीकरण मेरे प्रयोगों को बदतर बनाता है? मैंने MNIST शुरुआती ट्यूटोरियल पर आधारित 2 स्तरित NN नेटवर्क पर इसकी कोशिश की और बीएन मौजूद होने पर मुझे लगातार खराब परिणाम मिलते हैं: बीएन के साथ (एक पैमाने पर और केंद्र के साथ प्रशिक्षित और दूसरा नहीं) सटीकता 0.8423, 0.8221 और बीएन सटीकता के बिना है। .9477।

मेरी स्क्रिप्ट यहां मौजूद है https://github.com/brando90/tensor_flow_experiments/blob/master/tf_tutorials/beginner_tutorial_MNIST_BN.py

किसी ने भी इन समस्याओं का अनुभव किया है या बीएन इस तरह से है और मुझे इसे काम करने के लिए कुछ और करने की आवश्यकता है?

Tf.contrib.layers.batch_norm का नवीनतम संस्करण अब

लेकिन यह महत्वपूर्ण है कि या तो आप update_collections पास

मैं आपको अपना मॉडल बनाने के लिए 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 तक फिर से है। ऐसा क्यों था कि मुझे कुछ भी नहीं होने के लिए अपडेट_कोलेक्शन बदलने की आवश्यकता थी? क्या आप मुझे समझाते हैं कि इतनी बड़ी सटीकता को अंतर क्यों दिया गया? यह एक गैर-तुच्छ परिवर्तन की तरह लगता है (क्या यह कोई भी इसका डिफ़ॉल्ट मान नहीं होना चाहिए, अगर यह इतना ही मायने रखता है?)। धन्यवाद! :)

इसके अलावा, मैंने देखा कि आपने कहा कि यह एक प्लेसहोल्डर था और मुझे इसे मैन्युअल रूप से करने की आवश्यकता नहीं थी। हालाँकि, जब मैंने is_training के लिए एक प्लेसहोल्डर पास किया तो उसने कहा

TypeError: Using a tf.Tensor as a Python bool is not allowed. Use अगर t कोई भी नहीं है: instead of अगर 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 बयान है जो अपडेट को बल देता है। मेरा मानना ​​है कि कोड का उपयोग करने के लिए "बॉक्स के ठीक बाहर" डिफ़ॉल्ट होना चाहिए कोई नहीं।

1122 से ऊपर की मेरी टिप्पणी के अनुसार, मुझे लगा कि tf.get_variable_scope ()। Reuse_variables () समस्या का ध्यान रखता है, इसलिए प्रशिक्षण चरण में बैच_norm का तर्क पुन: उपयोग करना चाहिए। यह स्टेटमेंट variable_op_scope के साथ करना है (टेंसरफ़्लो में इसके प्रलेखन को पढ़ें)

Tf.placeholder के साथ बैच_नॉर्म का उपयोग

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 अपडेट नहीं कर रहे थे, जब updates_collections कोई नहीं है, यह अपडेट को गणना के भाग के रूप में मजबूर करता है।
हालाँकि जब किसी नेटवर्क में कई बैच_नॉर्म लेयर्स होते हैं तो यह सभी अपडेट ऑप्स को इकट्ठा करने और उन्हें एक साथ चलाने के लिए अधिक कुशल होता है, इसलिए प्रत्येक लेयर को अपडेट के समाप्त होने की प्रतीक्षा करने की आवश्यकता नहीं होती है।

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 स्तरित घने एनएन के साथ बैच मानदंड का उपयोग करने की कोशिश कर रहा था और मुझे NaN त्रुटि मिलती रही। किसी को पता है कि ऐसा क्यों हो सकता है? क्या बीएन के साथ ऐसा कभी संभव है? गड़बड़ लग रहा है, लेकिन यह मेरी शिक्षा की स्थापना, दर आदि नहीं हो सकता है (लेकिन मुझे लगता है कि यह नहीं होना चाहिए क्योंकि बीएन को इस तरह से रगड़ना चाहिए)

@sguada मैं batch_norm विशेष रूप से ध्वज updates_collections विषय में उपयोग करने का सही तरीका नहीं समझ रहा हूँ। अगर मुझे सही ढंग से समझ में आया कि झंडा None तो नेटवर्क कुशल नहीं है, इसलिए मुझे updates_collections=tf.GraphKeys.UPDATE_OPS देने देना चाहिए और फिर मुझे सभी बैच_नॉर्म अपडेट इकट्ठा करने चाहिए और उन्हें एक साथ चलाना चाहिए।

आप update_ops = tf.group(tf.get_collection(tf.GraphKeys.UPDATE_OPS)) _

मेरे पास कई अलग-अलग मॉडल हैं जो अलग-अलग बैच_नर्म परतों का उपयोग करते हैं, यह सही काम नहीं करेगा ?:

#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_d dependencies () _ का उपयोग कैसे करें। मैंने अन्य उदाहरणों को सिर्फ tf.with_d dependecies () का उपयोग करके देखा है, लेकिन मैं Tensorflow 0.10 के साथ ऐसा नहीं कर सकता। मुझे यह यहाँ मिला: _tf.python.control_flow_ops.with_d dependencies () _

संपादित करें:

प्रलेखन को अपडेट किया जाना चाहिए। इस तरह:

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_ का उपयोग करने के बीच कोई भी प्रदर्शन अंतर नहीं देख सकता । यहां तक ​​कि बैच के सामान्यीकरण के भारी उपयोग के साथ (कुल मिलाकर, मेरा _tf.get_collection (tf.GraphKeys.UPDATE_OPS) _ 140 अपडेट-ऑप्स देता है, ये सभी केवल बीएन-ऑप्स हैं)

संपादित करें: यह कहना मुश्किल है, अगर मेरे परिणाम सही हैं, लेकिन पूरे नेटवर्क वास्तव में तेजी से 1.5x हो जाता है। जहां तक ​​मुझे पता है, बीपी-सांख्यिकी की गणना सीपीयू पर की जाती है, अब तक जीपीयू नहीं।

क्या आप में से कोई भी प्रदर्शन लाभ देख सकता है? कृपया अपने परिणाम साझा करें :)

प्रदर्शन के मुद्दे पर वापस आते हुए, क्या वर्तमान बैच मानदंड GPU उपयोग से बिल्कुल अलग है? किसी को भी इस बैच के मानक कार्यान्वयन के साथ GPUs से लाभ का अनुभव हुआ है?

आप अपने लिए परीक्षण कर सकते हैं:
https://github.com/tensorflow/tensorflow/blob/4addf4b5806cd731949c6582a83f5824599cd1ef/tensorflow/python/ops/batch_norm_benchmark.py

स्पैम के लिए खेद है, लेकिन प्रलेखन वास्तव में यह नहीं समझाता है कि इस बीएन का उपयोग कैसे करें (शायद कहीं प्रदान किया जाना चाहिए?)। संक्षेप में यह कैसे पता चलता है कि इसे लागू करना चाहिए और प्रति फीचर (सक्रियण के बजाय) प्रति समान पैरामीटर सीखना चाहिए?

(ऐसा करने के लिए कम से कम एक कोड स्निपेट है?)

स्लिम बैच_नॉर्म रैपर आपके इनपुट टेंसर के अंतिम आयाम को सामान्य करता है। तो अगर यह एक 2 डी इनपुट टेंसर है जो पूरी तरह से जुड़ा हुआ परत से आ रहा है, यह बैच पर सामान्य करता है, और इस तरह प्रति-सक्रियण सामान्यीकरण करता है। यदि यह एक 4D टेंसर है जो एक कनवल्शन से आ रहा है, तो यह तीन पहले आयामों (बैच, चौड़ाई, गहराई) पर सामान्य हो जाएगा, और इस प्रकार प्रति-सुविधा सामान्यीकरण करेगा। @sguada शायद इस बारे में थोड़ा अधिक वर्णनात्मक हो रहा है।

@nmhkn आपके कोड स्निपेट के बारे में, क्या मैं पूछ सकता हूं कि reuse None is_training=True 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))

मैं उस काम की बहुत सराहना करता हूं, जो TF_ टीम ने यहां उपलब्ध है ताकि बैच_नॉर्म उपलब्ध और प्रभावी हो सके। मेरी खोज से, यह धागा इसका उपयोग करने के लिए सबसे अच्छा संसाधन है। यहां कई अलग-अलग समस्याएं और विचार उड़ रहे हैं, और बैच_नॉर्म लेयर का उपयोग करने के सबसे सरल मानक मामले के लिए सर्वसम्मति की सलाह लेना मुश्किल है। मुझे लगता है कि सटीक अनुशंसित उपयोग को निर्दिष्ट करने के लिए प्रलेखन के विस्तार में बहुत अधिक मूल्य होगा।

यह पता लगाने का मेरा सबसे अच्छा प्रयास है कि मुझे निम्नलिखित कोड में लाया गया:

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))

फिर मैंने प्रशिक्षण के लिए True_phraining_ph को सही और परीक्षण के लिए गलत सेट किया। यह मेरे लिए काम नहीं करता है। मॉडल ठीक-ठाक चलता है, लेकिन परीक्षण का प्रदर्शन बहुत ही भयानक है। इसके विपरीत, अगर मैं परीक्षण के समय के लिए is_training_ph = True बनाए रखता हूं, तो यह बहुत अच्छा काम करता है। इस प्रकार, मैं अनुमान लगा रहा हूं कि मेरे पास अभी भी एक स्कोप इश्यू है, ताकि यह उचित मौजूदा वैरिएबल नहीं ढूंढ पा रहा है।

@ davek44 मैं उसी कोड फ्रेमवर्क का उपयोग कर रहा हूं जिसे आप उपयोग कर रहे हैं और मैंने एक ही चीज देखी है: जब प्रशिक्षण चरण के दौरान is_training=True चालू हो जाता है और सत्यापन और / या परीक्षण चरण के लिए is_training=False बंद हो जाता है, मॉडल अच्छी तरह से वर्णित कागज की तरह गाड़ियों (मॉडल तेजी से धर्मान्तरित और मैं एक बड़ी सीखने की दर का उपयोग करने में सक्षम था), हालांकि परीक्षण प्रदर्शन भयानक है। अगर मैं हर समय is_training=True चालू करता हूं, तो मॉडल बैच मानदंड को सम्मिलित किए बिना उसी तरह प्रशिक्षित करता है। मुझे समझ नहीं आया कि मैंने क्या गलत किया है, मैं मापदंडों की निगरानी के लिए टेन्सरबोर्ड का उपयोग करने की योजना बना रहा हूं। यदि आप इस व्यवहार के कारण का निदान करते हैं तो क्या आप अपडेट करेंगे?

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'),

मैं उस कोड के साथ उसी खराब परीक्षण प्रदर्शन को देखता हूं।

अधिक जानकारी के बिना जानना असंभव है, मेरा अनुमान है कि आप केवल कुछ पुनरावृत्तियों के लिए प्रशिक्षित करते हैं, इसलिए मूविंग_मैंन और मूविंग_ऑवर अभी तक रूपांतरित नहीं हुए हैं।

जब आप अपने बैच को छोटा बनाते हैं तो प्रदर्शन कैसे कम होता है यह देखने के लिए आप परीक्षण के दौरान बैच_साइज़ को बदल सकते हैं।

मैं उस कोड के साथ उसी खराब परीक्षण प्रदर्शन को देखता हूं।

मैं बिल्कुल tf.slim batchnorm के साथ या tf.cond के साथ एक ही समस्या थी और इनपुट is_training एक प्लेसहोल्डर के रूप में।
पूर्व के मामले में, जब प्रशिक्षित मॉडल की जांच की गई, तो मुझे पता चला कि गतिमान और गतिशील विचरण में सभी शून्य शामिल हैं।
उत्तरार्द्ध मामले में, चल रहा मतलब और भिन्नता अधिक उचित (विभिन्न मूल्यों के साथ) दिखती है, लेकिन अगर मैं परीक्षण समय में is_training = गलत का उपयोग करता हूं, तो प्रदर्शन भी वास्तव में खराब है। Is_training = True का उपयोग करना, यह बेहतर काम करता है, लेकिन मुझे लगता है कि यह परीक्षण बैच के अंदर केवल चलती मीन और विचरण का उपयोग करता है।

@nmduc @ davek44 मैंने प्रशिक्षण और परीक्षण के दौरान tf.contrib.layers.batch_norm में गणना किए गए मूविंग और मूविंग विचरण को ट्रैक करने के लिए कुछ कोड लिखे। मुझे पता चला कि decay का मूल्य बहुत मायने रखता है (वे चलती औसत की गणना करने के लिए घातीय क्षय का उपयोग करते हैं) और decay 1.0 के साथ decay=.999 ), 0. के करीब एक मूल्य के लिए मतलब बूँदें चलती मैं ठीक उसी कोड लेकिन अलग से 2 परीक्षण रन किया decay में सेटिंग्स tf.contrib.layers.batch_norm , और मेरी मान्यता / परीक्षण सत्यता अधिक उचित लग रहा था।

परीक्षण रन decay=0.9 साथ परिणाम देता है

decay=0.999 ( decay=0.999 साथ परीक्षण चलाने के परिणाम tf.contrib.layers.batch_norm में डिफ़ॉल्ट सेटिंग है)

(यह भी लगता है जैसे बड़े क्षय मूल्य को सत्यापन सटीकता परिवर्तन देखने के लिए लंबे समय तक प्रशिक्षण के लिए मॉडल की आवश्यकता होगी)

हाँ, यह तय है। अपना विश्लेषण @zhongyuk साझा करने के लिए धन्यवाद!

मैं डेवलपर्स को क्षय = 0.9 डिफ़ॉल्ट बनाने पर विचार करने के लिए प्रोत्साहित करता हूं। यहां तक ​​कि 0.99 मेरे लिए अच्छी तरह से काम नहीं करता है। मशाल के कार्यान्वयन में भी डिफ़ॉल्ट मूल्य है; https://github.com/torch/nn/blob/master/BatchNormalization.lua में गति पैरामीटर

@zhongyuk साझा करने के लिए बहुत बहुत धन्यवाद। यह अब मेरे लिए काम करता है।

यह महत्वपूर्ण लगता है। @sguada को हमें 1.0 से पहले कार्रवाई के सही तरीके पर विचार करना चाहिए। अल्पावधि में, क्या इच्छुक पार्टियों में से कोई भी मुझे एक पीआर भेज सकता है जो इस तथ्य को प्रमाणित करता है कि खराब निकासी प्रदर्शन का अनुभव करने पर decay को काफी कम करना पड़ सकता है? मुझे पूरा यकीन है कि मुझे कभी भी उस पैरामीटर को मोड़ना नहीं पड़ा है, लेकिन यह वितरित सेटिंग का एक दुष्प्रभाव हो सकता है।

हम डिफ़ॉल्ट को 0.9 या दस्तावेज़ में बदल सकते हैं ताकि छोटे डेटासेट या कुछ अपडेट में इसका प्रभाव बेहतर हो सके।
हमारी वितरित सेटिंग में @vincentvanhoucke हम आम तौर पर लाखों अपडेट करते हैं इसलिए यह ठीक है, हालांकि अन्य मामलों में यहां जो केवल कुछ सैकड़ों अपडेट करता है वह एक बड़ा बदलाव करता है:
उदाहरण के लिए क्षय = 0.999 में 1000 अपडेट के बाद 0.36 पूर्वाग्रह होता है, लेकिन यह पूर्वाग्रह 10000 अपडेट के बाद 0.000045 और 50000 अपडेट के बाद 0.0 रह जाता है।

बस यह नोट करना चाहता था कि मुझे खराब परीक्षण प्रदर्शन की समस्या है, विशेष रूप से छोटे बैच आकारों (प्रशिक्षण के लिए उपयोग किए जाने वाले 200 के बजाय 10 से छोटे कुछ भी) का उपयोग करके परीक्षण सटीकता कम हो जाती है। मैंने परीक्षण / प्रशिक्षण मोड के बीच स्विच करने के लिए tf.placeholder का उपयोग किया है।

यह बहुत अच्छा है कि यह बैच सामान्यीकरण परत बेहतर प्रशिक्षण अभिसरण के लिए काम करता है, लेकिन यदि आप मॉडल को उत्पादन में लागू नहीं कर सकते हैं, तो इसका उपयोग करने के लिए बहुत कुछ नहीं है। क्या कोई भी इस बैच मानक परत का उपयोग करके छोटे या एकल डेटा नमूनों के साथ अच्छे परीक्षण प्रदर्शन की पुष्टि कर सकता है?

मैं यह पुष्टि कर सकता हूं कि is_training का उपयोग करते समय परीक्षण प्रदर्शन अच्छा है = छोटे बैचों के साथ गलत और यहां तक ​​कि बैच_साइज = 1 के साथ, क्योंकि यह बैच से सांख्यिकी का उपयोग नहीं कर रहा है, लेकिन प्रशिक्षण के दौरान सीखा हुआ आँकड़ा है। बस यह सुनिश्चित करने की आवश्यकता है कि आँकड़े डिफ़ॉल्ट क्षय = 0.999 के साथ परिवर्तित हो गए हैं, जो कम से कम 50k अपडेट का अर्थ है।

टीएफ डेवलपर की पुष्टि के साथ पालन करने के लिए, मैं दो अलग-अलग decay सेटिंग्स (और प्रशिक्षण बैच_साइज़ = 1) के साथ आँकड़ों के अभिसरण को ट्रैक करता हूं। decay=0.99 , आंकड़े सीखने (अपडेट) के 550 ~ 600 चरणों के बाद (पूर्वाग्रह <0.001) जुटते हैं। decay=0.9 , आंकड़े सीखने (अपडेट) / अपडेट करने के 100 चरणों के भीतर (biase <0.001) में परिवर्तित हो जाते हैं।

@sguada धन्यवाद, इसका मतलब यह भी है कि आउटपुट वास्तव में बैच के आकार से स्वतंत्र है? क्योंकि मैं अपनी सटीकता पर बड़े प्रभाव के साथ बहुत मामूली बदलाव देख रहा हूं (हो सकता है कि प्रदर्शन की मेरी परिभाषा इस थोड़े बदलाव से अधिक आसानी से प्रभावित हो)। सटीक होने के लिए, मेरे 128 आयामी आउटपुट टेंसर में सभी मूल्य ऐसे बढ़ जाते हैं कि कुल वेक्टर लंबाई बैच आकार के साथ लगभग रैखिक रूप से बढ़ जाती है। प्रति मूल्य यह एक अंतर से बहुत अधिक नहीं है, लेकिन अव्यक्त स्थानों में वेक्टर दूरी की गणना करते समय इसका बड़ा प्रभाव पड़ता है।

@zhongyuk धन्यवाद, मैंने decay=0.9 साथ लगभग 5k अपडेट चलाए हैं, इसलिए इसे बड़े बैच आकारों का उपयोग करके परिवर्तित और परीक्षण प्रदर्शन ठीक होना चाहिए। लेकिन अगर यह नहीं भी था, तो क्या यह एक परीक्षण के प्रशिक्षण के बीच अंतर होगा? मैं प्रशिक्षण और परीक्षण के दौरान खराब प्रदर्शन देख रहा हूँ अगर यह अभिसिंचित नहीं था, है ना?

मैं कुछ और जांच करूंगा और देखूंगा कि क्या मैं इस मुद्दे को दूसरे कार्य पर पुन: पेश कर सकता हूं। अब तक त्वरित फ़ीड के लिए धन्यवाद!

@dominikandreas यदि आपका खराब परीक्षण प्रदर्शन अभिसरण न करने वाले आँकड़ों के कारण होता है, तो आपको यथोचित प्रशिक्षण प्रदर्शन लेकिन खराब परीक्षण प्रदर्शन दिखाई देगा। क्योंकि प्रशिक्षण के दौरान, बैच सामान्यीकरण केवल प्रशिक्षण बैच के आंकड़ों का उपयोग करके किया जाता है। हालाँकि, परीक्षण समय के दौरान, यह इनपुट टेंसर को सामान्य करने के लिए सभी प्रशिक्षण बैचों के मूविंग औसत आँकड़ों का उपयोग कर रहा है।

मुझे मिला और मेरे कोड में त्रुटि, बैच सामान्यीकरण अब ठीक काम कर रहा है :-) आपके समर्थन के लिए धन्यवाद

हाय @zhongyuk , आप कैसे चलती औसत और विचरण का ट्रैक रखते थे?
धन्यवाद!

@rogertrullo आम तौर पर मैं चलती मीन और विचरण को ट्रैक करने के लिए TensorBoard को सेटअप करता हूं। इसके अलावा, मैंने पूर्वाग्रह पर नजर रखने के लिए प्रशिक्षण और संदर्भ के दौरान tf.get_variable("moving_mean") के दायरे में आंकड़े लाने की कोशिश की।

नमस्ते,
मेरे पास अन्य समस्या के रूप में एक ही समस्या है जो मेरे पास अच्छे प्रशिक्षण परिणाम हैं लेकिन बैच_नॉर्म का उपयोग करने के बाद सत्यापन / परीक्षण खराब है।
मैं इस तरह फ़ंक्शन का उपयोग करता हूं:
conv_normed1 = tf.contrib.layers.batch_norm (conv1 + block1_layer3_1_biases, updates_collections = कोई नहीं, पैमाना = सत्य, क्षय = बैच_नॉर्मल_से, केंद्र = सत्य, is_training = is_training)
क्षय मान 0.9 है
क्या मुझे पुन: उपयोग ध्वज को सेट करने की आवश्यकता है?
मैं किसी भी मदद के लिए खुशी होगी।

मैं इस धागे में वर्णित (प्रशिक्षण के लिए एक tf.bool; और ops.GraphKeys.UPDATE_OPS के साथ) और सब कुछ काम करता है।

जब बचत और उपयोग बहाल:
सेवर = tf.train.Saver ()
यह काम करता हैं,

लेकिन जब बचत का उपयोग कर:
सेवर = tf.train.Saver (tf.trainable_variables () + [global_step))
ताकि मैं स्टोरेज स्पेस (ग्रेडिएंट आदि को सेव करके) को बचा सकूं
पुनर्स्थापित करने पर एक त्रुटि है:
"uninitialized मान unpool4 / convc / bn / move_mean"

जाहिर तौर पर ऐसा इसलिए है क्योंकि मूविंग_मैंन (और मुझे लगता है कि मूविंग_वरियन) किसी भी लेयर के लिए सेव नहीं किया गया है। जैसा कि मैंने उनमें से बहुत से हैं (कई परतों में नेस्टेड) ​​- उन्हें सहेजे जाने वाले मूल्यों की सूची में जोड़ने का सबसे कुशल तरीका क्या है? इसके अलावा, यह देखते हुए कि ये ट्रेन योग्य चर हैं, क्यों इन्हें 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 () के साथ सेव फाइलें बहुत बड़ी हैं क्योंकि मुझे लगता है कि इसमें ग्रेडिएंट्स भी शामिल हैं; अंत में मैंने इस्तेमाल किया:

सेवर = tf.train.Saver ([x के लिए x में tf.global_variables () यदि 'एडम' x.name में नहीं है))

और क्योंकि सत्र प्रबंधक init उन्हें ठीक से प्रारंभ नहीं करता है:

sess.run (tf.variables_initializer ([x के लिए x में tf.global_variables () अगर 'Adam' में x.name])

(Tf.train.AdamOptimizer का उपयोग करके)

आप tf.model_variables () का उपयोग कर सकते हैं, जिसमें मॉडल के चर शामिल हैं, अर्थात मूविंग_मैं

@sguada आपको परेशान करने के लिए क्षमा करें, लेकिन क्या यह संभव है कि स्लिम का उपयोग कैसे करें। batch_norm का उपयोग कैसे करें।

मैं slim.batch_norm का उपयोग कर रहा हूं, लेकिन अच्छे प्रशिक्षण प्रदर्शन और खराब सत्यापन / परीक्षण प्रदर्शन प्राप्त करता हूं। मुझे लगता है कि यह reuse या scope या कुछ अन्य मापदंडों के अनुचित उपयोग के कारण होना चाहिए। हालांकि बैच के सामान्यीकरण के कई मुद्दे हैं, लेकिन इसका उपयोग करने के तरीके पर पूर्ण कोड स्निपेट लगाना मुश्किल है। विभिन्न चरणों में विभिन्न मापदंडों को कैसे पारित किया जाए।

कहते हैं, मेरे mnist_bn कोड में, मैंने tf.GraphKeys.UPDATE_OPS का उपयोग करके निर्भरता को नियंत्रित किया और is_training को एक प्लेसहोल्डर के रूप में सेट किया। यदि मैं {is_training: False} फ़ीड करता हूं, तो सत्यापन का प्रदर्शन अभी भी खराब है।

यदि कोई अधिकारी और पूर्ण (जिसका अर्थ है प्रशिक्षण, सत्यापन, परीक्षण सभी शामिल हैं) बैच सामान्यीकरण उदाहरण है तो मैं इसकी बहुत सराहना करूंगा।

आपका अग्रिम में ही बहुत धन्यवाद!

नमस्ते,
आपको हर बार बैच मानदंड का उपयोग करने के लिए अलग-अलग गुंजाइश निर्धारित करने की आवश्यकता होती है और इसे प्रशिक्षण / परीक्षण चरण (जब ट्रेन का परीक्षण FALSE जब ट्रेन) के अनुसार पुन: उपयोग इनपुट देता है, जो मेरे लिए काम करता है।

@ishaybee मदद के लिए धन्यवाद। मुझे मेरी समस्या मिल गई है = = यह चलती ठंड की वजह से चल रहा है।

चूंकि मैंने पर्याप्त कदम प्रशिक्षित नहीं किए हैं, इसलिए अनुमानित गतिमान / विचरण स्थिर नहीं है। परिणाम यह निकलता है: मॉडल मिनी-बैचों के प्रशिक्षण पर बहुत अच्छा प्रदर्शन करता है (आप जानते हैं कि शुरुआत में नुकसान जल्दी से कम हो जाता है), लेकिन सत्यापन का प्रदर्शन अनियमित है (क्योंकि अनुमानित जनसंख्या का मतलब / विचरण पर्याप्त स्थिर नहीं है)।

जब मैंने मॉडल को लंबे समय तक प्रशिक्षित किया, तो सत्यापन सटीकता भी सुंदर हो जाती है।

एक और महत्वपूर्ण बात यह है कि ट्रेन ऑप बनाने के लिए slim.learning.create_train_op का उपयोग करना सुनिश्चित करें । Tf देशी tf.train.GradientDescentOptimizer(0.1).minimize(loss) उपयोग न करें।

तो जवाब है, मैं बैच सामान्यीकरण का सही उपयोग कर रहा हूं, लेकिन मैंने प्रशिक्षण के दौरान इसकी गतिशीलता को पूरी तरह से नहीं समझा है।

================
इससे ज्यादा और क्या:

1. यहाँ एक पूर्ण उदाहरण है कि MNIST डेटासेट पर BN लेयर का उपयोग कैसे करें।
2. एक छोटे क्षय मूल्य का उपयोग करें वार्म-अप चरण में तेजी लाएगा। डिफ़ॉल्ट क्षय 0.999 है, एमएनआईएसटी जैसे छोटे डेटासेट के लिए, आप 0.99 या 0.95 चुन सकते हैं, और यह थोड़े समय में गर्म हो जाता है।

@soloice , नोटिस, कैसे के बारे में टिप्पणी में निम्नलिखित पैरामीटर बैच के लिए परत के अंदर पारित कर दिया है_नॉर्म:

बैच_नॉर्म_परम्स = {'is_training': is_training, 'decay': 0.9, 'updates_collections': कोई नहीं}

updates_collections बिना किसी को सेट नहीं किया जाता है (इसलिए माध्य अपडेट BatchNorm के अंदर जगह में किया जाता है), मैं किसी भी तरह से tf.GraphKeys.UPDATE_OPS को निष्पादित करने के लिए आसपास की परत (जैसे conv2d) की अपेक्षा नहीं करूंगा ताकि रनिंग माध्य को अद्यतन करने के लिए BatchNorm लेयर की आवश्यकता हो। इसलिए बाद में परीक्षण डेटा पर चलने में सक्षम हो।

या आप स्वयं को यहां स्पष्ट रूप से 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 का उपयोग करते हैं।

"कोल्ड स्टार्ट" के रूप में, जैसा कि आप ऊपर चर्चा में देख रहे हैं, घटते हुए बैचनॉर्म रनिंग का औसत क्षय (इनपुट परम) डिफ़ॉल्ट 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 ऐसा लगता है कि आप दो अलग-अलग बैच सामान्यीकरण परतों का उपयोग कर रहे हैं? आपको केवल एक बीएन परत का उपयोग करना चाहिए (ज़ाहिर है, अलग-अलग 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% ...

नमस्ते,
कृपया मेरा रैपर ऊपर देखें।
आपको "tf.variable_scope (स्कोप, रीयूज = पुनः उपयोग) के साथ उपयोग करना चाहिए:" मुझे लगता है।

हाय @ रिशाय ,
मैंने आपकी सलाह का पालन किया, अब मेरा कोड है:

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.") त्रुटि मिलती है

एक अजगर चर (मॉडल के इनपुट) और प्लेसहोल्डर के रूप में पुन: उपयोग को खिलाने की कोशिश करें।

मैंने कोशिश की है, और अब यह मूल्य के बारे में शिकायत करना बंद कर दिया ... लेकिन मुझे लगता है कि प्लेसहोल्डर मूल्य का उपयोग नहीं किया जा रहा है, क्योंकि मुझे कोई बदलाव नहीं दिखता है अगर मैं 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 के लिए प्लेसहोल्डर का उपयोग करने की आवश्यकता नहीं है। चाल मॉडल को दो बार बनाने की है, लेकिन चर को दूसरी बार साझा करना।

शुक्रिया @sguada ! आपके सुझावों को लागू करने के बाद, मैंने आखिरकार यह काम किया!

यह उपयोगी होगा यदि एपीआई 1.0 प्रलेखन परिलक्षित होता है कि आपको मैन्युअल रूप से ग्राफ़ में अपडेट ऑप्स जोड़ने की आवश्यकता है। एक नया tf उपयोगकर्ता होने के नाते, मैंने पाया कि मेरी परीक्षा की त्रुटि पागल थी और तब तक मुझे अपने ग्राफ को डिबग करने में काफी समय बिताना पड़ता था जब तक मुझे एहसास नहीं हो जाता था कि बैच का सामान्यीकरण समस्या है। तब मुझे यह पता लगाने में अधिक समय बिताना पड़ा कि डिफ़ॉल्ट रूप से क्षणों पर नज़र रखने वाले चर अपडेट नहीं करते हैं जब तक कि आप अनुकूलन के लिए एक कंट्राब फ़ंक्शन का उपयोग नहीं करते हैं। 1.0 के बाद से update_collections को कोई भी सेट करने का कोई विकल्प नहीं है, प्रलेखन से कोई संकेतक नहीं है कि यह एक मुद्दा भी हो सकता है। इसके अतिरिक्त, ऐसा लगता है कि प्रशिक्षण के मामले में चलने वाले ऑप पर नियंत्रण प्रवाह निर्भरता को जोड़ने के लिए एक पैरामीटर होने का कोई मतलब हो सकता है।

@danrsc बिल्कुल। बीएन परत का उपयोग काफी भ्रामक है। मैंने बैच सामान्यीकरण पर दस्तावेज़ या पूर्ण आधिकारिक ट्यूटोरियल जोड़ने का सुझाव दिया, लेकिन दुर्भाग्य से कोई प्रतिक्रिया नहीं मिली = =

पूरी तरह से सहमत हूँ। मुझे लगता है कि बीएन का उपयोग बहुत मुश्किल है और प्रलेखन वर्तमान में अपर्याप्त है। यह आमतौर पर इस्तेमाल की जाने वाली परत के लिए तय किया जाना चाहिए।

प्रलेखन मुद्दों की दृश्यता के लिए फिर से खोलना।

@sguada आपको

बस पिछले हफ्ते इस समस्या से भ्रमित हो गए और 3 दिनों के प्रशिक्षण को बर्बाद कर दिया ... उम्मीद है कि डॉक्स जल्द ही तय किए जा सकते हैं, और एपीआई डॉक्स में एक आधिकारिक बैच सामान्यीकरण उदाहरण जोड़ा जा सकता है।

@sguada मैंने देखा है कि आपने कहा था कि "tf.contrib.layers.batch_norm टेनर को is_training के रूप में ले सकता है, इसलिए कुछ विशेष करने की आवश्यकता नहीं है"।
हावेर, कोड में टिप्पणी है
यदि is_training का कोई स्थिर मूल्य नहीं है, क्योंकि यह Tensor ,
# एक Variable या Placeholder तो is_training_value कोई नहीं होगा और
# needs_moments सच होगा।
क्या इसका मतलब यह है कि अगर मैं एक प्लेसहोल्डर के रूप में सेट कर रहा हूं तो नीस_मॉमेंट्स टेस्ट के चरण में भी सही होंगे?
जहां तक ​​मुझे पता है, परीक्षण करते समय क्षणों की आवश्यकता नहीं है।

इसलिए अगर is_training Variable या Placeholder , तो इसका मतलब है कि यह बदल सकता है, इसलिए क्षणों की गणना करने के लिए ग्राफ की आवश्यकता है, इसलिए परत इसे बनाता है।
फिर रनिंग टाइम में True या False बैच moments या moving_mean और moving_variance ।

इसलिए परीक्षण के दौरान आप False का मूल्य निर्धारित करेंगे और moments का उपयोग नहीं किया जाएगा।

@ सुग्गा @ ब्रांडो 90

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

मैं इस तरह से बैचेनी का निर्माण करता हूं, हालांकि, चल रहा है और चल चर परीक्षण के दौरान अद्यतन किया जाता है, मुझे इसका कारण नहीं मिल सकता है।

मैंने @sguada जैसे दो मॉडल बनाने की कोशिश की, हालांकि, मेरा मॉडल जहां is_training = गलत बस क्रैश होता है।

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

मुझे लगता है कि शायद एक ठोस उदाहरण होना चाहिए कि पूरी तरह से जुड़े जाल के साथ एक बैच मानदंड के साथ-साथ सीएनएन के साथ कैसे करें। बेकार है कि मैं दिनों के लिए मॉडल प्रशिक्षित किया है चीजों को देखने से पहले काम करने की उम्मीद है कि हर कोई इस सुविधा का उपयोग करने की कोशिश कर रहा है।

दिलचस्प रूप से पर्याप्त है, बैच_नॉर्म के साथ-साथ प्रशिक्षण के बाद मॉडल को बहाल करने में एक zillion साल लगते हैं। टीएफ 2.0 के फिर से इस तरह से कुछ करने की कोशिश करने के लिए सबसे अधिक संभावना होगी।

@MisayaZ आपको दो बैच बनाने की जरूरत नहीं है। आप जो भी ट्रेन_पेज़ पास कर सकते हैं उसे लेयर बनाने की जरूरत है (यह मानकर कि यह tf.bool है) इसके अलावा आप UPDATE_OPS_COLLECTION वैरिएबल_कलेक्शन पास कर रहे हैं, जो बदलाव करते हैं कि कौन से कलेक्शन वेरिएबल में जोड़े गए हैं।

निम्नलिखित काम करना चाहिए:

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

@OktayGardener सुनिश्चित नहीं करता कि आप किस मॉडल को बनाने की कोशिश कर रहे हैं, ऐसा लगता है कि चर आपके चेकपॉइंट में सहेजे नहीं गए हैं।

बैच_नॉर्म भी पूरी तरह से_कोनेक्टेड परतों के साथ काम करता है।

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 धन्यवाद, मैं बाथरम के साथ एक नेटवर्क का निर्माण करता हूं, जिसे आप ऊपर बताए अनुसार कार्यान्वित करते हैं

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

गति धीमी है, मैं गणना समय प्राप्त करने के लिए टेंसरफ़्लो बेंचमार्क का उपयोग करता हूं:
मैं टेंसरफ़्लो / कोर / उपयोग / स्टेट_समराइज़र .cc: 392] ================================ कम्प्यूटेशन टाइम के द्वारा टॉप === ===========================
I टेंसोफ़्लो / कोर / यूज़ / स्टेट_समराइज़र .cc: 392] [नोड प्रकार] [प्रारंभ] [पहला] [एवीजी एमएस] [%] [सीएफडी%] [मेम केबी] [नाम]
मैं टेंसरफ़्लो / कोर / उपयोग / स्टेट_समराइज़र.सीसी: 392] कन्वोकेशन 106.164 51.354 51.004 23.145% 23.145% 692.224 conv8 / Conv2D
मैं टेंसरफ़्लो / कोर / उपयोग / स्टेट_समराइज़र.सीसी: 392] कन्वोकेशन 85.187 19.115 19.283 19.583 8.750% 31.896% 692.224 conv7 / Conv2D
I टेंसरफ़्लो / कोर / उपयोग / स्टेट_समराइज़र .cc: 392] स्क्वॉयरडिफायर 11.967 15.105 14.331 6.503% 38.399% 11075.584 conv1 / बैच_नॉर्म / क्षण / पर्याप्त_स्टैटिस्ट्रेशन
मैं टेंसरफ़्लो / कोर / उपयोग / स्टेट_समराइज़र .cc: 392] मुल 11.970 14.162 13.495 6.124% 44.523% 11075.584 conv1 / बैच_नॉर्म / बॉटमॉर्म / mul_1
I टेंसोफ़्लो / कोर / उपयोग / स्टेट_समराइज़र .cc: 392] कन्वोकेशन 3.948 8.170 7.986 3.624% 48.146% 11075.584 conv1 / Conv2D
मैं टेंसरफ़्लो / कोर / उपयोग / स्टेट_समराइज़र .cc: 392] उप 11.960 10.176 7.943 3.604% 51.751% 11075.584 conv1 / बैच_नॉर्म / क्षण / पर्याप्त_स्टैट / उप
I टेंसरफ़्लो / कोर / यूज़ / स्टेट_समराइज़र.सीसी: 392] स्क्वॉयरडिफायरेंस 45.570 5.908 7.177 3.257% 55.007% 5537.792 conv2 / बैच_नॉर्म / क्षण / पर्याप्त_स्टैटिस्ट्रेशन / स्क्वेरडिफाइन
मैं टेंसरफ़्लो / कोर / उपयोग / स्टेट_समराइज़र .cc: 392] मूल 45.574 7.755 6.902 3.132% 58.140% 5537.792 conv2 / batch_norm / batchnorm / mul_1
मैं टेंसरफ़्लो / कोर / उपयोग / स्टेट_समराइज़र .cc: 392] कन्वोकेशन 40.692 5.408 4.845 2.199% 60.338% 5537.792 conv2 / Conv2D
मैं टेंसरफ़्लो / कोर / उपयोग / स्टेट_समराइज़र .cc: 392] उप 45.563 6.067 4.784 2.171% 62.509% 5537.792 con

मुझे समझ में नहीं आ रहा है कि परीक्षण के दौरान कुछ ऑप्स क्यों निष्पादित किए जाते हैं और इसमें बहुत समय खर्च होता है, जैसे कि conv1 / बैच_नॉर्म / क्षण / पर्याप्त_स्टैटिस्टिक्स / स्क्वेरडिफायर।

परीक्षण में उस क्षण की आवश्यकता नहीं है, क्यों कुछ ऑप्स पल के तहत निष्पादित किए जाते हैं?

नमस्ते,

उपरोक्त batch_norm परत का उपयोग contrib.layers , मुझे 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)

धन्यवाद

अनुवर्ती कार्रवाई के रूप में, मैं बैच_नॉर्म की 16 परतों का पुन: उपयोग कर रहा हूं।
हालांकि, मैंने पाया कि 4 परतों का पुन: उपयोग करना काम करता है।

मैं सिर्फ यह नोटिस कर रहा हूं कि अगर मैं टेंसरफ्लो प्रक्रिया को मारता हूं और इसे फिर से शुरू करता हूं, तो मेरी त्रुटि कुछ युगों के लिए खराब हो जाती है (यानी इससे भी बदतर अंतिम चेकपॉइंट पर होना चाहिए)। मैं यह भी देखता हूं कि यदि मैं बैच_नॉर्म निकालता हूं, तो यह समस्या दूर हो जाती है। थोड़ी देर के लिए कोड को देखने के बाद, मुझे लगता है कि यह हो सकता है क्योंकि चर के मूल्यों को छाया चर से बहाल नहीं किया जाता है क्योंकि वे होगा यदि एक्सपोनेंशियल मॉविंग्सएवरेज क्लास का उपयोग चलती औसत का प्रबंधन करने के लिए किया गया था। इसका मतलब यह भी है कि अगर मैं मूल्यांकन करने के लिए एक अलग प्रक्रिया का उपयोग करता हूं, तो मुझे चर का अंतिम मूल्य जो भी हो रहा है, वह नहीं है और न ही चलती औसत। क्या मैं इसकी सही व्याख्या कर रहा हूं और क्या यह अभीष्ट व्यवहार है? ऐसा लगता है जैसे आप चाहते हैं कि छाया चर मूल्यों को बहाल किया जाए ...

मैंने समस्या को पकड़ा, मेरे पुनरावृत्तियों में चल रहा विचरण कुछ पुनरावृत्तियों के बाद नकारात्मक हो जाता है।

दसियों का आउटपुट: 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]

जैसा कि आप देख सकते हैं, आयाम में से एक के लिए नकारात्मक विचरण है। यह संभव ही कैसे है ?
पुनश्च बैच की मानक परत का उपयोग नेटवर्क की अंतिम पूरी तरह से जुड़ी परत के बाद और सॉफ्टमैक्स से पहले किया जाता है।

@ raghavgoyal14 क्या आप इसे

@abred : हां, मैंने fused=True , समान समस्या का उपयोग किया।

@sguada हाय, sguada, मुझे एक समस्या है।
दसवें प्रवाह में contrib.layers.batch_norm की परिभाषा:
def बैच_नॉर्म (इनपुट्स)
क्षय = 0.999,
केंद्र = सच,
पैमाने झूठी =,
एप्सिलॉन = 0.001,
activation_fn = कोई नहीं,
param_initializers = कोई नहीं,
param_regularizers = कोई नहीं,
updates_collections = ops.GraphKeys.UPDATE_OPS,
is_training = सच,
पुन: उपयोग = कोई नहीं,
variables_collections = कोई नहीं,
outputs_collections = कोई नहीं,
trainable = सच,
batch_weights = कोई नहीं,
में जुड़े = झूठी,
data_format = DATA_FORMAT_NHWC,
zero_debias_moving_mean = झूठी,
गुंजाइश = कोई नहीं,
renorm झूठी =,
renorm_clipping = कोई नहीं,
renorm_decay = 0.99):
पैमाना: यदि सही है, तो गामा द्वारा गुणा करें। यदि गलत है, गामा है
उपयोग नहीं किया। जब अगली परत रैखिक है (उदाहरण के लिए nn.relu), तो यह हो सकता है
स्केलिंग के बाद से विकलांग अगली परत द्वारा किया जा सकता है।

यदि मैं tf.contrib.layers.batch_norm (इनपुट, स्केल = गलत) का उपयोग करता हूं, तो "स्केल = गलत" का अर्थ है कि प्रशिक्षण के दौरान "y = गामा * x + बीटा" में गामा शून्य है या नहीं। आपका बहुत बहुत धन्यवाद।

जब पैमाने = गलत, गामा एक स्थिर 1 है।

@ppwwyxx आपकी मदद के लिए बहुत बहुत धन्यवाद। मैं Tens.flow में tf.contrib.layers.batch_norm (इनपुट, स्केल = गलत) का उपयोग करता हूं और अब मैं Tensorflow के Caffe को Caffe में परिवर्तित कर रहा हूं। कैफ़े में बैचमोरलेयर और स्केललेयर के पैराम कैसे सेट करें?
आपका बहुत बहुत धन्यवाद।

@ मिस्ज़ैज़ I में "is_training" के लिए प्लेसहोल्डर के साथ बैचनॉर्म का उपयोग करने का समान व्यवहार था। मैं ट्रेस में देखता हूं कि परीक्षण समय पर भी क्षणों की गणना की जा रही है, इसलिए मैंने स्रोत कोड में जाने का फैसला किया और मुझे यह पता चला:

    # 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" एक चर या प्लेसहोल्डर है, तो क्षणों को परिभाषित किया जाता है और रनटाइम पर उनकी गणना भी करता है, तब भी जब आप प्लेसहोल्डर को "गलत" पर सेट करते हैं। मैंने इसे एक प्लेसहोल्डर के रूप में छोड़ना पसंद किया क्योंकि इस तरह से मैं ग्राफ़ को फिर से परिभाषित किए बिना प्रशिक्षण के दौरान समय-समय पर परीक्षण कर सकता हूं, लेकिन मैंने इसे एक निरंतर के रूप में उपयोग करने और ट्रेन बनाम परीक्षण के लिए अलग-अलग व्यवहारों को परिभाषित करने का फैसला किया, और अब क्षणों की गणना नहीं की जाती है। परीक्षण के समय में।

@ 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)
        ...

मैं बैच 75 के बारे में बात कर रहा हूँ

    # 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 फाल्स में वृद्धि करता है और इस प्रकार ग्राफ के "क्षण" -पार्ट का उपयोग कभी नहीं किया जाता है और इस प्रकार इसे बंद नहीं किया जाना चाहिए

लेकिन मैंने परीक्षण नहीं किया है, इसलिए मैं इसके बारे में गलत हो सकता हूं :)

@ tano297 @abred तुम सही हो। जब मैं इस तरह से बैटचोर का उपयोग करता हूं, तो चलन और चलन भिन्नता बदल जाती है:

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 का उपयोग करते हुए अच्छे परिणाम प्राप्त कर सकता हूं = प्रशिक्षण और अनुमान दोनों के लिए सही है, लेकिन सेटिंग के दौरान is_training = गलत होने पर खराब परिणाम प्राप्त होते हैं (is_training (ट्रू) का उपयोग करके मामले से भी बदतर)। आपके विश्लेषण के अनुसार, अगर मैं सही तरीके से समझूं, तो बीएन में केवल क्षय = 0.9 की स्थापना करके इस समस्या को हल किया जा सकता है। क्या मैं सही हू?

BTW, क्या मुझे खरोंच से क्षय = 0.9 का उपयोग करके मॉडल को फिर से बनाना होगा? या चौकी से प्रशिक्षण फिर से शुरू (यानी, जब क्षय = 0.999 प्रशिक्षित) भी ठीक है?

धन्यवाद!

@nmduc @ davek44

नमस्ते, मैं उस समस्या से भी मिला, जिसका उपयोग करते समय मुझे अच्छे परिणाम मिल सकते हैं = प्रशिक्षण और अनुमान दोनों के लिए सही है, लेकिन सेटिंग के दौरान is_training = गलत होने पर गलत परिणाम मिलते हैं (in_training = True का उपयोग करके केस से भी बदतर)। क्या आप लोगों ने इस समस्या को हल किया है? धन्यवाद!

@tyshiwo मैं सिर्फ बैच_नॉर्म के लिए क्षय = 0.9 निर्धारित करता हूं और यह अब तक अच्छी तरह से काम करता है।

मैं इन सभी टिप्पणियों के बाद उलझन में था कि कैसे बैच नॉर्म का उपयोग ठीक से किया जाए: इसलिए यहां मेरे पास है। कृपया मुझे सुधारें अगर मैं गलत हूं।

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

जहां चरण_ट्रेन_पी एक पायथन बूलियन चर है और is_training एक प्लेसहोल्डर है जो बूलियन चर ले रहा है। मुझे लगता है कि tf.cond का उपयोग करना गलत है, अन्यथा क्या फ़ंक्शन बूलियन मापदंडों के साथ आया था। दूसरे शब्दों में, यदि tf.cond सत्य है, तो हमें प्रशिक्षण के लिए batch_norm कार्य करना चाहिए और परीक्षण के लिए एक और। इसलिए, डेवलपर्स हमें फ़ंक्शन के व्यवहार को बदलने के लिए इन बूलियन चर को बदलने की अनुमति देते हैं। इसलिए मैं जो कर रहा हूं वह है: phase_train_py झूठी ट्रेनिंग करते समय 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})

++++++++++++++++++++++++++++++++++++++++++++++++++ +++++++++++++++++++++++++++++
आप इस की जरूरत की जरूरत है
++++++++++++++++++++++++++++++++++++++++++++++++++ +++++++++++++++++++++++++++++

ऐसा लगता है कि TF v1.3 के साथ अभी भी समस्याएं हैं। मुझे यकीन है कि मैं निम्नलिखित विवरणों को नोट करता हूं, लेकिन अभी भी मूल्यांकन के दौरान is_training=False के साथ आधिकारिक tf.contrib.layers.batch_norm का उपयोग करने में विफल रहा है, लेकिन जब मैं मूल्यांकन के दौरान is_training=True अपरिवर्तित रखता हूं, तो यह है ठीक):
1. decay , घातीय मूविंग एवरेज वास्तव में सिग्नल प्रोसेसिंग में अल्फा फिल्टर है, अभिसरण का समय ट्रेन के लगभग 1 / (1-क्षय) चरणों का है। क्षय = 0.999 के लिए, आपको अभिसरण के लिए 1 / 0.001 = 1000 चरणों की आवश्यकता है। तो अपने प्रशिक्षण कदम संख्या के लिए उचित क्षय निर्धारित करें।

1. ट्रेन और परीक्षण मूल्यांकन के बीच स्विच करने के लिए प्लेसहोल्डर का उपयोग करना
2. यदि आप train_op पर अपडेट ऑप की नियंत्रण निर्भरता नहीं जोड़ना चाहते हैं तो updates_collections=None का उपयोग करें
3. reuse उचित मूल्य पर सेट करें।

ऐसा लगता है कि आधिकारिक बैच_नॉर्म का उपयोग करने का एकमात्र तरीका दो रेखांकन बनाना है, एक ट्रेन के लिए और दूसरा मूल्यांकन के लिए, क्रमशः is_training=True और is_training=False । इस तरह, आपको ट्रेन और मूल्यांकन के बीच गतिशील रूप से स्विच करने की आवश्यकता नहीं है। लेकिन यह एक बेवकूफ तरीका है क्योंकि आपको एक से अधिक ग्राफ बनाने की आवश्यकता है।

अंत में, मैं अपने आप से एक चलती औसत लिखता हूं, और मुझे लगता है कि यह काम कर गया! यह निम्नानुसार है (वेब ​​पर कोड के आधार पर और स्वयं द्वारा संशोधित)

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 और ट्रेन के दौरान गलत तरीके से बदलने के लिए स्वतंत्र हैं।

आशा है कि यह समुदाय की मदद करता है।

जब आप slim.batch_norm का उपयोग करते हैं, तो "tf.train.GradientDecentOptimizer (lr) .minimize (हानि) या अन्य ऑप्टिमाइज़र के बजाय" slim.learning.create_train_op "का उपयोग करना सुनिश्चित करें। यह देखने की कोशिश करें कि क्या यह काम करता है!

@vincentvanhoucke आपने इस सूत्र में एक और पोस्ट में लिखा है:

स्लिम बैच_नॉर्म रैपर आपके इनपुट टेंसर के अंतिम आयाम को सामान्य करता है। तो अगर यह एक 2 डी इनपुट टेंसर है जो पूरी तरह से जुड़ा हुआ परत से आ रहा है, यह बैच पर सामान्य करता है, और इस तरह प्रति-सक्रियण सामान्यीकरण करता है। यदि यह एक 4D टेंसर है जो एक कनवल्शन से आ रहा है, तो यह तीन पहले आयामों (बैच, चौड़ाई, गहराई) पर सामान्य हो जाएगा, और इस प्रकार प्रति-सुविधा सामान्यीकरण करेगा। @sguada शायद इस बारे में थोड़ा अधिक वर्णनात्मक हो रहा है।

क्या आप "स्लिम बैच_नॉर्म रैपर" फ़ंक्शन tf.contrib.layers.batch_norm मतलब रखते हैं? यदि हां, तो मैं इस जानकारी को इस फ़ंक्शन के प्रलेखन पाठ में जोड़ने का सुझाव दूंगा। इस प्रकार यह बहुत स्पष्ट हो जाता है, कि यह फ़ंक्शन बैच सामान्यीकरण को ठीक उसी तरह से करता है जैसे कि कागज में वर्णित है ... FC-Layer और Conv2D-Layer दोनों के लिए। फिलहाल केवल पाठ है "का उपयोग किया जा सकता है conv2d और पूरी तरह से जुड़े के लिए एक normalizer फ़ंक्शन।", जहां यह सामान्यीकरण अक्ष विषय से संबंधित है, तो यह स्पष्ट नहीं है।

@ZahlGraf मैं खुशी से एक पीआर पर विचार करूंगा जो प्रलेखन को स्पष्ट करता है। हम इतने लंबे समय से इस पर हैं कि मुझे अब इस बात की अच्छी समझ नहीं है कि क्या स्पष्ट है या नहीं, और इस विषय पर नए परिप्रेक्ष्य के साथ किसी के लिए स्पष्ट प्रलेखन का स्वागत करेंगे।

@vincentvanhoucke
मैंने अधिक विस्तृत विवरण के साथ एक पीआर बनाया, मुख्य रूप से इस सूत्र में आपके कथन के आधार पर:
https://github.com/tensorflow/tensorflow/pull/15653

कृपया एसेसी को हटा दें, क्योंकि यह मुद्दा बाहरी योगदान को आमंत्रित कर रहा है। अन्यथा, contributions welcome लेबल निकालें। धन्यवाद।

कृपया एसेसी को हटा दें, क्योंकि यह मुद्दा बाहरी योगदान को आमंत्रित कर रहा है। अन्यथा, contributions welcome लेबल निकालें। धन्यवाद।

बैच मानक परत को जोड़ने के मूल अनुरोध के बाद से इस बग को बंद करना संबोधित किया गया है। प्रलेखन के साथ हाल ही के कुछ मुद्दों पर अपने स्वयं के पीआर हैं
यदि आप बैच_नॉर्म के साथ कोई समस्या देखते हैं, तो कृपया या तो StackOverflow पर एक प्रश्न पूछें या किसी अन्य समस्या को खोलें।