Python n个时代后，具有灰色下降选择的成本函数值增加

我正在为多标签文本文档分类创建一个神经网络。 我有3750个单词的词汇存储在向量（V）中

对于每个输入文档，我创建一个大小为3750的向量（I）。如果在词汇表中的向量（V）的x索引处找到输入文档中的术语，则向量中的x索引将标记为1，否则为0。例子。 [1,1,0,0,0,1，…，0]

对于标签，我有1500个存储在向量（L）中的标签的词汇表。 如上所述，我为每个文档创建了一个向量（LB），并将第I个索引标记为1（如果文档有标签x）

标签数据也表示为带有1550个元素的向量，如[0，0，1，0，1，…，0]。第i个元素指示第i个标签是否为文本的正标签。文本的标签数量因文本而异

这是我的密码

from __future__ import division
import tensorflow as tf
import numpy as np
import time

def csv_to_numpy_array(filePath, delimiter):
    return np.genfromtxt(filePath, delimiter=delimiter, dtype=None)


def import_data():
    print("Load training data")
    trainX = csv_to_numpy_array("/home/shahzeb/temp/train_data/trainX.csv", delimiter=",")
    trainY = csv_to_numpy_array("/home/shahzeb/temp/train_data/trainY.csv", delimiter=",")
    return trainX, trainY


startTime = time.time()
trainX, trainY = import_data()

learning_rate = 0.001
training_epochs = 500

# Network Parameters
n_hidden_1 = 3560 # 1st layer number of features
n_hidden_2 = 3560 # 2nd layer number of features
n_input = trainX.shape[1]
n_classes = trainY.shape[1]

# tf Graph input
input_neurons = tf.placeholder("float", [None, n_input],name="input")
known_outputs = tf.placeholder("float", [None, n_classes],name="labels")


def model(x):

    with tf.name_scope("Relu_activation"):
        # Hidden layer with RELU activation
        w1 = tf.Variable(tf.random_normal([n_input, n_hidden_1]), name="w")
        b1 = tf.Variable(tf.random_normal([n_hidden_1]), name="b")
        layer_1 = tf.add(tf.matmul(x, w1), b1)
        layer_1 = tf.nn.relu(layer_1)
        # Hidden layer with sigmoid activation
    with tf.name_scope("Sigmoid"):
        w2 = tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2]), name="w")
        b2 = tf.Variable(tf.random_normal([n_hidden_2]), name="b")
        layer_2 = tf.add(tf.matmul(layer_1, w2), b2)
        layer_2 = tf.nn.sigmoid(layer_2)
        # Output layer with linear activation
    with tf.name_scope("output"):
        w3 = tf.Variable(tf.random_normal([n_hidden_2, n_classes]), name="w")
        b3 = tf.Variable(tf.random_normal([n_classes]), name="b")
        out_layer = tf.matmul(layer_2, w3) + b3
        return out_layer,w1,w2,w3

model_output_OP, w_1,w_2,w_3 = model(input_neurons)

with tf.name_scope("cost"):
    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=model_output_OP, labels=known_outputs))

with tf.name_scope("train"):
    optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)

with tf.name_scope("accuracy"):
    correct_predictions_OP = tf.equal(tf.argmax(model_output_OP, 1), tf.argmax(known_outputs, 1))
    accuracy_OP = tf.reduce_mean(tf.cast(correct_predictions_OP, "float"), name="Accuracy_op")

with tf.name_scope("summary"):
    model_output_OP_summary = tf.summary.histogram("output", model_output_OP)
    accuracy_OP_summary = tf.summary.scalar("accuracy",accuracy_OP)
    cost_summary = tf.summary.scalar("cost",cost)
    summary_op = tf.summary.merge_all()
    writer = tf.summary.FileWriter("/home/shahzeb/temp/summarylogs/", graph=tf.get_default_graph())

init = tf.global_variables_initializer()

with tf.Session() as sess:
    sess.run(init)
    # Training cycle
    for epoch in range(training_epochs):
        _, c, summary,train_accuracy,iw1,iw2,iw3 = sess.run([optimizer, cost,summary_op,accuracy_OP,
                                                 w_1,w_2,w_3
                                                 ],
                                                feed_dict={input_neurons: trainX, known_outputs: trainY})

        print("Epoch:", '%04d' % (epoch + 1), "cost=", "{:.9f}".format(c), "Accuracy =",train_accuracy)
        #np.set_printoptions(threshold=np.nan)
        #print(iw1)
        #print(iw2)
        #print(iw3)
        #rint("--------------")
        writer.add_summary(summary, epoch + 1)

    saver = tf.train.Saver()
    saver.save(sess, "/home/shahzeb/temp/trained_model/hidden_layer_nn.ckpt")
print("Done")

张力板上的图形如下所示。

---

为什么成本函数值在一定时期后增加。出了什么问题以及如何解决。

您的问题的关键是纪元数。对于给定的训练数据集，您可能使用了太多。因此，可能的解释是，在第150纪元前后的某个时候，你开始过度适应

---

对于如何处理这样的问题有一个很好的解释。一个简单的解决方案是实施“提前停止”机制，这可以通过Tensorflow的validationmonitor来完成。

问题的关键是纪元的数量。对于给定的训练数据集，您可能使用了太多。因此，可能的解释是，在第150纪元前后的某个时候，你开始过度适应

---

对于如何处理这样的问题有一个很好的解释。一个简单的解决方案是实施“提前停止”机制，这可以通过Tensorflow的validationmonitor来实现。

感谢您的回复，事实上，我对我的模型有疑问，因为训练数据集中有一些原始数据，即一些空行，并且有了这些数据，我的成本函数并没有快速增长，而是逐渐增长。一旦我把它去掉，成本函数的价值就开始迅速增加。这就是我对我的模型产生怀疑的原因。谢谢你的回复，事实上，我对我的模型有疑问，因为训练数据集中有一些原始数据，即一些空行，有了这些数据，我的成本函数并没有增加得那么快，而是逐渐增加的。一旦我把它去掉，成本函数的价值就开始迅速增加。这就是我对我的模型产生怀疑的原因。