Tensorflow，我的执行时间形状不匹配答案

【问题标题】：Tensorflow, I got a Shape mismatch in execution timeTensorflow，我的执行时间形状不匹配
【发布时间】：2018-12-05 10:07:45
【问题描述】：

大家下午好，

我目前在使用 tensorflow 时遇到了一些问题，因为由于某种原因，我在运行大约 3 个半小时后出现了 Shape 错误。这些文件使用 tensorflow 管道加载，并创建两个可重新初始化的数据集用于训练和测试。我知道数据具有正确的形状，因为我对预期的形状进行了硬编码重塑，而且我从来没有遇到过错误。问题是，在某个时间点运行网络时，有一个样本在展平操作中没有正确数量的数字。并且程序崩溃了，但是除了张量中的元素个数不能被10整除（我的batch size）之外没有其他解释。老实说，这对我来说毫无意义，因为数据与运行没有问题的其他批次完全通过相同的管道。

如果需要，我可以提供代码，但我认为更多的是未能从框架中理解某些概念。

提前感谢所有帮助。

编辑：请在这里找到代码，命名法 t 对应于具有时间数据 (X) 的层，f 对应于具有频率数据 (FREQ) 的层，q 对应于包含倒谱的层data (QUEF) 和 tf 对应于包含 2-D 数据的层，X 的频谱图 (SPECG)，Y 是标签。所有数据都是 tf.float32 除了标签是 tf.int64

编辑 2：出现问题的操作是 qsubnet_out 上的展平

编辑 3：可能是最重要的，似乎比某些层收敛到 NaN 训练循环：

for i in range(FLAGS.max_steps):
    start = time.time()
    sess.run([train],feed_dict={handle:train_handle})
    if i%10 == False:
        summary_op,entropy,acc,expected,output = sess.run([merged,loss,accuracy,Y,tf.argmax(logit,1)],feed_dict={handle:train_handle})
        summary_op,_,_ = sess.run([merged,loss,accuracy],feed_dict={handle:test_handle})

训练操作：

W = { 'tc1': [64,3], 'tc2':[128,3], 'tc3':[256,5], 'tc4': [128, 2],
              'fc1': [64,3], 'fc2':[128,3], 'fc3':[256,5], 'fc4': [128, 2],
              'qc1': [64,3], 'qc2':[128,3], 'qc3':[256,5], 'qc4': [128, 2],
              'tfc1': [64,(3,3)], 'tfc2':[128,(3,3)], 'tfc3':[256,(5,5)], 'tfc4': [128, (2,2)],
              'dense1': 1000, 'dense2': 100, 'dense3': 200,'dense4': 300, 'dense5': 200,
              'out' : NUM_CLASSES
            }
iter = tf.data.Iterator.from_string_handle(handle, train_dataset.output_types, train_dataset.output_shapes)
X,FREQ,QUEF,SPECG,Y = iter.get_next()
X.set_shape([FLAGS.batch_size,768,14])
FREQ.set_shape([FLAGS.batch_size,384,14])
QUEF.set_shape([FLAGS.batch_size,384,14])
SPECG.set_shape([FLAGS.batch_size,65,18,14])
logit = net.run(X,FREQ,QUEF,SPECG,W)
loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels=Y,logits=logit))

还有文件net.py：

