标签: softmax

从Udacity的深度学习类中,y_i的softmax只是指数除以整个Y向量的指数之和:

哪里S(y_i)是的SOFTMAX功能y_i,并e为指数和j是否定的.输入向量Y中的列数.

我尝试过以下方法:

import numpy as np

def softmax(x):
    """Compute softmax values for each sets of scores in x."""
    e_x = np.exp(x - np.max(x))
    return e_x / e_x.sum()

scores = [3.0, 1.0, 0.2]
print(softmax(scores))

返回:

[ 0.8360188   0.11314284  0.05083836]

但建议的解决方案是:

def softmax(x):
    """Compute softmax values for each sets of scores in x."""
    return np.exp(x) / np.sum(np.exp(x), axis=0)

它产生与第一个实现相同的输出,即使第一个实现显式获取每列和最大值的差异,然后除以总和.

有人可以用数学方式显示原因吗？一个是正​​确的而另一个是错的吗？

实现在代码和时间复杂性方面是否相似？哪个更有效率？

在神经网络的输出层中,通常使用softmax函数来近似概率分布:

由于指数,计算起来很昂贵.为什么不简单地执行Z变换以使所有输出都是正的,然后通过将所有输出除以所有输出的总和来归一化？

我最近遇到了tf.nn.sparse_softmax_cross_entropy_with_logits,我无法弄清楚与tf.nn.softmax_cross_entropy_with_logits相比有什么不同.

是训练矢量唯一的区别y必须是独热编码使用时sparse_softmax_cross_entropy_with_logits？

阅读API,我找不到任何其他差异softmax_cross_entropy_with_logits.但是为什么我们需要额外的功能呢？

如果提供单热编码训练数据/向量,不应softmax_cross_entropy_with_logits产生相同的结果sparse_softmax_cross_entropy_with_logits吗？

我最近在研究 CNN，我想知道 softmax 公式中温度的函数是什么？为什么我们应该使用高温来查看概率分布中更软的范数？Softmax 公式

我正在观看Stanford CS231的一些视频:用于视觉识别的卷积神经网络,但不太了解如何使用软件丢失函数计算分析梯度numpy.

从这个stackexchange答案,softmax梯度计算如下:

上面的Python实现是:

num_classes = W.shape[0]
num_train = X.shape[1]
for i in range(num_train):
  for j in range(num_classes):
    p = np.exp(f_i[j])/sum_i
    dW[j, :] += (p-(j == y[i])) * X[:, i]

任何人都可以解释上面的代码片段是如何工作的？softmax的详细实现也包括在下面.

