Python 2.7 ValueError:Tensor Tensor（“Const:0”，shape=（），dtype=float32）不能与tf.placeholder一起馈送

我正在尝试用tensorflow制作语音识别系统

• 输入数据是一个大小为50000 X 1的numpy数组

• 输出数据（映射数据）是一个大小为400 X 1的numpy数组

输入和映射数据在列表中以2个为一批传递

我用教程设计了神经网络。以下是代码片段：

对于RNN：

input_data = tf.placeholder(tf.float32, [batch_size, sound_constants.MAX_ROW_SIZE_IN_DATA, sound_constants.MAX_COLUMN_SIZE_IN_DATA], name="train_input")
target = tf.placeholder(tf.float32, [batch_size, sound_constants.MAX_ROW_SIZE_IN_TXT, sound_constants.MAX_COLUMN_SIZE_IN_TXT], name="train_output")

fwd_cell = tf.nn.rnn_cell.BasicLSTMCell(num_hidden, state_is_tuple=True, forget_bias=1.0)

# creating one backward cell
bkwd_cell = tf.nn.rnn_cell.BasicLSTMCell(num_hidden, state_is_tuple=True, forget_bias=1.0)

# creating bidirectional RNN
val, _, _ = tf.nn.static_bidirectional_rnn(fwd_cell, bkwd_cell, tf.unstack(input_data), dtype=tf.float32)

对于馈送数据：

feed = {g['input_data'] : trb[0], g['target'] : trb[1], g['dropout'] : 0.6}
accuracy_, _ = sess.run([g['accuracy'], g['ts']], feed_dict=feed)
accuracy += accuracy_

运行代码时，出现以下错误：

Traceback (most recent call last):
  File "/home/wolborg/PycharmProjects/speech-to-text-rnn/src/rnn_train_1.py", line 205, in <module>
    tr_losses, te_losses = train_network(g)
  File "/home/wolborg/PycharmProjects/speech-to-text-rnn/src/rnn_train_1.py", line 177, in train_network
    accuracy_, _ = sess.run([g['accuracy'], g['ts']], feed_dict=feed)
  File "/home/wolborg/anaconda2/lib/python2.7/site-packages/tensorflow/python/client/session.py", line 895, in run
    run_metadata_ptr)
  File "/home/wolborg/anaconda2/lib/python2.7/site-packages/tensorflow/python/client/session.py", line 1102, in _run
    raise ValueError('Tensor %s may not be fed.' % subfeed_t)
ValueError: Tensor Tensor("Const:0", shape=(), dtype=float32) may not be fed.

Process finished with exit code 1

