学习笔记 on 热尘的博客

cs224n学习笔记

Sun, 18 Jan 2026 23:02:00 +0800

cs224n学习笔记

词嵌入

我们学习过 cs231n，了解了神经网络的本质是将数据进行线性变换为我们所需要的数据模式（如分类等等）。

但是在自然语言处理这个领域，我们的语言难以直接被计算机所理解，所以我们要对我们的语言进行编码，注意这里的编码并不是像unicode那样无序编码，而是为了让计算机“理解”词意而编码，所以在这里引入词嵌入方法（PS:词嵌入在之后的 transformer 中仍然有一席之地）

词嵌入其实也是模型的一个学习阶段，拿现实来举一个例子，我们学习语言的时候，通过理解单词的实际意义来学习，词嵌入类似，但是我们无法让计算机通过五感来理解词义，所以我们对相同或者有类似词义的单词进行分类，所以每个单词对于计算机来说都是抽象概念，我们将在之后的训练中让各种抽象概念相互依存、连接。

词嵌入的实际操作非常简单，cs224n_a1 已经有详细的步骤拆分，这里不做赘述，我们只需要知道词嵌入是将语言的编码的重要工具即可。

依存句法分析器

这个模块的功能在 Transformer 中会集成在注意力机制中，但是学习这个模块这是我们理解语言分析的一个重要阶段。

在上文我们提到过计算机所理解的概念都是抽象的，但是人们的语言会有着不同的风格、歧义甚至是语法错误，为了让计算机依然能“看懂”我们的语言，便有了这个模块。

这个模块将我们的语言拆分为最简单的树形结构，让计算机理解起来不会有歧义。

那么现在的问题来到了怎么合理拆分构造我们的树形结构，首先不同的语言有不同的语法规范，其次我们要对这个依存句法分析器进行训练，让其能合理地处理任何句子。

在 cs224n 中我们采用神经网络对其进行训练，并且使用 pytorch 减少代码难度，写起来其实没多少东西。

神经机器翻译

这部分的代码实在是太乱了，我按照自己的理解进行讲解，如果有错误请联系我改正。

在这里我们引入了注意力机制和 LSTM 架构，那么我们所需训练的矩阵数便涉及了注意力机制的注意力模块和LSTM的遗忘门、输入门、输出门。

在笔记中我们只通过抽象概念来理解，并不会说明具体代码实现。

LSTM（长短期记忆网络）是为了解决长对话的理解而诞生的，主要模块有遗忘门、输入门、输出门。

遗忘门是解决过远的记忆，优化性能且防止过久记忆。

输入门便是对某些数据进行记忆。

输出门便是对现有的记忆进行编码，而后传导到下一个循环。

那么我们现在发现了一个问题，如果真的有一个问题需要我们长久记忆怎么办，我们的遗忘门在每一次循环都会按照时间步对之前的权重进行削减，那么我们在这里引入注意力机制，我们在遗忘之前对原始数据进行注意力机制的应用，令超长期记忆成为可能。

注意这里的注意力机制和 Transformer 中的自注意力机制有所不同，这里的注意力机制只会告诉模型应该注意前文的某某方面，而不会分析更多。

这部分的实现变得更为抽象，但是我们要明确一点，就像上文提到的，计算机所有点一切概念都是数字，都是抽象的，我们为模型实现任何的模块只是提供了模型分析某个方面的功能，具体的模块间的嵌合性以及那些矩阵权重数据的实际都不是我们需要考虑的，这些问题会在实际数据的训练中进行自拟合，这也提供了一个知识点便是我们不能将某一模块的权重单独拿出来放在另一个模型上，这是不合理的。

Attention is All You Need

Transformer 的知识点很多，我们按照架构数据处理主要模块来讲解。

自注意力机制

这是 Transformer 架构最具有革命性的模块。

首先从单一自注意力入手，这里我们将为每一个词元（这个待会解释）设置三个键值，分别为查询键值Q，自身键值K，本质键值V，这便是自注意机制要学习的三个主要参数，这里引用一下deepseek给我的例子

查询 Q ：每个词发出的"问题"：我该关注谁？

键 K ：每个词提供的"答案"：我有什么特点值得关注？

值 V ：每个词的"本质内容"，将被加权求和

之后我们便要计算注意力分数，计算方法不重要，重要的是我们的注意力分数代表了我们对这个词的关注度。

