Похоже, что параметры нормализации партии не обновляются в Tensorflow?

Question

Я новичок в TensorFlow. Мы устанавливаем одинаковые данные обучения на этапе обучения и на этапе тестирования. Но потери при обучении составляют

Потеря при испытании равна (Данные испытаний совпадают с данными по обучению.)

Очень странно, что две вышеупомянутые потери различны. Я не знаю, неправильно ли использовать пакетную нормализацию. Я дважды проверил, что мы установили обучение = True на этапе обучения, а обучение = False на этапе тестирования. Похоже, что параметры нормализации партии не обновляются. Кто-нибудь может мне помочь и посмотреть?

Шаг поезда и шаг теста:

  with tf.Graph().as_default():
        train_model = RnnClassifier(training=True)
        test_model = RnnClassifier(training=False)

        with tf.name_scope('train'):
            model_train_tensor_dict = train_model.forward(next_train_inputs)

            model_train_loss = model_train_tensor_dict['loss']
            global_step = tf.get_variable('global_step',
                                          dtype=tf.int32,
                                          initializer=0,
                                          trainable=False)
            learning_rate = tf.train.exponential_decay(FLAGS.base_learning_rate,
                                                       global_step,
                                                       FLAGS.learning_rate_decay_steps,
                                                       FLAGS.learning_rate_decay_rate,
                                                       staircase=True)
            optimizer = tf.train.MomentumOptimizer(learning_rate=learning_rate, momentum=0.9)
            with tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS)):
                model_train_ops = optimizer.minimize(model_train_loss, global_step=global_step)
            model_train_tensor_dict['global_step'] = global_step

        with tf.name_scope('test'):
            model_test_tensor_dict = test_model.forward(next_test_inputs)

RnnКлассификатор:

class BNLSTMCell(RNNCell):
    def __init__(self,
                 num_units,
                 training,
                 name,
                 reuse,
                 gate_initializer=tf.initializers.orthogonal(),
                 bias_initializer=tf.initializers.ones()):
        self.num_units = num_units
        self.training = training
        self.name = name
        self.reuse=reuse
        self.gate_initailizer = gate_initializer
        self.bias_initailizer = bias_initializer

    @property
    def state_size(self):
        '''
        :return: (cell_size, hidden_size)
        '''
        return (self.num_units, self.num_units)

    @property
    def output_size(self):
        return self.num_units

    def __call__(self, inputs, state, scope=None)
        if scope is None:
            scope = self.name
        with tf.variable_scope(scope, reuse=self.reuse):
            cell_state, hidden_state = state
            feature_size = inputs.get_shape().as_list()[1]

            W_XH = tf.get_variable('W_XH', shape=[feature_size, 4 * self.num_units], \
                                   initializer=self.gate_initailizer)
            print('W_XH: {}'.format(W_XH))

            W_HH = tf.get_variable('W_HH', shape=[self.num_units, 4 * self.num_units], \
                                   initializer=self.gate_initailizer)
            bias = tf.get_variable('bias', shape=[4 * self.num_units], \
                                   initailizer=self.bias_initailizer)

            hidden = bn('bn_xWXH', tf.matmul(inputs, W_XH), training=self.training) + \
                     bn('bn_hWHH', tf.matmul(hidden_state, W_HH), training=self.training) + \
                     bias
            forget, input, output, candidate_cell_state = tf.split(hidden, num_or_size_splits=4, axis=1)

            next_cell_state = tf.math.sigmoid(forget) * cell_state + \
                              tf.math.sigmoid(input) * tf.math.tanh(candidate_cell_state)

            bn_next_cell_state = bn('bn_next_cell_state', next_cell_state, training=self.training)
            next_hidden_state = tf.math.sigmoid(output) * tf.math.tanh(bn_next_cell_state)

            return next_hidden_state, (next_cell_state, next_hidden_state)