张量流中缺失层的怪异行为

Question

我用Tensorflow制作了一个CNN模型，该模型实现了辍学层。 我在网络函数中传递了is_training参数，因此该辍学将在测试阶段被禁用，并且我意识到当我禁用它时，错误会大大增加。 如果我正在使用dropout函数（不是逻辑）测试模型，则平均得到0.01的误差，而当我通过指定is_training为False（但仍通过dropout对其进行训练）来测试模型时，误差为0.8。 我不明白我的错误在哪里

这是模型函数：

def train_test_model(hypers, save_final_model=False):
    # Running the training session
    print("Starting training session...")
    with tf.Session() as sess:

        # Run the initializer
        sess.run(init)
        total_batch = int(mnist.train.num_examples / hypers.batch_size)
        # Training cycle
        try:
            for epoch in range(hypers.n_epochs):
                avg_cost = 0.

                # Loop over all batches
                for i in range(total_batch):
                    batch_x, batch_y = mnist.train.next_batch(hypers.batch_size)
                    # Run optimization op (backprop) and cost op (to get loss value)
                    _, c = sess.run([optimizer, cost], feed_dict={x: batch_x,
                                                                  y: batch_y})
                    # Compute average loss
                    avg_cost += c / total_batch
                # Display logs per epoch step
                if epoch % display_step == 0:

                    # Test model
                    correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))

                    # Calculate accuracy
                    # ORIGINAL:
                    # accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
                    # train_err = 1-accuracy.eval({x: mnist.train.images, y: mnist.train.labels})
                    # valid_err = 1-accuracy.eval({x: mnist.validation.images, y: mnist.validation.labels})

                    # WITH BATCHES FOR LESS MEM ALLOC
                    accuracy = tf.reduce_mean(tf.cast(correct_prediction, 'float'))
                    train_acc = 0
                    for i in range(total_batch):
                        batch_x, batch_y = mnist.train.next_batch(hypers.batch_size)
                        train_acc += accuracy.eval(feed_dict={x:batch_x,
                                                              y:batch_y})
                    train_acc /= total_batch

                    train_err = 1 - train_acc
                    valid_err = 1 - accuracy.eval({x: mnist.validation.images, y: mnist.validation.labels})
                    # Display accuracy
                    print("Epoch:", '%05d' % (epoch + 1), ", cost=",
                          "{:.9f}".format(avg_cost), ", train_err=", "{:.4f}".format(train_err), ", valid_err=",
                          "{:.4f}".format(valid_err))

                if epoch % 5 == 0:
                    v = input('Do you want to stop the model? [Y/n]')
                    if 'y' in v.lower():
                        raise KeyboardInterrupt

        except KeyboardInterrupt:
            hypers.n_epochs = epoch
            print("SIGINT Received, interrupting the training")



        print("\nOptimization Finished!\n")

        # Test model
        correct_prediction = tf.equal(tf.argmax(test_pred, 1), tf.argmax(y, 1))
        # Calculate accuracy
        accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
        # modified to batches
        train_acc = 0
        for i in range(total_batch):
            batch_x, batch_y = mnist.train.next_batch(hypers.batch_size)
            train_acc += accuracy.eval(feed_dict={x: batch_x,
                                                  y: batch_y})
        train_acc /= total_batch
        train_err = 1 - train_acc
        #
        valid_err = 1 - accuracy.eval({x: mnist.validation.images, y: mnist.validation.labels})
        print("Optimized for ", '%05d' % (epoch + 1), "epochs, to obtain training error", "{:.4f}".format(train_err),
              ", and validation error", "{:.4f}".format(valid_err))
        confusion = tf.confusion_matrix(tf.argmax(pred, 1), tf.argmax(y, 1))
        print("\nValidation Confusion matrix:\n",
              confusion.eval({x: mnist.validation.images, y: mnist.validation.labels}))

和训练功能：

upstream myapp {
    server unix:/tmp/unicorn.sock fail_timeout=0;
}

server {
    listen 3000;
    listen 3001 ssl;
    server_name example.com;

    ssl_certificate [...];
    ssl_certificate_key [...];

    root [...];

    try_files $uri/index.html $uri @myapp;

    location @myapp {
        proxy_pass http://myapp;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Host $http_host;
        proxy_set_header X-Forwarded-Proto $scheme; # I added this line
        proxy_redirect off;
    }

    error_page 500 502 503 504 /500.html;
    client_max_body_size 4G;
    keepalive_timeout 10;
}