但是考虑到对语言分析不够全面，并且联想到卷积神经网络中卷积核的概念，我们便引入了多头注意力机制，本质是对原本的单一自注意力机制的三个键值进行拆解，拆成 3$\times$N 个键值（设有N个头），之后对所有的头进行整合即可。

前馈神经网络（FFN）

这是 Transformer 中很有趣的一部分，正如我上文说的，我们实现的每一个模块都是为了提供给模型学习的能力，而不是单纯的功能。

前馈神经网络为模型提供了学习更复杂特征的能力，因为FFN将传统神经网络的线性变换替换为了非线性变换

$$ \text{FFN}(\mathbf{x}) = \sigma(\mathbf{x}\mathbf{W}_1 + \mathbf{b}_1)\mathbf{W}_2 + \mathbf{b}_2 $$

根据数学定理，我们可以知道这种形式的变换可以逼近任何的连续函数，这提供了 FFN 强大的学习分析能力。

残差连接与层归一化

这其实不是一个重要的模块，但是这是一个重要的小优化。

在我们刚刚接触神经网络时便知道学习的实际便是通过反向传播不断优化我们的各种矩阵超参数，但是如果我们需要深度学习，我们便需要增加层数，那么我们会遇到数学上的问题，比如梯度消失或无效学习，那么我们便要引入残差连接这个模块。

说直白一点，这个模块其实就是将我们的输出权重与原始权重加在一起，这防止了某一参数学着学着没了，也防止了过于激进的变换。

但是我们又发现，单纯相加之后又会过于破坏我们原本的矩阵，甚至导致越加越大难以计算，所以我们引入了层归一化（LayerNormalization）来进行“还原”操作。

感性理解一下，我认为这个模块令我们的 Transformer 变得优雅。

自然语言文本生成器

注意这里我并不是在讲解整个解码器，我相信理解上述模块后已经可以理解编码器，而解码器需要生成自然语言，我曾在这部分疑惑过，所以单独拿出来讲解。

在Transformer中，我们使用自回归解码器，解码器通过理解上文生成预测词向量，然后通过束搜索进行词汇预测。

那么什么是束搜索？

我们来回顾一下我们的起点——knn算法，我们查找前k个相似的图像，束搜索与此类似。

束搜索搜索k前相似，而后再每个相似后再搜索k前相似，在一定循环后选择得分（概率）最大的词列。

这种方法有些丑陋，于是有了许多剪枝和优化方法，在这里不过多赘述。

补充解释

词元：在生成式人工智能导论中，我们知道chatGPT并不是以每个单词进行编码，而是分为若干词元，比如一个词可以由许多词元构成，故此在上文使用词元概念

基础神经网络学习笔记

Sun, 02 Nov 2025 19:23:40 +0800

我猜测可能会有很多人跟我一样，在学完cs231n后仍然对神经网络没有一个整体印象，所以这是一份为后人能更轻松地理解神经网络而编写的学习笔记，本文通过我自己的理解对一份神经网络代码进行解释，将所有的知识点串联起来，希望可以造福后人。

import numpy as np

def unpickle(file):
 import pickle
 with open(file, 'rb') as fo:
 dict = pickle.load(fo, encoding='bytes')
 return dict


def fetch_data():
 train_data = []
 train_label = []
 test_data = []
 testlabel = []
 for i in range(5):
 data = unpickle(
 # datasets\cifar-10-batches-py\data_batch_1
 f'E:/projects/datasets/cifar-10-batches-py/data_batch_{i+1}')
 train_data.append(data[b'data'])
 train_label.append(data[b'labels'])
 test = unpickle('E:/projects/datasets/cifar-10-batches-py/test_batch')
 test_data = test[b'data']
 testlabel = test[b'labels']
 train_data = np.concatenate(train_data)
 train_label = np.concatenate(train_label)
 train_data = train_data.reshape(
 (50000, 3, 32, 32)).transpose(0, 2, 3, 1).astype("float32")
 train_data = train_data.reshape(-1, 32*32*3)
 test_data = test_data.reshape((10000, 3, 32, 32)).transpose(
 0, 2, 3, 1).astype("float32")
 test_data = test_data.reshape(-1, 32*32*3)
 return train_data, train_label, test_data, testlabel


