Question

我是张力流和机器学习的新手，但是尝试使用嵌入式面板对DNN进行建模。出于某种原因，我不断得到成本结果和准确性的罪恶浪潮。我想我的代码有问题，所以这里有：

这是我的模特和训练程序：

def neural_network_model(x):
    W = tf.Variable(
       tf.truncated_normal([vocab_size, embedding_size], stddev=1 / math.sqrt(vocab_size)),
       name="W")

    embedded = tf.nn.embedding_lookup(W, x)    
    embedding_aggregated = tf.reduce_sum(embedded, [1])

    hidden_1_layer = {
        'weights': tf.Variable(tf.random_normal([embedding_size, n_nodes_hl1])),
        'biases': tf.Variable(tf.random_normal([n_nodes_hl1]))
    }

    hidden_2_layer = {
        'weights': tf.Variable(tf.random_normal([n_nodes_hl1, n_nodes_hl2])),
        'biases': tf.Variable(tf.random_normal([n_nodes_hl2]))
    }    

    hidden_3_layer = {
        'weights': tf.Variable(tf.random_normal([n_nodes_hl2, n_nodes_hl3])),
        'biases': tf.Variable(tf.random_normal([n_nodes_hl3]))        
    }    

    output = {
        'weights': tf.Variable(tf.random_normal([n_nodes_hl3, n_classes])),
        'biases': tf.Variable(tf.random_normal([n_classes]))
    }    

    l1 = tf.matmul(embedding_aggregated, hidden_1_layer['weights']) + hidden_1_layer['biases']
    l1 = tf.nn.relu(l1)

    l2 = tf.matmul(l1, hidden_2_layer['weights']) + hidden_2_layer['biases']
    l2 = tf.nn.relu(l2)

    l3 = tf.matmul(l2, hidden_3_layer['weights']) + hidden_3_layer['biases']
    l3 = tf.nn.relu(l3)    

    output = tf.matmul(l3, output['weights']) + output['biases']        
    return output

def train_neural_network(x_batch, y_batch, test_x, test_y):
    global_step = tf.Variable(0, trainable=False, name='global_step')    

    logits = neural_network_model(x_batch)
    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits, y_batch))
    tf.scalar_summary('cost', cost)
    optimizer = tf.train.AdagradOptimizer(0.01).minimize(cost, global_step = global_step)

    test_logits = neural_network_model(test_x)
    prediction = tf.nn.softmax(test_logits)
    correct = tf.equal(tf.argmax(prediction, 1), tf.argmax(test_y, 1))
    accuracy = tf.reduce_mean(tf.cast(correct, tf.float32))
    tf.scalar_summary('accuracy', accuracy)

    merged = tf.merge_all_summaries()

    saver = tf.train.Saver()
    model_dir = "model_embedding"
    latest_checkpoint = tf.train.latest_checkpoint(model_dir)

    with tf.Session() as sess:        
        train_writer = tf.train.SummaryWriter(model_dir + "/eval", sess.graph)
        if (latest_checkpoint != None):
            print("Restoring: ", latest_checkpoint)
            saver.restore(sess, latest_checkpoint)
        else:
            print("Nothing to restore")
            sess.run(tf.initialize_all_variables())

        coord = tf.train.Coordinator()
        threads = tf.train.start_queue_runners(sess=sess, coord=coord)
        try:
            epoch = 1
            while not coord.should_stop():
                epoch_loss = 0

                _, c, summary = sess.run([optimizer, cost, merged])
                # embd = sess.run(emb)
                # for idx in range(xb.size):
                #     print(xb[idx])
                #     print(yb[idx])

                train_writer.add_summary(summary, global_step = global_step.eval())
                epoch_loss += c             

                print('Epoch', epoch, 'completed out of',hm_epochs,'loss:',epoch_loss)
                print("Global step: ", global_step.eval())
                print('Accuracy:',accuracy.eval())
                #saver.save(sess, model_dir+'/model.ckpt', global_step=global_step) # default to last 5 checkpoint saves

                epoch += 1
        except tf.errors.OutOfRangeError:
            print('Done training -- epoch limit reached')
        finally:            
            coord.request_stop()
            coord.join(threads)
    sess.close()

我的数据是一堆字整数ID，填充到2056大小均匀，最后添加了填充标记，所以很多我的张量最后都有一堆vocab_size整数值，以便填充到2056年。

我的代码有什么明显的错误吗？

Answer 1

对于遇到同样问题的人：

我的错误是重用neural_network_model()函数，从而创建了一组新的变量。答案在于阅读如何共享变量，TF有一个很好的页面描述Sharing Variables

DNN嵌入层返回sin波成本/精度

1 个答案: