我正在处理时间序列数据,预计输出60天.

我目前正在使用均方误差作为我的损失函数,结果很糟糕

我想实现加权均方误差,使得早期输出比后期输出重要得多.

加权均方根公式:

所以我需要一些方法来迭代张量的元素,带有索引(因为我需要同时迭代预测值和真值,然后将结果写入只有一个元素的张量.它们都是(？,60)但真的(1,60)列表.

我正在尝试的任何东西都在起作用.这是破碎版本的代码

def weighted_mse(y_true,y_pred):
    wmse = K.cast(0.0,'float')

    size = K.shape(y_true)[0]
    for i in range(0,K.eval(size)):
        wmse += 1/(i+1)*K.square((y_true[i]-y_pred)[i])

    wmse /= K.eval(size)
    return wmse

我目前正在收到此错误:

InvalidArgumentError (see above for traceback): You must feed a value for placeholder tensor 'dense_2_target' with dtype float
 [[Node: dense_2_target = Placeholder[dtype=DT_FLOAT, shape=[], _device="/job:localhost/replica:0/task:0/cpu:0"]()]]

阅读了类似帖子的回复之后,我认为掩码不能完成任务,并且在一个张量中循环元素也行不通,因为我无法访问其他张量中的相应元素.

任何建议,将不胜感激

实现损失函数以最小化Tensorflow中两批张量之间的成对Hausdorff距离的最有效方法是什么？

我有属于不同类别的个体，他们位于不同的区域，这些人口预计会从population低于该demand值的值增长到该值。

population_and_demand_by_category_and_zone <- tibble::tribble(
  ~category, ~zone, ~population, ~demand,
        "A",     1,         115,     138,
        "A",     2,         121,     145,
        "A",     3,         112,     134,
        "A",     4,          76,      91,
        "B",     1,          70,      99,
        "B",     2,          59,      83,
        "B",     3,          86,     121,
        "B",     4,         139,     196,
        "C",     1,         142,     160,
        "C",     2,          72,      81,
        "C",     3,          29,      33,
        "C",     4,          58,      66,
        "D",     1,          22,      47,
        "D",     2,          23,      49,
        "D",     3,          16,      34,
        "D",     4,          45,      96
)

区域具有给定的容量，当前人口低于此阈值，但某些区域的需求将超过容量。

demand_and_capacity_by_zone <- …

语境

我正在尝试对 XGBoost 二元分类器使用自定义损失函数。

这个想法是在 XGBoost 中实现 soft-Fbeta 损失，我在这里读到了这一点。简单地说：不使用标准的对数损失，而是使用直接优化 Fbeta 分数的损失函数。

警告

当然，Fbeta 本身是不可微分的，因此不能直接开箱即用。然而，我们的想法是使用概率（因此，在阈值化之前）来创建某种连续的 TP、FP 和 FN。在参考的 Medium 文章中查找更多详细信息。

试图

我的尝试如下（受到几个不同人的启发）。

import numpy as np
import xgboost as xgb

def gradient(y: np.array, p: np.array, beta: float):

    """Compute the gradient of the loss function. y is the true label, p
    the probability predicted by the model """
    
    # Define the denominator
    D = p.sum() + beta**2 * y.sum() 
    
    # Compute the gradient
    grad = (1 + beta**2) * y …

我正在尝试为 Keras 中的模型实现一个稍微修改的二元交叉熵损失函数。在 Keras 中，binary_crossentropy 定义为：

def binary_crossentropy(y_true, y_pred):
  return K.mean(K.binary_crossentropy(y_true, y_pred), axis=-1)

我拥有的数据是分组的（即有一列指示 group1、group2 等）但每个组的行数不同（即 group1 有 52 个观察值，group2 有 101 个观察值等）。

理想情况下，我想找到每个组的平均二元交叉熵，并返回最大平均二元交叉熵（最大的平均二元交叉熵，按组）。

似乎没有使用组的任何现成的解决方案，我无法想出一个解决方案。关于观察属于哪个组的信息会丢失，并且不会传递到 y_true 和 y_pred，而且我不确定 k-fold cv 将如何准确地改变作为 y_true 和 y_pred 传递的观察值/数量。如果有办法通过 Sequential 模型保留组信息，那可能就是解决方案。代码将完成类似的事情：

def custom_loss(y_true, y_pred):
  max_bc = []
  for group in groups:
     max_bc += [K.mean(K.binary_crossentropy(y_true, y_pred), axis=-1)]
  return max_bc

如果上述方法不可行，另一种度量可能是张量的第 75 个百分位值。就像是：

def custom_loss(y_true, y_pred):
  return K.binary_crossentropy(y_true, y_pred)[len(y_true)*0.75]

Run Code Online (Sandbox Code Playgroud)

但我确信这是错误的——我只是对 Keras 和 Tensorflow 不够熟悉，无法获得正确的代码。

编辑：我可能刚刚找到了一种方法来做百分位数，但结果并不如预期......对第一部分有所了解仍然很棒。

def custom_loss(y_true, y_pred):
  e = K.binary_crossentropy(y_true,y_pred)
  return distributions.percentile(e, q=75.)

我读过Keras 关于 VAE 实现的博客，其中 VAE 损失是这样定义的：

def vae_loss(x, x_decoded_mean):
    xent_loss = objectives.binary_crossentropy(x, x_decoded_mean)
    kl_loss = - 0.5 * K.mean(1 + z_log_sigma - K.square(z_mean) - K.exp(z_log_sigma), axis=-1)
    return xent_loss + kl_loss

我查看了Keras 文档，VAE 损失函数是这样定义的：在这个实现中，reconstruction_loss 乘以original_dim，我在第一个实现中没有看到这一点！

if args.mse:
        reconstruction_loss = mse(inputs, outputs)
    else:
        reconstruction_loss = binary_crossentropy(inputs,
                                                  outputs)

    reconstruction_loss *= original_dim
    kl_loss = 1 + z_log_var - K.square(z_mean) - K.exp(z_log_var)
    kl_loss = K.sum(kl_loss, axis=-1)
    kl_loss *= -0.5
    vae_loss = K.mean(reconstruction_loss + kl_loss)
    vae.add_loss(vae_loss)

有人可以解释一下为什么吗？谢谢你！

sparse_categorical_crossentropy是否可以使用损失函数计算精度、召回率、val_precesion 和 val_recall ？在这篇文章中，在此处输入作者建议使用的链接描述categorical_crossentropy，但就我而言，我需要使用sparse_categorical_crossentropy

主要问题：为什么 Lasso 回归的系数不会通过 最小化而缩小到零scipy.minimize？

我正在尝试使用 scipy.minimize 创建套索模型。然而，它仅在 alpha 为零时才起作用（因此仅像基本平方误差一样）。当 alpha 不为零时，它会返回更差的结果（更高的损失），并且仍然没有一个系数为零。

我知道 Lasso 是不可微分的，但我尝试使用 Powell 优化器，它应该处理非微分损失（我也尝试过 BFGS，它应该处理非平滑）。这些优化器都不起作用。

为了测试这一点，我创建了数据集，其中 y 是随机的（此处提供是可重现的），X 的第一个特征恰好是 y*.5，其他四个特征是随机的（此处也提供是可重现的）。我希望算法将这些随机系数缩小到零并只保留第一个系数，但它没有发生。

对于套索损失函数，我使用本文中的公式（图 1，第一页）

我的代码如下：

from scipy.optimize import minimize
import numpy as np

class Lasso:

    def _pred(self,X,w):
        return np.dot(X,w)

    def LossLasso(self,weights,X,y,alpha):
        w = weights
        yp = self._pred(X,w)
        loss = np.linalg.norm(y - yp)**2 + alpha * np.sum(abs(w))
        return loss

    def fit(self,X,y,alpha=0.0):
        initw = np.random.rand(X.shape[1]) #initial weights
        res = minimize(self.LossLasso,
                    initw,
                    args=(X,y,alpha),
                    method='Powell')
        return res

if __name__=='__main__': …

在tensorflow/keras中是否有一种自然/简单的方法来实现使用模型输出相对于模型输入的导数的自定义损失函数？

我想到了一些大致的内容（不用介意实际的公式——这只是一个演示）：

def my_loss_function(y_desired, y_model, x):
  return abs(y_desired - y_model) + abs(tf.gradients(y_model,x[0]))

这有两个问题。首先，损失函数通常无法访问输入。我的理解是，我可以通过直接引用该层来解决这个问题Input，例如作为全局变量。（当然，所有代码都只是示意性的。）

input_layer = Layer(...)
def my_loss(y1, y2):
  return abs(y1-y2)*input_layer[0]

input_layer第二个问题更严重：在执行图中似乎无法访问 , 的梯度。

这里有一个非常相似的问题，但没有解决方案：Custom loss function涉及Keras/Tensorflow中的梯度。我也曾沿着同样的路线进行过尝试，但没有运气。（对我来说，这不是正确的方法，而不是以Layer始终跟踪导数的方式包装 s ，这并不明显。）

在处理更复杂的事情之前，我知道我必须实现自己的backward通行证，我想尝试一些简单而美好的事情。因此，我尝试使用 PyTorch 进行均方误差损失的线性回归。当我定义自己的backward方法时出错了（参见下面的第三个实现选项），我怀疑这是因为我没有很清楚地考虑我需要将 PyTorch 作为渐变发送什么。所以，我怀疑我需要的是关于 PyTorch 希望我在这里以何种形式提供的一些解释/澄清/建议。

我正在使用 PyTorch 1.7.0，因此一堆旧示例不再有效（使用文档中描述的用户定义的 autograd 函数的不同方式）。

第一种方法（标准 PyTorch MSE 损失函数）

让我们首先在没有自定义损失函数的情况下使用标准方法：

import torch
import torch.nn as nn
import torch.nn.functional as F

# Let's generate some fake data
torch.manual_seed(42)
resid = torch.rand(100)    
inputs = torch.tensor([ [ xx ] for xx in range(100)] , dtype=torch.float32)
labels = torch.tensor([ (2 + 0.5*yy + resid[yy]) for yy in range(100)], dtype=torch.float32)

# Now we define a linear regression model
class linearRegression(torch.nn.Module):
    def __init__(self, …