相关疑难解决方法(0)

当试图用sigmoid激活函数得到交叉熵时,两者之间存在差异

1. loss1 = -tf.reduce_sum(p*tf.log(q), 1)
2. loss2 = tf.reduce_sum(tf.nn.sigmoid_cross_entropy_with_logits(labels=p, logits=logit_q),1)

但是当使用softmax激活功能时,它们是相同的.

以下是示例代码:

import tensorflow as tf

sess2 = tf.InteractiveSession()
p = tf.placeholder(tf.float32, shape=[None, 5])
logit_q = tf.placeholder(tf.float32, shape=[None, 5])
q = tf.nn.sigmoid(logit_q)
sess.run(tf.global_variables_initializer())

feed_dict = {p: [[0, 0, 0, 1, 0], [1,0,0,0,0]], logit_q: [[0.2, 0.2, 0.2, 0.2, 0.2], [0.3, 0.3, 0.2, 0.1, 0.1]]}
loss1 = -tf.reduce_sum(p*tf.log(q),1).eval(feed_dict)
loss2 = tf.reduce_sum(tf.nn.sigmoid_cross_entropy_with_logits(labels=p, logits=logit_q),1).eval(feed_dict)

print(p.eval(feed_dict), "\n", q.eval(feed_dict))
print("\n",loss1, "\n", loss2)

我正在学习如何使用Keras创建卷积神经网络.我正试图获得MNIST数据集的高精度.

显然categorical_crossentropy是2个以上的课程,binary_crossentropy2个课程.由于有10个数字,我应该使用categorical_crossentropy.然而,经过数十种模型的培训和测试,binary_crossentropy始终表现出色categorical_crossentropy.

在Kaggle,我使用了99 +%的精确度binary_crossentropy和10个时代.同时,categorical_crossentropy即使使用30个时代,我也无法使用97%以上(这不是很多,但我没有GPU,所以训练需要永远).

这就是我的模型现在的样子:

