DL基础:cs231n assignment 1
阅读原文时间:2023年07月08日阅读:6

cs231n assignment 1

20210804 - 20210808。

目录

建立模型的步骤:

  • __init__(self);在注释中约定模型的参数超参数。
  • 写出【loss function】,loss():要给出regularization_strength,如果给出label y就返回gradient。
  • 用stochastic gradient descent写出train()
  • 写出predict()

训练模型的步骤:

  • 得到train、validation、predict的X和y,顺便得到它们的维度;
  • 设置一堆超参数,开始训练,试出来哪些超参数更好。

矩阵求微分:

\[AB=C
\\
\frac{\part l}{\part B}=A^T\frac{\part l}{\part C}
\\
\frac{\part l}{\part A}=\frac{\part l}{\part C}B^T
\]

其中\(A^T\)就是\((\frac{\part C}{\part B})^T\),也就是\(\frac{\part l}{\part B}=(\frac{\part C}{\part B})^T\frac{\part l}{\part C}\)​;

\(B^T\)​就是\((\frac{\part C}{\part A})^T\)​,也就是\(\frac{\part l}{\part A}=\frac{\part l}{\part C}(\frac{\part C}{\part A})^T\)​​,是链式法则。

思想

k是一个超参数。对于新给出的一个数据,找到离它【距离】最近的k个样本,用 这k个样本中数目最多的类别 来预测 这个数据的类别。

距离:L1距离/Manhattan距离,L2距离/Euclidean距离。

(L1距离与选择的坐标轴有关,而转动坐标轴对L2距离没有影响。因此如果坐标轴有特殊的意义,可以考虑L1距离,否则L2距离更自然一些。)

cross-validation

一般做法:我们会把数据分成3组:train,validation,test。在validation上试出最合适的超参数,然后我们就用这一组超参数对应的模型了。

交叉验证:把test拿出来,然后把其余的分成若干组。对于一组超参数,把每一组都拿出来做一次validation(用其余组训练模型),然后对模型在各个validation上的表现取平均值,根据这个平均值选超参数。

在小数据集上是有用的,但在深度学习中不常用。

编程细节

# 神仙高效矢量化代码
dists[i, j] = np.sqrt(np.sum(np.square(X[i] - self.X_train[j]))) # np是万能的

dists[i, :] = np.sqrt(np.sum(np.square(X[i] - self.X_train), axis = 1)) # 进阶版,axis=1: :::::: -> :,0::::::: -> ......

dists = np.sqrt(
    np.sum(X**2, axis = 1, keepdims = True)
    + np.sum(self.X_train**2, axis = 1, keepdims = True).T
    - 2*np.dot(X, self.X_train.T)
) # 一次得到!更高更妙的广播操作,keepdims用来保持二维特性


max_index = np.argsort(dists[i]) # argsort返回的是数组值从小到大的索引值


maxdir = {} # this is a dictionary
sy = set(closest_y) # make it become set
for s in sy:
    maxdir[s] = closest_y.count(s)
y_pred[i] = int(max(maxdir, key = maxdir.get)) # 字典返回value最大的key


# Frobenius norm 可以用来检验两个矩阵是否相同
# 就是所有的difference平方和开根号
# 换句话说,把矩阵变成向量再求euclidean距离
difference = np.linalg.norm(dists - dists_one, ord='fro')
print('Difference was: %f' % (difference, ))
if difference < 0.001:
    print('Good! The distance matrices are the same')
else:
    print('Uh-oh! The distance matrices are different')

思想

线性分类器:

\[f(x,W)=Wx+b
\]

x是3072*1的图片(列向量),W是10*3072的权重矩阵,b是10*1的bias列向量。

最后我们得到一个10*1的列向量,其中【第i行的元素】就是【W第i行】和【x】的内积(再加一个bias),内积即相似程度。W的第i行可以被看成与类别i对应的pattern。

代码中的预处理

  • 算出mean,然后把每个数据都减去mean;
  • 直接把mean作为bias,svm只对W进行优化。

multi-class svm loss

