标签: loss-function

我看到很多关于 CEL 或二元交叉熵损失的解释，其中基本事实是 0 或 1，然后你会得到一个如下函数：

def CrossEntropy(yHat, y):
    if yHat == 1:
      return -log(y)
    else:
      return -log(1 - y)

然而，当你的 yHat 不是离散的 0 或 1 时，我对 BCE 如何工作感到困惑。例如，如果我想查看 MNIST 数字的重建损失，其中我的基本事实是 0 < yHat < 1，并且我的预测是也在同一范围内，这如何改变我的功能？

编辑：

抱歉，让我为我的困惑提供更多背景信息。在关于 VAE 的 PyTorch 教程中，他们使用 BCE 来计算重建损失，其中 yhat （据我所知，不是离散的）。看：

https://github.com/pytorch/examples/blob/master/vae/main.py

该实现有效......但我不明白在这种情况下如何计算 BCE 损失。

根据 Tensorflow 文档，可以通过添加 label_smoothing 参数来向 categorical_crossentropy 添加标签平滑。我的问题是稀疏分类交叉熵损失怎么样。此损失函数没有 label_smoothing 参数。

我想使用自定义损失函数训练模型，为此，我需要在以下方法中将张量转换为 numpy 数组：

def median_loss_estimation(y_true, y_predicted):
    a = y_predicted.numpy()

但我有这个错误：

AttributeError: 'Tensor' object has no attribute 'numpy'

为什么？如何将张量转换为 numpy 数组？

我正在尝试应用蒸馏的概念,基本上是为了训练一个新的小型网络与原始网络一样,但计算量较少.

我有每个样本的softmax输出而不是logits.

我的问题是,如何实现分类交叉熵损失函数？就像它采用原始标签的最大值并将其与相同索引中的相应预测值相乘,或者它在整个logits(One Hot encoding)中的总和如公式所示:

谢谢!!

操作系统平台和发行版：Linux Ubuntu16.04；TensorFlow版本：'1.4.0'

我可以使用以下代码正常运行：

import tensorflow as tf
from tensorflow.python.keras.layers import Dense
from tensorflow.python.keras.backend import categorical_crossentropy
from tensorflow.examples.tutorials.mnist import input_data
from tensorflow.python.keras.models import Model
from tensorflow.python.keras.layers import  Input

mnist_data = input_data.read_data_sets('MNIST_data', one_hot=True)
img_size_flat = 28*28
batch_size = 64

def gen(batch_size=32):
    while True:
        batch_data, batch_label = mnist_data.train.next_batch(batch_size)
        yield batch_data, batch_label   


inputs = Input(shape=(img_size_flat,))
x = Dense(128, activation='relu')(inputs)  # fully-connected layer with 128 units and ReLU activation
x = Dense(128, activation='relu')(x)
preds = Dense(10, activation='softmax')(x)  # output layer with 10 units and a …

梯度下降和溢出错误

我目前正在 python 中实现向量化梯度下降。但是，我仍然收到溢出错误。不过，我的数据集中的数字并不是很大。我正在使用这个公式：

我选择此实现是为了避免使用衍生工具。有人对如何解决这个问题有任何建议还是我实施错误？先感谢您！

数据集链接：https://www.kaggle.com/CooperUnion/anime-recommendations-database/data

## Cleaning Data ##
import math
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

data = pd.read_csv('anime.csv')
# print(data.corr())
# print(data['members'].isnull().values.any()) # Prints False
# print(data['rating'].isnull().values.any()) # Prints True

members = [] # Corresponding fan club size for row 
ratings = [] # Corresponding rating for row

for row in data.iterrows():
    if not math.isnan(row[1]['rating']): # Checks for Null ratings
        members.append(row[1]['members'])
        ratings.append(row[1]['rating'])


plt.plot(members, ratings)
plt.savefig('scatterplot.png')

theta0 = 0.3 # Random …

我正在用Keras进行二进制分类 loss='binary_crossentropy'，optimizer=tf.keras.optimizers.Adam最后一层是keras.layers.Dense(1, activation=tf.nn.sigmoid)。

