cs231n之KNN-SVM-Softmax-two_layer_net_features总结

训练分类器流程总结

除了KNN这种用最邻近dist直接更具得分分类的分类器，之后的SVM，softmax的线性分类器，多层神经网络乃至CNN系列，都是如下步骤

• -都是先用一个评分函数算出得分（Wx+b，区别只是W，b参数数量的区别（网络结构）以及激活函数区别）
• 再用一个损失函数衡量分类器的优劣，对其求导算出各个dW，优化损失，更新W权重
• 最后用学习到的权重w（其实就是一种映射）进行预测

具体分类器代码实现框架

class classifer_name(object):

def init(self,各类参数):

根据输入的各类参数，如input_size,hiddenlayer1_size,hiddenlayer2_size,output_size,std

来初始化W，b

self.params = {}
self.params["W1"] = 
self.params["b1"] =

def loss(self,X,y,reg) ----------------return loss,grads

1，从(__init__中定义的self.params)参数字典中读取W,b等的值,以及输入X的尺寸"""

		W1, b1 = self.params['W1'], self.params['b1']
    	 ……
        N, D = X.shape

2,向前向后传播计算scores,loss,grads

2.1，向前传播算scores

输入数据X和标签y，经过整个卷积网络W1,W2，b1,b2，Relu等计算scores

2.2，根据得分，取出最大的score，用softmax求损失loss

中心化防止梯度爆炸-np.max(scores,axis=1,keepdims=True)
求softmax得分 np.exp,np.sum(scores,axis=1,keepdims=True)/N,
求softmax损失：np.log（）.sum# 从所有scores中取出标签y对应的得分，求和为总得分，再除N
加上正则化损失：loss += reg * np.sum(W1 * W1)

2.3，(反向传播)对loss求导，计算dW1，dW2，为下一步训练做准备
①如计算softmax梯度：参考softmax章节（cs231_camp）

多层神经网络
用到ds3 = np.copy(scores),ds3[np.arange(N),y] -= 1实现以下求导公式
for j in range(num_class):
 	if j!=y[i]:
       dw[i,j]+=score[j]*X[i]
	else:
        dw[i,j]+=(score[j]-1)*X[i]
    反向传播求梯度时，需要加上正则化项求导
     grads["W3"] = np.dot(s2_relu.T,ds3) + 2 * reg * W3 # s3_relu.T输入需转置

以线性softmax为例

 loss = 0.0
  dW = np.zeros_like(W)
  num_classes = W.shape[1]
  num_train = X.shape[0]

  scores=X.dot(W)
  maxLogC = np.max(scores,axis=1)
  maxLogC=np.reshape(np.repeat(maxLogC,num_classes),scores.shape )
  expScores=np.exp(scores+maxLogC)

  #loss and gradient implement
  for i in range(num_train):
    # substract maxnium to make the exp standard

    esum=sum(expScores[i])
    eyi = expScores[i,y[i]]
    li = -np.log(eyi / esum)
    loss+=li

    for j in range(num_classes):
      dW[:,j]+=(expScores[i,j]/esum)*X[i]
	 dW[:,y[i]] -= X[i]
  loss /= num_train
  loss += 0.5*reg * np.sum(W*W)

  dW /= num_train
  dW += reg * W

以线性SVM为例

num_train = X.shape[0]  # 49000
  scores = np.dot(X, W)
  correct_class_scores = scores[np.arange(num_train), y]
  correct_class_scores = np.reshape(correct_class_scores, (num_train, -1))
  margin = scores - correct_class_scores + 1.0
  margin[np.arange(num_train), y] = 0.0
  margin[margin <= 0] = 0.0  # ** #
  loss += np.sum(margin) / num_train
  loss += 0.5 * reg * np.sum(W * W)

# 分两部分求导，具体看公式
  margin[margin > 0] = 1.0  # ** # 对i部分求导（>0置一，之后会乘以X）
  row_sum = np.sum(margin,