{ "version": "https://jsonfeed.org/version/1", "title": "Yuukoの小屋", "description": "Amor che nella mente mi regiona.", "home_page_url": "https://yuuko.site", "items": [ { "id": "https://yuuko.site/2026/06/15/CS/%E8%AE%A1%E7%BD%91/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C%E6%9E%B6%E6%9E%84/", "url": "https://yuuko.site/2026/06/15/CS/%E8%AE%A1%E7%BD%91/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C%E6%9E%B6%E6%9E%84/", "title": "计算机网络架构", "date_published": "2026-06-14T16:00:00.000Z", "content_html": "

计算机网络相关概念

\n

计算机网络是由若干个计算机节点或者相关硬件节点与链接这些节点的链路组成的网状数据通路。

\n

internet和Internet是两个需要区分的名词，前者是泛指的互联网结构，而后者是基于TCP/IP协议的现代 因特网。

\n

以太网是一种使用有线连接实现局域网连接的技术形式，以太网主要通过“星型拓扑结构 + 交换机 + 网线/光纤 + 物理网卡”的方式来实现。

\n

计算机网络的分类

\n

按网络使用者划分可以分为:

\n\n

按照空间拓扑结构可以分为

\n\n

按照分布范围分类

\n\n

计算机网络的功能

\n\n

网络的信息交换方式

\n

节点间的信息交换方式分为

\n\n

电路交换

\n

电路交换是通过电话线+电话交换机形式建立节点间的稳定通信线路资源，建立后通信线路由双方独占直到结束。因此电路交换通常只使用低频、连续且大量的

\n

电路交换分为三个阶段 -- 建立连接(开启占用通信资源) -> 传输数据(持续占用通信资源) -> 释放连接(释放通信资源)

\n

电路交换面临的问题有: 建立连接的时间长、线路利用率低与灵活性差、难以实现差错控制

\n

报文交换

\n

报文交换是用户节点将传输信息(比如源地址、目的地址等控制信息)封装为报文后传输。报文通过存储转发技术，在通信双方的节点中间的节点之间进行接收、存储、转发直到最终接收的节点。

\n

假如节点A到节点B存在多个路径，每一个报文可以独立选择如何经过

\n

交换节点能对报文进行差错检验，从而实现差错控制。报文交换方式不需要独占通信线路资源，线路利用率高。但是交换节点需要缓存报文后再转发，加大了缓存开销与转发的时间开销。如果报文过长，重传的成本也相应提高。

\n

分组交换

\n

分组交换则是将报文进一步拆分为等长的数据段，每一个细分的数据段的首部包含必要的控制信息(源地址、目的地址、分组号等)，组内的数据传输可能不通过相同的路径传输。网络中的分组交换器查询分组的首部后缓存并处理转发。

\n\n

分组方式降低了报文的出错概率与重传的代价，遇到分组出错后只需要重传分组片段而不需要重传整个报文。但是每一个分组都需要额外的控制信息管理分组段。增加了控制复杂度同时降低了有效信息密度。

\n

分组可能失序、丢失或者重复，通常需要控制信息的管理。数据报服务模式的分组可能通过不同路径到达目的主机，需要在目的主机重排序，也有可能在传输过程发生丢包。虚电路不会发生失序，但是和电路交换一样有连接的建立与占用的时间与通信资源的开销。

\n

分组交换的时延通常是最小的，相比而言最灵活且最适合突发式通信。

\n

网络的性能指标

\n\n

发送时延指发送结点分组信息全部推入传输链路的耗时。满足

\n

发送时延τs=分组长度l发送速度v\\text{发送时延} \\tau_s = \\frac{\\text{分组长度} l}{\\text{发送速度} v}\n发送时延τs​=发送速度v分组长度l​

\n

传播耗时为数据在信道中的传输时间

\n

传输时延τt=信道长度s电磁波的信道传输速度c\\text{传输时延} \\tau_t = \\frac{\\text{信道长度} s}{\\text{电磁波的信道传输速度}c}\n传输时延τt​=电磁波的信道传输速度c信道长度s​

\n

处理时延为交换结点内的处理耗时

\n

排队时延为数据在路由器等设备等输入输出队列中的排队耗时

\n

关于传输信道的其他性能指标有:

\n\n

计算机网络的体系架构

\n

计算机网络分层架构

\n

OSI 模型是ISO提出的网络体系标准，称为开放系统互联参考模型(OSI)，自上而下分为

\n
应用层 -> 表示层 -> 会话层 -> 传输层 -> 网络层 -> 数据链路层 -> 物理层
\n

分层的基本原则为:

\n\n

各个层间的数据块可以分为:

\n\n

下层传入当前层的信息称为协议数据单元(PDU)， 包含SDU与PCI，当前层将PCI处理后，将SDU传递到下一层作为下一层的PDU。第nnn 层的PDU记为 n-PDU

\n

因此满足

\n

(n−1)-SDU=n-PDU=n-SDU+n-PCI(n-1)\\text{-SDU} = n\\text{-PDU} = n\\text{-SDU} + n\\text{-PCI}\n(n−1)-SDU=n-PDU=n-SDU+n-PCI

\n

协议是各层对应实体之间的通信协规则集，协议由三个部分组成

\n\n

接口是单个实体的各层之间的访问点

\n

服务是下层为相邻的上层暴露的功能调用。

\n

三者整体结构关系为

\n
             协议\nn层     实体 ------实体\n         |      接口|  服务\nn-1层   实体 ------实体
\n

根据是否连接/是否可靠/是否应答可将服务分为:

\n\n

OSI结构

\n

物理层

\n

物理层是实现最底层传输信息流的层，比如设备的接口特征、通信的编码意义和电气特征等。

\n

传输介质并不属于物理层的信息，底层信息传输不会关注传输介质的不同，因此这是属于比物理层更底层的物理介质层。

\n

数据链路层

\n

数据链路层内的数据开始存在意义，而不是物理层中透明的原始比特流。数据链路层的数据单位是 帧。

\n

在数据链路层中，计算机能实现基本的差错控制与流量控制，以及对共享信道的访问控制。

\n

数据链路层是根据MAC地址进行结点与结点间通信的

\n

网络层

\n

网络层的传输单位是数据报(一种分组方式)，主要任务是将数据报单元传输到目的主机。虚电路模式与数据报模式的数据交换都是发生在网络层的数据交换。

\n

网络层提供的功能主要是

\n\n

网络层是基于IP地址进行主机间通信的

\n

传输层

\n

传输层负责主机端口间的信息通信。

\n

由于设备通信进程通常不唯一，因此传输层需要复用与分用的功能。

\n

由于传输层是端口间的信息传输，端口对应进程的对外通信需求，因此传输层是进程内核态的最顶层交互，再向上的封装都是进程用户态的暴露。

\n

会话层

\n

会话层管理的是不同主机进程间的会话，比如会话的建立、维护与终止等功能。

\n

会话层承担着会话同步的功能，支持在连接上有序传输数据并引入检查点机制，用于实现会话恢复与断点续传。

\n

TLS/SSL 协议的握手阶段时实现在会话层的。访问 HTTPS 网站时，客户端和服务器首先要打招呼、交换证书、协商将要使用的密码套件。这个“建立安全会话、维持会话”的过程，属于会话层的功能。

\n

表示层

\n

表示层用于解决设备信息系统异构时信息不一致以及数据的加密、压缩、解密等功能

\n

最经典的场景是在Windows系统和Macos/Linux之间建立SSH时，由于不同系统之间的编码方式/换行符等差异(比如Windows使用GBK编码，Linux/Macos默认使用UTF-8/换行符差异CRLF\\r\\n与LF\\n)

\n

TLS/SSL 在表示层实现数据的加密与解密的过程，对于下层的传输层等层次接收的数据是加密后的数据帧/数据流，而不是规律可读的数据。

\n

应用层

\n

用户与网络的接口

\n

Example

\n

在一个Flask+Nginx的后端通信场景,且单设备含有多网卡的场景中

\n

Flash监听本地回环的127.0.0.1:4000的端口，后端服务体现在应用层的用户后端程序实现中；表示层体现在Flask的底层实现，如pythonjson实现相关的序列化与反序列化/ gzip实现相关的压缩；会话层的功能，比如网络上或者业务上的会话维持，通常是基于Flask底层的依赖完成的，比如WSGI的Werkzeug库用于处理TCP socket请求、flask session 用于实现后端业务面上的加密与与Cookie

\n

传输层中，本地回环和外部端口监听体现了传输层的复用特点。后端的进程可以监听若干个本地回环的端口，不同于MAC，端口并不是设备唯一确定的。

\n

比如Nginx绑定外网端口<ip>:80并外部流量反向代理到后端的127.0.0.1:4000端口。

\n

同时Flask将监听127.0.0.1:4000的流量传入进程中，体现了传输层的分用的特点。

\n

而对于设备的不同的网卡，他们在物理层与数据链路层完全不同，因为他们的通信路径、MAC地址完全不同；在网络层中，不同网卡通常分配不同的IP地址，因此网络层的信息也是独立的；在传输层中，不同网卡的外部流量可能交由同一个进程管理，因此在传输层网卡之间存在相同的部分；在用户态的相关层中，用户可以查看不同的网卡信息，但是Flask等库已经封装了不同网卡等的调用方式，用户只关心进程级的信息交互，此时不同的网卡对用户整体使用是无关的。使用有线上网和无线上网对相同的网站访问没有区别

\n

TCP/IP结构

\n", "tags": [] }, { "id": "https://yuuko.site/2026/06/13/control/%E6%BB%91%E6%A8%A1%E6%8E%A7%E5%88%B6/", "url": "https://yuuko.site/2026/06/13/control/%E6%BB%91%E6%A8%A1%E6%8E%A7%E5%88%B6/", "title": "滑模控制", "date_published": "2026-06-12T16:00:00.000Z", "content_html": "

滑模控制

\n

滑模控制是通过将相空间分块的方式实现分段非线性控制的控制方法。

\n

相图

\n

对于微分方程

\n

dxdt=f(x)\\frac{\\mathrm{d} \\mathbf{x}}{\\mathrm{d} t} = f(\\mathbf{x})\ndtdx​=f(x)

\n

且 f(x)f(\\mathbf{x})f(x) 只通过 x\\mathbf{x}x 与 ttt 相关而不直接相关，这样的微分方程称为自洽微分方程, 同时保证，在一个初值下，自洽微分方程的解是存在且唯一的

\n

微分方程的解为 $x = \\phi(t,x_0) $, 即从初值 x0x_0x0​ 出发的解。

\n

我们可以证明: 对于方程的解 ϕ(t,x0)\\phi(t,x_0)ϕ(t,x0​), ϕ(t+c,x0)\\phi(t+c,x_0)ϕ(t+c,x0​) 仍然是方程的解，即解是 ttt 无关的

\n

方程的解集

\n

D={x∈D∣x=ϕ(t,x0),t∈J}D = \\left\\{\\mathbf{x}\\in D\\big| \\mathbf{x} = \\phi(t,\\mathbf{x}_0), t\\in J\\right\\}\nD={x∈D​x=ϕ(t,x0​),t∈J}

\n

称为方程的相空间，解曲线 xi=ϕ(t,x0)\\mathbf{x}_i = \\phi(t,\\mathbf{x}_0)xi​=ϕ(t,x0​) 实际是 t∈J⊂R→x∈D⊂Rnt\\in J\\subset \\mathbb{R} \\to \\mathbf{x} \\in D\\subset \\mathbb{R}^nt∈J⊂R→x∈D⊂Rn 的一条曲线，曲线在相空间DDD 上的投影称为相轨迹

\n

\"trajectory\"

\n

二阶系统滑模控制

\n

考虑二阶系统，其闭环传递函数为

\n

Φ(s)=αs2+βs+α\\Phi(s) = \\frac{\\alpha}{s^2+\\beta s+\\alpha}\nΦ(s)=s2+βs+αα​

\n

对应的微分方程为

\n

c¨+βc˙+αc=αr\\ddot{c} + \\beta \\dot{c} + \\alpha c = \\alpha r \nc¨+βc˙+αc=αr

\n

\"sys\"

\n

eee为误差函数，定义为 e=r−ce = r-ce=r−c

\n

考虑常值输入，此时有

\n

αe=α(r−c)=−e¨−βe˙\\begin{aligned}\n\\alpha e & = \\alpha (r-c) = -\\ddot{e} - \\beta\\dot{e}\n\\end{aligned}\nαe​=α(r−c)=−e¨−βe˙​

\n

因此原系统可以化为关于误差的零输入二阶系统

\n

e¨+βe˙+αe=0\\ddot{e} + \\beta\\dot{e} +\\alpha e = 0\ne¨+βe˙+αe=0

\n

特征方程根

\n

λ1=−β+β2−4α2,λ2=−β−β2−4α2\\lambda_1 = \\frac{-\\beta + \\sqrt{\\beta^2-4\\alpha}}{2}, \\lambda_2 = \\frac{-\\beta - \\sqrt{\\beta^2-4\\alpha}}{2}\nλ1​=2−β+β2−4α​​,λ2​=2−β−β2−4α​​

\n

对于方程

\n

e¨−(λ1+λ2)e˙+λ1λ2e=0\\ddot{e} -(\\lambda_1+\\lambda_2)\\dot{e} + \\lambda_1\\lambda_2 e = 0\ne¨−(λ1​+λ2​)e˙+λ1​λ2​e=0

\n

写为

\n

[e˙e]′=[λ1+λ2λ1λ210][e˙e]\\begin{bmatrix}\n\\dot e\\\\\ne\n\\end{bmatrix}' = \n\\begin{bmatrix}\n\\lambda_1+\\lambda_2 & \\lambda_1\\lambda_2\\\\\n1&0\n\\end{bmatrix}\n\\begin{bmatrix}\n\\dot e\\\\\ne\n\\end{bmatrix}\n[e˙e​]′=[λ1​+λ2​1​λ1​λ2​0​][e˙e​]

\n

因此对于 X=[e˙e]\\displaystyle X = \\begin{bmatrix}\\dot e\\\\ e\\end{bmatrix}X=[e˙e​], 有

\n

dXdt=AX\\frac{\\mathrm{d} X}{\\mathrm{d} t} = A X\ndtdX​=AX

\n

特征值为 λ1,λ2\\lambda_1,\\lambda_2λ1​,λ2​

\n

这个方程的相曲线即为当前零输入误差二阶系统的相曲线。

\n

由于

\n

de2=2ee˙\\mathrm{d} e^{2} = 2e\\dot e \nde2=2ee˙

\n

因此当e˙,e\\dot{e}, ee˙,e图的相曲线收敛到0时，表示 ∥e∥→0\\|e\\| \\to 0∥e∥→0 且不在变化，说明此时系统稳定。同时，当 ee˙<0e\\dot{e} <0ee˙<0 时， 系统的误差在下降。

\n

去掉中间的负反馈通路 β\\betaβ ,将二阶系统改为前向通路中存在一个-1的开关

\n\n

Φ(s)=αs2+α\\Phi(s) = \\frac{\\alpha}{s^2+\\alpha}\nΦ(s)=s2+αα​

\n\n

Φ(s)=−αs2−α\\Phi(s) = -\\frac{\\alpha}{s^2-\\alpha}\nΦ(s)=−s2−αα​

\n

\"sliding\"

\n

这两种状态单独存在的时候，两个系统都无法渐进稳定，但是通过某种切换策略，在两个系统之间有限次转换，就可以实现相轨迹趋向于原点。

\n

其中发散模量

\n

A=e˙0+αe02λ=s02αA = \\frac{\\dot e_0 +\\sqrt{\\alpha} e_0}{2\\lambda} = \\frac{s_0}{2\\sqrt \\alpha}\nA=2λe˙0​+α​e0​​=2α​s0​​

\n

Switch 2的稳定特征线为 $ \\dot e+ \\sqrt{\\alpha} e = 0$, 此时方程通解的发散模项为0

\n

当s>0s>0s>0 是向正向发散，当s<0s<0s<0的时候会将幅值先向0调整后再负向发散。因此，当 e>0,s<0e> 0,s<0e>0,s<0 或者 $e<0, s>0 $ 时， 发散项的贡献都是将误差向靠近0的收敛。

\n

当es>0es>0es>0 时，切换为Switch 1, 此时特征根为两个共轭纯虚根，因此对于轨迹的贡献为旋转贡献。

\n

因此以e(e˙+αe)=0e(\\dot e +\\sqrt \\alpha e ) = 0e(e˙+α​e)=0 作为滑模面进行滑模控制

\n

通常使用开关函数进行开关的切换

\n

sgn(s)={1s≥0−1s<0\\mathrm{sgn}(s) =\\begin{dcases}\n1& s\\geq 0\\\\\n-1 & s<0\n\\end{dcases} \nsgn(s)={1−1​s≥0s<0​

\n

实际使用时，会设计一个饱和边界层γ\\gammaγ , 使用连续的函数替换开关函数，比如

\n

Sat(x)={1x≥1xx∈(−1,1)−1x≤−1\\mathrm{Sat}\\left(x\\right) = \\begin{dcases}\n1 & x\\geq 1\\\\\nx & x\\in (-1,1)\\\\\n-1 & x\\leq -1\n\\end{dcases}\nSat(x)=⎩⎨⎧​1x−1​x≥1x∈(−1,1)x≤−1​

\n

或者

\n

tanh⁡(x)=ex−e−xex+e−x\\tanh (x) = \\frac{e^{x}-e^{-x}}{e^{x}+e^{-x}}\ntanh(x)=ex+e−xex−e−x​

\n

用于实现跳变的连续化与光滑化。使用 Sat(sγ)\\mathrm{Sat}\\left(\\dfrac{s}{\\gamma}\\right)Sat(γs​) 或者 tanh⁡(sγ)\\tanh\\left(\\dfrac{s}{\\gamma}\\right)tanh(γs​) 进行跳变，能将变化区域大致限制在饱和区 [−γ,γ][-\\gamma,\\gamma][−γ,γ] 中

\n

对于 nnn 阶高阶系统，滑模面是子空间内的超曲面

\n

s=s(x1,⋯ ,xm)s = s(x_1,\\cdots, x_m)\ns=s(x1​,⋯,xm​)

\n

需要更加复杂的切换逻辑

\n", "tags": [] }, { "id": "https://yuuko.site/2026/06/12/CS/LLM/CS336/tokenizer/", "url": "https://yuuko.site/2026/06/12/CS/LLM/CS336/tokenizer/", "title": "BPE-tokenizer", "date_published": "2026-06-11T16:00:00.000Z", "content_html": "

BPE - Tokenizer

\n

BPE的基本观念

\n

BPE Tokenizer 是将单个单词拆分为若干个子块进行tokenizer的方式，会训练一个Tokenizer Merge 表用于规定如何进行单个字母合并为子块，并训练一个token string子块与token id空间的映射表vocab以实现将字符转换为int类型的token id

\n

BPE 需要考虑一些Special token，它们是不可分token string单元，每一个作为整体映射到token id. 比如 "<|endoftext|>"

\n

BPE Merge 表的训练

\n

BPE 基于字符合并而贪心算法进行vocab和 Merge表

\n

假设Tokenizer 训练集为

\n
We</w> *20\nare</w> *12\nthe</w> *3\nworld</w> *9
\n

拆分为字频

\n
W e </W> *22\na r e </w> *12\nt h e </w> *3\nw o r l d </w> *9
\n
</w> *44\ne    *35\nw    *29\nr    *21\na    *12\no    * 9\nl    * 9\nd    * 9\nt    * 3\nh    * 3
\n

Top-2 字频的字为 w 和 e， 将这两个字进行有序的合并

\n
we </w> *22\na r e </w> *12\nt h e </w> *3\nw o r l d </w> *9
\n

更新字频表

\n
</w>  *44\nwe   *22\nr    *21\na    *12\no    * 9\nl    * 9\nd    * 9\ne    * 6\nt    * 3\nh    * 3
\n

此时可合并的Top-2 字频为r 与 a

\n
we </w> *22\nar e </w> *12\nt h e </w> *3\nw o r l d </w> *9
\n

更新词频表

\n
</w>  *44\nwe   *22\nar   *12\nr    * 9\no    * 9\nl    * 9\nd    * 9\ne    * 6\nt    * 3\nh    * 3
\n

以此方式迭代直到达到设定的合并上限

\n

正则表达式库re的使用

\n

遇到的问题

\n", "tags": [] }, { "id": "https://yuuko.site/2026/06/11/CS/%E8%AE%A1%E7%BB%84/%E7%A3%81%E7%9B%98/", "url": "https://yuuko.site/2026/06/11/CS/%E8%AE%A1%E7%BB%84/%E7%A3%81%E7%9B%98/", "title": "磁盘与SSD", "date_published": "2026-06-10T16:00:00.000Z", "content_html": "

磁盘存储器

\n

磁盘存储器由磁盘驱动器、磁盘控制器与盘片三个部分构成

\n

磁盘的存储单元，自上而下分为

\n\n

存储区域内存在相关信息

\n\n

最早的磁盘是IBM推出的温彻斯特磁盘(温盘)

\n

磁记录原理

\n

磁头和磁性记录相对移动时，电磁转换以实现数据的读写操作

\n

磁盘的管理

\n

磁盘的初始化

\n

磁盘的初始化分为低级格式化与高级格式化

\n

低级格式化将磁盘分为若干个扇区，扇区分为头部、尾部和数据部分，并使用CRC字段校验。低级格式化只是物理片段的划分，所以也叫物理格式化。

\n

高级格式化则是在分区上建立文件系统，初始化根目录等操作。因此也称为逻辑格式化。

\n

磁盘的容量也分为非格式化容量与格式化容量。非格式化容量是磁盘的理论存储上限，磁盘的磁记录表面可用的磁化单元总量；格式化容量是格式化后的实际可用存储容量。因此 非格式化容量 > 格式化容量

\n

磁盘的地址编码方式

\n
|柱面(磁道)号|盘面(磁头)号|扇区号|
\n

磁盘阵列

\n

RAID是将多个物理磁盘统一组合为一个逻辑磁盘的方式，数据在多个物理盘间交叉分割存储并并行访问，以获得更好的存储性能与安全性。

\n

磁盘的文件系统

\n

文件管理

\n

将磁盘进行分区，每一个分区的起始位置和大小记录在MBR中，而后是引导块进行OS的文件块加载进行自举。

\n

BIOS存储在ROM中，进行在硬件自检后加载引导块以启动操作系统。

\n

磁盘的调度算法

\n

磁盘读写时间由三个部分构成

\n\n

寻道时间由跨越磁道时间mmm和磁头臂启动时间sss构成

\n

Ts=mn+sT_s = mn+s\nTs​=mn+s

\n

平均寻道时间是最大寻道时间的一半

\n

旋转延迟时间为目标扇区旋转到磁头下的耗时，假设盘面转速为rrr,平均旋转延迟时间为

\n

Tr=12rT_r = \\frac{1}{2r}\nTr​=2r1​

\n

数据传输时间为读写 bbb 字节所需的时间。如果每条磁道存储NNN字节，则平均数据传输时间为

\n

Tt=brNT_t= \\frac{b}{rN}\nTt​=rNb​

\n

总平均存取时间为

\n

Ta=Ts+Tr+TtT_a = T_s+ T_r+T_t\nTa​=Ts​+Tr​+Tt​

\n

磁盘的存取时间中，寻道时间是最主要的时间开销部分，因此主要目标是降低寻道时间的开销。

\n

响应时间还需要考虑排队延迟和控制器时间的开销

\n

磁盘调度算法

\n

FCFS算法

\n

最简单且最公平的算法，但是大量进程竞争磁盘时，磁头会频繁长距离移动导致效率低下

\n

最短寻道时间优先(SSTF)

\n

基于贪心算法，每一次都寻找最短时间开销的磁道请求。

\n

SSTF可能在一个磁道区域来回移动导致较远的磁道出现"饥饿"现象

\n

SCAN算法

\n

根据当前的移动方向向最远处磁道移动，到达最远处后反向到达最内侧磁道。

\n

SCAN算法也称为电梯算法。它对最新扫描过的扇区不公平，需要更大的耗时才会返回该区域，因此局部性不如FCFS和SSTF。

\n

C-SCAN算法

\n

C-SCAN算法在到达磁盘最外侧边缘时，直接返回最内侧，返回过程不执行服务。当磁头从最内侧移动到最外侧时才进行服务。

\n

LOOK/C-LOOK 调度

\n

基于SCAN/C-SCAN改良，不到达磁道物理边缘，而只到达当前方向上的最远请求位置后就反向。

\n

NStepSCAN & FSCAN 算法

\n

由于SSTF/SCAN/C-SCAN 算法会出现磁道黏着现象。假设有进程始终在访问某个磁道，那么磁头就只会在当前磁道工作，导致其他磁道进程饥饿

\n

NStepSCAN将任务队列划分为若干长度为N的子队列，队列间FCFS，队列内SCAN。新请求放入新的队列当中，不放入正在执行的队列中。

\n

FSCAN将NStepSCAN简化为 N=2N=2N=2 的形式，即维护当前服务队列和新请求的队列两个部分，将当前扫描过程中新增的请求全放入新请求队列中，降低了实现开销。

\n

减少延迟时间的算法

\n\n

提高磁盘IO速度的方法

\n\n

SSD

\n

SSD 是基于Flash技术的存储设备，是E^2PROM的变体。

\n

SSD的读写操作以页为单位进行，擦除操作以块单位进行。

\n

SSD 的随机写速度较慢且擦写寿命较低，擦除的用时也比较长。因此提出了磨损均衡算法：

\n\n

静态磨损均衡的实际性能好于动态磨损均衡

\n", "tags": [] }, { "id": "https://yuuko.site/2026/06/09/CS/OS/IO/", "url": "https://yuuko.site/2026/06/09/CS/OS/IO/", "title": "IO管理", "date_published": "2026-06-08T16:00:00.000Z", "content_html": "

IO管理

\n

IO 设备

\n

根据信息交换可以分为

\n\n

打印机需要逐字符对照进行打印

\n

根据传输速率可以分为

\n\n

按共享属性分类为

\n\n

IO接口

\n

IO 接口(设备控制器)是CPU与IO 设备之间的桥梁。 设备管理器与CPU通过三根逻辑区分的总线相连，分别为数据总线、地址总线、控制总线。

\n

总线端维护了数据寄存器与控制/状态寄存器用于解决总线与IO速度不同步的信息缓冲问题

\n

在现代总线结构，比如显卡的PCIe结构中，都是使用高速串行总线结构，实际为单根高速总线的串行结构，在物理结构上串行，在逻辑结构上分段。

\n

IO接口可以有一个或者多个面向设备的接口，每一个接口可以传输数据、控制、状态信号。

\n

IO接口中存在IO逻辑电路，用于实现对于设备的控制.CPU启动设备后，向设备控制器发送相应命令与地址，但是传输给设备的信息需要经过IO逻辑进行解析并控制发送。

\n

控制设备器的主要作用

\n\n

IO 接口的类型

\n

传统意义下IO接口并不是一个大型控制器的集成，而是若干个IO接口功能模块的实现，IO接口根据不同的类型有不同的分类。

\n

根据数据传输的方式分类为并行接口与串行接口

\n

根据主机访问方式分为 程序查询接口、中断接口与DMA接口

\n

根据可编程性分为 可编程接口与不可编程接口， 在可编程接口中需要一套执行指令的PC/相关寄存器，甚至单个IO接口就是一个SoC，具有独立指令执行的功能的设备。

\n

根据设备类型不同分为 块设备接口、字符设备接口与网络设备接口

\n

IO 接口的编址

\n

可以分为独立编址方式与统一编址方式。

\n

独立编址方式中的IO接口的地址空间与主存相对独立，二者不属于相同的地址空间，因此主存的地址值能和主存的某个地址相同。

\n

统一编址方式则是将部分主存地址分配给IO设备，IO设备可以获得较大的编址空间，且可以使用统一的虚拟内存管理方式管理。缺点是减少了内存物理地址可用量。

\n

IO控制方式

\n

分为程序直接控制(程序查询方式)、中断驱动方式与DMA方式。

\n

程序直接控制

\n

程序直接控制方式中，IO设备与主机的数据交换完全由CPU控制，通过程序的执行实现。

\n

实现流程

\n\n

读取外设状态寄存器的查询方式可以分为

\n\n

程序中断方式

\n

通过中断技术让IO独占总线与CPU一段时间以实现信息与至指令的传输；当IO工作的时候将IO进程中断并实现IO设备和CPU中其他进程的并行工作，以节省CPU的资源。

\n

中断源是能够向CPU发送中断请求的设备或者事件，中断系统为每个中断源设置了中断请求标记触发器，置1时表示中断源请求中断。

\n

通过INTR的信号线发出的是可屏蔽中断。通过NMI的信号线发送的是不可屏蔽中断。不可屏蔽中断优先级高于可屏蔽中断，且可屏蔽中断在关中断状态不能中断。

\n

中断响应的过程可分为

\n\n

中断隐指令(关中断-保存断点-中断服务寻址)是中断前的准备指令，将前一进程状态保存，并加载中断服务程序以便实现中断。

\n

中断服务程序的实现过程分为中断过程和恢复过程，中断过程(开中断-执行中断服务程序-关中断)进行中断，恢复过程(恢复现场和PSW-开中断与中断返回)将中断现场恢复并开中断

\n

多重中断与中断屏蔽

\n

当系统存在多中断源竞争的时候需要使用优先级机制匹配中断，只有在开中断阶段的时候可屏蔽中断才能参与多重中断的竞争。

\n

多重中断是指多个中断源发生时，低优先级中断过程被高等级中断抢占并优先中断的过程。通过栈结构管理相应多重中断的断点，因为优先级执行机制是FILO的。

\n

中断处理优先级是多重中断的实际处理顺序，可以通过动态屏蔽技术动态调整。分为处理优先级与响应优先级，当中断系统不使用动态屏蔽技术的时候处理优先级等于响应优先级。

\n

中断请求寄存器维护每一个中断源的中断请求，中断屏蔽字寄存器维护进程的处理优先级。中断请求经由请求寄存器发送，在屏蔽字寄存器和处理优先级电路的运算下输出在当前中断请求状态下的处理优先级，再通过中断判优电路处理后输出真正的执行中断的响应优先级。

\n

逻辑上的中断实现需要维护一个 n×nn\\times nn×n 的中断屏蔽字表，比如

\n

[1111010001100111]\\begin{bmatrix}\n1&1&1&1\\\\\n0&1&0&0\\\\\n0&1&1&0\\\\\n0&1&1&1\n\\end{bmatrix}\n​1000​1111​1011​1001​​

\n

表示A>D>C>BA>D>C>BA>D>C>B，这是静态的中断响应优先级表

\n

但是基于当前中断请求状态的动态执行是通过vector+ 中断请求寄存器更新实现的。

\n

比如在初始请求寄存器为[A,B,C,D]=[0,1,1,1][A,B,C,D] = [0,1,1,1][A,B,C,D]=[0,1,1,1]时

\n\n

DMA 方式

\n

DMA 在IO接口和内存之间建立轮直接的数据通路，以提高CPU资源利用率，实现数据准准备阶段传输过程中的CPU任务与IO设备的并行。

\n
DMA控制器组成
\n\n

DMA控制器需要竞争总线的能力，且对于总线/CPU的优先级满足

\n
DMA > 不可屏蔽中断 > 可屏蔽中断
\n
DMA 传送方式
\n

DMA 与 CPU 共享主存的方式可分为

\n\n
DMA传送过程
\n

DMA传送需要CPU进行预处理，数据传送与后处理三个过程。

\n\n

IO 软件

\n

IO软件是运行在CPU侧进行IO设备与IO接口管理的软件系统，向上与文件系统、用户进程、虚拟存储器等系统交互，向下与底层IO设备系统交互。

\n

比如NVIDIA的驱动程序，面向下层显卡的实际计算管理，面向上层操作系统与用户暴露API，使用户能通过这些API进行显卡计算能力的使用，比如CUDA/OpenGL等计算

\n

IO 软件根据 用户侧 -- 硬件侧的自下而上的软件分类可分为

\n
用户 - 用户层软件 - 设备独立性软件 - 设备驱动软件 - 中断处理软件 - 硬件
\n

中断处理软件

\n

用于管理IO设备结束等情况下的中断管理，实现最基本的CPU/总线与IO设备的通信层任务

\n

操作系统对于中断处理软件本身也存在一层管理，包括三个环节

\n\n

设备驱动程序

\n

面向不同种类设备的专用管理软件，比如打印机的打印机驱动，鼠标设备的驱动，NVIDIA显卡的显卡驱动等。不同设备向主机暴露的API不同，访问方式不同，设备驱动程序正是提供这些API的软件层。

\n

类比VFS的统一管理多协议磁盘的形式，设备驱动程序类似于磁盘文件系统NTFS/ext4。

\n

设备独立层软件

\n

操作系统将设备驱动程序进行统一管理，比如网络的统一化接口Socket层，进行用户层网络调用的编程不需要考虑通过有线还是通过无线进行网络访问，而直接通过操作系统暴露的Socket获得网络资源。

\n

设备独立层软件引入物理设备与逻辑设备的概念，将实际用户层的访问与物理设备相解耦。比如在Unix中访问网卡信息，通常获得的不是真实的网卡名，而是映射后的网卡号以及相关信息

\n
asuna@AsunadeMacBook-Air ~ % ifconfig\nlo0: ...\ngif0: ...\nstf0: ...\nanpi0: ...\nanpi1: ...\nen3: ...\nen4: ...\nen1: ...\nen2: ...\nap1: ...\nen0: ...\nutun0: ...\nawdl0: ...\nllw0: ...\nutun1:...\nutun2: ...\nutun3: ...
\n

其中en*是映射真实物理网卡的逻辑网卡接口
\nlo0是本地回环的网络接口，纯粹软件虚拟实现且指向127.0.0.1
\nanpi*是Apple Silicon 的内部协议与通信接口，用于支撑内部系统服务的部分通信，并将这样的总线通信权限通过anpi*暴露给用户。

\n

用户层软件

\n

用户层软件就是整体实现与用户交互的软件接口，通过调用用户层的IO库函数与硬件进行交互。

\n

应用程序IO接口

\n

应用程序IO接口是OS面向用户侧提供的管理与访问IO设备的架构与编程规范。

\n

OS将物理设备抽象为块设备、字符设备、网络设备，网络设备虽然速度匹配，但是网络通信使用的是不可随机访问的数据包而不是数据块，因此不算块设备的范畴。

\n\n

阻塞IO与非阻塞IO

\n

IO接口面向不同的设备有两种执行模式: 阻塞与非阻塞，

\n

阻塞IO能在进程发起IO请求但是资源未满足时发生阻塞，并移动到相应等待队列。

\n

非阻塞IO发生时，进程会轮询资源就绪情况，且进程能同时执行其他的任务而不受IO请求的影响。

\n

设备独立性软件

\n

设备独立性软件和VFS相似，在设备驱动程序层之上，实现不同设备等公共操作，并暴露统一且抽象化的API。具体功能有

\n\n

高速缓存与缓冲区

\n

磁盘高速缓存(Disk cache)基于内存实现，利用内存的存储空间暂存磁盘读取的盘块信息以实现加快磁盘IO速度的效果。在内存实现方式有两种

\n\n

缓冲区

\n

IO设备大部分情况下IO速度远远慢于CPU的速度(如打印机)，也可能远快于CPU(显卡)

\n

缓冲区的实现方式有

\n\n

缓冲区总是单个时刻可读/可写的，所以其能实现的作用是在CPU处理时间内作为数据蓄水池

\n

单缓冲

\n

在缓冲区结构中，单次IO时间分为三个部分

\n\n

在单个周期内，当MiM_iMi​结束，就能执行Ti+1T_{i+1}Ti+1​.如果Ci>Ti+1C_{i}> T_{i+1}Ci​>Ti+1​ ，即CPU处理时间长于IO写时间，则缓存区写等待CPU执行；反之CPU写等缓存区写。通常情况下都是 Ci<Ti+1C_{i}<T_{i+1}Ci​<Ti+1​, 因此单轮耗时为

\n

Ts=max⁡(C,T)+M\\mathcal{T}_s = \\max(C,T)+M\nTs​=max(C,T)+M

\n

对于NNN轮IO写入的作业，总耗时为

\n

Ttotal=(N−1)(max⁡(C,T)+M)+(T+C+M)\\mathcal{T}_{total} = (N-1)(\\max(C,T)+M)+(T+C+M)\nTtotal​=(N−1)(max(C,T)+M)+(T+C+M)

\n

最后一轮没有CCC与TTT在时间轴上的cover，因此都需要计算

\n

双缓冲

\n

双缓冲是可切换的两个缓冲区的结构。在缓存区1写的时候，缓存区2也能向CPU传输信息

\n

如果IO写时间 TTT > 从缓冲区传入CPU的总时间 M+CM+CM+C, 则缓冲区2空闲等待缓冲区1写，反之需要缓冲区1满等待缓冲区2执行。因此单轮执行时间为

\n

Ts=max⁡(T,M+C)\\mathcal{T}_s = \\max(T,M+C)\nTs​=max(T,M+C)

\n

N轮的总执行时间为

\n

Ttotal=(N−1)max⁡(T,M+C)+(T+M+C)\\mathcal{T}_{total} = (N-1)\\max(T,M+C) +(T+M+C)\nTtotal​=(N−1)max(T,M+C)+(T+M+C)

\n

双缓冲能实现全双工通信，双向传输信息，每一台设备设置发送缓冲区与接收缓冲区

\n

循环缓冲

\n

循环缓冲区的实现逻辑与循环链表类似，通过环形空间和in/out两个指针指向当前写入的缓冲区与传入CPU的缓冲区。

\n

如果in指针追上out指针则为CPU速度慢于IO写速度；反之则为IO写速度慢于CPU速度

\n

缓冲池

\n

缓冲池是一套包括管理数据结构和操作函数的，能管理多个缓冲区的软件机制，能支持多进程共享。

\n

缓冲池按四种方式进行工作

\n\n

设备分配与回收

\n

设备独立性软件维护了一张系统设备表(SDT)，包含所有物理设备与相应的全局索引。每一个表项对应一个设备，包含设备类型、标识符等用于检索设备的信息。

\n

每一个物理设备私有一个设备控制表(DCT), 管理设备的各项具体属性，比如设备类型、设备标识符、设备状态、指向设备器控制表的指针、重复执行次数与时间和设备的队首指针等。

\n

**设备器控制表(COCT)用于标记设备器的状态信息，存在指向通道控制表(CHCT)**的指针

\n

通道控制表(CHCT) 标记每一个通道的状态信息，以及通道相关的所有的控制器的信息。

\n

通道是内存和IO设备的通信通道，是一个协处理器级别的IO管理设备，用于实现更加复杂化，可编程的，类似于DMA的IO设备管理。

\n

根据访问顺序自上而下的排列为

\n
SDT -> DCT -> COCT -> CHCT
\n

设备的分配的顺序为

\n\n

设备的分配算法会考虑是否死锁，

\n\n

死锁竞争的讨论见 进程的同步与互斥 与 死锁

\n

逻辑设备与物理设备的映射

\n

设备的逻辑化需要建立逻辑设备和物理设备之间的映射，对应的映射表为逻辑设备表(LUT)

\n

逻辑设备表可以为整个系统维护一个LUT表或者为单个用户维护LUT表，前者适用于单用户系统，后者适用于多用户系统

\n

SPOOLing技术

\n

SPOOLing技术用于缓和高速CPU和低速IO之间的速度矛盾。其核心是将高速磁盘作为缓冲进行相应信息的临时存储，通过软件模拟脱机IO的过程。

\n

脱机IO的本质是将不同的作业拿到外围机进行并行IO作业，一方面解放主计算机的CPU，一方面可以保证IO作业的连续性。

\n

通过SPOOLing技术能通过多道程序和磁盘缓冲空间代替IO的外围机，从而将一台物理独占设备仿真为多个逻辑设备。具体场景为多用户共享的打印中心。

\n

SPOOLing技术的构成结构有

\n\n

磁盘

\n

磁盘与SSD

\n", "tags": [] }, { "id": "https://yuuko.site/2026/06/07/CS/LLM/position_encoding/", "url": "https://yuuko.site/2026/06/07/CS/LLM/position_encoding/", "title": "Position Encoding", "date_published": "2026-06-06T16:00:00.000Z", "content_html": "

Position Encoding

\n

Attention Is All You Need 中提出了 Sinusoidal Position Encoding

\n

PE(pos,2i)=sin⁡(posf2i/dmod)PE(pos,2i+1)=cos⁡(posf2i/dmod)\\begin{aligned}\n\\mathrm{PE}(pos,2i) &= \\sin \\left(\\frac{pos}{f^{2i/d_{mod}}}\\right)\\\\\n\\mathrm{PE}(pos,2i+1)& = \\cos \\left(\\frac{pos}{f^{2i/d_{mod}}}\\right)\n\\end{aligned}\nPE(pos,2i)PE(pos,2i+1)​=sin(f2i/dmod​pos​)=cos(f2i/dmod​pos​)​

\n

对于token vector

\n

pos=pos = \npos=

\n", "tags": [ "LLM", "encoding" ] }, { "id": "https://yuuko.site/2026/06/07/CS/LLM/CS336/assignment1/", "url": "https://yuuko.site/2026/06/07/CS/LLM/CS336/assignment1/", "title": "Assignment1 -- Building a Transformer LM", "date_published": "2026-06-06T16:00:00.000Z", "content_html": "

Assignment1 -- Building a Transformer LM

\n

本作业从最基本的全连接层出发，进行一个简单的Transformer LM 的搭建

\n

torch的一些API的用法

\n

矩阵转置与对换

\n

使用<Tensor>.T可以实现矩阵的转置，同样可以使用更加泛用的<Tensor>.transpose(-2,-1)进行维度对换

\n

<Tensor>.transpose(i,j)相当于第 iii 维与第 $j $维进行对换

\n

核心函数的实现

\n

Linear

\n

简单的线性层的实现，相当于实现了一个张量乘法。

\n

在torch中实现乘法的方式:torch.matmul或者直接@。 在考虑张量的乘法的时候需要考虑乘法的维度对应问题

\n
def run_linear(\n    d_in: int,\n    d_out: int,\n    weights: Float[Tensor, \" d_out d_in\"],\n    in_features: Float[Tensor, \" ... d_in\"],\n) -> Float[Tensor, \" ... d_out\"]:\n    return in_features @ weights.T
\n

Embedding

\n

嵌入映射的函数的实现。输入的Token经过Tokenizer转换为token_ids后，通过embedding形成token的特征向量。具体的实现为查表

\n
def run_embedding(\n    vocab_size: int,\n    d_model: int,\n    weights: Float[Tensor, \" vocab_size d_model\"],\n    token_ids: Int[Tensor, \" ...\"],\n) -> Float[Tensor, \" ... d_model\"]:\n    return weights[token_ids]
\n

torch.Tensor支持python数组的操作方式，因此可以直接通过数组读token_ids的方式输出Tensor

\n

SwiGLU

\n

实现SwiGLU激活函数。同样是注意张量乘法维度的问题。SwiGLU的数学定义满足

\n

SwiGLU(x,W1,W2,W3)=W3(SiLU(W1x)⊙W2x)\\mathrm{SwiGLU}(x,W_1,W_2,W_3) = W_3(\\mathrm{SiLU}(W_1x)\\odot W_2x)\nSwiGLU(x,W1​,W2​,W3​)=W3​(SiLU(W1​x)⊙W2​x)

\n

其中SiLU和Sigmoid函数为

\n

SiLU=xσ(x)=x1+e−x\\mathrm{SiLU} = x\\sigma(x) = \\frac{x}{1+e^{-x}}\nSiLU=xσ(x)=1+e−xx​

\n
def run_swiglu(\n    d_model: int,\n    d_ff: int,\n    w1_weight: Float[Tensor, \" d_ff d_model\"],\n    w2_weight: Float[Tensor, \" d_model d_ff\"],\n    w3_weight: Float[Tensor, \" d_ff d_model\"],\n    in_features: Float[Tensor, \" ... d_model\"],\n) -> Float[Tensor, \" ... d_model\"]:\n    def run_silu(in_features):\n        return in_features / (1+ torch.exp( - in_features))\n    tensor_1 = in_features @ w1_weight.T   \n    tensor_2 = in_features @ w3_weight.T   \n    return (run_silu(tensor_1)* tensor_2) @ w2_weight.T
\n

计算中实现⊙\\odot⊙ ，即Hadamard积，直接使用A*B

\n

Softmax

\n

Softmax需要根据dim进行Tensor的切分，作为vector进行计算后再合并

\n

为防止最大值过大导致计算指数爆炸，通常在计算时将最大值减去

\n

Softmax(x)=(exi∑exj)i=(exi−xmax∑exj−xmax)i=Softmax(x−xmax)\\begin{aligned}\n\\mathrm{Softmax}(x)& = \\left(\\frac{e^{x_i}}{\\sum e^{x_j}}\\right)_i\\\\\n&=\\left(\\frac{e^{x_i-x_{max}}}{\\sum e^{x_j - x_{max}}}\\right)_i\\\\\n&=\\mathrm{Softmax}(x-x_{max})\n\\end{aligned}\nSoftmax(x)​=(∑exj​exi​​)i​=(∑exj​−xmax​exi​−xmax​​)i​=Softmax(x−xmax​)​

\n
def run_softmax(in_features: Float[Tensor, \" ...\"], dim: int) -> Float[Tensor, \" ...\"]:\n    max_val = torch.max(in_features,dim,keepdim=True).values\n    sum_val = torch.sum(torch.exp(in_feature - torch.max),dim,keepdim=True)\n    return torch.exp(in_feature - max_val) / sum_val
\n

keepdim 保证对应维度为1的axis不被压缩，仍然保留该维度。
\ntorch.exp实现了Tensor逐元素的指数运算

\n

Dot Self-Attention with Scaling

\n

Attention(Q,K,V)=Softmax(QKTdk)⋅V\\mathrm{Attention}(Q,K,V) = \\mathrm{Softmax}\\left(\\frac{QK^T}{\\sqrt{d_k}}\\right)\\cdot V\nAttention(Q,K,V)=Softmax(dk​​QKT​)⋅V

\n

在Attention的基础上，需要考虑Q,K 的masking

\n
def run_scaled_dot_product_attention(\n    Q: Float[Tensor, \" ... queries d_k\"],\n    K: Float[Tensor, \" ... keys d_k\"],\n    V: Float[Tensor, \" ... keys d_v\"],\n    mask: Bool[Tensor, \" ... queries keys\"] | None = None,\n) -> Float[Tensor, \" ... queries d_v\"]:\n    mul = Q @ K.transpose(-2,-1) / torch.sqrt(torch.tensor(K.shape[-1]), device = K.device, dtype = K.dtype)\n    if (mask is None):\n        mask_mul = mul\n    else:\n        mask_mul = torch.mask_fill(mask,-torch.inf)\n    return torch.softmax(mask_mul, dim = -1) @ V
\n

需要注意的是，torch.sqrt只能面向Tensor进行计算，所以需要将python int 的 d_k转换为Tensor后再进行开根

\n

mask 是一个Bool类型的Tensor，用于控制能输入Attention被“注意”的部分

\n

mask(i,j)={−∞ai,j is masked0ai,j isn’t masked\\text{mask}(i,j) = \\begin{dcases}\n-\\infty &a_{i,j}\\,\\text{is masked}\\\\\n0 &a_{i,j}\\,\\text{isn't masked}\n\\end{dcases}\nmask(i,j)={−∞0​ai,j​is maskedai,j​isn’t masked​

\n

mask矩阵和scaling QK product 输出的矩阵相加

\n

某一个项Masked后，经过Softmax就会变成e−∞=0e^{-\\infty} = 0e−∞=0, 反之保留原本的结果

\n

MultiHead-Attention

\n

多头注意力需要将输入的QKV矩阵的隐藏层平均分割为num_heads个，每一个Head分为d_k = d_model / num_heads

\n

在初始设置通道数的时候，总保证通道数是整除隐藏层维度的，因此单个输出头的隐藏层维度总是整数

\n

将不同输出头的Attention结果Concat，并最后经过output tensor

\n
def run_multihead_self_attention(\n    d_model: int,\n    num_heads: int,\n    q_proj_weight: Float[Tensor, \" d_model d_model\"],\n    k_proj_weight: Float[Tensor, \" d_model d_model\"],\n    v_proj_weight: Float[Tensor, \" d_model d_model\"],\n    o_proj_weight: Float[Tensor, \" d_model d_model\"],\n    in_features: Float[Tensor, \" ... sequence_length d_model\"],\n) -> Float[Tensor, \" ... sequence_length d_model\"]:\n    d_k = d_model // num_heads\n    Q = (in_features @ q_proj_weight).reshape(...,num_heads,d_k).transpose(-2, -3) \n    K = (in_features @ k_proj_weight).reshape(...,num_heads,d_k).transpose(-2, -3)\n    V = (in_features @ v_proj_weight).reshape(...,num_heads,d_k).transpose(-2, -3)\n\n    attn_output = run_scaled_dot_product_attention(Q, K, V)\n    attn_output = attn_output.transpose(-2, -3).reshape(*in_features.shape[:-1], d_model)\n    return attn_output @ o_proj_weight.T
\n

Cross-Entropy

\n

对于输入为logits ，Target 为One-Hot 的标记Tensor, Cross-Entropy 的实现为

\n
def run_cross_entropy(\n    inputs: Float[Tensor, \" batch_size vocab_size\"], targets: Int[Tensor, \" batch_size\"]\n) -> Float[Tensor, \"\"]:\n    inputs_ = run_softmax(inputs,dim=-1)\n    target_tensor = inputs_[torch.arange(inputs.shape[0]),targets]\n    return -torch.mean(torch.log(target_tensor))
\n

即表示为

\n

CE(x)=−1B∑log⁡Softmax(xi)\\mathrm{CE}(x) = -\\frac{1}{\\mathcal{B}}\\sum \\log \\mathrm{Softmax}(x_i)\nCE(x)=−B1​∑logSoftmax(xi​)

\n

RoPE

\n

RoPE旋转编码器 Position Encoding

\n
def run_rope(\n    d_k: int,\n    theta: float,\n    max_seq_len: int,\n    in_query_or_key: Float[Tensor, \" ... sequence_length d_k\"],\n    token_positions: Int[Tensor, \" ... sequence_length\"],\n) -> Float[Tensor, \" ... sequence_length d_k\"]:\n    x = in_query_or_key\n    dim_idx = torch.arange(0, d_k, 2, device = x.device, dtype = x.dtype)\n    feq = 1.0 / (theta ** (dim_idx / d_k))\n    angle = token_positions.to(x.dtype).unsqueeze(-1) * feq\n\n    cos_ = torch.cos(angle)\n    sin_ = torch.sin(angle)\n    x_even = x[...,0::2]\n    x_odd = x[...,1::2]\n    out_even = x_even * cos_ - x_odd * sin_\n    out_odd = x_even * sin_ + x_odd * cos_\n    out = torch.empty_like(x)\n    out[...,0::2] = out_even\n    out[...,1::2] = out_odd\n    return out
\n

Batch

\n

将Dataset 分割为若干个batch进行训练。输出为两个torch.Tensor x,y

\n

Q: 为什么输出x,y， 且y tensor是x tensor 后移1位

\n

A: 因为自回归语言模型的训练目标是 Next Token Prediction，也就是根据当前位置之前的 token 来预测下一个 token。

\n
def run_get_batch(\n    dataset: npt.NDArray, batch_size: int, context_length: int, device: str\n) -> tuple[torch.Tensor, torch.Tensor]:\n    max = len(dataset) - context_length\n    sample = torch.randint(0,max,(batch_size,))\n    x = torch.stack([torch.tensor(dataset[s : s + context_length]) for s in sample])\n    y = torch.stack([torch.tensor(dataset[s + 1 : s + 1 + context_length]) for s in sample])\n    return x.to(device), y.to(device)
\n

torch.randint 本身就能直接生成Tensor int的随机张量，不需要单个随机整数生成再载入Tensor中

\n

Gradient Clippiing

\n

对于给定梯度模阈值Scaling 梯度

\n

Scal_factor={1g<MM∥g∥+εg≥M\\mathrm{Scal\\_ factor} = \\begin{dcases}\n1 & g<M\\\\\n\\frac{M}{\\|g\\|+\\varepsilon} & g\\geq M\n\\end{dcases}\nScal_factor=⎩⎨⎧​1∥g∥+εM​​g<Mg≥M​

\n
def run_gradient_clipping(parameters: Iterable[torch.nn.Parameter], max_l2_norm: float) -> None:\n    norm = torch.tensor(0.0)\n    for p in parameters:\n        norm += torch.norm(p.grad) ** 2\n    total_norm = torch.sqrt(norm)\n    if total_norm > max_l2_norm:\n        for p in parameters:\n            p.grad *= max_l2_norm / (total_norm + 10**(-6))\n
\n

Checkpoint Save & Load

\n

实现模型状态的断点保存与加载,通过torch.save一个dict对象实现

\n
def run_save_checkpoint(\n    model: torch.nn.Module,\n    optimizer: torch.optim.Optimizer,\n    iteration: int,\n    out: str | os.PathLike | BinaryIO | IO[bytes],\n):\n    torch.save(\n        {\n            \"model\": model.state_dict(),\n            \"optimizer\": optimizer.state_dict(),\n            \"iteration\": iteration\n        },\n        out\n    )
\n

加载就是从dict中load出来

\n
\ndef run_load_checkpoint(\n    src: str | os.PathLike | BinaryIO | IO[bytes],\n    model: torch.nn.Module,\n    optimizer: torch.optim.Optimizer,\n) -> int:\n    checkpoint = torch.load(src)\n    model.load_state_dict(checkpoint[\"model\"])\n    optimizer.load_state_dict(checkpoint[\"optimizer\"])\n    return checkpoint[\"iteration\"]
\n", "tags": [] }, { "id": "https://yuuko.site/2026/06/05/CS/OS/%E6%96%87%E4%BB%B6%E7%AE%A1%E7%90%86/", "url": "https://yuuko.site/2026/06/05/CS/OS/%E6%96%87%E4%BB%B6%E7%AE%A1%E7%90%86/", "title": "文件管理", "date_published": "2026-06-04T16:00:00.000Z", "content_html": "

文件管理

\n
\n

Everything is a file

\n
\n

文件是存储在计算机持久性存储设备的信息集合。用户进行IO操作时，文件是逻辑操作的基本对象，而文件系统是操作系统面向用户的文件管理系统。

\n

文件的定义与属性

\n

文件是具有文件名的一组相关元素的集合，分为有结构文件与无结构文件。

\n\n

对于有结构文件，其由多个记录组成，因此称为记录式文件。根据记录的长度是否一致可以分为

\n\n

有结构文件根据记录组织方式分为

\n\n

顺序文件的记录按线性排列，可分为串结构与顺序结构。串结构的记录是时间先后顺序排列的，因此只能顺序扫描，效率低；而顺序结构的记录按键字排列，能通过偏移量直接定位记录。

\n

类似于磁带这样物理限制的硬件，只能存储与使用顺序文件。

\n

索引文件通常用于进行数据随机查询等任务。索引文件维护了一个索引表，索引表中包含了：索引号、文件长度于指针，指针指向相应的逻辑文件，但是逻辑文件对象是什么层度地址取决于程序员的逻辑。

\n
|索引号idx|长度m|指针ptr|
\n

对于定长记录，第 iii 条记录的首址是简单的 Ai=iLA_i = iLAi​=iL, 对于变长记录，第iii 条记录的首址是前序记录的后继

\n

Ai=∑k=1iAk+1A_i = \\sum_{k=1}^i A_k +1\nAi​=k=1∑i​Ak​+1

\n

索引顺序文件

\n

将索引文件与顺序文件相结合。分组的组间通过索引建立，可以无序；但是组内通过顺序文件构成，需要键字有序才能进行偏移量定位。

\n

索引顺序文件的查找逻辑和查找 中的分块查找相同。

\n

对于NNN条记录的普通顺序文件的普通顺序文件的查找需要 N2\\frac{N}{2}2N​ 次。 分块最优查找下，假设分为MMM块，则需要在块间和块内进行顺序查找，总共需要

\n

M2+N2M≥2M2⋅N2M=N\\frac{M}{2}+\\frac{N}{2M}\\geq 2\\sqrt{\\frac{M}{2}\\cdot\\frac{N}{2M}} = \\sqrt{N}\n2M​+2MN​≥22M​⋅2MN​​=N​

\n

当 M=NM = \\sqrt{N}M=N​ 时，查找效率最优

\n

散列文件 通过Hash函数进行文件索引

\n

文件的属性

\n

文件的属性包括

\n\n

文件系统结构

\n

根据与硬件系统交互的自下至上的结构可分为

\n\n

文件目录

\n

文件目录管理的目的是实现:

\n\n

文件控制块FCB

\n

和PCB刻画进程信息类似，FCB用于确定文件的相关信息。FCB包含的信息有

\n\n

为了避免在检索文件时将整个FCB全部调入内存，UNIX系统中将文件名和描述信息解耦，将文件描述信息组织位索引结点(inode)。通常inode就是FCB，在文件目录的目录项中，对应索引结点编号指向对应的inode，文件目录表建立的是文件名和索引节点编号的映射

\n
|文件名|索引节点编号|
\n

目录项大小相比FCB减小，每个盘块可以容纳更多的目录项，因此单次搜索可以降低平均磁盘启动的次数。

\n

索引节点由两个部分构成，分别为磁盘索引节点与内存索引节点

\n

磁盘索引节点是文件的相关信息，包括文件标识符、文件类型、权限、地址、长度等信息。文件加载进内存后，相应的内存索引节点则相比磁盘索引节点多了运行时信息，包括索引节点号、状态、访问计数器、链接指针等。

\n

文件目录的结构

\n

文件目录分为

\n\n

单级目录将FCB线性排列，满足了基本的按名存取的需求，但是其无法实现文件重名存储且查找效率低，文件无法共享。

\n

两级目录分为主文件目录(MFD)和用户文件目录(UFD)，满足了多用户的需求，主文件目录下放置多个文件名和用户目录的存储位置, 用户目录下放置用户私有文件。

\n

用户文件目录内是单级目录排列的，因此灵活性与查找效率仍然较差。

\n

树状目录是现代的文件目录结构，从根结点/出发，到若干个子目录。用户的专有目录在/usr/*

\n

树状目录的路径分为绝对路径与相对路径。绝对路径就是从根结点出发的完整路径，比如/var/root. 相对路径则是从进程当前路径为基准，其他文件的路径。比如这篇文章的相对路径为./source/_posts/OS/文件管理.md

\n

有向无环图的目录结构的形成逻辑和图 中的m叉树和DAG的转换相同，即将目录间共享的文件作为共同结点商去，就构成了有向无环图。但是有向无环图的目录结构带来了更复杂的文件用户权限管理和文件增删的逻辑，增加了管理的开销。

\n

文件目录的实现

\n

文件目录基于 线性列表/哈希表 实现

\n\n

文件目录的操作

\n

和日常使用计算机相同，文件目录的操作包含

\n\n

文件的物理结构

\n

文件的物理结构是指操作系统中抽象的文件对象与磁盘中的存储块之间的对应方式。

\n

文件的物理结构分为两个互补的核心部分

\n\n

连续分配方式

\n

根据磁盘连续的存储块进行分配。比如文件长度为nnn块，从第bbb块开始存放，则分配给该文件的块就是 b,b+1,⋯ ,b+n−1b,b+1,\\cdots , b+n-1b,b+1,⋯,b+n−1

\n

连续分配方式可以在 O(1)\\mathcal{O}(1)O(1) 时间内读取指定块，但是它和内存连续分配类似，可能产生大量的外部碎片。文件长度也需要预先知道，难以支持文件大小的动态拓展。

\n

和线性表插入的问题相同，对于连续分配方式的文件，需要增删新的文件需要整体移动文件，性能开销大。

\n

链接分配方式

\n

隐式链接

\n

磁盘块内存储指向下一个磁盘块的指针，用户无法管理内部指针。当磁盘块链断开时，后续磁盘块内的数据都无法访问。

\n

磁盘块能合并为簇对象，减少了指针存储的开销。簇内的块是连续分配的块，而簇间的指针序仍然存在。

\n

显式链接

\n

显式链接会维护一张文件分配表(FAT), 其在整个文件系统只有一张。FAT记录盘块的盘块号与其指向的下一个块的盘块号。这其实就是盘块的静态链表结构。

\n

FAT需要始终加载在内存中，内存开销较大，但是支持顺序访问也支持随机访问，性能效率高。

\n

索引分配

\n

索引表相当于将单个文件分配的硬盘块使用一个表进行维护，访问文件时只需要根据索引表的内容加载硬盘块。

\n

如果文件过大可以使用多级索引表进行硬盘块的索引。类似于 内存管理 中关于多级页表的形式，多级索引表也是将块号进行离散分表映射以节省存储开销。但是相应会增加磁盘IO的开销。

\n

混合索引方式

\n

混合索引方式则是对于大文件与小文件使用不同的文件索引方式。inode结构中可以存入多个直接块以及若干层索引间址，对应多级索引的管理方式。这样对于不同大小的文件使用不同的索引方式可以降低整体的性能开销。

\n

文件的操作

\n

文件的基本操作包括创建文件、删除文件、读/写文件

\n

创建文件的过程包括

\n\n

删除文件的过程包括

\n\n

读文件与写文件前都需要将文件从磁盘加载入内存中，这个过程称为打开文件，对应open()系统调用(这个操作会切换用户态至内核态，因为设计磁盘IO操作)

\n

打开文件的实现为：通过目录找到inode, 并根据inode维护一个打开文件表，用于记录当前活跃的文件信息。

\n

打开文件表有两层

\n\n

读文件的过程: 打开文件，如果文件不在内存中就将文件磁盘块加载进内存并更新读指针

\n

写文件的过程: 打开文件，如果文件不在内存中就将文件磁盘块加载进内存并更新写指针

\n

文件关闭时，通过系统调用close()关闭文件。对应的打开计数器减1，当计数器减到0，就释放打开文件表中关于这个文件的项并释放相关资源。

\n

文件加载入内存后，包含额外的信息有

\n\n

总结: 内存inode的信息是对于磁盘文件在内存的对象的信息管理；打开文件表是进程面/文件多开场景下的信息管理

\n

文件的共享

\n

文件的共享分为两个视角:

\n\n

进程对于文件共享管理的方式就是打开文件表以及相应的打开计数器与指针的管理

\n

用户侧的共享分为硬链接与软链接

\n

硬链接是基于索引结点的共享方式。文件加载进内存后，文件的物理地址与属性信息加载在内存inode中，用户目录项只维护文件名与指向inode的指针。

\n

文件内存inode维护了一个链接计数count，用于标记指向该文件的用户文件表个数。当用户A不再使用该文件时，将count减1，并删除A私有文件表中的目录项，只有当count等于0才真正从内存中释放该文件与inode。

\n

软链接是Namespace层面的链接，对于形成软链接的文件，分配一个Link类型的文件，里面只存储文件实际目录的字符串，直接存储在inode中。

\n

当原始文件被删除时，不会影响另外一个用户访问Link文件本身，但是会出现访问失败的错误。同时，软链接建立的只是文件目录的映射而不是指针的映射，所以并不会改变原始文件内存inode的链接计数器

\n

文件保护

\n

文件保护机制包括

\n\n

口令与加密防止其他用户的非法获取文件内容，访问控制用于管理用户对文件的权限。

\n

Linux/Macos中的chmod实现了对于三种用户类型的文件访问权限控制的方式。这是一种访问控制列表(Access-Control List,ACL)控制方式

\n\n

对于三种权限进行赋权:

\n\n

使用三位十进制数转二进制权限，每一个十进制位代表user类型，比如chmod 712 <file> 表示file user 具有rwx(111)， group users具有x(001), other users具有w(010)

\n

文件系统

\n

文件系统是整体文件管理逻辑在硬盘与IO侧的实现。

\n

FS -- 文件系统

\n

File System 是在硬盘中真实管理硬盘的系统。硬盘通常被划分为若干个分区，每一个分区包括一个FS用于管理分区内的块信息。

\n

FS的构成可以分为

\n\n

对于不同品牌/设别类型的外存，文件系统不尽相同，存在如ext4/NTFS/FAT等类型。

\n

操作系统在内存中维护与VS相关的信息：

\n\n

这些内存中信息在文件系统挂载时加载，在文件打开且运行时更新，卸载时释放。

\n

文件存储空间管理

\n

文件存储空间管理是面向磁盘空闲块的管理方式。

\n

空闲表法 和磁盘块分配中的连续分配方式类似，都是基于磁盘的连续磁盘空间进行分配。FS维护了一张空闲表用于记录空闲块的序号、起始盘块号、空闲盘块数等。

\n

空闲链表法 使用一个链表链接所有空闲盘区组织

\n

空闲链表法的基本单位可以是盘块/盘区，和簇结构类似，空闲盘区链就是将一块块连续空闲盘块区域使用链表链接，满足区内连续，区间链表序的关系。

\n

成组链接法
\n通过分组方法进一步拓展了空闲链表法的指示空间。通过每一组的第一个盘块作为索引块记录下一组的空闲表块的块号与数目。

\n

这是经典的离散映射拓展指示空间的方式，第一级空闲表块信息被加载到专门的内存栈中，称为空闲盘块号栈，通过盘块栈弹出表示顺序分配空闲盘块。

\n

位示图法

\n

通过一个二维二进制表维护磁盘盘块的使用情况。

\n

{ai,j=0(i,j)盘块空闲ai,j=1(i,j)盘块正在使用\\begin{dcases}\na_{i,j} = 0 & \\text{(i,j)盘块空闲}\\\\\na_{i,j} = 1 & \\text{(i,j)盘块正在使用}\n\\end{dcases}\n{ai,j​=0ai,j​=1​(i,j)盘块空闲(i,j)盘块正在使用​

\n

盘块的序号是横向顺序数下去的，因此对于一个m×nm\\times nm×n 的位示图表，坐标为(i,j)(i,j)(i,j) 的磁盘块的盘块号为

\n

b=m(i−1)+jb = m(i - 1)+j\nb=m(i−1)+j

\n

盘块的回收则是根据盘块值反解二维坐标的过程。即

\n

{i=⌈bm⌉j=(b−1)%m++1\\begin{dcases}\ni = \\left\\lceil\\frac{b}{m}\\right\\rceil \\\\\nj = (b-1) \\% m ++1\n\\end{dcases}\n⎩⎨⎧​i=⌈mb​⌉j=(b−1)%m++1​

\n

VFS -- 虚拟文件系统

\n

VFS 是 操作系统层与FS的中间层。由于现代操作系统会面对多种不同的FS，VFS统一化了面向操作系统的API，以保证系统能更加统一化的IO。

\n

VFS存在四种基础对象

\n\n

文件系统的挂载

\n

Windows 的单个盘，比如C:\\表示分区/卷，比如可以在一个机械硬盘中进行多个分区
\n\"disk\"

\n

每一个卷作为独立的根目录 ，OS根据相应的驱动器定位对应的文件系统，再从其目录中查找

\n

Unix以单一根目录为挂载点进行挂载，挂载点只能挂载单一设备，但是同一个设备可以使用多个挂载点。

\n

WSL中的挂载

\n
(base) asuna@Asuna:~$ df -h\nFilesystem      Size  Used Avail Use% Mounted on\nnone            3.9G     0  3.9G   0% /usr/lib/modules/6.6.114.1-microsoft-standard-WSL2\nnone            3.9G  4.0K  3.9G   1% /mnt/wsl\ndrivers         201G  198G  3.0G  99% /usr/lib/wsl/drivers\n/dev/sdd       1007G   71G  885G   8% /\nnone            3.9G   84K  3.9G   1% /mnt/wslg\nnone            3.9G     0  3.9G   0% /usr/lib/wsl/lib\nrootfs          3.9G  2.7M  3.9G   1% /init\nnone            3.9G  604K  3.9G   1% /run\nnone            3.9G     0  3.9G   0% /run/lock\nnone            3.9G     0  3.9G   0% /run/shm\nnone            3.9G   76K  3.9G   1% /mnt/wslg/versions.txt\nnone            3.9G   76K  3.9G   1% /mnt/wslg/doc\nC:\\             201G  198G  3.0G  99% /mnt/c\nD:\\             753G  626G  128G  84% /mnt/d\nE:\\             954G  837G  118G  88% /mnt/e\ntmpfs           781M   20K  781M   1% /run/user/1000
\n

WSL 可以访问宿主Windows机器的卷，挂载在/mnt/*上，因此也可以查看宿主机的硬盘挂载情况

\n

Macos的挂载方式与Linux类似
\n\"mount\"

\n", "tags": [] }, { "id": "https://yuuko.site/2026/06/04/CS/LLM/optimizer/", "url": "https://yuuko.site/2026/06/04/CS/LLM/optimizer/", "title": "optimizer", "date_published": "2026-06-03T16:00:00.000Z", "content_html": "", "tags": [] }, { "id": "https://yuuko.site/2026/06/02/CS/OS/%E5%86%85%E5%AD%98%E7%AE%A1%E7%90%86/", "url": "https://yuuko.site/2026/06/02/CS/OS/%E5%86%85%E5%AD%98%E7%AE%A1%E7%90%86/", "title": "内存管理", "date_published": "2026-06-01T16:00:00.000Z", "content_html": "

内存管理

\n

内存管理是操作系统对内存空间的分配、组织、管理、回收，以及物理/虚拟内存地址映射的一整套庞大的管理系统。

\n

内存的分配

\n

内存的分配包括连续分配方式与离散分配方式，其中连续分配方式是将

\n

连续内存分配方式

\n

连续分配管理方式直接向用户进程分配物理内存的连续内存空间。因为其物理空间是完整连续的，它的地址转换通常只需通过硬件的基址寄存器进行简单的加法计算即可完成，而不需要像非连续分配（分页/分段机制）那样，依赖页表或段表来进行复杂的离散内存寻址与映射。

\n

连续分配方式分为单一连续分配、固定分区分配与动态分区分配

\n

单一分区分配

\n

将内存分为系统区与用户区，用户区单次只允许一条进程访问。单一分区分配不会产生外部碎片，但是其对于内存的利用率过低，在现代操作系统中被淘汰。

\n

固定分区分配

\n

单一分区分配只支持单进程访问内存，多进程并发的场景受限。固定分区将物理内存空间分为固定大小的分区，每一个分块只能容纳一道进程作业。

\n

固定分区可以分为相同内存大小的分区与不同内存大小的分区。

\n\n

动态分区分配

\n

按照进程的动态需求分配连续内存空间。动态分区分配方式在进程释放后会出现内存碎片，这样的内存碎片存在于给进程分配的内存块外，因此称为外部碎片，即一小段的连续内存空间。假如之后的进程需求内存小于内存碎片，则可以直接从内存碎片分配内存空间，但是代价是再次释放进程后会将内存碎片分为更小的内存碎片，直到内存碎片无法支持任何进程。

\n

对于外部碎片，可以通过紧凑技术合并外部碎片。操作系统周期性地移动进程内存地址，将进程的首址与进程的终址拼接，从而将碎片合并。

\n

紧凑技术需要进行动态重定位以实现，性能开销较大。

\n

通常通过链表维护空闲分区，以起址排序。内存块回收时，内存空闲区的合并大致可以分为四类

\n\n

空闲内存块分配方式

\n

动态分区中有很多的内存块，如何将空闲的、具有足够大小的内存块分配给进程作业呢？

\n

根据分区索引方式分为顺序分配与索引分配。

\n
空闲内存块的顺序分配
\n

由于空闲分区内存块的链表是根据空闲地址升序排列的，**首次分配算法(First Fit)**使用最简单的顺序查找，找到第一个满足内存条件的空闲分区就分配给进程。

\n

首次分配算法下，通常高地址的内存块是没有被使用过的完整分块，因此有利于大内存开销的进程使用。但是低地址区域容易积累小的外部碎片。每次查找需要从表头开始，查找的开销也较大。

\n

基于首次分配算法的查找逻辑，**邻近适应算法(Next Fit)**的每一轮搜索起点为上次搜索的结束位置。但是首次分配算法的大内存块保留的优势因为搜索起点变化而被破坏，整体性能不如首次分配算法

\n

最佳适应算法(Best Fit) 将空闲内存块根据容量的升序排列，根据内存大小进行最优分配。最佳适应算法目的是追求单次分配的最大内存利用率，但是会产生相当多的微小外部碎片，实际内存利用率与性能不佳。

\n

最坏适应算法(Worth Fit) 将空闲分区按容量递减排列，主动将最大的内存块分割为小块，每次分块总是内存利用率最小的，从而避免生成小碎片。但是难以有足够的大内存块满足大作业的内存需求。

\n
空闲内存块的索引搜索分配
\n

通过索引表查找的方式分配空闲内存块。常见的方式有三种: 快速适应算法(Quick Fit)、伙伴系统(Buddy System)、哈希算法

\n

快速适应算法是根据常用进程占据的空间进行预分块，分为固定大小的内存块。但是回收时进行合并操作的逻辑较为复杂，因为合并后的块大小不一定是常用进程的分块大小，不可避免产生内部碎片。

\n

伙伴系统是将内存空间进行空间二分，形成一个内存块二叉树。如果内存块不足以分配给进程，就向上合并为更大的块以匹配需求。通常不会适应类似于红黑树/B树等更加复杂的数据结构进行内存的管理，更加复杂的数据结构意味着更加复杂的硬件逻辑与性能问题。

\n

哈希算法通过哈希函数得到空闲块的头指针以快速获取空闲分块链。

\n

离散内存分配方式

\n

即分页方式和分段方式，通过页表和段表的映射方式管理内存块

\n

基本分页存储管理

\n

分页管理模式将物理内存分为若干大小相等的物理内存单元，称为页框(物理块/页帧)；将逻辑空间分为与物理空间相等大小的区域称为页。系统以页框为单位分配进程的内存资源。

\n
页与页框的映射方式
\n

逻辑地址中的页有一个唯一的编号称为页号，同时物理地址的页框也有唯一编号称为页框号。

\n

页号到页框号的映射通过页表记录。页表包含每一个页的对应物理页框号、以及相应的状态信息(有效位、访问位等)

\n

逻辑地址的构成由页号+页内偏移量构成。页号用于确定逻辑地址所在的页面，页内偏移量用于确定相对于页面首址的偏移量。这两个地址共同刻画了单一逻辑地址对象。

\n

逻辑地址与物理地址的转换需要地址变换机构，通过页表将逻辑地址映射到物理空间。通过**页表寄存器(PTR)**加快地址变换的速度, 用以存放页表始址与长度。

\n

设逻辑侧的页大小/物理侧的页框大小为LLL, 逻辑地址为AAA, 物理地址EEE, 页表长度MMM

\n

地址变换的逻辑为:

\n\n
A = PL+W // 逻辑侧\nT = σ(P) // 页表映射\nE = TL+W // 物理侧
\n

如果地址转换速度慢或者页表过大，可能导致内存系统的性能下降。诸如快表、多级页表等技术解决了这样的问题

\n
基于快表的地址变换机构
\n

虚拟存储器 中提到 快表(TLB) 是基于Cache实现的、能快速并行查找的存储器。

\n

快表中的存储形式和内存页表一致，都是页号+页内偏移量的形式。但是遵循局部性原理存入更高频使用的页表项，能提高地址变换的整体性能。

\n

在有快表的地址变换机构中，CP优先向快表中的页号进行比较，如果快表页号命中就直接读取快表中存储的物理块号；否则就访问内存页表。

\n
两级页表结构
\n

两级页表结构将底层页表也做了一层页表离散映射，相当于将页表作为一个地址
\n。同时，系统只将活跃的页表调入内存，其余页表置于内存当中。

\n

假设单个页框内能容纳的页表项数量为 KKK

\n
P_1 = ⌊P_0/K⌋ // 一级页表索引\nP_2 = P_0 % k // 二级页表索引\nA = P_0L+W    // 逻辑侧 -- P_0 为总逻辑页号\nT = σ(P)      // 页表映射\nE = TL+W      // 物理侧
\n

两级页表结构本质是对页进行分组，满足

\n

P0=P1K+P2P_0 = P_1K+P_2\nP0​=P1​K+P2​

\n

因此逻辑地址由三个部分组成

\n
|一级页表索引|二级页表索引|页内偏移量|
\n

硬件系统通常设置一个外层页表寄存器用于存放一级页表的起始地址

\n

基本分段存储管理

\n

分页管理方式是硬件上的内存管理方式，分段管理方式是面向用户的内存管理方式。

\n

分段系统将用户进程的逻辑空间分为不同大小的段，包含如主程序段、子程序段、栈段与数据段等不同内存段，每一个段从0地址开始兵分配连续的段内空间。通过段号+段内偏移量确定逻辑地址

\n

分段结构中的逻辑地址结构

\n
|段号 S|段内偏移量 W|
\n

段表结构

\n
|段表|段长|本段在主存中的初始地址|
\n

用于确定段在物理地址中的区域，段地址变换机构也能通过段表进行逻辑地址与物理地址的映射

\n
段与共享
\n

系统能维护一个共享段表以支持多个共享段访问共享段表。不可修改的代码支持多个进程的并发执行，系统会将这样的纯代码放入只读段中。同时每一个进程都有私有的局部数据区，避免共享访问私有数据。

\n
段的保护
\n\n

段页式存储管理

\n

先根据用户逻辑讲进程地址分段，再将每一个段内存块根据页逻辑存储。进程的逻辑地址由三个部分构成

\n
|段号 S|页号 P|页内偏移量 W|
\n

段页寻址中段寻址部分需要通过段表实现，这和单段表的逻辑是一样的。

\n", "tags": [] }, { "id": "https://yuuko.site/2026/06/01/CS/LLM/moe/", "url": "https://yuuko.site/2026/06/01/CS/LLM/moe/", "title": "MoE -- Mixture of experts", "date_published": "2026-05-31T16:00:00.000Z", "content_html": "

Mixture of Experts

\n", "tags": [ "架构" ] }, { "id": "https://yuuko.site/2026/06/01/CS/OS/deadlock/", "url": "https://yuuko.site/2026/06/01/CS/OS/deadlock/", "title": "死锁", "date_published": "2026-05-31T16:00:00.000Z", "content_html": "

死锁

\n

死锁，即进程间的资源竞争陷入了一个循环等待的链，等待其他进程的资源但是自身占用了一定的资源。当进程链形成有向环且进程都等待时，系统处于死锁。

\n

死锁产生的原因

\n\n

死锁产生的必要条件

\n\n

死锁的预防

\n

死锁的预防即通过硬件手段扼杀死锁的产生，针对死锁产生的四个必要条件破坏。

\n\n

死锁避免

\n

死锁避免是通过软件方式对当前执行状态下的进程序列进行安全性检验。

\n

安全性检查

\n

系统安全性检查是对于某个进程组，进程序列 (P1,⋯ ,Pn)(P_1,\\cdots ,P_n)(P1​,⋯,Pn​) 的执行是否不会发生死锁。如果在某个初始分配条件下的任何进程序列都是安全序列，则系统是安全的；反之，如果系统不安全，其不一定会陷入死锁，因为系统不一定会选择不安全序列执行。

\n
#include <vector>\n#include <stdexcept>\n\nint num = 3;  // 3个进程\nint resource = 2; // 2个互斥资源\n\nstd::vector<std::vector<int>> max(num,std::vector<int>(resource));\nstd::vector<std::vector<int>> allocate(num,std::vector<int>(resource));\n\nstd::vector<bool> finish(num,false);\nstd::vector<int> work(resource);   // 当前可用资源\n\nfor (int i = 0; i < num; i++){     // 顺序执行example， 检测P0-P1-P2序列\n    std::vector<int> need(resource);\n    int sign = 0;\n    for (int j = 0; j < resource; j++){\n        need[j] = max[i][j] - allocate[i][j];\n        if (need[j] <= work[j]){\n            sign ++;\n        }\n    }    \n    if (sign == resource){\n        finish[i] = true;\n        for (int k = 0; k < resource; k++){\n            work[k] += allocate[i][k];\n        }\n    }\n    else{\n        throw std::runtime_error(\"Unsafe process seq\");\n    }\n}\n
\n

银行家算法

\n

银行家算法不需要遍历所有的安全序列。对于当前资源足够执行的进程，将试探性分配资源再通过安全性检查检测系统是否为安全状态，安全则正式分配，否则撤销分配。

\n

死锁检测

\n

死锁检测是在进程执行中，判断当前是否处于死锁状态，只根据当前的资源分配情况判断，而不进行进程的安全性检验与未来运行的预测。

\n

通常通过资源分配图进行简化与判断。有向边从进程指向资源表示进程申请资源；从资源指向进程表示进程已经分配的资源。

\n

简化：如果资源类中存在数量足够的资源，则将请求有向边反向；入股进程结点只有入度，则该进程资源分配足够，执行完成就可以删除相应入边并释放资源。

\n

如果简化进程资源分配图仍然存在有向边，则系统处于死锁状态。基于此，可以归纳出

\n

死锁定理： 系统死锁当且仅当资源分配图不可完全简化

\n

死锁解除

\n

通过操作系统进行死锁状态的解除

\n\n", "tags": [] }, { "id": "https://yuuko.site/2026/05/29/Reading/kawabata/%E4%BC%8A%E8%B1%86%E7%9A%84%E8%88%9E%E5%A5%B3/", "url": "https://yuuko.site/2026/05/29/Reading/kawabata/%E4%BC%8A%E8%B1%86%E7%9A%84%E8%88%9E%E5%A5%B3/", "title": "《伊豆的舞女》 -- 川端康诚", "date_published": "2026-05-28T16:00:00.000Z", "content_html": "

《伊豆的舞女》并不是我看过的第一本川端康诚的书，相比《雪国》、《千纸鹤》等刻作品刻画的日本压抑严肃社会背景下的扭曲的爱情，《伊豆的舞女》中的萍水相逢间平淡而朴素的好感与爱恋，却如山间的野花纯真，也如野花般易逝。

\n
\n

在黑暗中，少年的体温温暖着我。我任凭泪泉涌流，我的头脑恍如变成一池清水，一滴滴溢了出来，后来什么也没有留下，顿时觉得舒畅了。

\n
\n", "tags": [ "读书笔记", "川端康诚" ] }, { "id": "https://yuuko.site/2026/05/29/CS/OS/%E8%BF%9B%E7%A8%8B%E7%9A%84%E5%90%8C%E6%AD%A5%E4%B8%8E%E4%BA%92%E6%96%A5/", "url": "https://yuuko.site/2026/05/29/CS/OS/%E8%BF%9B%E7%A8%8B%E7%9A%84%E5%90%8C%E6%AD%A5%E4%B8%8E%E4%BA%92%E6%96%A5/", "title": "进程的同步与互斥", "date_published": "2026-05-28T16:00:00.000Z", "content_html": "

进程的同步与互斥

\n

进程会对临界资源的访问权限竞争。通常临界区只支持一个进程进行读/写，因为如果两条进程对临界区的相同数据进行写操作，有可能导致两个进程的发生先后不同，导致产生不同的执行结果。

\n

临界资源

\n

临界资源是能被多个进程访问，但是被多个进程同时访问会产生冲突的资源。临界区是访问这一块共享资源的代码。

\n

进程对临界资源的访问分为四个部分

\n\n

进程的同步

\n

进程的同步指的是多个异步进程，需要彼此协调运行次序，而在执行流程上产生等待或者进程信息传递等制约关系。比如进程B需要进程A提供的相关数据，A在缓冲区写入信息、B在缓冲区读信息，那么进程A就是进程B的严格前序进程，这两个进程是同步的。

\n

进程的互斥

\n

进程的互斥指的是，对于一个缓冲区有多个进程能进行读、写操作。当一个进程进入缓冲区后，其他需要访问缓冲区的进程只能等待当前进程结束才能进入缓冲区。

\n

避免多进程进入缓冲区的设计策略:

\n\n

实现临界区互斥的方法

\n

实现临界区互斥的方法通常都需要基于上面四个设计策略构建，其中让权等待是节省CPU性能开销的可选择策略。

\n

实现方法分为软件实现方法与硬件实现方法。

\n

软件实现方法

\n

单标志法

\n

单标志法通过一个一个公共变量turn指示当前允许进入临界区的进程编号

\n
#include <thread>\n#include <iostream>\n#include <atomic>\nstd::atomic<int> turn = 0;\n\nvoid critical_section(int id) {\n    std::cout << \"thread \" << id << \" in critical section\\n\";\n}\n\nvoid remainder_section(int id) {\n    std::cout << \"thread \" << id << \" in remainder section\\n\";\n}\n\nvoid thread0() {\n    while (true) {\n        while (turn != 0) {\n            // busy waiting\n        }\n\n        critical_section(0);\n\n        turn = 1;\n\n        remainder_section(0);\n    }\n}\nvoid thread1() {\n    while (true) {\n        while (turn != 1) {\n\n        }\n\n        critical_section(1);\n        turn = 0;\n        remainder_section(1);\n    }\n}\nint main() {\n    std::thread t0(thread0);\n    std::thread t1(thread1);\n\n    t0.join();\n    t1.join();\n\n    return 0;\n}
\n

两个进程必须按照turn的标记交替进入临界区访问，是互锁的，假如thread0不再申请临界区, 则turn始终为0，thread1也无法再申临界区，违背空闲让进原则

\n

双标志法

\n

在turn的基础上，添加了布尔数组flag[]， 用于表示进程访问临界区的意愿，flag[i]=true表示进程i需要访问临界区。

\n

双标志先检查法

\n
#include<iostream>\n#include<thread>\n#include<atomic>\n\nstd::atomic<int> turn = 0;\nstd::atomic<bool> flag[2] = (false,false);\n\nvoid critical_section(int id) {\n    std::cout << \"thread \" << id << \" in critical section\\n\";\n}\n\nvoid remainder_section(int id) {\n    std::cout << \"thread \" << id << \" in remainder section\\n\";\n}\nvoid thread0(){\n    while(flag[1]) ;   // 先进行其他进程的意愿检查\n    flag[0] = true;    // 再设置本进程的进入意愿\n    critical_section(0);\n    flag[0] = false;    // 访问完临界区后降低访问意愿\n    remainder_section(0);\n}\n\nvoid thread1(){\n    while(flag[0]) ;\n    flag[1] = true;\n    critical_section(1);\n    flag[1] = false;\n    remainder_section{1};\n}\nint main(){\n    int main() {\n        std::thread t0(thread0);\n        std::thread t1(thread1);\n\n        t0.join();\n        t1.join();\n\n        return 0;\n    }\n}
\n

双标志先检查法的问题在于，如果两个进程都通过了意愿检查，可能出现两个进程同时使用临界区的问题，违背了忙则等待原则

\n

双标志后检查法

\n
/* 其他的设置与 双标志先检查法 相同*/\nvoid thread0(){\n    flag[0] = true;      // 先设置本进程访问意愿\n    while(flag[1]);      // 再检查其他进程的访问优先级\n    critical_section(0);\n    flag[0] = false;    // 访问完临界区后降低访问意愿\n    remainder_section(0);\n}\n\n\nvoid thread1(){\n    flag[1] = true;\n    while(flag[0]) ;\n    critical_section(1);\n    flag[1] = false;\n    remainder_section{1};\n}\nint main(){\n    int main() {\n        std::thread t0(thread0);\n        std::thread t1(thread1);\n\n        t0.join();\n        t1.join();\n\n        return 0;\n    }\n}\n
\n

双标志后检查法解决了双标志先检查法的忙则等待问题，但是双标记后检查法可能遇到两个进程都想访问临界区，都进行等待，导致临界区空闲，违背了空闲让进与有限等待准则。

\n

Peterson 算法

\n

Peterson算法融合了turn与flag的优点，通过turn管理互斥访问，通过flag管理饥饿问题

\n
#include <array>\n#include <atomic>\n#include <chrono>\n#include <iostream>\n#include <mutex>\n#include <string>\n#include <thread>\n\nusing namespace std::chrono_literals;\n\nstd::array<std::atomic<bool>, 2> flag = {false, false};\nstd::atomic<int> turn{0};\n\nstd::atomic<int> shared_counter{0};\nstd::atomic<int> active_in_critical{0};\nstd::mutex output_mutex;\n\nvoid log(int process_id, const std::string& message) {\n    std::lock_guard<std::mutex> lock(output_mutex);\n    std::cout << \"P\" << process_id << \" | \" << message << '\\n';\n}\n\nvoid peterson_lock(int process_id) {\n    const int other = 1 - process_id;\n\n    flag[process_id].store(true);\n    turn.store(other);\n\n    log(process_id, \"wants to enter: flag[\" + std::to_string(process_id) +\n                        \"]=true, turn=\" + std::to_string(other));\n\n    bool printed_wait_message = false;\n    while (flag[other].load() && turn.load() == other) {\n        if (!printed_wait_message) {\n            log(process_id, \"waits because flag[\" + std::to_string(other) +\n                                \"]=true and turn=\" + std::to_string(other));\n            printed_wait_message = true;\n        }\n        std::this_thread::sleep_for(20ms);\n    }\n\n    if (printed_wait_message) {\n        log(process_id, \"can enter now\");\n    }\n}\n\nvoid peterson_unlock(int process_id) {\n    flag[process_id].store(false);\n    log(process_id, \"leaves: flag[\" + std::to_string(process_id) + \"]=false\");\n}\n\nvoid critical_section(int process_id, int round) {\n    const int already_inside = active_in_critical.fetch_add(1);\n    if (already_inside != 0) {\n        log(process_id, \"ERROR: mutual exclusion was broken\");\n    }\n\n    log(process_id, \"enters critical section, round \" + std::to_string(round));\n\n    const int before = shared_counter.load();\n    std::this_thread::sleep_for(80ms);\n    shared_counter.store(before + 1);\n\n    log(process_id, \"updates shared_counter: \" + std::to_string(before) +\n                        \" -> \" + std::to_string(before + 1));\n    log(process_id, \"exits critical section, round \" + std::to_string(round));\n\n    active_in_critical.fetch_sub(1);\n}\n\nvoid process(int process_id, int rounds) {\n    for (int round = 1; round <= rounds; ++round) {\n        peterson_lock(process_id);\n        critical_section(process_id, round);\n        peterson_unlock(process_id);\n\n        std::this_thread::sleep_for(process_id == 0 ? 35ms : 55ms);\n    }\n}\n\nint main() {\n    constexpr int rounds = 2;\n\n    std::cout << \"Peterson algorithm demo: two threads, one critical section\\n\";\n    std::cout << \"----------------------------------------------------------\\n\";\n\n    std::thread p0(process, 0, rounds);\n    std::thread p1(process, 1, rounds);\n\n    p0.join();\n    p1.join();\n\n    std::cout << \"----------------------------------------------------------\\n\";\n    std::cout << \"Final shared_counter = \" << shared_counter.load()\n              << \" (expected \" << rounds * 2 << \")\\n\";\n    return 0;\n}
\n

Peterson算法的while循环会持续检测是否具有进入临界区的权限(对于进程0，当对方进程进入的时候挂起,flag[1]=true+ turn =1), 因此没有遵循让权等待原则，但是这已经是纯软件互斥算法中最完善的方案。

\n

硬件实现算法

\n

硬件实现算法相当于给临界区资源添加锁

\n

中断屏蔽

\n

对于单处理器系统，一次只能执行单进程任务。因此能够通过关中断方式，保证进程在临界区执行时不进行进程的切换，保证进程访问临界区不受干扰。

\n

硬件指令 -- TestAndSet与 Swap

\n

TestAndSet原语实现了加锁功能

\n

以CPP伪代码实现

\n
#include <atomic>\nusing namespace std;\n\natomic<bool> TestAndSet(atomic<bool>& lock) {\n    return lock.exchange(true, memory_order_acquire);\n}\n\nvoid Unlock(atomic<bool>& lock) {\n    lock.store(false, memory_order_release);\n}\nint main(){\n    ...\n    while (TestAndSet(lock)) {\n        // 忙等待\n    }\n    fun_();       // 上锁的临界区代码段\n    Unlock(lock); // 开锁 \n    fun_other();\n}
\n

Swap实现的是交换两个原子变量的值

\n
#include<atomic>\nusing namespace std;\n\nvoid Swap(atomic<bool> a, atomic b){\n    atomic<bool> tmp = a;\n    a = b;\n    b = tmp;\n}\nint main(){\n    atomic<bool> key = true;\n    atomic<bool> lock = false;\n    while(key != false){\n        swap(lock, key);\n    }\n    fun_();\n    lock = false;\n    fun_other();\n}
\n

Swap实现的是，进程维护的Key值与临界区的Lock的原子布尔值的交换，进程持有Key = True访问临界区时，临界区的Lock变为True，此时相当于上锁。其他进程便无法访问临界区。但是通过TS与Swap实现的互斥锁，在临界区外的进程需要持续检查Key的值，形成忙等待。

\n

互斥锁

\n

互斥锁(自旋锁)和TS/Swap指令逻辑相同，基于这两个指令实现开/关锁管理进程与临界区

\n
atomic<bool> available = true;\nvoid acquire(){\n    while (!available);\n    available = false;\n}\nvoid release(){\n    available = true;\n}
\n

实际场景下的同步算法

\n

信号量机制

\n

信号量将互斥锁的二元占用状态推广为整数计数状态，可用于表示可用资源数量或限制并发访问数量；其 acquire/release 操作本质上是原子的计数检查、递减、递增与等待唤醒机制，而不只是普通整数比较。

\n

信号量只能通过两个标准原语访问wait()/ signal(), 也称为P/V操作

\n\n

伪代码实现:

\n
wait(S){\n    while(S<=0){\n         // 忙等待\n    }\n    S--;\n    \n}\nsignal(S){\n    S++;\n}
\n\n

通过整数S与进程链表L的整个结构体共同实现信号量。

\n
struct semaphore{\n    int val;\n    llist<process> *L;\n};\n\nvoid wait(semaphore S){\n    S.val -- ;\n    if (S.val < 0){\n        // L 中插入进程\n        block(S.L);\n    }\n}\nvoid signal(semaphroe S){\n    S.val ++;\n    if (S.val < 0){\n        // L 中 移除进程\n        wakeup(S.L);\n    }\n}\n
\n
信号量与互斥
\n
semaphore S = n; // 初始化信号量\nthread P1(){\n    P(S);    // 加锁\n    fun();   // 执行\n    V(S)     // 开锁\n}
\n
信号量与同步
\n
semaphore S = 0; // 初始化信号量\n\nthread P1(){\n    fun1();\n    V(S);\n}\n\nthread P2(){\n    while(S<=0);\n    P(S);\n    fun2();\n}
\n

进程P1执行完后，信号量才能增加到1，进程P2才能通过忙等待执行。因此通过信号量的序关系确定了进程的前驱关系

\n
信号量与计算图
\n

信号量可以描述程序段间的前后前驱关系，它能实现一个有向图的任务执行流程，每一个有向边对应一个同步问题。通过维护不同的信号量值，管理不同的前驱关系，从而构建一个进程前驱图。

\n

神经网络中的计算图是张量信息流作为有向边与算子计算结点构成顶点的DAG。由于数据依赖天然诱导执行依赖，因此它可以被视为一种前驱图。若从并行调度角度实现，每条依赖边都可以抽象为一个同步约束，信号量是表达这种约束的一种机制。

\n

生产者-消费者问题

\n

系统中存在多个生产者与消费者，其中生产者、消费者只能在缓冲区互斥读/写

\n

这个场景下，只需要判断缓冲区是否有“产品”与是否能访问。通过互斥信号量mutex实现互斥访问的限制，通过计数信号量empty的值表示当前缓冲区含有的产品量。

\n

CPP伪代码为

\n
\nsemaphore mutex = 1;  // 互斥缓冲区 -- 占用进程缓冲区P后不允许进程访问\nsemaphore empty = n;  // 空缓冲区值 -- 产品缓冲区的存量上限\nsemaphore full = 0;\n\nvoid producer(){\n    while(true){\n        produce();        // 生产产品\n        P(empty);         // 申请空缓冲区 -- 容量 -1\n        P(mutex);         // 申请进程互斥缓冲区 -- 禁止其他进程访问\n        put_product();    // 产品放入缓冲区 \n        V(mutex);         // 释放进程互斥缓冲区 \n        V(full);          // 满缓冲区 有效产品 +1\n    }\n}\n\nvoid consumer(){\n    while(true){\n        P(full);          // 申请满缓冲区 有效产品 -1\n        P(mutex);         // 申请进程互斥缓冲区\n        use_product();    // 消耗产品\n        V(mutex);         // 释放进程互斥缓冲区\n        V(empty);         // 释放空缓冲区 -- 容量 +1\n    }\n}\n
\n

读者-写者问题

\n

读者-写者问题是生产者-消费者问题的变式。写者互斥写、读者并行读，但是读者读和写者写不能同时发生。

\n

读者-写者问题分为两种权限优先

\n\n
读者优先
\n

写者的信号量权限为 rw = 1, 读者侧维护信号量account 表示当前在读的人数，如果读者归零，则写者能进入缓冲区写

\n

CPP伪代码实现

\n
int count = 0;\nsemaphore mutex = 1; \nsemaphore rw = 1;\n\nvoid reader(){\n    while(true){\n        P(mutex);   // 申请进程缓冲区\n        if (count == 0){\n            P(rw);  // 关闭 写者访问\n        }\n        count ++;\n        V(mutex);   // 释放进程缓冲区\n        read();\n        P(mutex);\n        count -- ;\n        if(count == 0){\n            V(rw);\n        }\n        V(mutex);\n    }\n}\n\n\nvoid writer(){\n    while(true){\n        P(rw);      // 申请rw锁，如果存在读者，则无法访问\n        write();\n        V(rw);\n    }\n}
\n
写者优先
\n

写者优逻辑中，还需要维护一个新的信号量w, 用于限制写者的唯一访问

\n

CPP伪代码

\n
int count = 0;       // 读者数\nsemaphore mutex = 1; // count锁\nsemaphore rw = 1;    // 写者优先权\nsemaphore w = 1;     // 文件的独占写信号量\n\n\nvoid writer(){\n    while(true){\n        P(rw);      // 阻止读者读\n        P(w);       // 写者单独写\n        write();\n        V(w);\n        P(rw);\n    }\n}\n\n\nvoid reader(){\n    while(true){\n        P(rw);      // 申请读权限，如果有写者则无法读\n        P(mutex);   // 申请进程缓冲区访问\n        if (count == 0){\n            P(w);   // 阻止写者访问，非抢占性优先\n        }\n        count ++;\n        V(mutex);\n        V(rw);\n        read();\n        P(mutex);\n        count -- ;\n        if(count == 0){\n            V(w);\n        }\n        V(mutex);\n    }\n}\n
\n

哲学家进餐问题

\n

圆形餐桌的每一个哲学家左右手各有一根筷子，进餐时哲学家需要拿起两根筷子进食，如果没有足够的筷子就进行等待。

\n

选定一个哲学家为000 号哲学家，且逆时针编号，则第iii 个哲学家的左手边的筷子与右手边的筷子的编号分别为

\n

{i左手边筷子(i+1)%5右手边筷子\\begin{dcases}\n\\quad i & \\text{左手边筷子}\\\\\n(i+1)\\% 5 &\\text{右手边筷子}\n\\end{dcases}\n{i(i+1)%5​左手边筷子右手边筷子​

\n

对于 nnn 个哲学家与 nnn 根筷子，会出现一个人有一只筷子的死锁情况: 每一个人都只有左手边筷子或者右手边筷子，此时会发生死锁。

\n

如果限制每一次只能有 n−1n-1n−1 个哲学家能吃饭，那么根据容斥原理，总有一个哲学家有两只筷子，此时这个哲学家吃完饭释放筷子资源后，其余哲学家也能继续进餐。因此基于这个想法，进餐人数的信号量初始为 n−1n-1n−1 时能避免死锁。

\n", "tags": [ "OS", "进程" ] }, { "id": "https://yuuko.site/2026/05/25/CS/OS/%E8%BF%9B%E7%A8%8B%E4%B8%8E%E7%BA%BF%E7%A8%8B/", "url": "https://yuuko.site/2026/05/25/CS/OS/%E8%BF%9B%E7%A8%8B%E4%B8%8E%E7%BA%BF%E7%A8%8B/", "title": "进程与线程", "date_published": "2026-05-24T16:00:00.000Z", "content_html": "

进程与线程

\n

进程是操作系统进行资源分配与调度的基本单位。

\n

进程的特征

\n\n

并行的效率

\n

Amdahl’s Law与 Gustafson’s Law 讨论了并行计算能提升多大的计算效率

\n

Amdahl's Law

\n

Amdahl's Law 讨论在等量任务的条件下，并行计算带来的计算效率优化上线。

\n

假设一个程序中可并行部分的比例为 ppp, 可以 NNN 路并行， 那么整体加速比为

\n

SN=1(1−p)+pNS_N = \\frac{1}{(1-p)+\\frac{p}{N}}\nSN​=(1−p)+Np​1​

\n

Amdahl's law 指出了并行优化的效率上限 -- 串行部分的比例。当 N→∞N\\to \\inftyN→∞ 时，加速比最大值为

\n

S∞=11−pS_\\infty = \\frac{1}{1-p}\nS∞​=1−p1​

\n

Gustafson’s Law

\n

Gustafson’s Law讨论在相等时间的情况下，并行计算得带来的计算任务量的效率优化上限。

\n

假设一个程序的可并行部分为ppp. 则相同时间下并行的任务量（加速比）为

\n

SN=1−p+Np=(N−1)p+1S_N = 1-p + Np = (N-1)p+1\nSN​=1−p+Np=(N−1)p+1

\n

这说明通过增加并行资源，能通过扩大并行任务规模并使并行部分占主导。

\n

进程的构成

\n

进程实体由三部分构成：

\n\n

进程控制块 (PCB)

\n

PCB是进程存在的唯一标志，在进程的整个生命周期内，OS均依赖PCB进行进程管理。

\n

PCB包含四类信息:

\n\n

进程的PCB是用户不透明的，我们能通过shell访问相应进程的PCB。

\n
# Linux\ncat /proc/[pid]         # 进程 PCB\ncat /proc/[pid]/status  # 进程 PCB中的状态特征\n\n# MacOS\n\nps -l -p [pid]          # 与 cat /proc/[pid]/status 一致\n
\n

对于不同OS，父进程中断对子进程的影响都不同。Linux系统对父进程中断并不会中断子进程的执行，而是由init(PID=1)进程收养并正常运行。

\n

PCB中的处理机状态信息与指令的相应状态信息相对应。当进程指令进入CPU时间片处理时，对应寄存器从内存中读取PCB处理机信息。

\n

程序段

\n

程序段是CPU可执行的代码部分，是代码的纯二进制指令部分。静态的二进制指令可以被多个进程共享。

\n

程序段包含

\n\n

数据段

\n

数据段包含进程运行所需的数据，包含.data、.bss与堆、栈

\n

.data用于放置已初始化的静态变量、.bss用于放置未初始化的静态变量

\n

Tip: 关于变量存储的空间

\n
int a = 1; // 在.data 数据段中\nint b[10]; // 在.bss 数据段中\n\nvoid main(){\n    static int List[10]; // 函数中静态变量声明在.data数据段中\n    int c = 1; // 在被调用的函数中声明的变量直接在栈中生成\n    int *p_arr = (int*)malloc(10*sizeof(int)) // 被调用函数中声明动态申请空间时，变量生成在堆中\n\n}
\n

共享库的存储映射区

\n

依赖库的加载，比如一些动态库.so/.dll

\n

静态库通常加载到.text中

\n

进程的生命周期

\n

进程的生命周期分为

\n\n

满足图

\n
\n创建态 -> 就绪态  <-> 运行态 -> 终止态\n            |          |\n            <------  阻塞态
\n

进程的创建

\n

在创建态下，OS通过创建原语建立新进程。

\n\n

终端登录、作业调度系统启动任务、用户程序请求、系统提供服务等事件都会创建新的进程。

\n

进程的终止

\n

分为正常结束、异常结束与外界干预

\n\n

终止进程的流程

\n\n

进程的阻塞与唤醒

\n

进程因为外部事件无法进行时会主动调用阻塞原语(Block), 将进程从运行态转变为阻塞态。

\n

阻塞原语与中断实现的逻辑相似。阻塞原语的实现过程

\n\n

阻塞进程的事件结束后，需要内核的中断处理程序或者合作进程调用**唤醒原语(Wakeup)**进行进程的唤醒

\n\n

进程的通信

\n

进程是独立的单元，进程间的通信通常需要申请内存区域搭建通信的介质进行信息交换。

\n

根据通信效率与量的不同可以分为:

\n\n

高级通信面对大量的数据与地址的传递

\n\n

仅当OS从内核态回到用户态的时候才会处理待处理的信号。处理信号的方式

\n\n

线程

\n

线程是程序执行流的最小单位，也是处理器调度的基本单位。

\n

在单个进程中有多个执行线程。一个线程不拥有独立的系统资源，比如地址空间，但是运行基本的线程私有数据，比如线程ID、PC、寄存器组和栈寄存器(这些是指令执行的基本单位，线程独立执行一些指令组，因此拥有这些物理元件的数据独立性)。线程的控制块TCB用于记录线程的执行上下文(即对应物理元件的备份值，如PC值，栈指针等)

\n

统一进程中的多个线程也能并发执行相同的程序代码。常见的，比如uWSGI创建的多线程后端服务，能访问同一个后端代码库。也能同时共享进程的资源与内存信息。

\n

线程间的CPU调用与生命周期是独立的。多CPU系统的线程可以在不同的CPU核心上运行

\n

线程间的调度的开销小于进程间的调度。

\n

线程控制块(TCB)

\n

TCB 包含

\n\n

线程的实现

\n

线程分为用户级线程(ULT)与内核态线程(KLT)，基于这两种线程存在多种进程实现方式。

\n\n

组合方式分为多对一模式、一对一模式与多对多模式

\n

一对一模式与内核级线程模式是一个模式的两个名字

\n

多对一模式是指始终只有一个线程能从用户态切换至内核态，实现并发的内核态运行。多对一模式并不能完成多内核/多CPU多线程并行

\n

多对多模式是能将实现多对多的内核态切换，同时避免一对一模型的全切换开销过大的问题。

\n

线程库是用户态线程的管理方式，程序员通过线程库的库函数(API)进行线程的创建与生命周期的管理。同时，高级语言能通过线程池进行多用户线程的管理，例如SQLite的ThreadPoolExecutor

\n

CPU调度

\n

CPU调度是指当进程数远大于CPU核心数时，如何分配CPU资源以实现进程的高效、公平的运行，从而实现进程的高并发。

\n

调度的层次

\n

调度自外向内分为三个层次

\n\n

进程调度的任务包括

\n\n

调度的实现

\n

进程调度通过调度器实现，调度器分为排队器、分派器与上下文切换器。

\n\n

上下文切换

\n

上下文切换是进程调度的核心占用步骤，因为PCB就是进程的信息载体本身。上下文切换分为上一个进程PCB的保存与下一个进程PCB的恢复与写入CPU寄存器，完整流程为

\n\n

上下文切换涉及复杂的访存与指令的执行，时间与资源的开销都较大。

\n

上下文切换是发生在进程间的，而模式切换是发生在进程或者线程内的状态变化。上下文切换只能由内核执行，因此当前进程切换必须为内核态。

\n

调度的时机

\n

进行进程调度的时刻有

\n\n

不能进行进程切换的场景(关中断状态)

\n\n

调度的方式

\n\n

调度的目标

\n

调度的目标是提高CPU的利用率，进程的调度目的是尽可能提高CPU的利用率。CPU利用率的计算公式为

\n

CPU利用率=CPU有效工作时间CPU有效工作时间+CPU空闲等待时间\\text{CPU利用率} = \\frac{\\text{CPU有效工作时间}}{\\text{CPU有效工作时间}+\\text{CPU空闲等待时间}}\nCPU利用率=CPU有效工作时间+CPU空闲等待时间CPU有效工作时间​

\n

系统吞吐量用于衡量系统的执行单个作业的平均速度。长作业通常占用CPU的时间，降低系统的吞吐量。

\n

周转时间指作业从提交到完成的整个生命周期所消耗的时间，包括等待、就绪态排队、阻塞态等待IO以及实际CPU的执行时间。对于nnn个作业的平均周转时间为均值

\n

调度算法

\n
先来先服务(FCFS)算法
\n

FCFS算法中的进程队列满足FIFO，即先来先执行，晚到晚执行的策略，属于非抢占式的算法。FCFS是公平算法但是对短进程不友好，效率较低；同时FCFS遇到高频IO的进程无法快速释放CPU资源，效率更低。

\n
短作业优先(SJF)算法 / 短进程优先(SPF)算法
\n

短作业优先算法会进行队列中的作业用时预测，将最短用时的作业分配CPU资源。

\n

预测算法是简单的预测时间加权。对于上一次实际用时 tnt_ntn​ 与预测用时 τn\\tau_nτn​, 以及预测因子 α\\alphaα, 本轮的预测用时为

\n

τn+1=αtn+(1−α)τn\\tau_{n+1} = \\alpha t_n + (1-\\alpha)\\tau_n \nτn+1​=αtn​+(1−α)τn​

\n

SJF对于长作业不利，如果短作业频繁创建，长作业会始终得不到CPU资源而产生饥饿现象(调度策略使某一进程出现无限期等待)；同时SJF只考虑了作业长度作为优先级而没考虑进程的优先级，无法保证紧迫作业及时处理。

\n
高响应比优先调度算法
\n

基于响应比评估作业的整体优先级，综合考虑了作业的时效性与等候时间

\n

响应比=等待时间+估计运行时间估计运行时间\\text{响应比} = \\frac{\\text{等待时间}+\\text{估计运行时间}}{\\text{估计运行时间}}\n响应比=估计运行时间等待时间+估计运行时间​

\n
优先级调度算法
\n

根据系统优先级进行作业的调度

\n

优先级调度算法根据是否能在进程期间抢占CPU资源分为

\n\n

通常 系统进程 > 用户进程， 交互性进程 > 非交互性进程， IO进程 > 计算进程(IO设备的传输与处理优先级高，相关的数据信息无法暂存，处理速度也慢于CPU)

\n

根据进程优先级是否可变可以分为静态优先级与动态优先级。其中静态优先级指进程优先级在创建时就固定不可变，调度简单但是有可能出现饥饿现象；动态优先级可以根据等待时间或者进程属性进行动态的改变。

\n
时间片轮转(RR)算法
\n

时间片一个执行窗口，如果进程执行时间长于时间片，就将进程CPU资源释放给下一个进程，并放入就绪队列。时间片轮转能保证进程的公平性，不会遇到饥饿现象，但是面临性能开销较大的问题。

\n

当进程结束但是时间片未结束，此时也触发时间片的轮转，为下一个几次呢分配CPU资源

\n
多级队列调度算法
\n

将就绪进程分为多个不同优先级、不同或相同调度算法的进程队列，进行进程的调度与执行。潜在的问题为高级队列进程频繁创建的场景下，低等级队列的进程饥饿

\n
多级反馈队列调度算法
\n

相比多级队列调度算法， 多级反馈队列调度算法打通了不同优先级队列的通道。多级反馈队列的通常基于递增时间片的进程队列实现，通常越低级、越底层的队列的时间片越长，越接近FCFS。

\n

新到达的进程通常先进入最高优先级队列。若进程在当前队列的时间片内未执行完，则被剥夺 CPU，并被移动到下一较低优先级队列的队尾继续等待；若进程已经处于最低优先级队列，则被剥夺 CPU 后通常回到该最低级队列队尾等待。、、

\n

多处理机调度

\n

多处理器系统分为非对称多处理器(AMP)和对称多处理器(SMP)。AMP有一个独立主CPU进行全部调度与决策，从CPU只执行任务；SMP的CPU是平等执行与调度进程的，调度程序可以将任意就绪进程分配给不同的CPU

\n

在多核CPU/多CPU系统中，某个进程在CPU1运行，调度到CPU2时，相应的寄存器与Cache都要进行移动。因此系统应尽量使进程在单个CPU中调度，称为处理器亲和性

\n

CPU多核性能平均化称为 性能均衡，因此需要进行CPU间的进程调度实现多核平均化。从这个角度看，处理器亲和性与性能均衡是相对矛盾的，性能均衡会抵消处理器亲和性的性能优化。

\n

面向多处理机的调度方式可以分为公有队列调度与私有队列调度

\n\n

处理器的亲和性的提升方法分为软亲和与硬亲和。软亲和指调度器进行进程软绑定在某个CPU上，尽量向这个CPU调度；硬亲和指用户进程通过系统调度主动请求系统绑定在某个CPU上。

\n

协程

\n

协程是语言实现的，可以在线程内部执行、中断并恢复的程序控制结构，通过yield()自主管理CPU的调用，其性能开销小于线程的切换

\n", "tags": [] }, { "id": "https://yuuko.site/2026/05/24/CS/LLM/deepnet/", "url": "https://yuuko.site/2026/05/24/CS/LLM/deepnet/", "title": "DeepNet", "date_published": "2026-05-23T16:00:00.000Z", "content_html": "

DeepNet

\n

本篇文章作为Transformer 中的 Layer Normalization与梯度稳定性的后继文章，进一步进行Layer Normalization的相关学习

\n

Warm-up 与初始化方式对于梯度下降稳定性的影响

\n

在本节设置了三个实验组进行对比

\n\n

Xavier的缩放初始化是对于第 lll 层，l∈[1,N]l\\in[1,N]l∈[1,N], 有随着深度递减的缩放因子kl=N+1−lk_l = N+1-lkl​=N+1−l, 使得

\n

Wol∼N(0,1kl2d′)W_o^l\\sim \\mathcal{N}(0,\\frac{1}{k_l^2d'})\nWol​∼N(0,kl2​d′1​)

\n

\"scaling_init\"

\n

其采用的评估指标为整个模型各轮训练的输出更新的模, θi\\theta_iθi​ 表示第iii轮训练后的参数, θ0\\theta_0θ0​ 表示初始化参数

\n

∥ΔFi∥=∥F(x,θi)−F(x,θ0)∥\\|\\Delta F_i\\| = \\|F(x,\\theta_i)-F(x,\\theta_0)\\|\n∥ΔFi​∥=∥F(x,θi​)−F(x,θ0​)∥

\n

在图4.a中，对照组1 的Model Update在初始步就出现了爆炸。这一结论和 Transformer 中的 Layer Normalization与梯度稳定性 中的结论是一致的。

\n

通过图3的子图对比，作者将Model Update 而非梯度模作为评估梯度下降稳定性的评估指标，因为在对照组2、3的对比中，对照组3的梯度模更大，但是具有更好的收敛效果。

\n

DeepNet 的结构

\n

本文的主体创新点，即DeepNorm 架构。相对于Pre-LN,就是在主输入信号处增加了一个可学习参数 α>1\\alpha>1α>1, 对输入tensor进行了放大。

\n

\"deepnet_architecture\"

\n

Lemma 1.: 对于 X=(x1,⋯ ,xn)∈Rn×dX=(\\mathbf{x}_1,\\cdots,\\mathbf{x}_n)\\in \\mathbb{R}^{n\\times d}X=(x1​,⋯,xn​)∈Rn×d, Var(xi)=1,E(xi)=0\\mathrm{Var}(\\mathbf{x}_i) = 1, \\mathbf{E}(\\mathbf{x}_i) = 0Var(xi​)=1,E(xi​)=0, qi∈[0,1]q_i\\in [0,1]qi​∈[0,1], 则有

\n

Softmax(q1,⋯ ,qn)⋅X≍xi\\mathrm{Softmax}(q_1,\\cdots, q_n)\\cdot X \\asymp \\mathbf{x}_i\nSoftmax(q1​,⋯,qn​)⋅X≍xi​

\n

这里的 ≍\\asymp≍ 表示 equal bound of magnitude，即只比较数量级上的上下界，而不要求两个向量在方向或逐元素取值上相同。
\nProof:

\n

Softmax(q1,⋯ ,qn)⋅X=(exp⁡qi∑exp⁡qj)i⋅(x1,⋯ ,xn)T=∑xiexp⁡qi∑exp⁡qj\\begin{aligned}\n\\mathrm{Softmax}(q_1,\\cdots, q_n) \\cdot X &= \\left(\\frac{\\exp{q_i}}{\\sum \\exp{q_j}}\\right)_{i}\\cdot \\left(\\mathbf{x}_1,\\cdots ,\\mathbf{x}_n \\right)^T\\\\\n&=\\sum \\frac{\\mathbf{x}_i\\exp q_i}{\\sum\\exp q_j}\n\\end{aligned}\nSoftmax(q1​,⋯,qn​)⋅X​=(∑expqj​expqi​​)i​⋅(x1​,⋯,xn​)T=∑∑expqj​xi​expqi​​​

\n

由于

\n

n≤∑exp⁡qj≤nen\\leq\\sum \\exp q_j\\leq ne\nn≤∑expqj​≤ne

\n

有

\n

1∑exp⁡qj=Θ(1n)\\frac{1}{\\sum \\exp q_j} = \\Theta\\left(\\frac{1}{n}\\right)\n∑expqj​1​=Θ(n1​)

\n

因此可以写成凸集的形式

\n

Softmax(q1,⋯ ,qn)X=∑i=1nwixi,wi=exp⁡qi∑exp⁡qj=Θ(1n).\\mathrm{Softmax}(q_1,\\cdots,q_n)X\n= \\sum_{i=1}^n w_i\\mathbf{x}_i,\n\\quad\nw_i=\\frac{\\exp{q_i}}{\\sum \\exp q_j}=\\Theta\\left(\\frac1n\\right).\nSoftmax(q1​,⋯,qn​)X=i=1∑n​wi​xi​,wi​=∑expqj​expqi​​=Θ(n1​).

\n

因此，由 wi=Θ(1n)w_i=\\Theta\\left(\\frac1n\\right)wi​=Θ(n1​) 可得

\n

∑i=1nwixi≍∑i=1n1nxi.\\sum_{i=1}^n w_i\\mathbf{x}_i\n\\asymp\n\\sum_{i=1}^n \\frac1n\\mathbf{x}_i .\ni=1∑n​wi​xi​≍i=1∑n​n1​xi​.

\n

又因为每个 xi\\mathbf{x}_ixi​ 都满足 E(xi)=0\\mathbf{E}(\\mathbf{x}_i)=0E(xi​)=0 且 Var(xi)=1\\mathrm{Var}(\\mathbf{x}_i)=1Var(xi​)=1，所以所有 xi\\mathbf{x}_ixi​ 具有相同的 magnitude bound。于是 nnn 个同阶向量经过 1n\\frac1nn1​ 量级的权重加权求和后，其输出仍然具有与单个 xi\\mathbf{x}_ixi​ 相同的 magnitude bound，即

\n

∑i=1n1nxi≍xi.\\sum_{i=1}^n \\frac1n\\mathbf{x}_i \\asymp \\mathbf{x}_i .\ni=1∑n​n1​xi​≍xi​.

\n

因此

\n

Softmax(q1,⋯ ,qn)X=∑i=1nwixi≍xi.\\mathrm{Softmax}(q_1,\\cdots,q_n)X\n= \\sum_{i=1}^n w_i\\mathbf{x}_i\n\\asymp \\mathbf{x}_i .\nSoftmax(q1​,⋯,qn​)X=i=1∑n​wi​xi​≍xi​.

\n

Lemma 1对Attention输出头的阶进行了估计，保证了输入和输出的阶是相等的，Attention不会导致Model Update发生爆炸

\n

Lemma 2 方差的阶的可加性

\n

Var(X+Y)≍Var(X)+Var(Y)\\mathrm{Var}(X+Y)\\asymp \\mathrm{Var}(X) + \\mathrm{Var}(Y)\nVar(X+Y)≍Var(X)+Var(Y)

\n

Proof:
\n展开得

\n

Var(X+Y)=E[(X+Y)2]−[E(X+Y)]2=E(X2)−E2(X)+E(Y2)−E2(Y)+2E(XY)−E(X)E(Y)=Var(X)+Var(Y)+2cov(X,Y)\\begin{aligned}\n\\mathrm{Var}(X+Y) &= \\mathbb{E}[(X+Y)^2] - [\\mathbb{E}(X+Y)]^2\\\\\n& = \\mathbb{E}(X^2) - \\mathbb{E}^2(X) +\\mathbb{E}(Y^2) - \\mathbb{E}^2(Y) +2\\mathbb{E}(XY) - \\mathbb{E}(X)\\mathbb{E}(Y)\\\\\n& = \\mathrm{Var}(X) +\\mathrm{Var}(Y)+2\\mathrm{cov}(X,Y)\n\\end{aligned}\nVar(X+Y)​=E[(X+Y)2]−[E(X+Y)]2=E(X2)−E2(X)+E(Y2)−E2(Y)+2E(XY)−E(X)E(Y)=Var(X)+Var(Y)+2cov(X,Y)​

\n

Theorem 1 对于NNN层DeepNet结构 F(x,θ)F(x,\\theta)F(x,θ) , 每一层的DeepNet可表示为 xl+1=f(xl,θl)=LN(αxl+Gθl(xl))x_{l+1} = f(x_l,\\theta_l) = \\mathrm{LN}(\\alpha x_l+G_{\\theta_l}(x_l))xl+1​=f(xl​,θl​)=LN(αxl​+Gθl​​(xl​)), θi∈{θ1,⋯ ,θ2N}\\theta_i\\in \\left\\{\\theta_1,\\cdots,\\theta_{2N}\\right\\}θi​∈{θ1​,⋯,θ2N​}

\n

其中奇数参数是Selt-Attention的参数权重，偶数参数是FFN的参数权重。则有

\n

∥ΔF∥≤∑i=1nvi2+wi2α∥θi∗−θi∥\\|\\Delta F\\|\\leq \\sum_{i=1}^n \\frac{\\sqrt{v_i^2+w_i^2}}{\\alpha}\\|\\theta^*_i-\\theta_i\\|\n∥ΔF∥≤i=1∑n​αvi2​+wi2​​​∥θi∗​−θi​∥

\n

基于最简化的情况，Self-Attention Layer 与 FFN layer 都视为 Gθ(xl)≍vlwlxlG_\\theta(x_l) \\asymp v_lw_lx_lGθ​(xl​)≍vl​wl​xl​, 则每一个Layer的递推输出为

\n

xl+1=f(xl,θl)=αxl+Gθl(xl)Var(αxl+Gθl(xl))≍(α+vlwl)xl(α2+vl2wl2)Var(xl)\\begin{aligned}\nx_{l+1} = f(x_l,\\theta_l) &= \\frac{\\alpha x_l+G_{\\theta_l}(x_l)}{\\sqrt{\\mathrm{Var}(\\alpha x_l+G_{\\theta_l}(x_l))}}\\\\\n& \\asymp \\frac{(\\alpha+v_lw_l)x_l}{\\sqrt{(\\alpha^2+v_l^2w_l^2)\\mathrm{Var}(x_l)}}\\\\\n\\end{aligned}\nxl+1​=f(xl​,θl​)​=Var(αxl​+Gθl​​(xl​))​αxl​+Gθl​​(xl​)​≍(α2+vl2​wl2​)Var(xl​)​(α+vl​wl​)xl​​​

\n

根据Lemma 1, Var(xl)≍Var(x0)=1\\mathrm{Var}(x_l) \\asymp \\mathrm{Var}(x_0) = 1Var(xl​)≍Var(x0​)=1, 故

\n

xl+1=f(xl,θl)≍α+vlwlα2+vl2wl2xlx_{l+1} = f(x_l,\\theta_l) \\asymp \\frac{\\alpha+v_lw_l}{\\sqrt{\\alpha^2+v_l^2w_l^2}}x_l\nxl+1​=f(xl​,θl​)≍α2+vl2​wl2​​α+vl​wl​​xl​

\n

因此

\n

∂fl∂xl≍α+vlwlα2+vl2wl2\\frac{\\partial f_l}{\\partial x_l} \\asymp \\frac{\\alpha+v_lw_l}{\\sqrt{\\alpha^2+v_l^2w_l^2}}\n∂xl​∂fl​​≍α2+vl2​wl2​​α+vl​wl​​

\n

视 θl=(vl,wl)\\theta_l = (v_l,w_l)θl​=(vl​,wl​)

\n

∂fl∂θl≍αxl(α−vlwl)(α2+vl2wl2)32(wl,vl)\\frac{\\partial f_l}{\\partial \\theta_l} \\asymp \\frac{\\alpha x_l(\\alpha -v_lw_l)}{(\\alpha^2+v_l^2w_l^2)^{\\frac{3}{2}}} \\left(w_l,v_l\\right)\n∂θl​∂fl​​≍(α2+vl2​wl2​)23​αxl​(α−vl​wl​)​(wl​,vl​)

\n

因此可展开Layer Model Update

\n

∥ΔF∥=∥f(x2N∗,θ2N∗)−f(x2N,θ2N)∥=∥∂f∂xl(x2N,θ2N)(x2N∗−x2N)+∂f∂θl(x2N,θ2N)(θ2N∗−θ2N)∥≤∥∂f∂xl(x2N,θ2N)∥∥x2N∗−x2N∥+∥∂f∂θl(x2N,θ2N)∥∥θ2N∗−θ2N∥≍α+v2Nw2Nα2+v2N2w2N2∥x2N∗−x2N∥+αx2N(α−v2Nw2N)(α2+v2N2w2N2)32∥(w2N,v2N)∥∥θ2N∗−θ2N∥∣≤∥x2N∗−x2N∥+αx2N(α−v2Nw2N)(α2+v2N2w2N2)32w2N2+v2N2∥θ2N∗−θ2N∥≍∥x2N∗−x2N∥+w2N2+v2N2α∥θ2N∗−θ2N∥ \\begin{aligned}\n\\|\\Delta F\\| &= \\|f(x_{2N}^*,\\theta_{2N}^*)-f(x_{2N},\\theta_{2N})\\|\\\\\n& = \\|\\frac{\\partial f}{\\partial x_l}(x_{2N},\\theta_{2N})(x^*_{2N}-x_{2N}) +\\frac{\\partial f}{\\partial \\theta_l}(x_{2N},\\theta_{2N})(\\theta_{2N}^*-\\theta_{2N})\\|\\\\\n&\\leq \\|\\frac{\\partial f}{\\partial x_l}(x_{2N},\\theta_{2N}) \\| \\|x^*_{2N}-x_{2N}\\| +\\|\\frac{\\partial f}{\\partial \\theta_l}(x_{2N},\\theta_{2N})\\|\\|\\theta_{2N}^*-\\theta_{2N}\\|\\\\\n&\\asymp \\frac{\\alpha+v_{2N}w_{2N}}{\\sqrt{\\alpha^2+v_{2N}^2w_{2N}^2}}\\|x^*_{2N}-x_{2N}\\|+ \\frac{\\alpha x_{2N}(\\alpha -v_{2N}w_{2N})}{(\\alpha^2+v_{2N}^2w_{2N}^2)^{\\frac{3}{2}}} \\|\\left(w_{2N},v_{2N}\\right)\\|\\|\\theta_{2N}^*-\\theta_{2N}\\||\\\\\n&\\leq \\|x^*_{2N}-x_{2N}\\|+\\frac{\\alpha x_{2N}(\\alpha -v_{2N}w_{2N})}{(\\alpha^2+v_{2N}^2w_{2N}^2)^{\\frac{3}{2}}} \\sqrt{w_{2N}^2+v_{2N}^2}\\|\\theta_{2N}^*-\\theta_{2N}\\|\\\\\n&\\asymp \\|x^*_{2N}-x_{2N}\\|+\\frac{\\sqrt{w_{2N}^2+v_{2N}^2}}{\\alpha}\\|\\theta_{2N}^*-\\theta_{2N}\\|\\\n\\end{aligned}\n∥ΔF∥​=∥f(x2N∗​,θ2N∗​)−f(x2N​,θ2N​)∥=∥∂xl​∂f​(x2N​,θ2N​)(x2N∗​−x2N​)+∂θl​∂f​(x2N​,θ2N​)(θ2N∗​−θ2N​)∥≤∥∂xl​∂f​(x2N​,θ2N​)∥∥x2N∗​−x2N​∥+∥∂θl​∂f​(x2N​,θ2N​)∥∥θ2N∗​−θ2N​∥≍α2+v2N2​w2N2​​α+v2N​w2N​​∥x2N∗​−x2N​∥+(α2+v2N2​w2N2​)23​αx2N​(α−v2N​w2N​)​∥(w2N​,v2N​)∥∥θ2N∗​−θ2N​∥∣≤∥x2N∗​−x2N​∥+(α2+v2N2​w2N2​)23​αx2N​(α−v2N​w2N​)​w2N2​+v2N2​​∥θ2N∗​−θ2N​∥≍∥x2N∗​−x2N​∥+αw2N2​+v2N2​​​∥θ2N∗​−θ2N​∥ ​

\n

递推得

\n

∥ΔF∥≤∑i=12Nwi2+vi2α∥θi∗−θi∥\\|\\Delta F\\|\\leq\\sum_{i=1}^{2N}\\frac{\\sqrt{w_{i}^2+v_{i}^2}}{\\alpha}\\|\\theta_{i}^*-\\theta_{i}\\|\n∥ΔF∥≤i=1∑2N​αwi2​+vi2​​​∥θi∗​−θi​∥

\n

由于每一个wi,viw_i,v_iwi​,vi​ 的初始化都与scaling factor β\\betaβ 相关， 因此整个Model Update 的 Bound 能通过 α,β\\alpha, \\betaα,β 控制，我们能通过设计这两个值的大小实现稳定训练Deeper的Network且保证收敛

\n", "tags": [] }, { "id": "https://yuuko.site/2026/05/23/CS/LLM/ln/", "url": "https://yuuko.site/2026/05/23/CS/LLM/ln/", "title": "Transformer 中的 Layer Normalization与梯度稳定性", "date_published": "2026-05-22T16:00:00.000Z", "content_html": "

On Layer Normalization in the Transformer Architecture

\n

本文介绍了Pre-LN, 将归一化层放置在残差分支，以降低训练初始状态的训练梯度爆炸的现象。通过Post-LN架构进行训练刚需Warm-up(即通过初始降低学习率的方式进行训练)， 本文提出的Pre-LN通过迁移LN层位置的方式降低了整体梯度的稳定性与相对大小。将模型从Warm-up 中解脱出来。

\n

Layer Normalization的作用

\n

LN(x)=γ⊙x−μσ2+ε+β\\mathrm{LN}(x) = \\gamma \\odot \\frac{x-\\mu}{\\sqrt{\\sigma^2+\\varepsilon}}+\\beta\nLN(x)=γ⊙σ2+ε​x−μ​+β

\n

其中 γ,β\\gamma, \\betaγ,β 是可学习的参数。

\n

整个 LN\\mathrm{LN}LN层的作用可视为一个归一化与一个仿射变换作用，内层归一化可表示为

\n

Normal:x→x−μσ2+ε\\mathrm{Normal}: x\\to \\frac{x-\\mu}{\\sqrt{\\sigma^2+\\varepsilon}}\nNormal:x→σ2+ε​x−μ​

\n

归一化的 Normal(x)\\mathrm{Normal}(x)Normal(x)变为期望000, 方差111的标准向量

\n

Var(Normal(x))=σ2σ2+ε→1E(Normal(x))=0\\begin{aligned}\n\\mathrm{Var}(\\mathrm{Normal}(x)) &= \\frac{\\sigma^2}{\\sigma^2+\\varepsilon}\\to 1 \\\\\n\\mathrm{E}(\\mathrm{Normal}(x)) &= 0\n\\end{aligned}\nVar(Normal(x))E(Normal(x))​=σ2+εσ2​→1=0​

\n

可学习的参数 γ,β\\gamma, \\betaγ,β 能改变向量的整体期望与均值以增强 LN\\mathrm{LN}LN 层的调节能力。

\n

Post-Layer Normalization 的 梯度爆炸与 Warm-up

\n

本文对于Multi Head Attention 的梯度阶估计过程提出了一个简化计算的模型，再通过实验论证假设对于完整的MHA Residue Flow 也成立。

\n

初始权重使用Xavier初始化，每个权重www满足

\n

Var(w)=2nin+nout\\mathrm{Var}(w) = \\frac{2}{n_{in}+n_{out}} \nVar(w)=nin​+nout​2​

\n

Post-LN 层的一次前向传播的公式

\n

{x~tpost=LN(xtpost+MHA(xtpost))xt+1post=LN(x~tpost+FFN(x~tpost))\\begin{dcases}\n\\tilde{x}^{post}_t = \\mathrm{LN}(x^{post}_t+\\mathrm{MHA}(x^{post}_t))\\\\\nx^{post}_{t+1} = \\mathrm{LN}(\\tilde{x}^{post}_t+ \\mathrm{FFN}(\\tilde{x}^{post}_t))\n\\end{dcases}\n{x~tpost​=LN(xtpost​+MHA(xtpost​))xt+1post​=LN(x~tpost​+FFN(x~tpost​))​

\n

Pre-LN 层的一次前向传播的公式

\n

{x~tpre=xtpre+MHA(LN(xtpre))xt+1pre=x~tpre+FFN(LN(x~tpre))\\begin{dcases}\n\\tilde{x}^{pre}_t = x^{pre}_t + \\mathrm{MHA}(\\mathrm{LN}(x^{pre}_t))\\\\\nx^{pre}_{t+1} = \\tilde{x}^{pre}_t+\\mathrm{FFN}(\\mathrm{LN}(\\tilde{x}^{pre}_t))\n\\end{dcases}\n{x~tpre​=xtpre​+MHA(LN(xtpre​))xt+1pre​=x~tpre​+FFN(LN(x~tpre​))​

\n

记

\n

JLN(x)=∂LN(x)∂xJ_{\\mathrm{LN}}(x) = \\frac{\\partial \\mathrm{LN}(x)}{\\partial x}\nJLN​(x)=∂x∂LN(x)​

\n

为 LN\\mathrm{LN}LN层的Jacobian 矩阵

\n

则Post-LN满足

\n

dx~tpost=JLN(xtpost+MHA(xtpost))⋅(dxtpost+dMHA(xtpost))=JLN(xtpost+MHA(xtpost))⋅(I+JMHA(xtpost))⋅dxtpost\\begin{aligned}\n\\mathrm{d}\\tilde{x}^{post}_t &= J_{\\mathrm{LN}}(x^{post}_t+\\mathrm{MHA}(x^{post}_t))\\cdot (\\mathrm{d} x^{post}_t+ \\mathrm{d} \\mathrm{MHA}(x^{post}_t))\\\\\n&=J_{\\mathrm{LN}}(x^{post}_t+\\mathrm{MHA}(x^{post}_t))\\cdot(I+J_{\\mathrm{MHA}}(x^{post}_t)) \\cdot \\mathrm{d}x^{post}_t\n\\end{aligned}\ndx~tpost​​=JLN​(xtpost​+MHA(xtpost​))⋅(dxtpost​+dMHA(xtpost​))=JLN​(xtpost​+MHA(xtpost​))⋅(I+JMHA​(xtpost​))⋅dxtpost​​

\n

dxt+1post=JLN(x~tpost+FFN(x~tpost))⋅(I+JFFN(x~tpost))dx~tpost\\begin{aligned}\n\\mathrm{d} x^{post}_{t+1} = J_\\mathrm{LN}(\\tilde{x}^{post}_t+\\mathrm{FFN}(\\tilde{x}^{post}_t))\\cdot (I+J_\\mathrm{FFN}(\\tilde{x}^{post}_t))\\mathrm{d}\\tilde{x}^{post}_t\n\\end{aligned}\ndxt+1post​=JLN​(x~tpost​+FFN(x~tpost​))⋅(I+JFFN​(x~tpost​))dx~tpost​​

\n

∂xt+1post∂xtpost=JLN(x~tpost+FFN(x~tpost))⋅(I+JFFN(x~tpost))⋅JLN(xtpost+MHA(xtpost))⋅(I+JMHA(xtpost))\\frac{\\partial x^{post}_{t+1}}{\\partial x^{post}_{t}} = J_\\mathrm{LN}(\\tilde{x}^{post}_t+\\mathrm{FFN}(\\tilde{x}^{post}_t))\\cdot (I+J_\\mathrm{FFN}(\\tilde{x}^{post}_t))\\cdot J_{\\mathrm{LN}}(x^{post}_t+\\mathrm{MHA}(x^{post}_t))\\cdot(I+J_{\\mathrm{MHA}}(x^{post}_t))\n∂xtpost​∂xt+1post​​=JLN​(x~tpost​+FFN(x~tpost​))⋅(I+JFFN​(x~tpost​))⋅JLN​(xtpost​+MHA(xtpost​))⋅(I+JMHA​(xtpost​))

\n

Pre-LN满足

\n

dx~tpre=(I+JMHA(LN(xtpre))⋅JLN(xtpre))dxtpredxt+1pre=(I+JFFN(LN(x~tpre))⋅JLN(x~tpre))dx~tpre\\begin{aligned}\n\\mathrm{d} \\tilde{x}^{pre}_{t} &= (I + J_{\\mathrm{MHA}}(\\mathrm{LN}(x^{pre}_t))\\cdot J_{\\mathrm{LN}}(x^{pre}_t))\\mathrm{d}x^{pre}_t\\\\\n\\mathrm{d} x^{pre}_{t+1}&=(I + J_{\\mathrm{FFN}}(\\mathrm{LN}(\\tilde{x}^{pre}_t))\\cdot J_{\\mathrm{LN}}(\\tilde{x}^{pre}_t))\\mathrm{d}\\tilde{x}^{pre}_t\n\\end{aligned}\ndx~tpre​dxt+1pre​​=(I+JMHA​(LN(xtpre​))⋅JLN​(xtpre​))dxtpre​=(I+JFFN​(LN(x~tpre​))⋅JLN​(x~tpre​))dx~tpre​​

\n

∂xt+1pre∂xtpre=(I+JFFN(LN(x~tpre))⋅JLN(x~tpre))⋅(I+JMHA(LN(xtpre))⋅JLN(xtpre))\\frac{\\partial x^{pre}_{t+1}}{\\partial x^{pre}_t} = (I + J_{\\mathrm{FFN}}(\\mathrm{LN}(\\tilde{x}^{pre}_t))\\cdot J_{\\mathrm{LN}}(\\tilde{x}^{pre}_t))\\cdot(I + J_{\\mathrm{MHA}}(\\mathrm{LN}(x^{pre}_t))\\cdot J_{\\mathrm{LN}}(x^{pre}_t))\n∂xtpre​∂xt+1pre​​=(I+JFFN​(LN(x~tpre​))⋅JLN​(x~tpre​))⋅(I+JMHA​(LN(xtpre​))⋅JLN​(xtpre​))

\n

MHA贡献的梯度流动

\n

基于本文关于MHA的假定，有WQ=WK=0W_Q = W_K = 0WQ​=WK​=0, 因此单一Attention头的输出为

\n

h=Softmax(QKTd)⋅V=Softmax(0)⋅X⋅WV=1nX⋅WV=1n∑j=1nxjwVj\\begin{aligned}\nh &= \\mathrm{Softmax}(\\frac{QK^T}{\\sqrt{d}})\\cdot V\\\\\n& = \\mathrm{Softmax}(\\bold{0}) \\cdot X\\cdot W_V\\\\\n& = \\frac{1}{n}X\\cdot W_V\\\\\n& = \\frac{1}{n} \\sum_{j=1}^n x^j w_{V}^j\n\\end{aligned}\nh​=Softmax(d​QKT​)⋅V=Softmax(0)⋅X⋅WV​=n1​X⋅WV​=n1​j=1∑n​xjwVj​​

\n

MHA(X)=Concat(h1,⋯ ,hn)⋅WO\\mathrm{MHA}(X) = \\mathrm{Concat}(h_1,\\cdots, h_n)\\cdot W_O\nMHA(X)=Concat(h1​,⋯,hn​)⋅WO​

\n

计算MHA的微分

\n

d MHA(X)=d Concat(h1,⋯ ,hn)⋅WO+Concat(h1,⋯ ,hn)⋅dWO=Concat(dh1,⋯ ,dhn)⋅WO+Concat(h1,⋯ ,hn)⋅dWO=Concat(dX⋅WVi)⋅WO=dX⋅Concat(WVi)⋅WO=1n∑j=in(dxj)⋅Concat(WVi)⋅WO:=1n∑j=in(dxj)WV,l\\begin{aligned}\n\\mathrm{d\\,MHA}(X)&= \\mathrm{d\\,Concat}(h_1,\\cdots, h_n)\\cdot W_O+ \\mathrm{Concat}(h_1,\\cdots, h_n)\\cdot \\mathrm{d}W_O \\\\\n& = \\mathrm{Concat}(\\mathrm{d}h_1,\\cdots,\\mathrm{d}h_n)\\cdot W_O + \\mathrm{Concat}(h_1,\\cdots, h_n)\\cdot \\mathrm{d}W_O\\\\\n& = \\mathrm{Concat}(\\mathrm{d}X \\cdot W_V^i)\\cdot W_O\\\\\n& = \\mathrm{d}X\\cdot \\mathrm{Concat}(W_V^i)\\cdot W_O\\\\\n& = \\frac{1}{n}\\sum_{j=i}^n\\left(\\mathrm{d}x^j\\right)\\cdot \\mathrm{Concat}(W_V^i)\\cdot W_O\\\\\n& :=\\frac{1}{n}\\sum_{j=i}^n\\left(\\mathrm{d}x^j\\right) W_{V,l}\n\\end{aligned}\ndMHA(X)​=dConcat(h1​,⋯,hn​)⋅WO​+Concat(h1​,⋯,hn​)⋅dWO​=Concat(dh1​,⋯,dhn​)⋅WO​+Concat(h1​,⋯,hn​)⋅dWO​=Concat(dX⋅WVi​)⋅WO​=dX⋅Concat(WVi​)⋅WO​=n1​j=i∑n​(dxj)⋅Concat(WVi​)⋅WO​:=n1​j=i∑n​(dxj)WV,l​​

\n

其中 WV,lW_{V,l}WV,l​ 是等效的随机矩阵

\n

WV,l=Concat(WVi)⋅WOW_{V,l} = \\mathrm{Concat}(W_V^i)\\cdot W_O \nWV,l​=Concat(WVi​)⋅WO​

\n

对应Jacobian矩阵为

\n

JMHA=1n11T⊗WV,lJ_{\\mathrm{MHA}} = \\frac{1}{n}\\bold{1}\\bold{1}^T\\otimes W_{V,l}\nJMHA​=n1​11T⊗WV,l​

\n

残差梯度流为

\n

I+JMHA=I+1n11T⊗WV,lI+J_\\mathrm{MHA} = I+\\frac{1}{n}\\bold{1}\\bold{1}^T\\otimes W_{V,l}\nI+JMHA​=I+n1​11T⊗WV,l​

\n

LN层Jacobian矩阵谱范数的阶估计

\n

根据上文推导，需要计算LN层的Jacobian矩阵的大小。在此我们只考虑未仿射变换的归一化映射的梯度，因为仿射变换后只需要进行梯度的线性缩放。

\n

LN(x)=x−μσ\\mathrm{LN}(x) = \\frac{x-\\mu}{\\sigma}\nLN(x)=σx−μ​

\n

取无偏向量

\n

y=x(I−1n1T1)=(x1−1n∑xix2−1n∑xi⋮xn−1n∑xi)y = x(I-\\frac{1}{n}\\bold{1}^T\\bold{1}) = \\begin{pmatrix}\nx_1 - \\frac{1}{n}\\sum x_i\\\\[1em]\nx_2 - \\frac{1}{n}\\sum x_i\\\\[1em]\n\\vdots\\\\[1em]\nx_n - \\frac{1}{n}\\sum x_i\n\\end{pmatrix}\ny=x(I−n1​1T1)=​x1​−n1​∑xi​x2​−n1​∑xi​⋮xn​−n1​∑xi​​​

\n

其中

\n

∥y∥=1n∑i(xi−μ)2=1n∑i(xi2−2μxi+μ2)=1n∑ixi2−μ2\\begin{aligned}\n\\|y\\| &= \\sqrt{\\frac{1}{n}\\sum_i (x_i-\\mu)^2}\\\\\n&=\\sqrt{\\frac{1}{n} \\sum_i (x_i^2-2\\mu x_i+\\mu^2)}\\\\\n\n&=\\sqrt{\\frac{1}{n}\\sum_i x_i^2-\\mu^2}\n\\end{aligned}\n∥y∥​=n1​i∑​(xi​−μ)2​=n1​i∑​(xi2​−2μxi​+μ2)​=n1​i∑​xi2​−μ2​​

\n

有O(∥y∥)=O(∥x∥)\\mathcal{O}(\\|y\\|) = \\mathcal{O}(\\|x\\|)O(∥y∥)=O(∥x∥)

\n

因此

\n

LN(x)=y1n∑yj2\\mathrm{LN}(x) = \\frac{y}{\\sqrt{\\frac{1}{n}\\sum y_j^2}}\nLN(x)=n1​∑yj2​​y​

\n

∂LN(x)i∂yj=nδi,j∑yj2−yiyj∑yj2∑yj2=n∥y∥(δi,j−yiyj∥y∥2)\\begin{aligned}\n\\frac{\\partial \\mathrm{LN}(x)_i}{\\partial y_j} & = \\sqrt{n} \\frac{\\delta_{i,j} \\sqrt{\\sum y_j^2} - y_i\\frac{y_j}{\\sqrt{\\sum y_j^2}}}{\\sum y_j^2}\\\\\n& = \\frac{\\sqrt{n}}{\\|y\\|}\\left(\\delta_{i,j} -\\frac{y_iy_j}{\\|y\\|^2} \\right)\n\\end{aligned}\n∂yj​∂LN(x)i​​​=n​∑yj2​δi,j​∑yj2​​−yi​∑yj2​​yj​​​=∥y∥n​​(δi,j​−∥y∥2yi​yj​​)​

\n

因此

\n

JLN(x)=∂LN(x)∂y∂y∂x=n∥y∥(I−yiyj∥y∥2)(I−1T1)\\begin{aligned}\nJ_{\\mathrm{LN}}(x) &= \\frac{\\partial \\mathrm{LN}(x)}{\\partial y}\\frac{\\partial y}{\\partial x}\\\\\n&=\\frac{\\sqrt{n}}{\\|y\\|}\\left(I-\\frac{y_iy_j}{\\|y\\|^2}\\right)(I- \\bold{1}^T\\bold{1})\n\\end{aligned}\nJLN​(x)​=∂y∂LN(x)​∂x∂y​=∥y∥n​​(I−∥y∥2yi​yj​​)(I−1T1)​

\n

∥JLN(x)∥=O(n∥y∥)=O(n∥x∥)\\|J_\\mathrm{LN}(x)\\| = \\mathcal{O}(\\frac{\\sqrt{n}}{\\|y\\|}) = \\mathcal{O}(\\frac{\\sqrt{n}}{\\|x\\|})\n∥JLN​(x)∥=O(∥y∥n​​)=O(∥x∥n​​)

\n

基于以上结果进行主定理的叙述

\n
\n

Definition 1.1: 随机变量的 (ε,δ)(\\varepsilon,\\delta)(ε,δ)-Bounded

\n

对于实随机变量 Z≥0Z\\geq 0Z≥0, 如果ZZZ满足

\n

P(Z−μμ≤ε)≥1−δ\\mathbb{P}\\left(\\frac{Z-\\mu}{\\mu}\\leq \\varepsilon\\right) \\geq 1-\\delta\nP(μZ−μ​≤ε)≥1−δ

\n

也即

\n

P(Z−μμ≥ε)≤δ\\mathbb{P}\\left(\\frac{Z-\\mu}{\\mu}\\geq \\varepsilon\\right) \\leq \\delta\nP(μZ−μ​≥ε)≤δ

\n

其中ε>0,0<δ<1\\varepsilon > 0, 0<\\delta <1ε>0,0<δ<1, 则称随机变量ZZZ是 (ε−δ)(\\varepsilon-\\delta)(ε−δ)-Bounded

\n
\n

这个结论和Chebyshev不等式的结构相似, Chebyshev不等式能说明对方差有界随机变量都是 (ε,σ2ε2)(\\varepsilon, \\frac{\\sigma^2}{\\varepsilon^2})(ε,ε2σ2​)-Bounded的

\n

整体损失函数梯度谱范数

\n

Post-LN架构的损失函数定义为顶部第LLL层的交叉熵

\n

L(xL+1,ipost)=−log⁡softmaxyi(WembxL+1,ipost)=−log⁡(P(Softmax(WembxL+1,ipost)∣ yi))\\mathcal{L}(x^{post}_{L+1,i}) = -\\log \\mathrm{softmax}_{y_i} (W^{emb}x^{post}_{L+1,i}) = -\\log(\\mathbb{P}(\\mathrm{Softmax}(W^{emb}x^{post}_{L+1,i})|\\, y_i))\nL(xL+1,ipost​)=−logsoftmaxyi​​(WembxL+1,ipost​)=−log(P(Softmax(WembxL+1,ipost​)∣yi​))

\n

Pre-LN架构尾部多一个LN块，损失函数为

\n

L(xfinal,ipre)=−log⁡softmaxyi(Wembxfinal,ipre)=−log⁡(P(Softmax(Wembxfinal,ipre)∣ yi))\\mathcal{L}(x^{pre}_{final,i}) = -\\log\\mathrm{softmax}_{y_i}(W^{emb}x^{pre}_{final,i}) = -\\log(\\mathbb{P}(\\mathrm{Softmax}(W^{emb}x^{pre}_{final,i})|\\, y_i))\nL(xfinal,ipre​)=−logsoftmaxyi​​(Wembxfinal,ipre​)=−log(P(Softmax(Wembxfinal,ipre​)∣yi​))

\n

其中

\n

xfinal,ipre=LN(xL+1,ipre)x^{pre}_{final,i} = \\mathrm{LN}(x^{pre}_{L+1,i})\nxfinal,ipre​=LN(xL+1,ipre​)

\n

Theorem 1. 假设 ∥WL+1,ipost∥\\|W^{post}_{L+1,i}\\|∥WL+1,ipost​∥, ∥WL+1,ipre∥\\|W^{pre}_{L+1,i}\\|∥WL+1,ipre​∥ 均为(ε,δ)(\\varepsilon,\\delta)(ε,δ)-Bounded的。 则Post-LN与Pre-LN结构的梯度谱范数满足

\n

{∥∂L~(xL+1post)∂W2,L∥F=O(dln⁡d)∥∂L~(xfinalpre)∂W2,L∥F=O(dln⁡dL)\\begin{dcases}\n\\left\\|\\frac{\\partial\\tilde{\\mathcal{L}} (x^{post}_{L+1})}{\\partial W^{2,L}}\\right\\|_F= \\mathcal{O}(d\\sqrt{\\ln d})\\\\[2em]\n\\left\\|\\frac{\\partial\\tilde{\\mathcal{L}}(x^{pre}_{final})}{\\partial W^{2,L}}\\right\\|_F=\\mathcal{O}(d\\sqrt{\\frac{\\ln d}{L}}) \n\\end{dcases}\n⎩⎨⎧​​∂W2,L∂L~(xL+1post​)​​F​=O(dlnd​)​∂W2,L∂L~(xfinalpre​)​​F​=O(dLlnd​​)​

\n

其中 W2,LW^{2,L}W2,L 是FFN中的参数矩阵

\n

Proof:
\n由链式法则

\n

∂L~(xL+1post)∂W2,L=∂L~(xL+1post)∂xL+1post(∏k=lL∂xk+1post∂xkpost)∂xlpostW2,L\\begin{aligned}\n\\frac{\\partial\\tilde{\\mathcal{L}} (x^{post}_{L+1})}{\\partial W^{2,L}}&= \\frac{\\partial \\tilde{\\mathcal{L}}(x^{post}_{L+1})}{\\partial x^{post}_{L+1}}\\left(\\prod_{k=l}^L\\frac{\\partial x^{post}_{k+1}}{\\partial x^{post}_{k}}\\right)\\frac{\\partial x^{post}_l}{W^{2,L}} \n\\end{aligned}\n∂W2,L∂L~(xL+1post​)​​=∂xL+1post​∂L~(xL+1post​)​(k=l∏L​∂xkpost​∂xk+1post​​)W2,L∂xlpost​​​

\n

∂L~∂xL+1post\\dfrac{\\partial\\tilde{L}}{\\partial x^{post}_{L+1}}∂xL+1post​∂L~​ 是有界的，因为 xL+1postx^{post}_{L+1}xL+1post​ 是 (ε,δ)(\\varepsilon,\\delta)(ε,δ)-Bounded的

\n

∣∂L~∂xL+1post∣=∣∂P(Softmax(WembxL+1post∣yi))P(Softmax(WembxL+1post∣yi))⋅∂xL+1post∣=O(1)\\left|\\dfrac{\\partial\\tilde{L}}{\\partial x^{post}_{L+1}}\\right| = \\left|\\frac{\\partial \\mathbb{P}(\\mathrm{Softmax}(W^{emb}x^{post}_{L+1}|y_i))}{\\mathbb{P}(\\mathrm{Softmax}(W^{emb}x^{post}_{L+1}|y_i))\\cdot\\partial x^{post}_{L+1}}\\right|= \\mathcal{O}(1)\n​∂xL+1post​∂L~​​=​P(Softmax(WembxL+1post​∣yi​))⋅∂xL+1post​∂P(Softmax(WembxL+1post​∣yi​))​​=O(1)

\n

(此处略相关递推的阶估计，上文有相关Jacobian矩阵，只需进行估阶即可)关键在于

\n

{Post-LN:∥JLN(xL+1post)∥2=O(n∥xL+1post∥2)=O(1)Pre-LN:∣JLN(xfinalpre)∥2=O(n∥xfinalpre∥2)=O(1L)\\begin{dcases}\n\\text{Post-LN:}&\\left\\|J_{\\mathrm{LN}}(x^{post}_{L+1})\\right\\|^2 = \\mathcal{O}(\\frac{n}{\\|x^{post}_{L+1}\\|^2}) = \\mathcal{O}(1)\\\\[2em]\n\\text{Pre-LN:}&\\left|J_{\\mathrm{LN}}(x^{pre}_{final})\\right\\|^2 = \\mathcal{O}(\\frac{n}{\\|x^{pre}_{final}\\|^2}) = \\mathcal{O}(\\frac{1}{L}) \n\\end{dcases}\n⎩⎨⎧​Post-LN:Pre-LN:​​JLN​(xL+1post​)​2=O(∥xL+1post​∥2n​)=O(1)​JLN​(xfinalpre​)​2=O(∥xfinalpre​∥2n​)=O(L1​)​

\n

Theorem 1 的结论证明了：在初始化时刻，Post-LN 的梯度规模是常数阶，这意味着它与模型深度 LLL 无关，无法感知并抑制深层带来的不稳定因素；而 Pre-LN 的梯度规模具有 O(1L)O(\\frac{1}{\\sqrt{L}})O(L​1​) 的衰减性，能随着模型深度的增加降低初始梯度强度，减弱了对 warmup 的依赖。

\n", "tags": [] }, { "id": "https://yuuko.site/2026/05/23/CS/LLM/mHC/", "url": "https://yuuko.site/2026/05/23/CS/LLM/mHC/", "title": "From ResNet to mHC", "date_published": "2026-05-22T16:00:00.000Z", "content_html": "

Tensor Flow 的 演化历程

\n

整体的发展脉络分为四类

\n\n

Plain Chain

\n

最原始的信息流就是层的复合，满足 xl+1=Fl(xl,θl)x_{l+1} = \\mathcal{F}_{l}(x_l,\\theta_l)xl+1​=Fl​(xl​,θl​), 这样的深层网络的微分就是

\n

∂xl+1∂x0=∏i=1l∂Fi∂xi\\frac{\\partial x_{l+1}}{\\partial x_0} = \\prod_{i = 1}^l \\frac{\\partial \\mathcal{F}_i}{\\partial x_i}\n∂x0​∂xl+1​​=i=1∏l​∂xi​∂Fi​​

\n

Gradient of Loss Function

\n

∂L∂xl=∂L∂xL∏i=lL−1JFi(xi)\\frac{\\partial \\mathcal{L}}{\\partial x_l} = \\frac{\\partial \\mathcal{L}}{\\partial x_L}\\prod_{i=l}^{L-1}J_{\\mathcal{F}_i}(x_i)\n∂xl​∂L​=∂xL​∂L​i=l∏L−1​JFi​​(xi​)

\n

Plain Chain 容易出现梯度消失或者梯度爆炸的现象。 随着梯度的模大于0或者小于0，指数发散(爆炸)或者收敛到0(消失)

\n

ResNet

\n

xl+1=xl+Fl(xl,θl)x_{l+1} = x_{l} + \\mathcal{F}_{l}(x_l,\\theta_l)\nxl+1​=xl​+Fl​(xl​,θl​)

\n

将模型的更新量作为线性可加的残差，将整体的复合非线性映射变为了一个恒等映射+微小扰动量的形式。

\n

\"resnet\"

\n

DenseNet

\n

DenseNet在ResNet的Skip Connections的基础上,将加性结构换为高维嵌入, 每一层的输入都是前面所有层输出的Concat, 即

\n

xl+1=Fl(Concat[x0,⋯ ,xl])x_{l+1} = \\mathcal{F}_l(\\mathrm{Concat}[x_0,\\cdots,x_l])\nxl+1​=Fl​(Concat[x0​,⋯,xl​])

\n

\"densenet\"
\nDenseNet的性能开销和维度爆炸无疑是相当恐怖的。在CV领域DenseNet取得了不错的效果，但是在LLM中，其结构无法合适的Scaling-Up

\n

Post-LN、Pre-LN及相关的衍生架构 -- 深度Transformer 中的 residual stream与稳定化

\n

Transformer 中的 Layer Normalization与梯度稳定性 与 DeepNet 对相关的架构进行了讨论。在ResNet的基础结构上，研究LayerNorm的位置对于整体训练的效果、收敛的速度与稳定性的优化

\n

Neural ODE

\n

Deep Equilibrium Model

\n

MoE

\n

MoE 是 Tenor Flow go wider 的结构范式

\n

MoE -- Mixture of experts

\n

Hyper-Connections

\n

本文认为类似于梯度消失/梯度爆炸在深层网络的训练中的问题已经被Post-LN / Pre-LN (Transformer 中的 Layer Normalization与梯度稳定性)解决了，但是二者之间存在对抗性博弈。

\n\n

\"cosine-similarity\"

\n

实验结果展示了HC在深层网络中余弦相似度较低的结果，表明HC相比Pre-LN解决了表示崩溃的问题

\n

Hyper-Connection 由两个部分拼接而成

\n\n

作为残差链接的横向的和纵向的线性拓展。相当于将n路ResNet 之间嵌入了线性层(如果是SHC则为静态参数线性层，如果是DHC则为可学习的线性层)

\n

\"hc\"

\n

Hidden Matrix的不同hidden vector 在初始化时状态是相同的，即满足

\n

H0=(h0,h0,⋯ ,h0)∈Rn×d\\mathrm{H}_0 = (h_0,h_0,\\cdots ,h_0) \\in \\mathbb{R}^{n\\times d }\nH0​=(h0​,h0​,⋯,h0​)∈Rn×d

\n

其中hidden vector 的个数nnn 称为拓展率, 表示 Width-Connections 在横向拓展的维度，这个维度对hidden vector本身的信息量没有影响。

\n

在后续的非线性变换后，不同的hidden vector才变为具有不同意义的vector构成 hidden matrix

\n

由图可以写出层间的残差递推公式, 对于第iii 层的残差，有

\n

hi,t+1=∑αj,ihj,t+βiLayer(∑αk,0hk)h_{i,t+1} = \\sum \\alpha_{j,i} h_{j,t} + \\beta_i \\mathrm{Layer}(\\sum \\alpha_{k,0} h_k)\nhi,t+1​=∑αj,i​hj,t​+βi​Layer(∑αk,0​hk​)

\n

用矩阵形式编码相应的参数:

\n

HC=(0BAmAr)=(0β1β2⋯βnα1,0α1,1α1,2⋯α1,nα2,0α2,1α2,2⋯α2,n⋮⋱an,0αn,1αn,2⋯αn,n)\\mathcal{HC} = \n\\begin{pmatrix}\n0 & B\\\\\nA_m & A_r\n\\end{pmatrix} = \\begin{pmatrix}\n0 & \\beta_1 & \\beta_2 & \\cdots & \\beta_n\\\\\n\\alpha_{1,0} & \\alpha_{1,1} & \\alpha_{1,2} & \\cdots & \\alpha_{1,n}\\\\\n\\alpha_{2,0} & \\alpha_{2,1} & \\alpha_{2,2} & \\cdots & \\alpha_{2,n}\\\\\n\\vdots & &&\\ddots\\\\\na_{n,0} & \\alpha_{n,1} & \\alpha_{n,2} & \\cdots & \\alpha_{n,n}\\\\\n\\end{pmatrix}\nHC=(0Am​​BAr​​)=​0α1,0​α2,0​⋮an,0​​β1​α1,1​α2,1​αn,1​​β2​α1,2​α2,2​αn,2​​⋯⋯⋯⋱⋯​βn​α1,n​α2,n​αn,n​​​

\n

记第 ttt 层的残差通道的Layer为 τ\\tauτ，单层的递推写为矩阵方程的形式

\n

Ht+1=BTτ(AmTHt)+ArTHt\\mathrm{H}_{t+1} = B^{\\mathsf{T}}\\tau (A_m^\\mathsf{T} \\mathrm{H_t}) + A_r^{\\mathsf{T}} \\mathrm{H}_t\nHt+1​=BTτ(AmT​Ht​)+ArT​Ht​

\n

Stastic Hyper-Connections

\n

SHC 中的权重矩阵是固定学习的权重矩阵 HC\\mathcal{HC}HC。训练完后，在实际的推理阶段并不会改变相应的参数。

\n

Dynamic Hyper-Connections

\n

DHC 中的权重矩阵依赖于输入的Hidden matrix, 但是并不是类似于在线学习的方式，而是作为Hidden matrix 的函数进行动态输出。

\n

DHC 中在每一个 Hidden Matrix 的输入时都会先进行相应的处理后再输出参数。相应的处理为

\n

{H‾t=LayerNorm(Ht)B(Ht)=sβ∘tanh⁡(H‾tWβ)T+BAm(Ht)=sm∘tanh⁡(H‾tWm)+AmAr(Ht)=sr∘tanh⁡(H‾tWr)+Ar\\begin{dcases}\n\\overline{\\mathrm{H}}_t = \\mathrm{LayerNorm} (\\mathrm{H}_t) \\\\\n\\mathcal{B}(\\mathrm{H}_t) = s_\\beta\\circ \\tanh (\\overline{\\mathrm{H}}_tW_\\beta)^\\mathsf{T}+B\\\\\n\\mathcal{A}_m(\\mathrm{H_t}) = s_m\\circ \\tanh (\\overline{\\mathrm{H}}_t W_m) + A_m\\\\\n\\mathcal{A}_r(\\mathrm{H}_t) = s_r\\circ \\tanh (\\overline{\\mathrm{H}}_t W_r)+A_r\n\\end{dcases}\n⎩⎨⎧​Ht​=LayerNorm(Ht​)B(Ht​)=sβ​∘tanh(Ht​Wβ​)T+BAm​(Ht​)=sm​∘tanh(Ht​Wm​)+Am​Ar​(Ht​)=sr​∘tanh(Ht​Wr​)+Ar​​

\n

相比SHC， 每一个"输出头" 都是一个局部的线性层+ tanh⁡\\tanhtanh 激活函数的结构

\n

在单次训练中，DHC相比 SHC多训练了线性层，但是换取了更高的信息密度，且这几个线性层的参数量约为 O(dn)\\mathcal{O}(dn)O(dn) , 在模型训练的开销较小的情况下，通过实时生成的非线性权重打破了传统残差连接的表达瓶颈，从而实现了极高的信息利用率和收敛稳定性。

\n

实验证明SHC在小任务的条件下性能与DHC相近，但是在更深的网络、更复杂任务(比如图像生成/大参数LLM预训练)的情况下DHC性能远高于SHC

\n

\"result\"

\n

Manifold-Constrained Hyper-Connections

\n", "tags": [] }, { "id": "https://yuuko.site/2026/05/21/CS/OS/%E5%9F%BA%E6%9C%AC%E8%A7%82%E5%BF%B5/", "url": "https://yuuko.site/2026/05/21/CS/OS/%E5%9F%BA%E6%9C%AC%E8%A7%82%E5%BF%B5/", "title": "操作系统的基本概念", "date_published": "2026-05-20T16:00:00.000Z", "content_html": "

操作系统

\n

操作系统是计算机将硬件系统和用户的连接，是计算机的Harness。计算机系统自下而上分为: 硬件、操作系统、应用与用户。操作系统负责管理硬件资源、为应用程序提供运行环境并充当硬件和用户之间的桥梁。

\n

操作系统的发展过程与分类

\n

原始模式:手动操作阶段，人工通过穿孔纸带输入计算机。分别分为人工操作模式与脱机IO模式。脱机IO通过外围机读取数据到磁带再供CPU调入内存。外围机和高速磁带的读取速度远远高于手动输入，大幅提高CPU IO速度

\n

批处理方式: 基于脱机IO实现的自动连续处理，以提高CPU和系统资源的利用率。可分为

\n\n", "tags": [] }, { "id": "https://yuuko.site/2026/05/21/CS/%E8%AE%A1%E7%BB%84/Bus/", "url": "https://yuuko.site/2026/05/21/CS/%E8%AE%A1%E7%BB%84/Bus/", "title": "总线", "date_published": "2026-05-20T16:00:00.000Z", "content_html": "

总线

\n

总线分为CPU内的总线(片内总线)与CPU和其他功能部件之间的总线(系统总线)，I/O总线与通信总线。

\n

多总线硬件系统的系统总线通常可分为

\n\n

I/O 总线是CPU与内部I/O设备的总线结构，如显卡、网卡等，通常使用标准化的内部总线协议

\n

通信总线是CPU与外部I/O设备或者其他计算机通信的总线结构，常见协议有USB、RS-232、RS-485等

\n

总线结构

\n

总线结构发展历程经历三种结构

\n\n

总线的性能指标

\n\n

总线事务

\n

总线事务是主设备到从设备到一次信息交换的过程。分为三个基本段

\n\n

总线的连续传输模式可分为:

\n\n

总线的物理传输方式可分为串行通信与并行通信。其中并行通信能通过多条数据线同步传输数据，但是会出现信号串扰和时序偏移等问题，实际传输效率低于串行通信。

\n

串行通信可分为

\n\n

总线定时

\n

总线定时方式可分为

\n\n", "tags": [ "硬件", "计组" ] } ] }