操作数不能一起广播

Question

我正试着用小批量训练一个模型，但我有一个....错误。

我使用的函数与我在其他模型中已经使用过的函数相同，但这一次崩溃了。

def random_mini_batches(X, Y, mini_batch_size = 64):
"""
Creates a list of random minibatches from (X, Y)

Arguments:
X -- input data, of shape (input size, number of examples)
Y -- true "label" vector (1, number of examples)
mini_batch_size - size of the mini-batches, integer

Returns:
mini_batches -- list of synchronous (mini_batch_X, mini_batch_Y)
"""

m = X.shape[1]                  # number of training examples
mini_batches = []

# Step 1: Shuffle (X, Y)
permutation = list(np.random.permutation(m))
shuffled_X = X.iloc[:, permutation]
shuffled_Y = Y[:, permutation].reshape((Y.shape[0],m))

# Step 2: Partition (shuffled_X, shuffled_Y). Minus the end case.
num_complete_minibatches = math.floor(m/mini_batch_size) # number of mini batches of size mini_batch_size in your partitionning
for k in range(0, num_complete_minibatches):
    mini_batch_X = shuffled_X.iloc[:, k * mini_batch_size : k * mini_batch_size + mini_batch_size]
    mini_batch_Y = shuffled_Y[:, k * mini_batch_size : k * mini_batch_size + mini_batch_size]
    mini_batch = (mini_batch_X, mini_batch_Y)
    mini_batches.append(mini_batch)

# Handling the end case (last mini-batch < mini_batch_size)
if m % mini_batch_size != 0:
    mini_batch_X = shuffled_X.iloc[:, num_complete_minibatches * mini_batch_size : m]
    mini_batch_Y = shuffled_Y[:, num_complete_minibatches * mini_batch_size : m]
    mini_batch = (mini_batch_X, mini_batch_Y)
    mini_batches.append(mini_batch)

return mini_batches

我在一个有20层的NN中使用了这个函数，X和Y如下：

现在我尝试用5层神经网络和形状再次使用它

​

然而，我得到了这个错误

在代码epoch_cost += minibatch_cost/num_minibatches的这一部分。

完整的代码如下所示：

        for epoch in range(num_epochs):

        epoch_cost = 0
        num_minibatches = int(m / minibatch_size) # number of minibatches of size minibatch_size in the train set

        minibatches = random_mini_batches(X_train, Y_train, minibatch_size)

        for minibatch in minibatches:

            #Select a minibatch
            (minibatch_X, minibatch_Y) = minibatch

            _, minibatch_cost = sess.run([optimizer, cost], feed_dict = {X: minibatch_X, Y: minibatch_Y})

            epoch_cost += minibatch_cost/num_minibatches

    # Print the cost every epoch
        if print_cost == True and epoch % 100 == 0:
            print("Cost after epoch %i: %f" % (epoch, epoch_cost))
        if print_cost == True and epoch % 5 == 0:
            costs.append(epoch_cost)

提前感谢

Answer 1

我用以下命令解决了这个问题：

epoch_cost += np.mean(minibatch_cost)/num_minibatches

如果有人有其他的解决方案，我很乐意听听。