model = Sequential()
model.add(Convolution2D(100, 5, 5, border_mode='valid', input_shape=(28, 28, 1), init='glorot_uniform', activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Convolution2D(100, 3, 3, init='glorot_uniform', activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.3))
model.add(Flatten())
model.add(Dense(100, init='glorot_uniform', activation='relu'))
model.add(Dropout(0.3))
model.add(Dense(100, init='glorot_uniform', activation='relu'))
model.add(Dropout(0.3))
model.add(Dense(10, init='glorot_uniform', activation='softmax'))
model.compile(loss='binary_crossentropy', optimizer='adamax', metrics=['accuracy'])

我正在使用以下代码在keras中训练一个简单的模型用于NLP任务.变量名称对于训练,测试和验证集是不言自明的.该数据集有19个类,因此网络的最后一层有19个输出.标签也是单热编码的.

nb_classes = 19
model1 = Sequential()
model1.add(Embedding(nb_words,
                     EMBEDDING_DIM,
                     weights=[embedding_matrix],
                     input_length=MAX_SEQUENCE_LENGTH,
                     trainable=False))
model1.add(LSTM(num_lstm, dropout=rate_drop_lstm, recurrent_dropout=rate_drop_lstm))
model1.add(Dropout(rate_drop_dense))
model1.add(BatchNormalization())
model1.add(Dense(num_dense, activation=act))
model1.add(Dropout(rate_drop_dense))
model1.add(BatchNormalization())

model1.add(Dense(nb_classes, activation = 'sigmoid'))


model1.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
#One hot encode all labels
ytrain_enc = np_utils.to_categorical(train_labels)
yval_enc = np_utils.to_categorical(val_labels)
ytestenc = np_utils.to_categorical(test_labels)

model1.fit(train_data, ytrain_enc,
             validation_data=(val_data, yval_enc),
             epochs=200,
             batch_size=384,
             shuffle=True,
             verbose=1)

在第一个时代之后,这给了我这些输出.

Epoch 1/200
216632/216632 [==============================] - 2442s - loss: 0.1427 - acc: 0.9443 - val_loss: 0.0526 - val_acc: 0.9826

然后我在测试数据集上评估我的模型,这也显示我在0.98附近的准确度.

model1.evaluate(test_data, y = ytestenc, batch_size=384, verbose=1)

但是,标签是单热编码的,所以我需要类的预测向量,以便我可以生成混淆矩阵等.所以我使用,

PREDICTED_CLASSES = model1.predict_classes(test_data, …

当损失函数是均方误差时,如何定义准确度？是绝对百分比误差吗？

我使用的模型具有输出激活线性和编译 loss= mean_squared_error

model.add(Dense(1))
model.add(Activation('linear'))  # number

model.compile(loss='mean_squared_error', optimizer='adam', metrics=['accuracy'])

输出看起来像这样:

Epoch 99/100
1000/1000 [==============================] - 687s 687ms/step - loss: 0.0463 - acc: 0.9689 - val_loss: 3.7303 - val_acc: 0.3250
Epoch 100/100
1000/1000 [==============================] - 688s 688ms/step - loss: 0.0424 - acc: 0.9740 - val_loss: 3.4221 - val_acc: 0.3701

那么例如val_acc:0.3250是什么意思？Mean_squared_error应该是标量而不是百分比 - 不应该吗？那么val_acc - 均方误差,或平均百分比误差或其他函数？

根据维基百科上的MSE定义:https://en.wikipedia.org/wiki/Mean_squared_error

MSE是估计量质量的度量 - 它总是非负的,接近零的值更好.

这是否意味着价值val_acc: 0.0优于val_acc: 0.325？

编辑:我训练时精确度量输出的更多示例 - 随着我训练更多,精度会增加.虽然损失函数 - mse应该减少.是否为mse定义了准确度 - 它是如何在Keras中定义的？

lAllocator: After …

有人可以帮我理解这个问题.

我必须训练一个神经网络,它应该输出200个相互独立的类别,这些类别中的每一个都是从0到1的百分比.对我而言,这似乎是一个binary_crossentropy问题,但我在互联网上看到的每个例子都使用binary_crossentropy单个输出.由于我的输出应该是200,如果我申请binary_crossentropy,这是正确的吗？

这是我的想法,是一个正确的方法还是我应该改变它？

inputs = Input(shape=(input_shape,))
hidden = Dense(2048, activation='relu')(inputs)
hidden = Dense(2048, activation='relu')(hidden)
output = Dense(200, name='output_cat', activation='sigmoid')(hidden)
model = Model(inputs=inputs, outputs=[output])
loss_map = {'output_cat': 'binary_crossentropy'}
model.compile(loss=loss_map, optimizer="sgd", metrics=['mae', 'accuracy'])

我有一个多标签分类，其中每个目标都是一个不互斥的 1 和 0 向量（为了清楚起见，我的目标类似于[0, 1, 0, 0, 1, 1, ... ]）。

到目前为止我的理解是：

• 我应该使用二元交叉熵函数。（如本答案所述）

• 另外，我知道这tf.keras.losses.BinaryCrossentropy()是围绕 tensorflow 的sigmoid_cross_entropy_with_logits. 这可以与from_logits True或一起使用False。（如本问题所述）

• 由于sigmoid_cross_entropy_with_logits自己执行 sigmoid，它期望输入在 [-inf,+inf] 范围内。

• tf.keras.losses.BinaryCrossentropy()，当网络实现自己最后一层的 sigmoid 激活时，必须与 一起使用from_logits=False。然后它将推断 sigmoid 函数并将输出传递给sigmoid_cross_entropy_with_logits将再次执行 sigmoid的输出。然而，由于 sigmoid/logit 函数的渐近线，这可能会导致数值问题。

• 为了提高数值稳定性，我们可以避免最后一个 sigmoid 层并使用 tf.keras.losses.BinaryCrossentropy(from_logits=False)

题：

如果我们使用tf.keras.losses.BinaryCrossentropy(from_logits=False)，我应该使用什么目标？我是否需要更改 one-hot 向量的目标？

我想我应该在推理时将 sigmoid 激活应用于网络输出。有没有办法添加仅在推理模式下而不是在训练模式下活动的 sigmoid 层？

来自 deeplearning.ai ：

\n

构建神经网络的一般方法是：

\n\n

\n
1. 定义神经网络结构（输入单元数、隐藏单元数等）。
\n
2. 初始化模型参数
\n
3. 循环:\n\n
   \n
   • 实现前向传播
   \n
   • 计算损失
   \n
   • 实现反向传播以获得梯度
   \n
   • 更新参数（梯度下降）
   \n
\n

\n

损失函数如何影响网络的学习方式？

例如，这是我对前向和反向传播的实现，我认为它是正确的，因为我可以使用以下代码训练模型以获得可接受的结果：

for i in range(number_iterations):\n\n\n  # forward propagation\n\n\n    Z1 = np.dot(weight_layer_1, xtrain) + bias_1\n    a_1 = sigmoid(Z1)\n\n    Z2 = np.dot(weight_layer_2, a_1) + bias_2\n    a_2 = sigmoid(Z2)\n\n    mse_cost = np.sum(cost_all_examples)\n    cost_cross_entropy = -(1.0/len(X_train) * (np.dot(np.log(a_2), Y_train.T) + np.dot(np.log(1-a_2), (1-Y_train).T)))\n\n#     Back propagation and gradient descent\n    d_Z2 = np.multiply((a_2 - xtrain), d_sigmoid(a_2))\n    d_weight_2 = np.dot(d_Z2, …

下面是预测第二天收盘上涨还是下跌的代码（上=1，下=0）

我所做的是创建一个数据框并仅使用 PriceChange（今天收盘 - 昨天收盘）来预测第二天价格上涨或下跌（第二天收盘 - 今天收盘）

所以数据框看起来像这样

df['PriceChange'] = (df['Close'] > df['Close'].shift(1)).astype(int)
df['Closeupnextday'] = (df['Close'].shift(-1) > df['Close']).astype(int)

        PriceChange  Closeupnextday
0             0               1
1             1               1
2             1               1
3             1               1
4             1               0
5             0               0
6             0               0
7             0               1

它不断给我 1.000 的准确度，公平地说，它应该只有 50+% 的准确度。我相信下面的代码有问题，但我找不到。

我应该补充一点，在 20/500 纪元之后，它不断给我 1.000 的准确度

任何建议请？

def load_data(stock, seq_len):
    amount_of_features = len(stock.columns)
    data = stock.as_matrix() #pd.DataFrame(stock)
    sequence_length = seq_len + 1
    result = []
    for index in range(len(data) - sequence_length):
        result.append(data[index: …