机器学习(4)-理解SVM的损失函数和梯度表达式的实现+编程总结

1.对于SVM这里总结下代码实现SVM的两种代码实现(for循环和矩阵操作)
首先看看SVM的损失函数,梯度函数
损失函数最终形式:
L = (1/N)∑iLi + λR(W)
其中:
R(W) = ∑k∑s (Wk,s)2
Li = ∑j≠yi max(0, (xiW)j−(xyiW)j+Δ)
理解:yi表示提前知道第yi个分类是正确的。比yi大的评分表示判断错的得分,因为如果正确,第yi个分类的得分应该是最高的。

梯度函数最终形式:
∇Wyi Li = - xiT(∑j≠yi 1(xiWj - xiWyi +1>0)) + 2λWyi (j = y[i])
∇Wj Li = xiT 1(xiWj - xiWyi +1>0) + 2λWj , (j≠yi) (j != y[i])

其中,注意1(·)是示性函数,其取值规则为:1(表达式为真) =1;1(表达式为假) =0。
理解:这里分了两种情况,当计算dW矩阵的时候,计算每一张图的dW矩阵,第y[i]列的计算要注意(我觉得这里不好懂),计算其他列的计算比较好理解。
下面先看for循环的实现代码:

def svm_loss_naive(W, X, y, reg):


  Inputs:
  - W: A numpy array of shape (D, C) containing weights.
  - X: A numpy array of shape (N, D) containing a minibatch of data.
  - y: A numpy array of shape (N,) containing training labels; y[i] = c means
    that X[i] has label c, where 0 <= c < C.
  - reg: (float) regularization strength

  Returns a tuple of:
  - loss as single float
  - gradient with respect to weights W; an array of same shape as W
  """
  dW = np.zeros(W.shape) # initialize the gradient as zero

  # compute the loss and the gradient
  num_classes = W.shape[1]
  num_train = X.shape[0]
  loss = 0.0
  for i in xrange(num_train):
    scores = X[i].dot(W)
    correct_class_score = scores[y[i]]
    for j in xrange(num_classes):
      if j == y[i]:
        continue
      margin = scores[j] - correct_class_score + 1 # note delta = 1
      if margin > 0:#也就是只有1(xiWj - xiWyi +1>0)的时候才进行loss和gradient的计算
        loss += margin
        dW[:,y[i]]+= -X[i,:]
        dW[:,j] += X[i,:]
        #上面两行代码这样理解,每张图片输入,就是i循环一次,对应的j循环了num_class次,就是把dW矩阵的每一列都遍历到了,(也就是每张图对应一个dW,i循环完了,就是将num_train个dW矩阵叠加了一遍),这里dW[:,y[i]]+= -X[i,:]在每一次i循环都执行,就是第y[i]列是其他列的和,其他列只循环了一次。
         if margin > 0:表示有错误的评分出现,这个时候才会产生损失值,所以这里才会有loss的计算

  # Right now the loss is a sum over all training examples, but we want it
  # to be an average instead so we divide by num_train.
  loss /= num_train
  dW = dW/num_train
  # Add regularization to the loss.
  loss += 0.5*reg * np.sum(W * W)
  dW = dW+ reg*W
  return loss, dW

下面看看矩阵操作的实现:

def svm_loss_vectorized(W, X, y, reg):

  loss = 0.0
  dW = np.zeros(W.shape) # initialize the gradient as zero
  num_classes = W.shape[1]
  num_train = X.shape[0]
  #############################################################################
  # TODO:                                                                     #
  # Implement a vectorized version of the structured SVM loss, storing the    #
  # result in loss.                                                           #
  #############################################################################
  scores = X.dot(W)
  score_correct = scores[np.arange(num_train),y]#根据已知的y,找出本应该得分最高的分类得分,存放入一个矩阵,这个矩阵大小【1*N】

  score_correct = np.reshape(score_correct,(num_train,1))#必须这样才能把矩阵变为[N*1],不能用转置,python中转置操作对以为矩阵不起作用(有点坑)
  margin_matrix = scores - score_correct +1#矩阵化实现(xiW)j−(xyiW)j+Δ

  margin_matrix[np.arange(num_train),y] =0 #因为loss公式中指明j=y[i]的列不参与计算,因为这一列是本应该分类正确的,其他列都是和这一列作比较。

  margin_matrix[margin_matrix<=0] =0

  loss = np.sum(margin_matrix)#计算所有loss的和

  loss /= num_train
  loss = loss + 0.5*reg*np.sum(W*W)

  #############################################################################
  #                             END OF YOUR CODE                              #
  #############################################################################

  #############################################################################
  # TODO:                                                                     #
  # Implement a vectorized version of the gradient for the structured SVM     #
  # loss, storing the result in dW.                                           #
  #                                                                           #
  # Hint: Instead of computing the gradient from scratch, it may be easier    #
  # to reuse some of the intermediate values that you used to compute the     #
  # loss.                                                                     #
  #############################################################################
  margin_matrix[margin_matrix>0] =1#这一步是对用梯度公式中 1(xiWj - xiWyi +1>0))  这一项

  row_sum = np.sum(margin_matrix, axis=1)#将所有非正确分类,且这个非正确分类的评分要大于正确的评分,做个求和
  margin_matrix[np.arange(num_train), y] = -row_sum
#上面两句代码对应for循环中的dW[:,y[i]]+= -X[i,:]这一句
  dW = np.dot(X.T, margin_matrix) / num_train + reg * W
 #然后根据矩阵的对应关系进行计算,就是维度关系
  return loss, dW

后面会根据梯度下降发来跟新W
其实代码就一句话

self.W += -learning_rate * grad

只是这里的grad一般使用很小的batch来计算的,为了加快运算速度而已。

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值