Question

我有以下代码（只有2次迭代，为了简单起见，我没有在下面的代码中检索新的批处理）：

for i in range(2):
    if (i % reset_point) != 0 or i == 0:
        char_id_batch, word_id_batch, pos_id_batch = Reader.retrieve_batch_sent(start, batch_size_counter, remote_or_not)
        feed_dict = {char_id: char_id_batch, word_id: word_id_batch, y: pos_id_batch}
        _, predicted_output_result, y_reshape_result, correct_prediction_result, acc_result = sess.run([train_op, 
                                    predicted_output, 
                                    y_reshape, 
                                    correct_prediction, 
                                    accuracy], feed_dict=feed_dict)
        y_pred = []
        y_actu = []
        for j in range(len(predicted_output_result)):
            y_pred.append(predicted_output_result[j].tolist().index(max(predicted_output_result[j])))
            y_actu.append(y_reshape_result[j].tolist().index(max(y_reshape_result[j])))
        y_actu = pd.Series(y_actu, name='Actual')
        y_pred = pd.Series(y_pred, name='Predicted')
        df_confusion = pd.crosstab(y_actu, y_pred)
        print(df_confusion)
        print('accuracy at iteration %d is: %0.3f' % (i, acc_result))


        predicted_output_result1, acc_result1 = sess.run([predicted_output, accuracy], feed_dict=feed_dict)
        y_pred = []
        y_actu = []
        for j in range(len(predicted_output_result1)):
            y_pred.append(predicted_output_result1[j].tolist().index(max(predicted_output_result1[j])))
            y_actu.append(y_reshape_result[j].tolist().index(max(y_reshape_result[j])))
        y_actu = pd.Series(y_actu, name='Actual')
        y_pred = pd.Series(y_pred, name='Predicted')
        df_confusion = pd.crosstab(y_actu, y_pred)
        print(df_confusion)
        print('accuracy at iteration %d is: %0.3f' % (i, acc_result1))


        predicted_output_result2, acc_result2= sess.run([predicted_output, accuracy], feed_dict=feed_dict)
        y_pred = []
        y_actu = []
        for j in range(len(predicted_output_result2)):
            y_pred.append(predicted_output_result2[j].tolist().index(max(predicted_output_result2[j])))
            y_actu.append(y_reshape_result[j].tolist().index(max(y_reshape_result[j])))
        y_actu = pd.Series(y_actu, name='Actual')
        y_pred = pd.Series(y_pred, name='Predicted')
        df_confusion = pd.crosstab(y_actu, y_pred)
        print(df_confusion)
        print('accuracy at iteration %d is: %0.3f' % (i, acc_result2))

当我跑步时，我得到以下结果（未显示全部）：

Predicted   0     8   10
Actual                  
0           27  4132   0
1           38    87   7
2           79   173   2
accuracy at iteration 0 is: 0.004

Predicted    12
Actual         
0          4159
1           132
2           254
accuracy at iteration 0 is: 0.081

Predicted    12
Actual         
0          4159
1           132
2           254
accuracy at iteration 0 is: 0.081

Predicted    12
Actual         
0          4159
1           132
2           254
accuracy at iteration 1 is: 0.081

Predicted    14
Actual         
0          4159
1           132
2           254
accuracy at iteration 1 is: 0.072

Predicted    14
Actual         
0          4159
1           132
2           254
accuracy at iteration 1 is: 0.072

如您所见，iteration 0的第二个和第三个结果重复出现。同样在iteration 1的第一次会话中。但iteration 1的第二个结果发生了变化，其中iteration 1的第三个结果与iteration 1的第二个结果相同。

然而，如果我在所有三个会话运行中都包含train_op，那么我会得到不同的结果。

有人可以解释发生了什么吗？为什么包含和不包括train_op？
哪一个是正确的，即我是否应该包括train_op？如果我包括或不包括train_op？

我有以下代码（只有2次迭代，为了简单起见，我没有在下面的代码中检索新的批处理）：