\[L_i=\sum_{j\ne y_i}
\left \{
\begin{array}{ll}
0, & if~s_{y_{i}} \ge s_j+1 \\
s_j-s_{y_{i}}+1, & otherwise\\
\end{array}
\right.
\\
=\sum_{j\ne y_i}max(0,s_j-s_{y_{i}}+1)
\]

我们看除正确类别外的9个类别的得分:如果正确类别的得分高于该错误类别得分,高于它一个安全的bound(此处为1),loss是0,否则loss是【错误类别得分+bound-正确类别】。

正则项

\[L(W)=\frac{1}{N}\sum_{i=1}^n{L_i(f(x_i,W),y_i)}+\lambda R(W)
\]

λ是正则化强度。就是鼓励更简洁的模型,penalize the complexity of the model。

L2 regularization:\(R(W)=\sum_k \sum_l W_{k,l}^2\)​​。所有数的平方和。

L1 regularization:\(R(W)=\sum_k \sum_l |W_{k,l}|\)​。所有数的绝对值和。

编程细节

# numpy真是魔法
mask = range(num_training, num_training + num_validation)
X_val = X_train[mask]

如果【正确类别得分没有高于错误类别一个安全的bound】,求梯度的时候不仅要错误类别分数降低,还要正确类别分数升高。

# W是3072*10,X是100*3072

scores = X.dot(W)
correct_class_score = scores[np.arange(num_train),y]
scores_to_calc = scores - correct_class_score.reshape(-1, 1) + 1.
# 想让矩阵变成只有一列(行数不知道多少),通过mat.reshape(-1,1)
# 也就是所有分数减去正确分数再加1
scores_to_calc[scores_to_calc <= 0] = 0
loss = np.sum(scores) / num_train - 1 # 减去正确类别

scores_to_calc[scores_to_calc > 0] = 1
mask = np.array(scores_to_calc) # 数组深复制
mask[np.arange(num_train), y] = -np.sum(scores_to_calc, axis = 1) # 有多少个+1超过bound的错误类别分数,正确类别的loss梯度就要减多少次
dW = X.T.dot(mask) / num_train

# Add regularization to the loss.
loss += reg * np.sum(W * W)
dW += 2 * reg * W

梯度下降法,是沿loss负梯度的方向向下走,所以是W -= learning_rage * grad

思想

softmax的loss function是这样的:

我们认为P是一个概率。给出样本\(x_i\),判断其类别为k的概率:

\[P(Y=k|X=x_i)=\frac{e^{s_k}}{\sum_j e^{s_j}}
\]

就是【类别k得分的exp】比上【各个类别得分的exp之和】。

损失函数就是【-log正确类别概率】,概率=1时loss=0,概率=0时loss=正无穷。

\[L_i=-logP(Y=y_i|X=x_i)
\]

编程细节

X_train = np.reshape(X_train, (X_train.shape[0], -1))
# reshape,保留第一个维度,剩下全压缩到一个维度(-1)


X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])
# hstack,就是把两个矩阵水平靠着放在一起
# 等价于np.concatenate([ndarray数组], axis=1)

要想用np广播,就要在np.sum()的时候加上keepdims=True

思想

linear score function:

\[f=Wx+b
\]

2-layer Neural Network:

\[f=W_2max(W_1x,0)
\\
f=W_2max(W_1x+b_1,0)+b_2
\]

非线性运算(如这里的max)很重要,否则线性堆叠在一起还是线性。

forward pass:先算h,再算s,再算loss。

backward pass:求loss的微分,先算dscore,再算db2、dW2、dh,通过dh再算dW1和db1。

epoch是什么

一个epoch表示把所有数据送入模型训练一遍的过程。

minibatch是为了算gradient快一些。

iterations_per_epoch = max(num_train / batch_size, 1),就是说我们要iterate几次才能完成一个epoch。

完成一个epoch之后,我们把learning_rate调低,learning_rate *= learning_rate_decay

编程细节

算loss的时候算的是N个example的mean,并且别忘了加regularization term。

算gradient的时候也别忘了加上正则项。

y_pred = np.argsort(self.loss(X),axis = 1)[:,-1]
# argsort把元素从小到大排序,给我们排序好的下标。我们要得分最大的,因此[:,-1]

思想

feather engineering。