{TypeError}無法散列的類型：“ numpy.ndarray”

Question

我使用tensorflow來構建模型並想要訓練它，但出現此錯誤：

{TypeError}無法散列的類型： 'numpy.ndarray'

我的代碼的一部分如下：

with tf.Session() as sess:
    init = tf.global_variables_initializer()
    sess.run(init)
    for epoch in range(a.epochs):
        input, target = load_batch_data(batch_size=16, a=a)
        batch_input = input.astype(np.float32)
        batch_target = target.astype(np.float32)
        sess.run(predict_real, feed_dict={input: batch_input, target: batch_target})

'predict_real'是模型的輸出，我只是嘗試運行它，但是出錯了！

這是我的模型的代碼：

def build_model(input, target):
    with tf.variable_scope("generator"):
      out_channels = int(target.get_shape()[-1])
      outputs = create_generator(input, out_channels)


    with tf.name_scope("real_discriminator"):
        with tf.variable_scope("discriminator"):
           predict_real = create_discriminator(input, target)

    with tf.name_scope("fake_discriminator"):
         with tf.variable_scope("discriminator", reuse=True):
           predict_fake = create_discriminator(input, outputs)

    with tf.name_scope("discriminator_loss"):
         discrim_loss = tf.reduce_mean(-(tf.log(predict_real + EPS) + tf.log(1 - predict_fake + EPS)))

    with tf.name_scope("generator_loss"):
       gen_loss_GAN = tf.reduce_mean(-tf.log(predict_fake + EPS))
       gen_loss_L1 = tf.reduce_mean(tf.abs(target - outputs))
       gen_loss = gen_loss_GAN * a.gan_weight + gen_loss_L1 * a.l1_weight

    with tf.name_scope("discriminator_train"):
       discrim_tvars = [var for var in tf.trainable_variables() if var.name.startswith("discriminator")]
       discrim_optim = tf.train.AdamOptimizer(a.lr, a.beta1)
       discrim_grads_and_vars = discrim_optim.compute_gradients(discrim_loss, var_list=discrim_tvars)
       discrim_train = discrim_optim.apply_gradients(discrim_grads_and_vars)

    with tf.name_scope("generator_train"):
        with tf.control_dependencies([discrim_train]):
            gen_tvars = [var for var in tf.trainable_variables() if var.name.startswith("generator")]
            gen_optim = tf.train.AdamOptimizer(a.lr, a.beta1)
            gen_grads_and_vars = gen_optim.compute_gradients(gen_loss, var_list=gen_tvars)
            gen_train = gen_optim.apply_gradients(gen_grads_and_vars)

    ema = tf.train.ExponentialMovingAverage(decay=0.99)
    update_losses = ema.apply([discrim_loss, gen_loss_GAN, gen_loss_L1])

    global_step = tf.train.get_or_create_global_step()
    incr_global_step = tf.assign(global_step, global_step+1)
    return Model(
      predict_real=predict_real,
      predict_fake=predict_fake,
      discrim_loss=ema.average(discrim_loss),
      discrim_grads_and_vars=discrim_grads_and_vars,
      gen_loss_GAN=ema.average(gen_loss_GAN),
      gen_loss_L1=ema.average(gen_loss_L1),
      gen_grads_and_vars=gen_grads_and_vars,
      outputs=outputs,
      train=tf.group(update_losses, incr_global_step, gen_train),
)

Answer 1

從python文檔中：

如果對象的哈希值在其生命周期內始終不變（需要使用hash （）方法），並且可以與其他對象進行比較（需要使用eq （）方法），則該對象是可哈希的。 比較相等的可哈希對象必須具有相同的哈希值。

散列性使對象可用作字典鍵和set成員，因為這些數據結構在內部使用散列值。

Python的所有不可變內置對象都是可哈希的，而沒有可變容器（例如列表或字典）是可哈希的。 作為用戶定義類實例的對象默認情況下可哈希化； 它們都比較不相等，並且其哈希值是其id（）。

（ https://docs.python.org/3.1/glossary.html ）

您正在嘗試從ndarray創建一個不可哈希的字典。

您可以嘗試使用tuple(np.ndarray)

PS：請使您的問題更容易理解。 發布整個代碼不是獲得答案的好方法。 您應該調試並找到問題所在的確切行，打印輸入，輸出並說出您所期望的而不是所得到的。