Neural network 在tensorflow中，不支持分割标签和功能？

我想制作划分标签和特征的数据，因为tf.nn.softmax\u cross\u entropy\u需要登录

queue = tf.RandomShuffleQueue(
capacity=capacity,
min_after_dequeue=min_after_dequeue,
dtypes=[tf.float32],
shapes=[[n_input+1]] # 
)

创建队列并放置标签和功能

之后，我应该为成本函数划分标签和特性。但如何做到这一点呢

多谢各位

import tensorflow as tf
import numpy as np

# Parameters
learning_rate   = 0.003
training_epochs = 30
batch_size      = 2
display_step    = 1
min_after_dequeue = 5
capacity = 16246832

# Network Parameters
# feature size
n_input    = 199 

# 1st layer num features
n_hidden_1 = 150 

# 2nd layer num features
n_hidden_2 = 100

# 3rd layer num features 
n_hidden_3 = 50 

# 4th layer num features
n_hidden_4 = 30 

#class
n_classes  = 3 


#read csv, 0 index is label
filename_queue = tf.train.string_input_producer(["data.csv"])


record_default = [[0.0] for x in xrange(200)] # with a label and 199 features

#testfile
reader = tf.TextLineReader()

#file read
key, value = reader.read(filename_queue)

#decode
features = tf.decode_csv(value, record_defaults= record_default)


featurespack = tf.pack(features)
#xy = tf.map_fn(fn = lambda f: [f[1:],f[0]], elems=featurespack)


#for the batch
queue = tf.RandomShuffleQueue(
    capacity=capacity,
    min_after_dequeue=min_after_dequeue,
    dtypes=[tf.float32],
    shapes=[[n_input+1]]
)


#enqueue
enqueue_op = queue.enqueue(featurespack)

#dequeue
inputs = queue.dequeue_many(batch_size)


#threading
qr = tf.train.QueueRunner(queue, [enqueue_op] * 4)

#features n=199
x = tf.placeholder("float", [None, n_input])
# class 0,1,2
y = tf.placeholder("float", [None, n_classes])

#dropout
dropout_keep_prob = tf.placeholder("float")

# Create model
def multilayer_perceptron(_X, _weights, _biases, _keep_prob):
    layer_1 = tf.nn.dropout(tf.nn.relu(tf.add(tf.matmul(_X, _weights['h1']), _biases['b1'])), _keep_prob)
    layer_2 = tf.nn.dropout(tf.nn.relu(tf.add(tf.matmul(layer_1, _weights['h2']), _biases['b2'])), _keep_prob)
    layer_3 = tf.nn.dropout(tf.nn.relu(tf.add(tf.matmul(layer_2, _weights['h3']), _biases['b3'])), _keep_prob)
    layer_4 = tf.nn.dropout(tf.nn.relu(tf.add(tf.matmul(layer_3, _weights['h4']), _biases['b4'])), _keep_prob)
    return tf.sigmoid(tf.matmul(layer_4, _weights['out']) + _biases['out'])

# Store layers weight & bias
weights = {
    'h1': tf.Variable(tf.random_normal([n_input, n_hidden_1], stddev=0.1)),
    'h2': tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2], stddev=0.1)),
    'h3': tf.Variable(tf.random_normal([n_hidden_2, n_hidden_3], stddev=0.1)),
    'h4': tf.Variable(tf.random_normal([n_hidden_3, n_hidden_4], stddev=0.1)),
    'out': tf.Variable(tf.random_normal([n_hidden_4, n_classes], stddev=0.1))
}
biases = {
    'b1': tf.Variable(tf.random_normal([n_hidden_1])),
    'b2': tf.Variable(tf.random_normal([n_hidden_2])),
    'b3': tf.Variable(tf.random_normal([n_hidden_3])),
    'b4': tf.Variable(tf.random_normal([n_hidden_4])),
    'out': tf.Variable(tf.random_normal([n_classes]))
}


# Construct model
pred = multilayer_perceptron(x, weights, biases, dropout_keep_prob)

# Define loss and optimizer
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(pred, y)) # Softmax loss
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost) # Adam Optimizer
# optimizer = tf.train.MomentumOptimizer(learning_rate=learning_rate, momentum=0.8).minimize(cost) # Adam Optimizer

# Initializing the variables

print "1"
with tf.Session() as sess:

    #init
    tf.initialize_all_variables().run

    #what is
    coord = tf.train.Coordinator()

    #queue start what is
    tf.train.start_queue_runners (coord=coord)


    #i dont know well
    enqueue_threads = qr.create_threads(sess, coord=coord, start=True)

    print sess.run(features)
    print sess.run(features)
    print sess.run(features)
    print sess.run(features)
    print sess.run(features)


    #
    #print sess.run(feature)
    #Training cycle
    for epoch in range(training_epochs):
        print epoch
        avg_cost = 0.

        # Loop over all batches
        for i in range(10):
            print i
            if coord.should_stop():
                break
            #get inputs
            inputs_value = sess.run(inputs)

            #THIS IS NOT WORK
            batch_xs = np.ndarray([x[1:] for x in inputs_value])
            batch_ys = np.ndarray([x[0] for x in inputs_value])

            print 'batch', len(batch_ys), len(batch_xs)
            #batch_xs, batch_ys = mnist.train.next_batch(batch_size)
            # Fit training using batch data
            #optimzierm put x and y
            sess.run(optimizer, feed_dict={x: batch_xs, y: batch_ys, dropout_keep_prob: 0.5})
            # Compute average loss
            avg_cost += sess.run(cost, feed_dict={x: batch_xs, y: batch_ys, dropout_keep_prob: 0.5})/batch_size

        # Display logs per epoch step
        if epoch % display_step == 0:
            print ("Epoch: %03d/%03d cost: %.9f" % (epoch, training_epochs, avg_cost))
            # Test model
            correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
            # Calculate accuracy
            accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
            #print ("Accuracy:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels, dropout_keep_prob: 1.}))

    coord.request_stop ()
    coord.join (enqueue_threads)
    print ("Optimization Finished!")

---

我不明白这个问题我不明白这个问题