据我所知，loss价值是在训练阶段用来评估模型的。但是，当我Keras对测试数据集使用模型评估时（例如m_recall.evaluate(testData,testLabel)，也有一些loss值，并附带accuracy以下输出所示的值）

test size:  (1889, 18525)
1889/1889 [==============================] - 1s 345us/step
m_acc:  [0.5690245978371045, 0.9523557437797776]
1889/1889 [==============================] - 1s 352us/step
m_recall:  [0.24519687695911097, 0.9359449444150344]
1889/1889 [==============================] - 1s 350us/step
m_f1:  [0.502442331737344, 0.9216516675489677]
1889/1889 [==============================] - 1s 360us/step
metric name:  ['loss', 'acc']

loss测试期间的意义/用途是什么？为什么它是如此之高（如0.5690在m_acc）？准确度评估对我来说似乎不错（例如，0.9523在中m_acc），但我也很担心loss，这是否会使我的模型表现不佳？

PS m_acc，m_recall等等都只是我的名字我的模型的方法（它们是由不同的指标受训GridSearchCV）

更新： 我只是意识到loss …

在寻找在 PyTorch 模型中实现 L1 正则化的方法时，我遇到了这个问题，现在已经有 2 年历史了，所以我想知道这个主题是否有任何新内容？

我还发现了这种处理缺少的 l1 函数的最新方法。但是我不明白如何将它用于基本的神经网络，如下所示。

class FFNNModel(nn.Module):
    def __init__(self, input_dim, output_dim, hidden_dim, dropout_rate):
        super(FFNNModel, self).__init__()
        self.input_dim = input_dim
        self.output_dim = output_dim
        self.hidden_dim = hidden_dim
        self.dropout_rate = dropout_rate
        self.drop_layer = nn.Dropout(p=self.dropout_rate)
        self.fully = nn.ModuleList()
        current_dim = input_dim
        for h_dim in hidden_dim:
            self.fully.append(nn.Linear(current_dim, h_dim))
            current_dim = h_dim
        self.fully.append(nn.Linear(current_dim, output_dim))

    def forward(self, x):
        for layer in self.fully[:-1]:
            x = self.drop_layer(F.relu(layer(x)))
        x = F.softmax(self.fully[-1](x), dim=0)
        return x

我希望在训练前简单地把它放在一边：

model = FFNNModel(30,5,[100,200,300,100],0.2)
regularizer = …

我有一个多标签分类，其中每个目标都是一个不互斥的 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 层？

我已经使用Keras Sequential API 创建了一个模型，并使用Glove 预训练嵌入

def create_model(
        input_length=20,
        output_length=20):

    encoder_input = tf.keras.Input(shape=(input_length,))
    decoder_input = tf.keras.Input(shape=(output_length,))

    encoder = tf.keras.layers.Embedding(original_embedding_matrix.shape[0], original_embedding_dim, weights=[original_embedding_matrix], mask_zero=True)(encoder_input)
    encoder, h_encoder, u_encoder = tf.keras.layers.LSTM(64, return_state=True)(encoder)

    decoder = tf.keras.layers.Embedding(clone_embedding_matrix.shape[0], clone_embedding_dim, weights=[clone_embedding_matrix], mask_zero=True)(decoder_input)
    decoder = tf.keras.layers.LSTM(64, return_sequences=True)(decoder, initial_state=[h_encoder, u_encoder])
    decoder = tf.keras.layers.TimeDistributed(tf.keras.layers.Dense(clone_vocab_size+1))(decoder)

    model = tf.keras.Model(inputs=[encoder_input, decoder_input], outputs=[decoder])
    model.compile(optimizer='adam', loss=tf.keras.losses.MeanSquaredError(), metrics=['accuracy'])

    return model

model = create_model()

这是我的编码器/解码器形状：

training_encoder_input.shape --> (2500, 20) 
training_decoder_input.shape --> (2500, 20) 
training_decoder_output.shape ---> (2500, 20, 11272) 
clone_vocab_size ---> 11271

的输出model.summary()：

Model: "functional_1"
__________________________________________________________________________________________________ …