相关疑难解决方法(0)

从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)

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

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

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

使用给定的fp数种类，例如float16，直接构造具有完全错误结果的和。例如，使用python / numpy：

import numpy as np

one = np.float16(1)
ope = np.nextafter(one,one+one)

np.array((ope,one,-one,-one)).cumsum()
# array([1.001, 2.   , 1.   , 0.   ], dtype=float16)

在这里，我们习惯于cumsum强制天真的求和。留给自己的设备numpy使用不同的求和顺序，会得到更好的答案：

np.array((ope,one,-one,-one)).sum()
# 0.000977

以上是基于取消。为了排除此类示例，让我们仅允许使用非否定术语。对于幼稚的求和，给出具有非常错误的求和的示例仍然很容易。以下求和10 ^ 4个相同的项，每个项等于10 ^ -4：

np.full(10**4,10**-4,np.float16).cumsum()
# array([1.0e-04, 2.0e-04, 3.0e-04, ..., 2.5e-01, 2.5e-01, 2.5e-01],
  dtype=float16)

最后一项相差4倍。

同样，允许numpy使用成对求和给出更好的结果：

np.full(10**4,10**-4,np.float16).sum()
# 1.0

可以构造超过成对求和的和。选择低于分辨率为1的eps时，我们可以使用1，eps，0，eps，3x0，eps，7x0，eps，15x0，eps，...，但这涉及到疯狂的术语数量。

我的问题：仅使用float16和非否定项，就需要多少项来从成对求和中得出至少相差2倍的结果。

奖励：同样的问题是“积极”而不是“非消极”。可能吗？

在pytorch分类网络模型中定义为这样，

class Net(torch.nn.Module):
    def __init__(self, n_feature, n_hidden, n_output):
        super(Net, self).__init__()
        self.hidden = torch.nn.Linear(n_feature, n_hidden)   # hidden layer
        self.out = torch.nn.Linear(n_hidden, n_output)   # output layer

    def forward(self, x):
        x = F.relu(self.hidden(x))      # activation function for hidden layer
        x = self.out(x)
        return x

这里应用了 softmax 吗？在我看来，事情应该是这样的，

class Net(torch.nn.Module):
    def __init__(self, n_feature, n_hidden, n_output):
        super(Net, self).__init__()
        self.hidden = torch.nn.Linear(n_feature, n_hidden)   # hidden layer
        self.relu =  torch.nn.ReLu(inplace=True)
        self.out = torch.nn.Linear(n_hidden, n_output)   # output layer
        self.softmax = torch.nn.Softmax(dim=n_output)
    def forward(self, x):
        x = …

以下是我尝试计算softmax的小代码。它适用于单个阵列。但是随着数量的增加（例如1000等），它会爆炸

import numpy as np

def softmax(x):
 print (x.shape)
 softmax1 = np.exp(x)/np.sum(np.exp(x))
 return softmax1


def test_softmax():
  print "Running your code"
  #print softmax(np.array([1,2]))
  test1 = softmax(np.array([1,2]))
  ans1 = np.array([0.26894142,  0.73105858])
  assert np.allclose(test1, ans1, rtol=1e-05, atol=1e-06)
  print ("Softmax values %s" % test1)

  test2 = softmax(np.array([[1001,1002],[3,4]]))
  print test2
  ans2 = np.array([
      [0.26894142, 0.73105858],
      [0.26894142, 0.73105858]])
  assert np.allclose(test2, ans2, rtol=1e-05, atol=1e-06)

if __name__ == "__main__":
 test_softmax()

我收到一个错误RuntimeWarning：exp遇到溢出运行您的代码softmax1 = np.exp（x）/np.sum（np.exp（x））