def run(X,FREQ,QUEF,SPECG,W):
    time = tf.layers.batch_normalization(X,axis=-1,training=True,trainable=True)
    freq = tf.layers.batch_normalization(FREQ,axis=-1,training=True,trainable=True)
    quef = tf.layers.batch_normalization(QUEF,axis=-1,training=True,trainable=True)
    time_freq = tf.layers.batch_normalization(SPECG,axis=-1,training=True,trainable=True)


    regularizer = tf.contrib.layers.l2_regularizer(0.1);
    #########################################################################################################
    #### TIME SUBNET
    with tf.device('/GPU:1'):
        tc1 = tf.layers.conv1d(inputs=time,filters=W['tc1'][0],kernel_size=W['tc1'][1],strides=1,padding='SAME',kernel_initializer=tf.initializers.random_normal,kernel_regularizer=regularizer,name='tc1')
        trelu1 = tf.nn.relu(features=tc1,name='trelu1')
        tpool1 = tf.layers.max_pooling1d(trelu1,pool_size=2,strides=1)

        tc2 = tf.layers.conv1d(inputs=tpool1,filters=W['tc2'][0],kernel_size=W['tc2'][1],strides=1,padding='SAME',kernel_initializer=tf.initializers.random_normal,kernel_regularizer=regularizer,name='tc2')
        tc3 = tf.layers.conv1d(inputs=tc2,filters=W['tc3'][0],kernel_size=W['tc3'][1],strides=1,padding='SAME',kernel_initializer=tf.initializers.random_normal,kernel_regularizer=regularizer,name='tc3')
        trelu2 = tf.nn.relu(tc3,name='trelu2')
        tpool2 = tf.layers.max_pooling1d(trelu2,pool_size=2,strides=1)

        tc4 = tf.layers.conv1d(inputs=tpool2,filters=W['tc4'][0],kernel_size=W['tc4'][1],strides=1,padding='SAME',kernel_initializer=tf.initializers.random_normal,kernel_regularizer=regularizer,name='tc4')
        tsubnet_out = tf.nn.relu6(tc4,'trelu61')
    #########################################################################################################
    #### CEPSTRUM SUBNET (QUEFRENCIAL)
        qc1 = tf.layers.conv1d(inputs=quef,filters=W['qc1'][0],kernel_size=W['qc1'][1],strides=1,padding='SAME',kernel_initializer=tf.initializers.random_normal,kernel_regularizer=regularizer,name='qc1')
        qrelu1 = tf.nn.relu(features=qc1,name='qrelu1')
        qpool1 = tf.layers.max_pooling1d(qrelu1,pool_size=2,strides=1)

        qc2 = tf.layers.conv1d(inputs=qpool1,filters=W['qc2'][0],kernel_size=W['qc2'][1],padding='SAME',strides=1,kernel_initializer=tf.initializers.random_normal,kernel_regularizer=regularizer,name='qc2')
        qc3 = tf.layers.conv1d(inputs=qc2,filters=W['qc3'][0],kernel_size=W['qc3'][1],padding='SAME',strides=1,kernel_initializer=tf.initializers.random_normal,kernel_regularizer=regularizer,name='qc3')
        qrelu2 = tf.nn.relu(qc3,name='qrelu2')
        qpool2 = tf.layers.max_pooling1d(qrelu2,pool_size=2,strides=1)

        qc4 = tf.layers.conv1d(inputs=qpool2,filters=W['qc4'][0],kernel_size=W['qc4'][1],padding='SAME',strides=1,kernel_initializer=tf.initializers.random_normal,kernel_regularizer=regularizer,name='qc4')
        qsubnet_out = tf.nn.relu6(qc4,'qrelu61')
    #########################################################################################################
    #FREQ SUBNET  
    with tf.device('/GPU:1'):
        fc1 = tf.layers.conv1d(inputs=freq,filters=W['fc1'][0],kernel_size=W['fc1'][1],padding='SAME',strides=1,kernel_initializer=tf.initializers.random_normal,kernel_regularizer=regularizer,name='fc1')
        frelu1 = tf.nn.relu(features=fc1,name='trelu1')
        fpool1 = tf.layers.max_pooling1d(frelu1,pool_size=2,strides=1)

        fc2 = tf.layers.conv1d(inputs=fpool1,filters=W['fc2'][0],kernel_size=W['fc2'][1],padding='SAME',strides=1,kernel_initializer=tf.initializers.random_normal,kernel_regularizer=regularizer,name='fc2')
        fc3 = tf.layers.conv1d(inputs=fc2,filters=W['fc3'][0],kernel_size=W['fc3'][1],padding='SAME',strides=1,kernel_initializer=tf.initializers.random_normal,kernel_regularizer=regularizer,name='fc3')
        frelu2 = tf.nn.relu(fc3,name='frelu2')
        fpool2 = tf.layers.max_pooling1d(frelu2,pool_size=2,strides=1)

        fc4 = tf.layers.conv1d(inputs=fpool2,filters=W['fc4'][0],kernel_size=W['fc4'][1],padding='SAME',strides=1,kernel_initializer=tf.initializers.random_normal,kernel_regularizer=regularizer,name='fc4')
        fsubnet_out = tf.nn.relu6(fc4,'frelu61')


    ########################################################################################################
    ## TIME/FREQ SUBNET
    with tf.device('/GPU:0'):
        tfc1 = tf.layers.conv2d(inputs=time_freq,filters=W['tfc1'][0],kernel_size=W['tfc1'][1],padding='SAME', strides=1,kernel_initializer=tf.initializers.random_normal,kernel_regularizer=regularizer,name='tfc1')
        tfrelu1 = tf.nn.relu(tfc1)
        tfpool1 = tf.layers.max_pooling2d(tfrelu1,pool_size=[2, 2],strides=[1, 1])

        tfc2 = tf.layers.conv2d(inputs=tfpool1,filters=W['tfc2'][0],kernel_size=W['tfc2'][1],padding='SAME', strides=1,kernel_initializer=tf.initializers.random_normal,kernel_regularizer=regularizer,name='tfc2')
        tfc3 = tf.layers.conv2d(inputs=tfc2,filters=W['tfc3'][0],kernel_size=W['tfc3'][1],padding='SAME', strides=1,kernel_initializer=tf.initializers.random_normal,kernel_regularizer=regularizer,name='tfc3')
        tfrelu2 = tf.nn.relu(tfc3)
        tfpool2 = tf.layers.max_pooling2d(tfrelu2,pool_size=[2, 2], strides=[1, 1])

        tfc4 = tf.layers.conv2d(inputs=tfpool2,filters=W['tfc4'][0],kernel_size=W['tfc4'][1],padding='SAME', strides=1,kernel_initializer=tf.initializers.random_normal,kernel_regularizer=regularizer,name='tfc4')
        tfsubnet_out = tf.nn.relu6(tfc4,'tfrelu61')
        ########################################################################################################
       ##Flatten subnet outputs
        tsubnet_out = tf.layers.flatten(tsubnet_out)
        fsubnet_out = tf.layers.flatten(fsubnet_out)
        tfsubnet_out = tf.layers.flatten(tfsubnet_out)
        qsubnet_out = tf.layers.flatten(qsubnet_out)

        #Final subnet computation
        input_final = tf.concat((tsubnet_out,fsubnet_out,qsubnet_out,tfsubnet_out),1)
        dense1 = tf.layers.dense(input_final,W['dense1'],tf.nn.relu, kernel_initializer=tf.initializers.random_normal,name='dense1')
        dense2 = tf.layers.dense(dense1,W['dense2'],tf.nn.relu, kernel_initializer=tf.initializers.random_normal,name='dense2')
        dense3 = tf.layers.dense(dense2,W['dense3'],tf.nn.relu, kernel_initializer=tf.initializers.random_normal,name='dense3')
        dense4 = tf.layers.dense(dense3,W['dense4'],tf.nn.relu, kernel_initializer=tf.initializers.random_normal,name='dense4')
        dense5 = tf.layers.dense(dense4,W['dense5'],tf.nn.relu, kernel_initializer=tf.initializers.random_normal,name='dense5')
        out = tf.layers.dense(dense5,W['out'],tf.nn.relu, name='out')
    return out

【问题讨论】：

没有代码和错误信息，没人能给你答案，问题不是概念性的，你的代码或数据有错误。
如果需要其他任何部分，请添加代码，询问，我会提供

标签： python tensorflow tensorflow-datasets

【解决方案1】：

终于在几天后，我能够跟踪问题。最后，我提交了与代码无关的内容。但它与 Tensorflow 数据集的创建有关。由于在批处理中，如果数据集的长度不能被批处理大小整除。标志 drop_remainder 为 True。

我不会删除这个问题，因为我相信这是一个未来可能会有更多人遇到的问题，并且来源不容易识别。

【讨论】：