回溯（最近一次呼叫最后一次）：
文件“/home/wolborg/PycharmProjects/speech to text rnn/src/rnn_train_1.py”，第205行，in
tr_损耗，te_损耗=列车网络（g）
文件“/home/wolborg/PycharmProjects/speech to text rnn/src/rnn_train_1.py”，第177行，列车网络中
准确度，uu=sess.run（[g['accurity']，g['ts']，feed\u dict=feed）
文件“/home/wolborg/anaconda2/lib/python2.7/site packages/tensorflow/python/client/session.py”，第895行，正在运行
运行_元数据_ptr）
文件“/home/wolborg/anaconda2/lib/python2.7/site packages/tensorflow/python/client/session.py”，第1102行，正在运行
raise VALUE ERROR（'张量%s可能无法进给。'%subfeed\t）
ValueError:不能馈送张量张量（“常数：0”，形状=（），数据类型=浮点32）。
进程已完成，退出代码为1

早些时候，我使用tf.sparse_占位符遇到了这个问题，然后在浏览之后，我将输入类型更改为tf.placeholder并进行了相关更改。现在我不知道我在哪里犯了错误

请提出一些建议，如我应该如何提供数据

完整代码：

import tensorflow as tf

# for taking MFCC and label input
import numpy as np
import rnn_input_data_1
import sound_constants

# input constants

# Training Parameters
num_input = 10 # mfcc data input
training_data_size = 8 # determines number of files in training and testing module
testing_data_size = num_input - training_data_size

# Network Parameters
learning_rate = 0.0001 # for large training set, it can be set 0.001
num_hidden = 200 # number of hidden layers
num_classes = 28 # total alphabet classes (a-z) + extra symbols (', ' ')
epoch = 1 # number of iterations
batch_size = 2 # number of batches

mfcc_coeffs, text_data = rnn_input_data_1.mfcc_and_text_encoding()

class DataGenerator:
    def __init__(self, data_size):
    self.ptr = 0
    self.epochs = 0
    self.data_size = data_size

    def next_batch(self):
    self.ptr += batch_size
    if self.ptr > self.data_size:
        self.epochs += 1
        self.ptr = 0

    return mfcc_coeffs[self.ptr-batch_size : self.ptr], text_data[self.ptr-batch_size : self.ptr]

def reset_graph():
    if 'sess' in globals() and sess:
    sess.close()
    tf.reset_default_graph()

def struct_network():

    print ('Inside struct network !!')

    reset_graph()

    input_data = tf.placeholder(tf.float32, [batch_size, sound_constants.MAX_ROW_SIZE_IN_DATA, sound_constants.MAX_COLUMN_SIZE_IN_DATA], name="train_input")
    target = tf.placeholder(tf.float32, [batch_size, sound_constants.MAX_ROW_SIZE_IN_TXT, sound_constants.MAX_COLUMN_SIZE_IN_TXT], name="train_output")

    keep_prob = tf.constant(1.0)

    fwd_cell = tf.nn.rnn_cell.BasicLSTMCell(num_hidden, state_is_tuple=True, forget_bias=1.0)

    # creating one backward cell
    bkwd_cell = tf.nn.rnn_cell.BasicLSTMCell(num_hidden, state_is_tuple=True, forget_bias=1.0)

    # creating bidirectional RNN
    val, _, _ = tf.nn.static_bidirectional_rnn(fwd_cell, bkwd_cell, tf.unstack(input_data), dtype=tf.float32)

    # adding dropouts
    val = tf.nn.dropout(val, keep_prob)

    val = tf.transpose(val, [1, 0, 2])
    last = tf.gather(val, int(val.get_shape()[0]) - 1)

    # creating bidirectional RNN
    print ('BiRNN created !!')


    print ('Last Size: ', last.get_shape())

    weight = tf.Variable(tf.truncated_normal([num_hidden * 2, sound_constants.MAX_ROW_SIZE_IN_TXT]))
    bias = tf.Variable(tf.constant(0.1, shape=[sound_constants.MAX_ROW_SIZE_IN_TXT]))

    # mapping to 28 output classes
    logits = tf.matmul(last, weight) + bias
    prediction = tf.nn.softmax(logits)
    prediction = tf.reshape(prediction, shape = [batch_size, sound_constants.MAX_ROW_SIZE_IN_TXT, sound_constants.MAX_COLUMN_SIZE_IN_TXT])

    # getting probability distribution
    mat1 = tf.cast(tf.argmax(prediction,1),tf.float32)
    correct = tf.equal(prediction, target)
    accuracy = tf.reduce_mean(tf.cast(correct, tf.float32))

    logits = tf.reshape(logits, shape=[batch_size, sound_constants.MAX_ROW_SIZE_IN_TXT, sound_constants.MAX_COLUMN_SIZE_IN_TXT])


    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=target))
    train_step = tf.train.AdamOptimizer(1e-4).minimize(loss)

    # returning components as dictionary elements
    return {'input_data' : input_data,
        'target' : target,
        'dropout': keep_prob,
        'loss': loss,
        'ts': train_step,
        'preds': prediction,
        'accuracy': accuracy
        }


def train_network(graph):


    # initialize tensorflow session and all variables
    # tf_gpu_config = tf.ConfigProto(allow_soft_placement = True, log_device_placement = True)
    # tf_gpu_config.gpu_options.allow_growth = True


    # with tf.Session(config = tf_gpu_config) as sess:
    with tf.Session() as sess:

    train_instance = DataGenerator(training_data_size)
    test_instance = DataGenerator(testing_data_size)

    print ('Training data size: ', train_instance.data_size)
    print ('Testing data size: ', test_instance.data_size)

    sess.run(tf.global_variables_initializer())
    print ('Starting session...')
    step, accuracy = 0, 0
    tr_losses, te_losses = [], []
    current_epoch = 0
    while current_epoch < epoch:
        step += 1
        trb = train_instance.next_batch()

        feed = {g['input_data'] : trb[0], g['target'] : trb[1], g['dropout'] : 0.6}
        accuracy_, _ = sess.run([g['accuracy'], g['ts']], feed_dict=feed)
        accuracy += accuracy_

        if train_instance.epochs > current_epoch:
            current_epoch += 1
            tr_losses.append(accuracy / step)
            step, accuracy = 0, 0

            #eval test set
            te_epoch = test_instance.epochs
            while test_instance.epochs == te_epoch:
                step += 1
                print ('Testing round ', step)
                trc = test_instance.next_batch()
                feed = {g['input_data']: trc[0], g['target']: trc[1]}
                accuracy_ = sess.run([g['accuracy']], feed_dict=feed)[0]
                accuracy += accuracy_

            te_losses.append(accuracy / step)
            step, accuracy = 0,0
            print("Accuracy after epoch", current_epoch, " - tr:", tr_losses[-1], "- te:", te_losses[-1])

    return tr_losses, te_losses

g = struct_network()
tr_losses, te_losses = train_network(g)