def preprocess_data(train_data, test_data):
 mean = np.mean(train_data, axis=0)
 train_data -= mean
 test_data -= mean
 return train_data, test_data


class NeuralNetwork:
 def __init__(self, input_size, hidden_size, output_size, std=1e-4):
 self.params = {}
 self.params['W1'] = std * np.random.randn(input_size, hidden_size)
 self.params['b1'] = np.zeros(hidden_size)
 self.params['W2'] = std * np.random.randn(hidden_size, output_size)
 self.params['b2'] = np.zeros(output_size)

 def relu(self, x):
 return np.maximum(0, x)

 def relu_backward(self, dout, cache):
 dx, x = dout, cache
 dx[x <= 0] = 0
 return dx

 def loss(self, X, y=None, reg=0.0):
 W1, b1 = self.params['W1'], self.params['b1']
 W2, b2 = self.params['W2'], self.params['b2']

 Hidden_layer = self.relu(np.dot(X, W1) + b1)
 scores = np.dot(Hidden_layer, W2) + b2

 if y is None:
 return scores

 loss = np.sum(-np.log(np.exp(scores[range(len(scores)), y]) /
 np.sum(np.exp(scores), axis=1)))
 loss /= len(X)
 loss += 0.5*reg*(np.sum(W1*W1)+np.sum(W2*W2))

 grads = {}

 dscores = np.exp(scores)/np.sum(np.exp(scores), axis=1, keepdims=True)
 dscores[range(len(scores)), y] -= 1
 dscores /= len(X)
 grads['W2'] = np.dot(Hidden_layer.T, dscores) + reg*W2
 grads['b2'] = np.sum(dscores, axis=0)
 dhidden = np.dot(dscores, W2.T)
 dhidden_relu = self.relu_backward(dhidden, Hidden_layer)
 grads['W1'] = np.dot(X.T, dhidden_relu) + reg*W1
 grads['b1'] = np.sum(dhidden, axis=0)

 return loss, grads

 def train(self, X, y,
 learning_rate=1e-3, learning_rate_decay=0.95,
 reg=5e-6, num_iters=100,
 batch_size=200, verbose=False):
 num_train = X.shape[0]
 iterations_per_epoch = max(num_train // batch_size, 1)

 for it in range(num_iters):
 idx = np.random.choice(num_train, batch_size, replace=True)
 X_batch = X[idx]
 y_batch = y[idx]
 loss, grads = self.loss(X_batch, y=y_batch, reg=reg)

 self.params['W1'] -= learning_rate * grads['W1']
 self.params['b1'] -= learning_rate * grads['b1']
 self.params['W2'] -= learning_rate * grads['W2']
 self.params['b2'] -= learning_rate * grads['b2']

 # if verbose and it % 100 == 0:
 # print('iteration %d / %d: loss %f' % (it, num_iters, loss))
 if it % iterations_per_epoch == 0 and it != 0:
 learning_rate *= learning_rate_decay

 def predict(self, X):
 Hidden_layer = self.relu(
 np.dot(X, self.params['W1']) + self.params['b1'])
 scores = np.dot(Hidden_layer, self.params['W2']) + self.params['b2']
 return np.argmax(scores, axis=1)


def main():
 train_data, train_label, test_data, testlabel = fetch_data()
 train_data, test_data = preprocess_data(train_data, test_data)
 net = NeuralNetwork(32*32*3, 100, 10)
 net.train(train_data, train_label, num_iters=10000,
 batch_size=200, verbose=True)
 print(f'train accuracy: {np.mean(net.predict(train_data) == train_label)}')
 return


if __name__ == '__main__':
 main()

这里是本文所使用的代码。（训练内容为CIFAR-10数据集）

首先，fetch_data和 unpickle函数作为数据读入函数，在这里不做讲解，我们只需要知道 train_data,train_label,test_data,testlabel这四个都分别是什么即可，train_data是一个n*3072的矩阵，它存储了n个训练需要的图像数据，train_label是一个列表，有n项，存储了 train_data对应的答案，test_data,testlabel同理。
之后我们需要对数据进行预处理，我们来看 preprocess_data函数，这份代码中只采用了均值减法初始化，这是最为常见的初始化方式，且在这份代码中效果显著，当然我们仍然可以在这个函数中添加更多的初始化方式，比如归一化等等，但是我们需要注意数据的类别，防止产生负优化，比如在CIFAR-10数据集上，归一化会显著降低它的准确率。
现在我们马上就要进入最紧张刺激的神经网络环节了，但是在训练之前，我们仍然需要明确我们的神经网络格式，比如在这份代码中，我们使用的是一个两层全连接神经网络，所以我们有这个预处理函数
```
 def __init__(self, input_size, hidden_size, output_size, std=1e-4):
 self.params = {}
 self.params['W1'] = std * np.random.randn(input_size, hidden_size)
 self.params['b1'] = np.zeros(hidden_size)
 self.params['W2'] = std * np.random.randn(hidden_size, output_size)
 self.params['b2'] = np.zeros(output_size)
```
这里，我们对每一层分别定义了它的权重W和偏量b，这四个参数是我们需要训练的主要参数，并且我们注意到，他们都是根据神经元数量来定义的矩阵，那么我现在来解释一下为什么是矩阵。我们来看这个初始化函数的传入参数 input_size, hidden_size, output_size, std=1e-4，std先不用管，前面三个分别是输入的格式，第一层格式，输出格式，我们完全可以简单理解为我们需要将一个有若干个数字的集合，通过一系列的数学运算，先压缩为 hidden_size的大小，最后再压缩为 output_size的大小，而这里的 output_size就是我们需要分类的10个标签。而这里对参数的初始化使用了随机数，因为全部为0是不正确的，因为我们后续还要对其进行求偏导以及计算梯度。

初始化之后，我们就可以进行训练了，而训练的目的是迭代计算出最好的参数，也就是神经网络初始化所定义的四个参数。

 def train(self, X, y,
 learning_rate=1e-3, learning_rate_decay=0.95,
 reg=5e-6, num_iters=100,
 batch_size=200, verbose=False):
 num_train = X.shape[0]
 iterations_per_epoch = max(num_train // batch_size, 1)

 for it in range(num_iters):
 idx = np.random.choice(num_train, batch_size, replace=True)
 X_batch = X[idx]
 y_batch = y[idx]
 loss, grads = self.loss(X_batch, y=y_batch, reg=reg)

 self.params['W1'] -= learning_rate * grads['W1']
 self.params['b1'] -= learning_rate * grads['b1']
 self.params['W2'] -= learning_rate * grads['W2']
 self.params['b2'] -= learning_rate * grads['b2']

 # if verbose and it % 100 == 0:
 # print('iteration %d / %d: loss %f' % (it, num_iters, loss))
 if it % iterations_per_epoch == 0 and it != 0:
 learning_rate *= learning_rate_decay

我们来看这个训练主函数，reg是我们定义的L2正则化超参数，我们直接来看迭代训练循环，我们每一次迭代随机抽取数据进行训练，用这份数据计算出四个参数的梯度，以此来更新我们的参数，使我们的参数不断优化。在这个函数中我们还使用了两个参数，learning_rate和 learning_rate_decay，这两个参数用来不断降低模型的学习率，使参数的迭代越来越精确。

我们发现在训练迭代中使用了一个很重要的 loss函数来计算我们的参数梯度，这也是神经网络最重要的部分。
```
 def relu(self, x):
 return np.maximum(0, x)

 def relu_backward(self, dout, cache):
 dx, x = dout, cache
 dx[x <= 0] = 0
 return dx

 def loss(self, X, y=None, reg=0.0):
 W1, b1 = self.params['W1'], self.params['b1']
 W2, b2 = self.params['W2'], self.params['b2']

 Hidden_layer = self.relu(np.dot(X, W1) + b1)
 scores = np.dot(Hidden_layer, W2) + b2

 if y is None:
 return scores

 loss = np.sum(-np.log(np.exp(scores[range(len(scores)), y]) /
 np.sum(np.exp(scores), axis=1)))
 loss /= len(X)
 loss += 0.5*reg*(np.sum(W1*W1)+np.sum(W2*W2))

 grads = {}

 dscores = np.exp(scores)/np.sum(np.exp(scores), axis=1, keepdims=True)
 dscores[range(len(scores)), y] -= 1
 dscores /= len(X)
 grads['W2'] = np.dot(Hidden_layer.T, dscores) + reg*W2
 grads['b2'] = np.sum(dscores, axis=0)
 dhidden = np.dot(dscores, W2.T)
 dhidden_relu = self.relu_backward(dhidden, Hidden_layer)
 grads['W1'] = np.dot(X.T, dhidden_relu) + reg*W1
 grads['b1'] = np.sum(dhidden, axis=0)

 return loss, grads
```
这里便是我们计算所需要的函数，我们来对 loss函数逐步分析。首先传入现有参数没有什么好说的，然后便是我们的正向传播环节，我们先用现有参数计算出10个类别所对应的得分，然后我们将这10个分数放进线性分类器里进行计算，最后得到的就是我们的损失 loss。之后便是我们喜闻乐见的反向传播环节，所谓反向传播，其实就是按照线性求导法则对两层神经网络的所有参数求偏导，以此找到loss下降最快的点，才能以此更新参数。26-28行都是在对softmax线性分类器求梯度，到了29行我们发现我们在运算时对矩阵进行了转置，通俗地讲，我们明白矩阵是不服从乘法交换律的，所以如果我们想让它正确地乘，便需要给他转个方向，这样才可以进行矩阵乘法。还有一点需要注意，在32行我们对激活函数进行了求导，因为我们在前向传播的时候在第一层使用了激活函数，所以这一步也必不可少。至此，我们便可以完整地计算出参数梯度，并以此迭代训练我们的四个主要参数。

01分数规划学习笔记

Thu, 16 Nov 2023 17:48:00 +0800

起因：P1642 规划

说实话我的印象里是做过这种题的，但是当时好像理解后就跑路了，现在来复习一下。

什么是01分数规划呢?

其实就是让你跑一个01背包，但是物品有三个权值，重量都为1，然后让你求选的物品的剩下两个权值比值最大，也就是性价比。

这种东西在没有选择依赖关系的情况下看起来确实可以贪心，但是这样就没意思了，所以我们来说说有依赖关系怎么求，对于最普通的01分数规划问题来说一般都是二分答案，也就是我们要求的那个最优的性价比。

之后我们根据这个平均性价比，反推出一个物品相对于平均值的贡献，然后就可以大力用各种各样的dp求出当前的最大值了，如果大于0就说明还有优化空间，反之则没有。

要退役了，什么最优比率生成树，什么最优比率环也不打算学，就这样吧。

01BFS学习笔记

Wed, 25 Oct 2023 10:29:00 +0800

本人随机跳题到了一道看起来是最短路的题，但是本人并不想去暴力建图懒，发现如果抽象成一张图的话边权只有 $0$ 或者 $1$，于是去学了个01BFS。

什么是01BFS呢，其实这是一种最短路的优化，我们都知道BFS要用到queue来维护正确性，但是这在找边权不相等的最短路里就很难受，所以我们需要给他规定一个转移顺序。

我们把queue换成deque，如果这条边边权是1的话就放在队尾，否则放在队首，参考dij里priority_queue的证明，这其实就是找到性质手动模拟了一个优先队列，并且我们的复杂度是优秀的 $O(n)$，以为少了一个堆的log，就很优秀。

当然适用范围有点窄，只能在边权为 $0$ 和一种其他正数中使用。

参考题目：P1849 [USACO12MAR] Tractor S

#include<bits/stdc++.h>
using namespace std;
const int N=1005;
int n,sx,sy,a[N][N],t[N][N];
int stx[6]{-1,0,1,0};
int sty[6]{0,-1,0,1};
deque<pair<int,int>>q;
void BFS(){
 q.push_front(make_pair(sx,sy));
 memset(t,-1,sizeof t);
 t[sx][sy]=0;
 while(q.size()){
 int x=q.front().first;
 int y=q.front().second;
 q.pop_front();
 for(int i=0;i<4;i++){
 int tx,ty;
 tx=x+stx[i];
 ty=y+sty[i];
 if(tx<0||tx>=N) continue;
 if(ty<0||ty>=N) continue;
 if(t[tx][ty]!=-1) continue;
 if(a[tx][ty]){
 t[tx][ty]=t[x][y]+1;
 q.push_back(make_pair(tx,ty));
 }else{
 t[tx][ty]=t[x][y];
 q.push_front(make_pair(tx,ty));
 }
 }
 }
}

int main(){
 scanf("%d%d%d",&n,&sx,&sy);
 for(int i=1;i<=n;i++){
 int s1,s2;
 scanf("%d%d",&s1,&s2);
 a[s1][s2]=1;
 }
 BFS();
 printf("%d",t[0][0]);
 return 0;
}