斯坦福cs231n课程记录——assignment1 SVM

 ​​# Preprocessing: subtract the mean image

    
 # first: compute the image mean based on the training data
    
 mean_image = np.mean(X_train, axis=0)
    
 print (mean_image[:10]) # print a few of the elements
    
 plt.figure(figsize=(4,4))
    
 plt.imshow(mean_image.reshape((32,32,3)).astype('uint8')) # visualize the mean image
    
 plt.show()
    
    
    
    

 [ 129.16667347  134.23142857  130.79826531  128.36589796  133.4004898

    
   129.92885714  129.62573469  134.69042857  130.9032449   129.91483673]
    
    
    
    

 # second: subtract the mean image from train and test data

    
 X_train -= mean_image
    
 X_val -= mean_image
    
 X_test -= mean_image
    
 X_dev -= mean_image
    
    
    
    

 # third: append the bias dimension of ones (i.e. bias trick) so that our SVM

    
 # only has to worry about optimizing a single weight matrix W.
    
 X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])
    
 X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])
    
 X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])
    
 X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])
    
  
    
 print (X_train.shape, X_val.shape, X_test.shape, X_dev.shape)
    
    
    
    

    (49000, 3073) (1000, 3073) (1000, 3073) (500, 3073)
    

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

    
     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:
    
             loss += margin
    
             # 如果 margin 大于 0，计算梯度
    
             dW[:, j] += X[i].T
    
             dW[:, y[i]] -= X[i].T
    
  
    
     # 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
    
     # 对梯度除以 num_train 进行平均
    
     dW /= num_train
    
  
    
     # Add regularization to the loss.
    
     loss += reg * np.sum(W * W)
    
     # 对正则项求梯度
    
     dW += 2 * 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_train = X.shape[0]  # 得到样本的数目
    
     scores = np.dot(X, W)  # 计算所有的得分
    
     y_score = scores[np.arange(num_train), y].reshape((-1, 1))  # 得到每个样本对应label的得分
    
     mask = (scores - y_score + 1) > 0  # 有效的score下标，多算label
    
     scores = (scores - y_score + 1) * mask  # 有效的得分
    
     loss = (np.sum(scores) - num_train * 1) / num_train  # 去掉每个样本多加的对应label得分，然后平均
    
     loss += reg * np.sum(W * W)
    
  
    
     # dw = x.T * dl/ds
    
     ds = np.ones_like(scores)  # 初始化ds
    
     ds *= mask  # 有效的score梯度为1，无效的为0
    
     ds[np.arange(num_train), y] = -1 * (np.sum(mask, axis=1) - 1)  # 每个样本对应label的梯度计算了(有效的score次)，取负号
    
     dW = np.dot(X.T, ds) / num_train   # 平均
    
     dW += 2 * reg * W  # 加上正则项的梯度
    
  
    
     return loss, dW