将tensorflow导入为tf
#用于获取MFCC和标签输入
将numpy作为np导入
导入rnn\u输入数据\u 1
导入声音常量
#输入常数
#训练参数
num#U input=10#mfcc数据输入
training_data_size=8#确定培训和测试模块中的文件数
测试数据大小=输入数量-训练数据大小
#网络参数
学习率=0.0001#对于大型培训集，可设置为0.001
num_hidden=200#隐藏层数
num#U classes=28#字母表总类别（a-z）+额外符号（'，''）
历元=1#迭代次数
批次大小=2#批次数
mfcc_系数，text_data=rnn_输入_数据_1.mfcc_和_text_编码（）
类数据生成器：
定义初始化（自身、数据大小）：
self.ptr=0
self.epochs=0
self.data\u size=数据大小
def下一批（自身）：
self.ptr+=批量大小
如果self.ptr>self.data\u大小：
self.epochs+=1
self.ptr=0
返回mfcc_系数[self.ptr-batch_size:self.ptr]，文本_数据[self.ptr-batch_size:self.ptr]
def reset_graph（）：
如果globals（）和sess中的“sess”：
sess.close（）
tf.reset_default_graph（）
def struct_network（）：
打印（'内部结构网络！！'）
重置图（）
input\u data=tf.占位符（tf.float32，[批次大小、声音常量、最大行大小、声音常量、最大列大小、数据中），name=“train\u input”）
target=tf.placeholder（tf.float32，[batch\u size，sound\u constants.MAX\u ROW\u size\u IN\u TXT，sound\u constants.MAX\u COLUMN\u size\u IN\u TXT]，name=“train\u output”）
保持_prob=tf.恒定（1.0）
fwd\u cell=tf.nn.rnn\u cell.BasicLSTMCell（num\u hidden，state\u is\u tuple=True，forget\u bias=1.0）
#创建一个反向单元格
bkwd\u cell=tf.nn.rnn\u cell.BasicLSTMCell（num\u hidden，state\u is\u tuple=True，forget\u bias=1.0）
#创建双向RNN
val，uu，uu=tf.nn.static_双向_rnn（fwd_单元格，bkwd_单元格，tf.unstack（输入_数据），dtype=tf.float32）
#增加辍学者
val=tf.nn.dropout（val，keep_prob）
val=tf.transpose（val[1,0,2]）
last=tf.gather（val，int（val.get_shape（）[0]）-1）
#创建双向RNN
打印（'BiRNN created！！'）
打印（'Last Size:'，Last.get_shape（））
weight=tf.Variable（tf.truncated\u normal（[num\u hidden*2，sound\u constants.MAX\u ROW\u SIZE\u IN\u TXT]））
bias=tf.Variable（tf.constant（0.1，shape=[sound\u constants.MAX\u ROW\u SIZE\u IN\u TXT]））
#映射到28个输出类
logits=tf.matmul（最后一个，重量）+偏差
预测=tf.nn.softmax（logits）
prediction=tf.reforme（prediction，shape=[批处理大小，声音大小常数.MAX\u行大小\u文本，声音大小常数.MAX\u列大小\u文本]）
#获得概率分布
mat1=tf.cast（tf.argmax（预测，1），tf.float32）
正确=tf.相等（预测，目标）
准确度=tf.reduce_平均值（tf.cast（正确，tf.float32））
logits=tf.reformate（logits，shape=[批处理大小、声音大小常数.MAX\u行大小\u文本、声音大小常数.MAX\u列大小\u文本]）
损失=tf.reduce_平均值（tf.nn.softmax_交叉_熵_与_logits（logits=logits，labels=target））
列步=tf.列AdamOptimizer（1e-4）.最小化（损失）
#将组件作为字典元素返回
返回{'input_data'：input_data，
“目标”：目标，
“辍学”：保留问题，
“损失”：损失，
"ts":火车站,，
“preds”：预测，
“准确性”：准确性
}
def列_网络（图）：
#初始化tensorflow会话和所有变量
#tf\u gpu\u config=tf.ConfigProto（允许软放置=True，日志设备放置=True）
#tf_gpu_config.gpu_options.allow_growth=True
#使用tf.Session（config=tf\u gpu\u config）作为sess：
使用tf.Session（）作为sess：
训练实例=数据生成器（训练数据大小）
测试实例=数据生成器（测试数据大小）
打印（'训练数据大小：'，训练实例。数据大小）
打印（'测试数据大小：'，测试实例。数据大小）
sess.run（tf.global\u variables\u initializer（））
打印（'正在启动会话…'）
步进，精度=0，0
tr_损失，te_损失=[]，[]
当前时间=0
当前时代<时代：
步骤+=1
trb=训练\u实例。下一个\u批（）
feed={g['input_data']：trb[0]，g['target']：trb[1]，g['droot']：0.6}
准确度，uu=sess.run（[g['accurity']，g['ts']，feed\u dict=feed）
精度+=累计