Question

我正在尝试创建一个图表，显示迷你批量准确度与神经网络验证准确度之间的相关性。但相反，我有一个疯狂的图形，它以超高频率闪烁，并放大了图形的一小部分。

这是我的代码：

num_nodes=1024
batch_size = 128
beta = 0.01


def animate(i):
    graph_data = open('NeuralNetData.txt','r').read()
    lines = graph_data.split('\n')
    xs = []
    ys = []
    for line in lines:
        if len(line) > 1:
            x, y = line.split(',')
            xs.append(x)
            ys.append(y)
    ax1.clear()
    ax1.plot(xs, ys,label='validation accuracy')
    ax1.legend(loc='lower right')
    ax1.set_ylabel("Accuracy(%)", fontsize=15)
    ax1.set_xlabel("Images Seen", fontsize=15)
    ax1.set_title("Neural Network Accuracy Data\nStochastic Gradient Descent", fontsize=10)
    plt.show()

def animate2(i):
   graph_data = open('NeuralNetData2.txt','r').read()
   lines = graph_data.split('\n')
   xs = []
   ys = []
   for line in lines:
      if len(line) > 1:
          x, y = line.split(',')
          xs.append(x)
          ys.append(y)
   ax1.plot(xs, ys, label='mini-batch accuracy')
   ax1.legend(loc='lower right')
   plt.tight_layout()
   plt.show()

style.use('fivethirtyeight')

#Creating Graph
fig = plt.figure(figsize=(50,50))
ax1 = fig.add_subplot(1,1,1)

#1 hidden layer using RELUs and trying regularization techniques

with graph.as_default():

    # Input data. For the training data, we use a placeholder that will be fed
    # at run time with a training minibatch.
    tf_train_dataset = tf.placeholder(tf.float32, shape=(batch_size, image_size * image_size))
    tf_train_labels = tf.placeholder(tf.float32, shape=(batch_size, num_labels))
    tf_valid_dataset = tf.constant(valid_dataset)
    tf_test_dataset = tf.constant(test_dataset)

    # Variables.
    weights_1 = tf.Variable(tf.truncated_normal([image_size * image_size, num_nodes]))
    biases_1 = tf.Variable(tf.zeros([num_nodes]))
    weights_2 = tf.Variable(tf.truncated_normal([num_nodes, num_labels]))
    biases_2 = tf.Variable(tf.zeros([num_labels]))

    # Training computation.
    logits_1 = tf.matmul(tf_train_dataset, weights_1) + biases_1
    relu_layer= tf.nn.relu(logits_1)
    logits_2 = tf.matmul(relu_layer, weights_2) + biases_2
    # Normal loss function
    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits_2, labels=tf_train_labels))
    # Loss function with L2 Regularization with beta=0.01
    regularizers = tf.nn.l2_loss(weights_1) + tf.nn.l2_loss(weights_2)
    loss = tf.reduce_mean(loss + beta * regularizers)

    # Optimizer.
    optimizer = tf.train.GradientDescentOptimizer(0.5).minimize(loss)

    # Predictions for the training
    train_prediction = tf.nn.softmax(logits_2)

    # Predictions for validation 
    logits_1 = tf.matmul(tf_valid_dataset, weights_1) + biases_1
    relu_layer= tf.nn.relu(logits_1)
    logits_2 = tf.matmul(relu_layer, weights_2) + biases_2

    valid_prediction = tf.nn.softmax(logits_2)

    # Predictions for test
    logits_1 = tf.matmul(tf_test_dataset, weights_1) + biases_1
    relu_layer= tf.nn.relu(logits_1)
    logits_2 = tf.matmul(relu_layer, weights_2) + biases_2

    test_prediction =  tf.nn.softmax(logits_2)

num_steps = 3001

open("NeuralNetData.txt","w").close()
open("NeuralNetData.txt","a+")
open("NeuralNetData2.txt","w+").close()
open("NeuralNetData2.txt","a+")

with tf.Session(graph=graph) as session:
    tf.global_variables_initializer().run()
    print("Initialized")
    for step in range(num_steps):
        f= open("NeuralNetData.txt","a")
        t= open("NeuralNetData2.txt","a")
        # Pick an offset within the training data, which has been randomized.
        # Note: we could use better randomization across epochs.
        offset = (step * batch_size) % (train_labels.shape[0] - batch_size)
        images_seen = step* batch_size
        # Generate a minibatch.
        batch_data = train_dataset[offset:(offset + batch_size), :]
        batch_labels = train_labels[offset:(offset + batch_size), :]
        # Prepare a dictionary telling the session where to feed the minibatch.
        # The key of the dictionary is the placeholder node of the graph to be fed,
        # and the value is the numpy array to feed to it.
        feed_dict = {tf_train_dataset : batch_data, tf_train_labels : batch_labels}
        _, l, predictions = session.run([optimizer, loss, train_prediction], feed_dict=feed_dict)
        if (images_seen % 1000 == 0):
            print("Minibatch loss at step {}: {}".format(step, l))
            print("Minibatch accuracy: {:.1f}".format(accuracy(predictions, batch_labels)))
            print("Validation accuracy: {:.1f}".format(accuracy(valid_prediction.eval(), valid_labels)))
            x=str(images_seen)
            y=str(accuracy(valid_prediction.eval(), valid_labels))
            f.write(x+','+y+'\n')
            f.close()
            r=str(accuracy(predictions, batch_labels))
            t.write(x+','+r+'\n')
            t.close()
            ani = animation.FuncAnimation(fig, animate, interval=1000)
            ani2 = animation.FuncAnimation(fig, animate2, interval=1000)
    print("Test accuracy: {:.1f}".format(accuracy(test_prediction.eval(), test_labels)))

Answer 1

首先，不要在plt.show()调用的更新函数内调用FuncAnimation。相反，它应该在脚本结束时调用一次。

其次，您似乎使用了两个不同的FuncAnimations，它们在同一个轴上工作（ax1）。其中一个是清除轴。所以可能发生的情况是，当一个函数被另一个函数清除时，该图更新 - 结果可能接近混乱。

第三，您正在创建6002个FuncAnimations而不是仅创建一个或两个。它们中的每一个都将在相同的轴上运行。所以如果上面已经产生混乱，这将产生6002次混乱。

为什么我的图形是一个疯狂的闪烁怪物？

1 个答案: