深度学习SSIM损失pytorch svm损失函数推导

w
                 cat  duck frog
             |p1 0.1  0.2  0.2
n_i=第i个样品 |p2 0.2  0.3  0.1
p=pixel      |p3 0.5  0.1  0.1
-------------------------
      x      |      score
    p1  p2 p3|   cat  duck  frog
n1  10  14 10|   8.8 [7.2]  4.4  -->第一个样品得分
n2  5   10  8|   6.5  4.8  2.8  -->第二个样品
n3  10  5   5|   4.5  4.0  3.0  -->第三个样品

[7.2]代表第一个样品的真实类别为duck，分数是7.2


那么按照损失函数的计算方法：
L_i=max(0,8.8-7.2+1)+max(0,4.4-7.2+1)
   =1.8+0=1.8

w
                 cat      duck frog
             |p1 0.1+0.01  0.2  0.2
n_i=第i个样品 |p2 0.2       0.3  0.1
p=pixel      |p3 0.5       0.1  0.1
-------------------------
      x      |      score
    p1  p2 p3|   cat      duck  frog
n1  10  14 10|   8.8+0.1  [7.2]  4.4  -->第一个样品得分
n2  5   10  8|   6.5      4.8    2.8  -->第二个样品
n3  10  5   5|   4.5      4.0    3.0  -->第三个样品

代码表示如下

方式一：Non-vectorized implementation

dW = np.zeros(W.shape) # initialize the gradient as zero
  
 # compute the loss and the gradient
   ...
  for i in xrange(num_train):
    ...
    for j in xrange(num_classes):
      ...
      if margin > 0:
          ...
          dW[:,y[i]] -= X[i,:] 
          dW[:,j] += X[i,:]

方式二：Vectorized implementation

下面具体举例说明：

#假设scores为我们得到的分数，scores=(N,C)
scores=np.array([[1, 2, 3],[4, 5, 6],[7, 8, 9]])
#y表示每一个样本真正的类别
y=np.array([2,1,1])
#这儿选出每行，对应的y的值
#https://mlxai.github.io/2017/01/06/vectorized-implementation-of-svm-loss-and-#
yi_scores = scores[np.arange(scores.shape[0]),y]
# yi_scores=>array([3, 5, 8])
#计算边界函数
margins = np.maximum(0, scores - np.matrix(yi_scores).T + 1)
"""
matrix([[0, 0, 1],
        [0, 1, 2],
        [0, 1, 2]])
"""
#这儿就是一个小技巧，因为若j=yi时，系数是需要为-1的
margins[np.arange(3),y] = 0
"""
matrix([[0, 0, 0],
        [0, 0, 2],
        [0, 0, 2]])
"""
loss = np.mean(np.sum(margins, axis=1))
binary = margins
#二值化处理
binary[margins > 0] = 1
"""
matrix([[0, 0, 0],
        [0, 0, 1],
        [0, 0, 1]])
"""
#计算每个样本分类错误的个数
row_sum = np.sum(binary, axis=1)
"""
matrix([[0],
        [1],
        [1]])
"""
#这儿的技巧同上面的技巧结合起来，就可以实现分类错误时，系数可以根据yi是否等于j
#进行梯度-(X转置)，或梯度+(X转置)的操作
binary[np.arange(3), y] = -row_sum.T
"""
matrix([[ 0,  0,  0],
        [ 0, -1,  1],
        [ 0, -1,  1]])
"""
#相当于一次性做完方式一的循环操作
dW = np.dot(X.T, binary)