def softmax_loss_naive(W, X, y, reg):
  """
  Softmax loss function, naive implementation (with loops)
  Inputs:
  - W: C x D array of weights
  - X: D x N array of data. Data are D-dimensional columns
  - y: 1-dimensional array of length N with labels 0...K-1, for …

我有兴趣实现一个可以处理大型词汇表的分层softmax模型,比如大约10M类.这样做的最佳方法是扩展到大班级和高效吗？例如,至少有一篇论文表明,当使用每个节点sqrt(N)类别的2级树时,HS可以为大型词汇实现~25倍的加速.我也对具有任意分支因子的任意深度树的更通用版本感兴趣.

我在这里看到一些选项:

1)tf.gather为每个批次运行,我们收集索引和拆分.这会产生大批量和胖树的问题,现在系数重复很多,导致OOM错误.

2)与#1类似,我们可以使用tf.embedding_lookup哪个可以帮助解决OOM错误,但是现在可以将所有内容保存在CPU上,并且可以减慢速度.

3)使用tf.map_fn与parallel_iterations=1分别处理每个样本,并返回到使用收集.这更具可扩展性,但由于序列化,它并没有真正接近25倍的加速.

有没有更好的方法来实施HS？深层和窄层与短树和宽树有不同的方式吗？

我在神经网络的最后一层使用Softmax激活函数.但我在安全实现此功能时遇到问题.

一个天真的实现将是这个:

Vector y = mlp(x); // output of the neural network without softmax activation function
for(int f = 0; f < y.rows(); f++)
  y(f) = exp(y(f));
y /= y.sum();

对于> 100个隐藏节点,这不能很好地工作,因为y NaN在很多情况下(如果y(f)> 709,exp(y(f))将返回inf).我想出了这个版本:

Vector y = mlp(x); // output of the neural network without softmax activation function
for(int f = 0; f < y.rows(); f++)
  y(f) = safeExp(y(f), y.rows());
y /= y.sum();

在哪里safeExp定义为

double safeExp(double x, int div)
{
  static const double maxX = …

我尝试使用以下代码实现soft-max(out_vec是numpy浮点数的向量):

numerator = np.exp(out_vec)
denominator = np.sum(np.exp(out_vec))
out_vec = numerator/denominator

但是,因为有一个溢出错误np.exp(out_vec).因此,我检查(手动)上限np.exp()是什么,并发现np.exp(709)是一个数字,但np.exp(710)被认为是np.inf.因此,为了避免溢出错误,我修改了我的代码如下:

out_vec[out_vec > 709] = 709 #prevent np.exp overflow
numerator = np.exp(out_vec)
denominator = np.sum(np.exp(out_vec))
out_vec = numerator/denominator

现在,我得到一个不同的错误:

RuntimeWarning: invalid value encountered in greater out_vec[out_vec > 709] = 709

我添加的产品线有什么问题？我查了一下这个特定的错误,我找到的只是人们对如何忽略错误的建议.简单地忽略错误对我没有帮助,因为每次我的代码遇到这个错误时都不会给出通常的结果.

我在对pytorch 中的 MNIST 数据集的2 个隐藏层的全连接深度神经网络进行分类时遇到问题。

我想在两个隐藏层中都使用tanh作为激活，但最后，我应该使用softmax。

对于损失，我选择nn.CrossEntropyLoss()了 PyTORch，它（正如我发现的那样）不想将单热编码标签作为真正的标签，而是采用 LongTensor 类。

我的模型是nn.Sequential()，当我最终使用 softmax 时，它在测试数据的准确性方面给了我更糟糕的结果。为什么？

import torch
from torch import nn

inputs, n_hidden0, n_hidden1, out = 784, 128, 64, 10
n_epochs = 500
model = nn.Sequential(
    nn.Linear(inputs, n_hidden0, bias=True), 
    nn.Tanh(),
    nn.Linear(n_hidden0, n_hidden1, bias=True),
    nn.Tanh(),
    nn.Linear(n_hidden1, out, bias=True),
    nn.Softmax()  # SHOULD THIS BE THERE?
)
                 
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.5)

for epoch in range(n_epochs):
    y_pred = model(X_train)
    loss = criterion(y_pred, …

我注意到tf.nn.softmax_cross_entropy_with_logits_v2(labels, logits)主要执行3个操作:

1. 将softmax应用于logits(y_hat)以对其进行标准化:y_hat_softmax = softmax(y_hat).

2. 计算交叉熵损失: y_cross = y_true * tf.log(y_hat_softmax)

3. 对实例的不同类求和: -tf.reduce_sum(y_cross, reduction_indices=[1])

从这里借来的代码完美地证明了这一点.

y_true = tf.convert_to_tensor(np.array([[0.0, 1.0, 0.0],[0.0, 0.0, 1.0]]))
y_hat = tf.convert_to_tensor(np.array([[0.5, 1.5, 0.1],[2.2, 1.3, 1.7]]))

# first step
y_hat_softmax = tf.nn.softmax(y_hat)

# second step
y_cross = y_true * tf.log(y_hat_softmax)

# third step
result = - tf.reduce_sum(y_cross, 1)

# use tf.nn.softmax_cross_entropy_with_logits_v2
result_tf = tf.nn.softmax_cross_entropy_with_logits_v2(labels = y_true, logits = y_hat)

with tf.Session() as sess:
    sess.run(result)
    sess.run(result_tf)
    print('y_hat_softmax:\n{0}\n'.format(y_hat_softmax.eval()))
    print('y_true: \n{0}\n'.format(y_true.eval()))
    print('y_cross: \n{0}\n'.format(y_cross.eval()))
    print('result: …