for i in range(2):
    if (i % reset_point) != 0 or i == 0:
        char_id_batch, word_id_batch, pos_id_batch = Reader.retrieve_batch_sent(start, batch_size_counter, remote_or_not)
        feed_dict = {char_id: char_id_batch, word_id: word_id_batch, y: pos_id_batch}
        _, predicted_output_result, y_reshape_result, correct_prediction_result, acc_result = sess.run([train_op, 
                                    predicted_output, 
                                    y_reshape, 
                                    correct_prediction, 
                                    accuracy], feed_dict=feed_dict)
        y_pred = []
        y_actu = []
        for j in range(len(predicted_output_result)):
            y_pred.append(predicted_output_result[j].tolist().index(max(predicted_output_result[j])))
            y_actu.append(y_reshape_result[j].tolist().index(max(y_reshape_result[j])))
        y_actu = pd.Series(y_actu, name='Actual')
        y_pred = pd.Series(y_pred, name='Predicted')
        df_confusion = pd.crosstab(y_actu, y_pred)
        print(df_confusion)
        print('accuracy at iteration %d is: %0.3f' % (i, acc_result))


        predicted_output_result1, acc_result1 = sess.run([predicted_output, accuracy], feed_dict=feed_dict)
        y_pred = []
        y_actu = []
        for j in range(len(predicted_output_result1)):
            y_pred.append(predicted_output_result1[j].tolist().index(max(predicted_output_result1[j])))
            y_actu.append(y_reshape_result[j].tolist().index(max(y_reshape_result[j])))
        y_actu = pd.Series(y_actu, name='Actual')
        y_pred = pd.Series(y_pred, name='Predicted')
        df_confusion = pd.crosstab(y_actu, y_pred)
        print(df_confusion)
        print('accuracy at iteration %d is: %0.3f' % (i, acc_result1))


        predicted_output_result2, acc_result2= sess.run([predicted_output, accuracy], feed_dict=feed_dict)
        y_pred = []
        y_actu = []
        for j in range(len(predicted_output_result2)):
            y_pred.append(predicted_output_result2[j].tolist().index(max(predicted_output_result2[j])))
            y_actu.append(y_reshape_result[j].tolist().index(max(y_reshape_result[j])))
        y_actu = pd.Series(y_actu, name='Actual')
        y_pred = pd.Series(y_pred, name='Predicted')
        df_confusion = pd.crosstab(y_actu, y_pred)
        print(df_confusion)
        print('accuracy at iteration %d is: %0.3f' % (i, acc_result2))

当我跑步时，我得到以下结果（未显示全部）：

Predicted   0     8   10
Actual                  
0           27  4132   0
1           38    87   7
2           79   173   2
accuracy at iteration 0 is: 0.004

Predicted    12
Actual         
0          4159
1           132
2           254
accuracy at iteration 0 is: 0.081

Predicted    12
Actual         
0          4159
1           132
2           254
accuracy at iteration 0 is: 0.081

Predicted    12
Actual         
0          4159
1           132
2           254
accuracy at iteration 1 is: 0.081

Predicted    14
Actual         
0          4159
1           132
2           254
accuracy at iteration 1 is: 0.072

Predicted    14
Actual         
0          4159
1           132
2           254
accuracy at iteration 1 is: 0.072

如您所见，iteration 0的第二个和第三个结果重复出现。同样在iteration 1的第一次会话中。但iteration 1的第二个结果发生了变化，其中iteration 1的第三个结果与iteration 1的第二个结果相同。

然而，如果我在所有三个会话运行中都包含train_op，那么我会得到不同的结果。

有人可以解释发生了什么吗？为什么包含和不包括train_op？
哪一个是正确的，即我是否应该包括train_op？如果我包括或不包括train_op？

添加train_op，accuracy，predicted_output：

correct_prediction = tf.equal(tf.argmax(predicted_output, 1), tf.argmax(y_reshape, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
train_op = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(loss)
predicted_output = tf.matmul(output_sent, h_layer_weights) + h_layer_bias

Answer 1

首先，注意：您尚未显示train_op，predicted_output或accuracy的定义，因此我接受了培训（虽然相当自信）在下面的答案中猜测这些操作实际上是什么。但是，如果您异常地定义它们，请优化代码示例（并简化其中的大部分内容）以澄清。

那就是说，这里发生了什么：没有train_op，你只是在评估predicted_output和accuracy。这些只是获取feed_dict中的数据，并为您提供NN的输出和准确性（它对NN模型的目标进行分类/预测的程度）。注意，这些步骤都没有实际采用渐变步骤或更改模型参数以尝试更好地解释数据。因此，您不应期望您的模型发生变化，因此您应该期望准确性也不会改变。

顾名思义，train_op是实际采用渐变步骤并训练模型的操作。因此，当你在第二次迭代中再次运行它时，它会改变模型，你的准确性会发生变化（改进是理想的，但这是随机优化，所以只要性能通常在迭代次数上有所提高，就会出现精度损失），并且您将获得新值，正如您在代码中看到的那样。

在会话运行

1 个答案: