<?xml version="1.0" encoding="UTF-8"?><rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/"><channel><title>羽落天青 | Uke&apos;s Blog</title><description>No description</description><link>https://tiany1yu.github.io/</link><language>zh_CN</language><item><title>好久不见</title><link>https://tiany1yu.github.io/posts/writing/%E5%A5%BD%E4%B9%85%E4%B8%8D%E8%A7%81/</link><guid isPermaLink="true">https://tiany1yu.github.io/posts/writing/%E5%A5%BD%E4%B9%85%E4%B8%8D%E8%A7%81/</guid><pubDate>Fri, 09 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;很久很久没有来更新我这个博客了，但却不是因为太忙或是怎么的，一方面感觉自己之前写的内容太低质，太幼稚；另一方面觉得自己并没有什么好分享的。&lt;/p&gt;
&lt;p&gt;一些储存心路的什么之类，倒是可以在这里更新一下，就随笔当发在树洞了。&lt;/p&gt;
&lt;p&gt;半年过去了，我的能力没什么增长，但是AI却是发生了翻天覆地的变化：大多数人认可AGI已至；iclr投稿数超6w；OPENAI公开700余篇数学手稿……scaling law现在并没有看出有接近拐点的势头。如果按照这样的节奏继续走，RSI将会自然而然的出现，AI将自然而然的成长为上帝。&lt;/p&gt;
&lt;p&gt;对于刚刚入门research不久的我来说，面临这样的百废待兴的时代，我很迷茫。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;科研上&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;印象中工业界应该落后科研界，在许多理论提出后很久，application才会一步一步落位，可现在的AI界，我们研究的一些事情也许会在几个月甚至几周之后会被新一代的AI自然而然的解决，在scaling这条通天路下，科研界也许才是些花招。而且在autoresearch的冲击下，论文的发表数量以及其评级这样的metric，似乎都要丧失意义。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;课程上&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;在大模型的平权下，大家知识几乎平权，能力也接近平权。大学的课程基本真正意义上的丧失了意义。老师假装上课，学生假装听课、做作业，助教假装批改作业。大家之间隔着一层AI的纱，隔着一层旧时代metric的壁。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;价值上&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;ai时代，”天赋“的定义越来越不明晰了。可能在大家有了外置大脑的时代，良好的沟通能力，投入度和精力变成了天赋的一个很大组成部分（？，人的价值，至少是我定义的自我价值正在逐渐消解。人快活成了一个甲方和agent之间的接口。很多metric，本来有不少能力上认可的意味，现在可能只剩筛选上的价值。&lt;/p&gt;
&lt;p&gt;希望仰望星空，但是天上雾霭遮挡，什么都看不清，甚至也许没有任何人能看清。&lt;/p&gt;
&lt;p&gt;那就看清脚下吧，摸着石头过河。我现在算是与自己和解了。焦虑多了，人反而要丧失前进的动力；既然每人知道哪里是前方，就沿着当前的方向走吧，走一步，看一步。知道价值网络要大变了，那就按着目标网络走吧😄。至少现在，我仍然有很多想做的事，有想做的研究，想认识的世界，也很想看看未来究竟会有什么样的发展。既然如此，倒也不急着证明什么终极意义。&lt;/p&gt;
&lt;p&gt;也许再过半年，又会觉得此时的自己太过幼稚。&lt;/p&gt;
</content:encoded></item><item><title>DQN</title><link>https://tiany1yu.github.io/posts/notes/dqn/</link><guid isPermaLink="true">https://tiany1yu.github.io/posts/notes/dqn/</guid><pubDate>Mon, 15 Jun 2026 00:00:00 GMT</pubDate><content:encoded>&lt;h3&gt;1.自然扩展&lt;/h3&gt;
&lt;p&gt;在先前的[[Sarsa Q-learning and Dyna-Q]]算法中，我们始终需要维护一张$Q(s,a)$的表格，而这在$state$的数量巨量或者直接为离散情况时，这是不现实的
于是我们尝试用函数来拟合这个表格
从深度学习的学习之中，我们知道，多层感知机是一种很好的拟合函数
今天介绍的DQN算法便可以用来解决这样的情况，我们把函数记为$Q_\omega(s,a)$
我们把这样的网络记为Q-网络&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/assets/img/notes/20260615-DQN/DQN.png&quot; alt=&quot;DQN.png&quot; /&gt;
我们沿用Q-learning的更新准则：
$$Q(s_t,a_t)\leftarrow Q(s_t,a_t)+\alpha\left[r+\gamma \max_{a\in A}Q(s_{t+1},a)-Q(s_t,a_t)\right]$$
当Q逐渐收敛到某个具体值时，$\left\lvert r+\gamma \max_a Q(s_{t+1},a)-Q(s_t,a_t)\right\rvert$会逐渐收敛到0
因此，很自然的，我们将Q网络的损失函数定义为：
$$\omega^*=arg\min_\omega\frac{1}{2N}\sum_{i=1}^N\left[r+\gamma \max_a Q_\omega(s_{i+1},a)-Q(s_i,a_i)\right]^2$$&lt;/p&gt;
&lt;h2&gt;2.经验回放和目标网络&lt;/h2&gt;
&lt;p&gt;以上均很自然，可如果完全使用TD的更新方法，学习率近乎为0
原因有二：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;始终使用时间连续，前后相关的数据，不满足数据的相互独立，会出现过拟合&lt;/li&gt;
&lt;li&gt;损失函数的目标始终在变动，也许会导致正反馈式的自举现象，那么就可能很难收敛，甚至出现无限增长的现象&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;2.1 经验回放&lt;/h3&gt;
&lt;p&gt;为了解决（1），我们引入了经验回放
也就是我们采样环境之后，我们维护一个经验缓冲区，存储四元组$\langle s,a,r,s_{next} \rangle$
每次从缓冲区中随机取样
这不仅解决了（1）的问题，还降低了与环境交互的次数，也就降低了成本&lt;/p&gt;
&lt;h3&gt;2.2 目标函数&lt;/h3&gt;
&lt;p&gt;为了解决（2），我们引入了目标网络，也即维护两个Q网络：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;原有的$Q$网络，$Q_\omega(s,a)$&lt;/li&gt;
&lt;li&gt;目标网络,$Q_{w^-}(s,a)$
其中，$Q_\omega$正常更新，而$Q_{\omega^-}$每隔$C$步与$Q_{w}$同步，即：$Q_{\omega^-}\leftarrow Q_\omega$&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;3.DQN的改进&lt;/h2&gt;
&lt;h3&gt;3.1double DQN&lt;/h3&gt;
&lt;p&gt;每次都筛选最大的Q来自举更新会最终导致整个网络的Q都被严重抬高
于是：
从$Q$网络中选择argmax，但是用$Q_{w^-}$来更新，有效抑制Q爆炸，提升网络的稳定性&lt;/p&gt;
&lt;h3&gt;3.2 dueling DQN&lt;/h3&gt;
&lt;p&gt;将原本Q的更新拆成两块
$$Q_{\eta,\alpha,\beta}(s,a)=V_{\eta,\alpha}(s,a)+A_{\eta,\beta}(s,a)$$
其中，A命名为优势函数
V与A分别共用一部分神经网络$\eta$，并分别分立一部分参数
但当然，如果如此建模，V+C A-C,不会使得Q值改变，也就是说不唯一
我们减去$\max_a A$，此时满足唯一性，且满足贝尔曼最优方程
但是max不具备鲁棒性，我们一般用均值代替，也就是
$$Q_{\eta,\alpha,\beta}(s,a)=V_{\eta,\alpha}(s,a)+A_{\eta,\beta}(s,a)-\frac{1}{\lvert A\rvert}\sum_{a&apos;}A_{\eta,\beta}(s,a&apos;)$$
这显著提高了泛化性，采样路径可以改变同state，不同action的动作价值&lt;/p&gt;
&lt;h3&gt;3.3 PER&lt;/h3&gt;
&lt;p&gt;用TD Error来衡量一个经验的价值（目标值减去当前预测值的绝对值），使用SumTree使得TD Error越大的经验越容易被抽中，显著加快了收敛&lt;/p&gt;
&lt;h3&gt;3.4 Distributional RL&lt;/h3&gt;
&lt;p&gt;C51预测一个柱状图分布，也就是人为取51个固定端点，用softmax预测各个区间的概率而非只预测均值，这提高了信息量，增强了鲁棒性&lt;/p&gt;
&lt;h3&gt;3.5 n-step Learning&lt;/h3&gt;
&lt;p&gt;与多步SARSA一致，将原本$r_t+\gamma V_{t+1}$扩展为n步，平衡了方差和偏差&lt;/p&gt;
&lt;h3&gt;3.6 noisy nets&lt;/h3&gt;
&lt;p&gt;舍弃$\epsilon-\text{贪婪策略}$，这种依赖人工调节超参数，真正意义上的平衡了探索和利用：
$$y = (\mu^w + \sigma^w \odot \epsilon^w)x + (\mu^b + \sigma^b \odot \epsilon^b)$$
1.自动退火，逐渐减少探索
2.连续探索，而非随机探索&lt;/p&gt;
&lt;h2&gt;4.代码实践&lt;/h2&gt;
&lt;p&gt;我们采用CartPole环境，此环境目标是通过左右移动使得小车上的木杆保持竖直
&lt;img src=&quot;/assets/img/notes/20260615-DQN/CartPole.png&quot; alt=&quot;CartPole.png&quot; /&gt;
done的条件是车子偏离初始位置太远，或者杆子倾斜角度太大，或者坚持超过200帧&lt;/p&gt;
&lt;p&gt;（日后更新)&lt;/p&gt;
</content:encoded></item><item><title>REINFORCE&amp;ACTOR_CRITIC</title><link>https://tiany1yu.github.io/posts/notes/reinforce-actor-critic/</link><guid isPermaLink="true">https://tiany1yu.github.io/posts/notes/reinforce-actor-critic/</guid><pubDate>Mon, 15 Jun 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;先前我们所涉及的所有算法，都是针对价值函数进行迭代，而策略方面往往仅局限于$\epsilon-\text{贪婪算法}$，几乎不进行更新
我们先介绍基于策略的经典算法：REINFORCE，也就是策略梯度算法&lt;/p&gt;
&lt;h2&gt;1.REINFORCE&lt;/h2&gt;
&lt;p&gt;我们严格定义一下该算法
首先，我们记轨迹为：
$$\tau=(s_0,a_0,r_0,s_1,a_1,r_1,\cdots)$$
记轨迹概率为,其中T是与环境可能交互的最大步数：
$$\rho_\theta(\tau)=\rho_0(s_0)\prod_{t=0}^T\pi_\theta(a_t\mid s_t) P(s_{t+1}\mid s_t,a_t)$$
环境转移概率,初始概率分布与策略无关，因此
$$\nabla_\theta \log{\rho_\theta(\tau)}=\sum_{t=0}^T\nabla_\theta \log{\pi_\theta(a_t\mid s_t)}$$
优化目标为：
$$J(\theta)=\mathbb{E}&lt;em&gt;{\tau \sim \rho&lt;/em&gt;\theta}[R(\tau)]=\sum_\tau R(\tau)\rho_\theta(\tau)$$
故，
$$
\begin{aligned}
\nabla_\theta J(\theta)=&amp;amp;\sum_\tau R(\tau)\nabla_\theta\rho_\theta(\tau)\text{（这是因为在}\tau\text{确定的情况下，}R(\tau)\text{与}\theta\text{无关）}\nonumber \
=&amp;amp;\sum_\tau R(\tau)\rho_\theta(\tau)\nabla_\theta log{\rho_\theta(\tau)}\nonumber \
=&amp;amp;\mathbb{E}&lt;em&gt;{\tau \sim \rho&lt;/em&gt;\theta}[R(\tau)\nabla_\theta log{\rho_\theta(\tau)}]\nonumber \
=&amp;amp;\mathbb{E}&lt;em&gt;{\tau \sim \rho&lt;/em&gt;\theta}[\sum_{t=0}^T R(\tau)\nabla_\theta log{\pi_\theta(a_t\mid s_t)}]\nonumber \
\end{aligned}
$$&lt;/p&gt;
&lt;p&gt;我们记录这里的$R(\tau)$为$\psi_t$，故有：
$$\nabla_\theta J(\theta)=\mathbb{E}&lt;em&gt;{\tau \sim \rho&lt;/em&gt;\theta}[\sum_{t=0}^T \psi_t(\tau)\nabla_\theta log{\pi_\theta(a_t\mid s_t)}]$$
我们不加证明的给出$\psi_t$的六种取值：
$$
\begin{aligned}
\psi_t &amp;amp;= \sum_{t&apos;=0}^T\gamma^{t&apos;}r_{t&apos;} \qquad\text{(1)} \
\psi_t &amp;amp;= \sum_{t&apos;=t}^T\gamma^{t&apos;-t}r_{t&apos;} \qquad\text{(2)} \
\psi_t &amp;amp;= \sum_{t&apos;=t}^T\gamma^{t&apos;-t}r_{t&apos;}-b(s_t) \qquad\text{(3)} \
\psi_t &amp;amp;= Q^{\pi_\theta}(s_t,a_t) \qquad\text{(4)} \
\psi_t &amp;amp;= A^{\pi_\theta}(s_t,a_t) \qquad\text{(5)} \
\psi_t &amp;amp;= r_t+\gamma V^{\pi_\theta}(s_{t+1})-V^{\pi_\theta}(s_t) \qquad\text{(6)}
\end{aligned}
$$
（1）的方差非常大，一条轨迹可以影响此轨迹所有节点的策略，而事实上$a_t$不可能影响已发生的奖励，会有非常大的噪声，需要采样大量数据才可以收敛
（2）依旧无偏差，方差比（1）要小很多
（3）加入了baseline，一般取$V^\pi(s)$,baseline的引入不增加偏差，故依旧无偏，一个好的baseline可以降低方差
（4）（5）（6）从（4）开始，摆脱了MC更新，减小了方差，可以一个时间步一更新而非一个采样序列一更新，但是同时，一般来说Q，A，V都未知，需要引入2.的critic来学习
（4）到（5）到（6），通常方差逐渐减小，但是偏差逐渐增大，对critic精确性的依赖逐步加深，其中（5）应用于大量经典算法（如PPO等）&lt;/p&gt;
&lt;h2&gt;2.ACTOR-CRITIC&lt;/h2&gt;
&lt;p&gt;actor和critic分别为两个神经网络，其中：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Actor 要做的是与环境交互，并在 Critic 价值函数的指导下用策略梯度学习一个更好的策略。&lt;/li&gt;
&lt;li&gt;Critic 要做的是通过 Actor 与环境交互收集的数据学习一个价值函数，这个价值函数会用于判断在当前状态什么动作是好的，什么动作不是好的，进而帮助 Actor 进行策略更新。
critic有很多种更新方式，如（3）中可以采用MC更新，（4）（5）（6）可以使用TD更新，TD(n)以及一些后续会提到的更新方式等&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;3.实践&lt;/h2&gt;
&lt;p&gt;后续更新&lt;/p&gt;
</content:encoded></item><item><title>sarsa Q-learning and Dyna-Q</title><link>https://tiany1yu.github.io/posts/notes/sarsa-q-learning-and-dyna-q/</link><guid isPermaLink="true">https://tiany1yu.github.io/posts/notes/sarsa-q-learning-and-dyna-q/</guid><pubDate>Mon, 15 Jun 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;我们简单介绍三种算法，并附上代码实践&lt;/p&gt;
&lt;h2&gt;1 TD&lt;/h2&gt;
&lt;p&gt;我们给出下面的式子：
$$
\begin{aligned}
V_\pi(s)
&amp;amp;=\mathbb{E}&lt;em&gt;\pi[G_t\mid S_t=s]\nonumber \
&amp;amp;=\mathbb{E}&lt;/em&gt;\pi[r_i+\gamma G_{t+1} \mid S_t=s] \nonumber \
&amp;amp;=\mathbb{E}&lt;em&gt;\pi[r_t+\gamma V&lt;/em&gt;\pi(S_{t+1})\mid S_t=s]&lt;/p&gt;
&lt;p&gt;\end{aligned}
$$
最后一个等号是因为全期望公式
回顾[[MDP]]中的蒙特卡洛算法，我们需要采样完一整条路径，再采用上式的第一行进行增量更新，形式类似：
$$V_\pi(S_t)\leftarrow V_\pi(S_t)+\alpha[G_t-V_\pi(S_t)]$$
其中，$\alpha=\frac{1}{N(s)}$或最好至少有$\sum\alpha\to\infty$且$\sum\alpha^2&amp;lt;\infty$
采样一条路径耗时长，方差大，我们可以采用第三行来进行增量更新，也就是：
$$V_\pi(S_t)\leftarrow V_\pi(S_t)+\alpha[r_t+\gamma V_\pi(S_{t+1})-V(S_t)]$$
这便是强化学习中的TD方法
我们发现，这大大降低了随机性，也就降低了方差，但同时，自举式的更新导致这是一种有偏估计（在离线策略或函数逼近时将不一定能收敛到全局最优）&lt;/p&gt;
&lt;h2&gt;2 SARSA&lt;/h2&gt;
&lt;p&gt;我们尝试使用类似策略迭代的方式来解决这个问题
我们已经可以使用TD进行策略评估，那我们该如何进行策略提升呢？
那么可以有：
$$Q(s_t,a_t)\leftarrow Q(s_t,a_t)+\alpha [r_t+\gamma Q(s_{t+1},a_{t+1})-Q(s_t,a_t)]$$
然后每次更新选择$arg\max_a Q(s,a)$即可
但是，这样做存在问题，也就是如何平衡探索与利用？
我们是采样更新，而非像DP那样挑选每个动作，也许有一些动作从来没更新
于是，我们定义
$$
\pi(a\mid s)=
\begin{cases}
\frac{\epsilon}{\lvert A \rvert}+1-\epsilon,&amp;amp; \text{if }a=arg\max_a Q(s,a)\
\frac{\epsilon}{\lvert A \rvert},&amp;amp; \text{else}
\end{cases}
$$
&lt;img src=&quot;/assets/img/notes/20260615-sarsa-Q-learning-and-Dyna-Q/sarsa.png&quot; alt=&quot;sarsa.png&quot; /&gt;
这个算法与s，a，r，以及s&apos;,a&apos;有关，因此得名sarsa&lt;/p&gt;
&lt;h2&gt;3 多步 Sarsa&lt;/h2&gt;
&lt;p&gt;$$Q(s_t,a_t)\leftarrow Q(s_t,a_t)+\alpha [r_t+\gamma Q(s_{t+1},a_{t+1})+\gamma^2Q(s_{t+2},a_{t+2})+\cdots+\gamma^nQ(s_{t+2},a_{t+2})-Q(s_t,a_t)]$$&lt;/p&gt;
&lt;p&gt;这便是n步sarsa算法的更新方式，可以在一定程度上中和这种自举的算法的偏差&lt;/p&gt;
&lt;h2&gt;4 Q-learning&lt;/h2&gt;
&lt;p&gt;$$Q(s_t,a_t)\leftarrow Q(s_t,a_t)+\alpha [r_t+\gamma\max_a Q(s_{t+1},a)-Q(s_t,a_t)]$$
这是一种离线策略算法，直接估计的是贝尔曼最优方程&lt;/p&gt;
&lt;h2&gt;5 Dyna-Q&lt;/h2&gt;
&lt;p&gt;之前介绍的都是无模型的算法，也就是不对环境进行建模的算法，而Dyna-Q会进行Q-planning
&lt;img src=&quot;/assets/img/notes/20260615-sarsa-Q-learning-and-Dyna-Q/Dyna-Q.png&quot; alt=&quot;Dyna-Q.png&quot; /&gt;
&lt;img src=&quot;/assets/img/notes/20260615-sarsa-Q-learning-and-Dyna-Q/Dyna-Q%E6%B5%81%E7%A8%8B%E5%9B%BE.png&quot; alt=&quot;Dyna-Q流程图.png&quot; /&gt;这里的M也就是模型
书中的算法是执行在确定性环境中，那么M就是一个简单的记忆模型，而非推测模型
Dyna-Q好在哪里？
每一次采样，通过Q-planning可以生成n个假采样并更新数据，更新效率极高，在取样困难等场景非常管用&lt;/p&gt;
&lt;h2&gt;6 代码实践&lt;/h2&gt;
&lt;p&gt;（日后更新）&lt;/p&gt;
</content:encoded></item><item><title>DP</title><link>https://tiany1yu.github.io/posts/notes/dp/</link><guid isPermaLink="true">https://tiany1yu.github.io/posts/notes/dp/</guid><pubDate>Sun, 31 May 2026 00:00:00 GMT</pubDate><content:encoded>&lt;h2&gt;1.前言&lt;/h2&gt;
&lt;p&gt;本文介绍的是强化学习中的DP求解，分别介绍策略迭代与价值迭代算法&lt;/p&gt;
&lt;p&gt;显然，DP是建立在已知奖励函数，状态转移函数，也就是完全的白盒环境的基础上的，这一点与之后将要介绍的算法不同&lt;/p&gt;
&lt;p&gt;本文依旧参照《动手学强化学习》，大致分为这几个板块：
前言，策略迭代，价值迭代，DP实践，一些思考&lt;/p&gt;
&lt;h2&gt;2.策略迭代算法&lt;/h2&gt;
&lt;p&gt;策略迭代算法主要分为两个部分：策略评估与策略提升，两个步骤不断交替迭代最终得到最优解&lt;/p&gt;
&lt;h3&gt;2.1 策略评估&lt;/h3&gt;
&lt;p&gt;先回顾一下[[MDP]]中所学的贝尔曼方程：
$$V^\pi(s)=\sum_{a \in A}\pi(a\mid s)\left(r(s,a)+\gamma\sum_{s&apos; \in S}P(s&apos;\mid s,a)V^\pi(s&apos;)\right)$$
我们可以看作根据下一时间步的价值来计算这一时间步的价值，
我们运用简单的DP思想，把当前计算视为一个子问题，那么，可以记作：
$$V^{k+1}(s)=\sum_{a\in A}\pi(s\mid a)\left(r(s,a)+\gamma\sum_{s&apos;\in S}P(s&apos; \mid s,a)V^k(s&apos;)\right)$$
当$V^k(s)=V^\pi(s),\forall s \in S$成立时，此时价值函数不会再变动，也即找到了不动点
事实上，当$k\to +\infty$时，可以证明$V^k\to V^\pi$
我们设置一个阈值$\Delta$，
若满足$\max_{s\in S}\lvert V^{k+1}(s)-V^k(s)\rvert \leq\Delta$
那么在程序上可以认为达到收敛&lt;/p&gt;
&lt;h3&gt;2.2 策略提升&lt;/h3&gt;
&lt;p&gt;若一个智能体在状态为$s$时采取了动作$a$，但之后仍然遵循策略$\pi$，
且满足$Q^\pi(s,a) \geq V^\pi(s)$，
那么新策略一定有$V^{\pi&apos;}(s)\geq V^\pi(s)$
我们把这样的假设推广到所有状态，假设存在一个&lt;strong&gt;确定性策略&lt;/strong&gt;，满足上述式子$\forall s \in S$成立
那么我们记作$V^{\pi&apos;} \geq V^\pi$(策略提升定理)
那么我们可以贪心的选取在每一时间步时动作价值函数最大的作为&lt;strong&gt;确定性策略&lt;/strong&gt;：
$$\pi&apos;(a\mid s)=arg\max_{a\in A}Q(a,s)=\max_{a\in A}\left(r(s,a)+\gamma\sum_{s&apos; \in S}P(s&apos;\mid s,a)V^\pi(s&apos;)\right)$$
策略提升定理的具体证明如下：
$$
\begin{aligned}
V^\pi(s)\leq&amp;amp;Q^{\pi}(s,\pi&apos;(s))\nonumber \
=&amp;amp;\mathbb{E}&lt;em&gt;{\pi&apos;}[R_t+\gamma V^\pi(S&lt;/em&gt;{t+1})\mid S_t=s]\nonumber \
\leq&amp;amp;\mathbb{E}&lt;em&gt;{\pi&apos;}[R_t+\gamma Q^{\pi}(S&lt;/em&gt;{t+1},\pi&apos;(S_{t+1}))\mid S_t=s] \nonumber \
=&amp;amp;\mathbb{E}&lt;em&gt;{\pi&apos;}[R_t+\gamma R&lt;/em&gt;{t+1}+\gamma^2V(S_{t+2})\mid S_t=s]\nonumber \
\leq&amp;amp;\mathbb{E}&lt;em&gt;{\pi&apos;}[R_t+\gamma R&lt;/em&gt;{t+1}+\gamma^2R_{t+2}+\cdots]\nonumber \
=&amp;amp;V^{\pi&apos;}(s) \nonumber
\end{aligned}
$$&lt;/p&gt;
&lt;h3&gt;3.3 策略迭代算法&lt;/h3&gt;
&lt;p&gt;策略迭代算法的流程大致如下：
$$\pi^0\xrightarrow{策略评估}V^{\pi^0}\xrightarrow{策略提升}\pi^1\xrightarrow{策略评估}V^{\pi^1}\xrightarrow{策略提升}\pi^2\xrightarrow{策略评估}\cdots\xrightarrow{策略提升}\pi^*$$
更新直至$\pi&apos;$与$\pi$一致即可&lt;/p&gt;
&lt;h2&gt;3.价值迭代算法&lt;/h2&gt;
&lt;p&gt;我们上面的过程中，策略评估需要很多轮才能收敛，很费时费力。
是否可以只更新一次策略呢？
答案是肯定的，也就得到了我们的价值迭代算法
利用[[MDP]]中的贝尔曼最优方程：
$$V^&lt;em&gt;(s)=\max_{a\in A}\left(r(s,a)+\gamma\sum_{s&apos;\in S}P(s&apos;\mid s,a)V^&lt;/em&gt;(s&apos;)\right)$$
转换为DP的子问题格式：
$$V^{k+1}(s)=\max_{a\in A}\left(r(s,a)+\gamma\sum_{s&apos;\in S}P(s&apos;\mid s,a)V^k(s&apos;)\right)$$
我们只需要维护一个状态价值函数即可：
与策略迭代类似，每次先评估，再更新
更新直至$\pi&apos;$与$\pi$一致即可&lt;/p&gt;
&lt;h2&gt;4.DP实践&lt;/h2&gt;
&lt;p&gt;接下来，我们分别在悬崖漫步环境与冰湖环境练手DP算法：&lt;/p&gt;
&lt;h3&gt;4.1 环境与必要类准备&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;import copy

class CliffWalkingEnv:

    def __init__(self,nrow:int=4,ncol:int=12):

        self.nrow=nrow

        self.ncol=ncol

        self.createP()

        #P为状态转移矩阵，P=[(p,state,reward,done),……]

    def createP(self):

        self.P=[[[]for j in range(4)]for i in range(self.nrow*self.ncol)]

        vector=[[-1,0],[1,0],[0,-1],[0,1]]

        for i in range(self.nrow):

            for j in range(self.ncol):

                for a in range(4):

                    if(i==self.nrow-1 and j&amp;gt;0):

                        self.P[i*self.ncol+j][a]=[(1,i*self.ncol+j,0,1)]

                    else:

                        next_i=min((max(0,i+vector[a][0])),self.nrow-1)

                        next_j=min((max(0,j+vector[a][1])),self.ncol-1)

                        if next_i==self.nrow-1 and next_j&amp;gt;0:

                            if next_j==self.ncol-1:

                                self.P[i*self.ncol+j][a]=[(1,next_i*self.ncol+next_j,-1,1)]

                            else:

                                self.P[i*self.ncol+j][a]=[(1,next_i*self.ncol+next_j,-100,1)]

                        else:

                            self.P[i*self.ncol+j][a]=[(1,next_i*self.ncol+next_j,-1,0)]

  



#输出代码直接照抄

def print_agent(agent, action_meaning, disaster=[], end=[]):

    print(&quot;状态价值：&quot;)

    for i in range(agent.env.nrow):

        for j in range(agent.env.ncol):

            # 为了输出美观,保持输出6个字符

            print(&apos;%6.6s&apos; % (&apos;%.3f&apos; % agent.v[i * agent.env.ncol + j]), end=&apos; &apos;)

        print()

  

    print(&quot;策略：&quot;)

    for i in range(agent.env.nrow):

        for j in range(agent.env.ncol):

            # 一些特殊的状态,例如悬崖漫步中的悬崖

            if (i * agent.env.ncol + j) in disaster:

                print(&apos;****&apos;, end=&apos; &apos;)

            elif (i * agent.env.ncol + j) in end:  # 目标状态

                print(&apos;EEEE&apos;, end=&apos; &apos;)

            else:

                a = agent.pi[i * agent.env.ncol + j]

                pi_str = &apos;&apos;

                for k in range(len(action_meaning)):

                    pi_str += action_meaning[k] if a[k] &amp;gt; 0 else &apos;o&apos;

                print(pi_str, end=&apos; &apos;)

        print()
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;4.2策略迭代与价值迭代&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;class PolicyIteration:

    def __init__(self,env,theta,gamma):

        self.env=env

        self.theta=theta

        self.gamma=gamma

        self.pi=[[1/4 for i in range(4)]for s in range(self.env.nrow*self.env.ncol)]

        self.v=[0 for s in range(self.env.nrow*self.env.ncol)]

    def policy_evaluation(self):

        cnt=0

        while(1):

            delta=0

            new_v=[0 for s in range(self.env.nrow*self.env.ncol)]

            for s in range(self.env.nrow*self.env.ncol):

                for a in range(4):

                    qsa=0

                    for a_i in self.env.P[s][a]:

                        p,next_s,r,done=a_i

                        qsa+=p*(r+self.gamma*self.v[next_s]*(1-done))

                    new_v[s]+=qsa*self.pi[s][a]

                delta=max(delta,abs(new_v[s]-self.v[s]))

            self.v=new_v

            cnt+=1

            if delta&amp;lt;self.theta:

                print(f&quot;策略评估在{cnt}轮之后结束&quot;)

                break

    def policy_improvement(self):

        for s in range(self.env.nrow*self.env.ncol):

            qsa_list=[]

            for a in range(4):

                qsa=0

                for a_i in self.env.P[s][a]:

                    p,next_s,r,done=a_i

                    qsa+=p*(r+self.gamma*self.v[next_s]*(1-done))

                qsa_list.append(qsa)

            self.v[s]=max(qsa_list)

            cnt=qsa_list.count(self.v[s])

            self.pi[s]=[1/cnt if qsa_list[a]==self.v[s] else 0 for a in range(4)]

        print(&quot;策略提升完成&quot;)

    def policy_iteration(self):

        cnt=0

        while 1:

            cnt+=1

            old_pi=copy.deepcopy(self.pi)

            self.policy_evaluation()

            self.policy_improvement()

            if(old_pi==self.pi):

                print(f&quot;共策略迭代{cnt}轮&quot;)

                break

  

class ValueIteration:

    def __init__(self,env,theta,gamma):

        self.env=env

        self.theta=theta

        self.gamma=gamma

        self.pi=[[1/4 for i in range(4)]for s in range(self.env.nrow*self.env.ncol)]

        self.v=[0 for s in range(self.env.nrow*self.env.ncol)]

    def value_iteration(self):

        cnt=0

        while(1):

            delta=0

            new_v=[0 for s in range(self.env.nrow*self.env.ncol)]

            for s in range(self.env.nrow*self.env.ncol):

                qsa_list=[]

                for a in range(4):

                    qsa=0

                    for a_i in self.env.P[s][a]:

                        p,next_s,r,done=a_i

                        qsa+=p*(r+self.gamma*self.v[next_s]*(1-done))

                    qsa_list.append(qsa)

                new_v[s]=max(qsa_list)

                delta=max(delta,abs(new_v[s]-self.v[s]))

            cnt+=1

            self.v=new_v

            if(delta&amp;lt;self.theta):

                print(f&quot;价值迭代结束，共进行了{cnt}轮&quot;)

                self.get_policy()

                break

    def get_policy(self):

        for s in range(self.env.nrow*self.env.ncol):

            qsa_list=[]

            for a in range(4):

                qsa=0

                for a_i in self.env.P[s][a]:

                    p,next_s,r,done=a_i

                    qsa+=p*(r+self.gamma*self.v[next_s]*(1-done))

                qsa_list.append(qsa)

            ma=max(qsa_list)

            cnt=qsa_list.count(ma)

            self.pi[s]=[1/cnt if qsa_list[a]==ma else 0 for a in range(4)]

  
  if __name__ == &apos;__main__&apos;:

    import gym

    env = gym.make(&quot;FrozenLake-v1&quot;)  # 创建环境

    env = env.unwrapped  # 解封装才能访问状态转移矩阵P

    env.render()  # 环境渲染,通常是弹窗显示或打印出可视化的环境

    action_meaning = [&apos;&amp;lt;&apos;, &apos;v&apos;, &apos;&amp;gt;&apos;, &apos;^&apos;]

    theta = 1e-5

    gamma = 0.9

    #agent = PolicyIteration(env, theta, gamma)

    #agent.policy_iteration()

    agent = ValueIteration(env, theta, gamma)

    agent.value_iteration()

    print_agent(agent, action_meaning, [5, 7, 11, 12], [15])

    env = CliffWalkingEnv()

    action_meaning = [&apos;^&apos;, &apos;v&apos;, &apos;&amp;lt;&apos;, &apos;&amp;gt;&apos;]

    theta = 0.001

    gamma = 0.9

    #agent = PolicyIteration(env, theta, gamma)

    #agent.policy_iteration()

    agent = ValueIteration(env, theta, gamma)

    agent.value_iteration()

    print_agent(agent, action_meaning, list(range(37, 47)), [47])
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;5.一些思考&lt;/h2&gt;
&lt;p&gt;DP算法只能解决白盒环境，也就是环境完全已知的情况&lt;/p&gt;
&lt;p&gt;与OI的DP的区别在于：&lt;/p&gt;
&lt;p&gt;1.虽然强化学习DP生成的策略是确定性的，但是动作可能具有一定随机性（eg：冰湖环境），传统dp不好解决&lt;/p&gt;
&lt;p&gt;2.我所接触到的传统dp（现在大一下）（除了一些转换为最短路问题的等），状态基本建立在DAG上，而强化学习的DP通过迭代可以解决有环的图等问题&lt;/p&gt;
&lt;p&gt;3.强化学习DP可以修改超参数$\gamma$来调整奖励的累计，而普通DP一般$\gamma=1$（可以见[[MDP]]中的思考部分）&lt;/p&gt;
</content:encoded></item><item><title>MDP</title><link>https://tiany1yu.github.io/posts/notes/mdp/</link><guid isPermaLink="true">https://tiany1yu.github.io/posts/notes/mdp/</guid><pubDate>Wed, 27 May 2026 00:00:00 GMT</pubDate><content:encoded>&lt;h2&gt;1.前言&lt;/h2&gt;
&lt;p&gt;MDP在[[MAB]]的基础上，加入了与环境的交互：
1.环境不再是一成不变的，而是具有state的变化
2.action具有改变环境的能力&lt;/p&gt;
&lt;p&gt;本文依旧参照《动手学强化学习》，大致分为这几个板块：&lt;/p&gt;
&lt;p&gt;前言、马尔可夫过程、MDP的数学推导，最后会有一些自己对这些公式的理解&lt;/p&gt;
&lt;h2&gt;2.马尔可夫过程&lt;/h2&gt;
&lt;p&gt;我们将已知历史信息$(s_1,\dots,s_t)$的下一个时间步为$s_{t+1}$的概率记为$P(s_{t+1}\mid s_1,\dots,s_t)$&lt;/p&gt;
&lt;p&gt;当$P(s_{t+1}\mid s_1,\dots,s_t)=P(s_{t+1}\mid s_t)$时,我们称一个随机过程具有马尔可夫性质&lt;/p&gt;
&lt;h2&gt;3.MDP的数学推导&lt;/h2&gt;
&lt;p&gt;我们按照$MP \to MRP \to MDP$的顺序来进行推导&lt;/p&gt;
&lt;h3&gt;3.1 MP&lt;/h3&gt;
&lt;p&gt;我们一般使用元组$\langle \mathcal{S},\mathcal{P} \rangle$来描述MP，其中$S$是有限数量的状态集合，$P$是状态转移矩阵&lt;/p&gt;
&lt;p&gt;假设共有$n$个离散的状态,此时：
$$\mathcal S={s_1,\dots,s_n}$$
$$
\mathbf P=\begin{pmatrix}&lt;br /&gt;
P(s_1\mid s_1)&amp;amp;\cdots &amp;amp;P(s_n\mid s_1)\
\vdots &amp;amp; \ddots &amp;amp; \vdots\
P(s_n\mid s_1) &amp;amp; \cdots &amp;amp; P(s_n\mid s_n)
\end{pmatrix}
$$&lt;/p&gt;
&lt;h3&gt;3.2 MRP&lt;/h3&gt;
&lt;p&gt;我们在MP的基础上加上奖励函数$r$与折扣因子$\gamma$,那我们就得到了MRP
一般由四元组$\langle \mathcal S,\mathbf P, r, \gamma  \rangle$来定义，其中
$r$为奖励函数，$r(s)$指在$s$状态下获得奖励的期望，
$\gamma$为折扣因子，引入它可以确保价值收敛，范围为$[0,1)$，可以通过调整使之更关注长期/短期利益&lt;/p&gt;
&lt;h4&gt;3.2.1 回报&lt;/h4&gt;
&lt;p&gt;我们定义从第$t$时间步开始的所有奖励的衰减之和定义为回报$G_t(return)$
$$G_t=R_t+\gamma R_{t+1} +\gamma^2 R_{t+2}+\dots =\sum_{k=0}^\infty \gamma^k R_{t+k}$$
其中，$R_t$表示$t$时间步时获得的奖励&lt;/p&gt;
&lt;h4&gt;3.2.2 价值函数&lt;/h4&gt;
&lt;h1&gt;我们把一个时间步的回报的期望定义为价值
所有状态的价值组成了价值函数，（输入为某个state，输出为某个价值），定义为
$$V(s)=\mathbb{E}[G_t\mid S_t=s]$$
而，
$$
\begin{aligned}
V(s)&amp;amp;=\mathbb{E}[G_t\mid S_t=s]\
&amp;amp;=\mathbb{E}[R_t+\gamma R_{t+1}+ \gamma^2 R_{t+2} + \dots \mid S_t=s]\
&amp;amp;=\mathbb{E}[R_t+\gamma(R_{t+1}+\gamma R_{t+2})+\dots \mid S_t=s]\
&amp;amp;=\mathbb{E}[R_t+\gamma V(S_{t+1}) \mid S_t=s]
\end{aligned}
$$
故我们可以得到：
$$V(s)=r(s)+\gamma \sum_{s&apos; \in S} P(s&apos; \mid s)V(s&apos;)$$
这就是大名鼎鼎的贝尔曼方程
我们整理所有共$t$个状态，组成列向量
得到矩阵形式的贝尔曼方程：
$$\mathbf{V}=\mathbf R + \gamma \mathbf P \mathbf V$$
$$
\begin{bmatrix}V(s_1)\
V(s_2)\
\vdots\
V(s_t)\end{bmatrix}&lt;/h1&gt;
&lt;p&gt;\begin{bmatrix}r(s_1)\
r(s_2)\
\vdots\
r(s_t)\end{bmatrix}
+
\gamma
\begin{bmatrix}
P(s_1\mid s_1)&amp;amp;P(s_2\mid s_1)&amp;amp;\cdots&amp;amp;P(s_t\mid s_1)\
P(s_1\mid s_2)&amp;amp;P(s_2\mid s_2)&amp;amp;\cdots&amp;amp;P(s_t\mid s_2)\
\vdots&amp;amp;\vdots&amp;amp;\ddots&amp;amp;\vdots\
P(s_1\mid s_1)&amp;amp;P(s_2\mid s_1)&amp;amp;\cdots&amp;amp;P(s_t\mid s_1)\
\end{bmatrix}
\begin{bmatrix}V(s_1)\
V(s_2)\
\vdots\
V(s_t)\end{bmatrix}
$$
故移项解得：
$$\mathbf V= (\mathbf I - \gamma \mathbf P)^{-1}\mathbf R$$&lt;/p&gt;
&lt;h3&gt;3.3 MDP&lt;/h3&gt;
&lt;p&gt;总算推进到了MDP&lt;/p&gt;
&lt;p&gt;MP与MRP都没有“动作”“策略”的参与，本质上是一个自己运行，无干预的系统
如果有一个外界的“刺激”可以改变这个随机过程（加入智能体的&quot;动作&quot;），就得到了MDP
我们可以把MDP记为一个五元组:
$$\langle \mathcal S,\mathcal A,\mathbf P, r, \gamma  \rangle$$
其中$\mathcal A$为动作集合&lt;/p&gt;
&lt;p&gt;在这种情况下，我们不把$\mathbf P$记作一个概率分布矩阵，而是记作一个状态转移函数，原因有二：
1）记作概率分布矩阵不可行，因为引入了不同的动作，而每一个动作都具有自己的概率分布矩阵，故只能记作一个三阶张量
2）状态集合非有限时，仍可以记作状态转移函数，说明状态转移函数更为普遍&lt;/p&gt;
&lt;p&gt;agent与环境相互交互的过程大致如下：
&lt;img src=&quot;/assets/img/notes/20260527-MDP/MDP.png&quot; alt=&quot;MDP.png&quot; /&gt;&lt;/p&gt;
&lt;h4&gt;3.3.1 策略（policy）&lt;/h4&gt;
&lt;p&gt;智能体的&lt;strong&gt;策略&lt;/strong&gt;（Policy）通常用字母$\pi$表示。策略$\pi(a\mid s)=P(A_t=a\mid S_t=s)$是一个函数，表示在输入状态情况下采取动作的概率。&lt;/p&gt;
&lt;p&gt;在 MDP 中，由于马尔可夫性质的存在，策略只需要与当前状态有关，不需要考虑历史状态。&lt;/p&gt;
&lt;h4&gt;3.3.2 状态价值函数$V^{\pi}(s)$&lt;/h4&gt;
&lt;p&gt;与MRP定义类似，状态价值函数被定义为基于策略$\pi$的回报的期望，定义为：
$$V^{\pi}(s)=\mathbb{E}_{\pi}[G_t\mid S_t=s]$$&lt;/p&gt;
&lt;h4&gt;3.3.3 动作价值函数$Q^{\pi}(s,a)$&lt;/h4&gt;
&lt;p&gt;与MRP不同的是，我们额外定义一个基于$\pi$的函数，定义为:
$$Q^{\pi}(s,a)=\mathbb{E}&lt;em&gt;{\pi}[G_t\mid S_t=s,A_t=a]$$
状态价值函数和动作价值函数之间的联系：
$$V^{\pi}(s)=\sum&lt;/em&gt;{a \in A} \pi(a\mid s)Q^{\pi}(s,a)$$
其意义是显然的，不过多解释&lt;/p&gt;
&lt;p&gt;当然，还有Q的计算式：
$$Q^{\pi}(s,a)=r(s,a)+\gamma\sum _{s&apos; \in S}P(s&apos;\mid s ,a)V^{\pi}(s&apos;)$$&lt;/p&gt;
&lt;h4&gt;3.3.4 贝尔曼期望方程&lt;/h4&gt;
&lt;p&gt;$$
\begin{aligned}
V^{\pi}(s)&amp;amp;=\mathbb{E}[R(s)+\gamma V^{\pi}(S_{t+1} \mid S_t=s)]\nonumber \
&amp;amp;=\sum_{a \in A}\pi(a \mid s)\left(r(s,a)+\gamma\sum_{s&apos; \in S} P(s&apos; \mid s,a) V^{\pi}(s&apos;) \right)
\end{aligned}
$$&lt;/p&gt;
&lt;p&gt;$$
\begin{aligned}
Q^{\pi}(s,a)&amp;amp;=\mathbb{E}[R(s,a)+\gamma Q^{\pi}(S_{t+1},A_{t+1} \mid S_t=s,A_t=a)] \nonumber \
&amp;amp;=r(s,a)+\gamma \sum_{s&apos; \in S} P(s&apos;\mid s,a)\sum_{a&apos;\in A}\pi(a&apos;\mid s)Q^{\pi}(s&apos;,a&apos;)\
\end{aligned}
$$&lt;/p&gt;
&lt;h3&gt;3.4蒙特卡洛方法&lt;/h3&gt;
&lt;p&gt;MC,简单的一种取样方法，即将随机取样的平均值当作期望的近似，即为：
$$V^{\pi}(s)=\mathbb{E}[G_t \mid S_t=s] \approx \frac{\sum_{i=1}^{N}G_t^{(i)}}{N}$$
我们依旧可以使用[[MAB]]中的增量更新的方法&lt;/p&gt;
&lt;h3&gt;3.5 占用度量&lt;/h3&gt;
&lt;p&gt;如果我们用$P^{\pi}&lt;em&gt;t(s)$来定义采取策略$\pi$,在$t$时刻，状态为$s$的概率，并且定义$v_0(s)$为初始概率分布
那么，我们可以定义一个策略的状态访问分布为：
$$\mathcal{v}^{\pi}(s)=(1-\gamma)\sum&lt;/em&gt;{t=0}^{\infty}\gamma^{t}P_t^{\pi}(s)$$
其中，$1-\gamma$为归一化参数，目的是使得状态访问分布相加为1
类似的，我们还可以定义策略的占用度量：
$$\rho^{\pi}(s,a)=(1-\gamma)\sum_{t=0}^{\infty}\gamma^tP_t^\pi(s)\pi(a\mid s)$$&lt;/p&gt;
&lt;h3&gt;3.6 最优策略&lt;/h3&gt;
&lt;p&gt;我们定义$\pi&amp;gt;\pi&apos;$当且仅当$\forall s\in S,V^{\pi}(s)\ge V^{\pi&apos;}(s)$
于是在有限状态和动作集合的 MDP 中，至少存在一个策略比其他所有策略都好或者至少存在一个策略不差于其他所有策略，这个策略就是&lt;strong&gt;最优策略&lt;/strong&gt;（optimal policy）。最优策略可能有很多个，我们都将其表示为$\pi^&lt;em&gt;(s)$。
由此，我们可以定义最优状态价值函数$V^&lt;/em&gt;(s)$与最优动作价值函数$Q^&lt;em&gt;(s,a)$
$$V^&lt;/em&gt;(s)=\max_\pi V^\pi(s),\forall s \in S$$
$$Q^&lt;em&gt;(s,a)=\max_\pi Q^\pi(s,a),\forall s \in S,\forall a \in A$$
为了使Q最大，我们要使得之后的每个选择都选择最优价值，即：
$$Q^&lt;/em&gt;(s,a)=r(s,a)+\gamma \sum_{s&apos; \in S}P(s&apos; \mid s,a)V^&lt;em&gt;(s&apos;)=r(s,a)+\gamma \sum_{s&apos; \in S}P(s&apos; \mid s,a)\max_{a&apos; \in A}Q^&lt;/em&gt;(s&apos;,a&apos;)$$
同样的，最优的状态价值出自最优的动作，即：
$$V^&lt;em&gt;(s)=\max_{a \in A}Q^&lt;/em&gt;(s,a)=\max_{a\in A}\left(r(s,a)+\gamma\sum_{s&apos; \in S} P(s&apos; \mid s,a) V^&lt;em&gt;(s&apos;) \right)$$
我们把
$$Q^&lt;/em&gt;(s,a)=r(s,a)+\gamma \sum_{s&apos; \in S}P(s&apos; \mid s,a)\max_{a&apos; \in A}Q^&lt;em&gt;(s&apos;,a&apos;)$$
与
$$V^&lt;/em&gt;(s)=\max_{a\in A}\left(r(s,a)+\gamma\sum_{s&apos; \in S} P(s&apos; \mid s,a) V*(s&apos;) \right)$$
称作贝尔曼最优方程&lt;/p&gt;
&lt;h2&gt;4.一些总结&lt;/h2&gt;
&lt;p&gt;虽然全程手打公式很痛苦，公式也很复杂，但是实际上全然是为了严谨定义所以显的复杂，实际上，在策略确定时（假设已经最优），即为
$$V(s)=r(s)+\gamma V(s&apos;)$$
其中，s&apos;是在策略$\pi$下，当前状态为$s$的可能下一状态
考虑简单的01背包问题，其贝尔曼最优方程即为：&lt;/p&gt;
&lt;p&gt;$$F(i,c)=\max_{a\in{0,1},\ aw_i\le c} \left[a v_i+F(i-1,c-aw_i)\right]$$
化成类似定义的形式：
$$V^&lt;em&gt;(i, c) = \max_{a \in {0, 1}} \left{ a \cdot v_i + 1 \cdot \sum_{s&apos;} 1 \cdot V^&lt;/em&gt;(s&apos;) \right}$$
也就是取$\gamma=1$（收益无衰减），且策略均为确定性策略的结果&lt;/p&gt;
&lt;p&gt;从特殊到一般，MDP提供了描述所有相关事务的一种工具，并深刻的揭示，定义了价值，比DP等层次更高&lt;/p&gt;
</content:encoded></item><item><title>MAB</title><link>https://tiany1yu.github.io/posts/notes/mab/</link><guid isPermaLink="true">https://tiany1yu.github.io/posts/notes/mab/</guid><pubDate>Tue, 19 May 2026 00:00:00 GMT</pubDate><content:encoded>&lt;h2&gt;1.&lt;/h2&gt;
&lt;p&gt;首先，基于整个问题给出一个形式化的描述：
多臂老虎机问题不存在$state$,也就可以建模为一个元组$\left\langle A , R \right\rangle$，其中：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$A$ 为动作集合&lt;/li&gt;
&lt;li&gt;$R$ 为奖励概率分布&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;多臂老虎机的优化目标为最大化一段时间步$T$内累计的奖励，也即：&lt;/p&gt;
&lt;p&gt;$$
\max \sum_{t=1}^{T} r_t, \quad r_t \sim R(\cdot \mid a_t)
$$&lt;/p&gt;
&lt;p&gt;我们将其转换为最小化懊悔（cumulative regret)
我们将懊悔定义为:&lt;/p&gt;
&lt;p&gt;$$
R(a) = Q^* - Q(a)
$$&lt;/p&gt;
&lt;p&gt;其中，&lt;/p&gt;
&lt;p&gt;$$
Q(a) = E_{r \sim R(\cdot \mid a)}[r]
$$&lt;/p&gt;
&lt;p&gt;$$
Q^* = \max_{a \in A} Q(a)
$$&lt;/p&gt;
&lt;h2&gt;关于期望奖励估值的伪代码：&lt;/h2&gt;
&lt;h2&gt;对于$\forall a \in A$,先初始化计数器$N(a) = 0$ 和初始化奖励估计值 $\hat{Q}(a)=0$
$\textbf{for} \quad t=1 \to T \quad \textbf{do}$
选取某个拉杆，该动作记为$a_t$
得到奖励$r_t$
更新计数器$N(a)$++;
更新奖励估计值$\hat{Q}(a_t)=\hat Q(a_t)+\frac{1}{N(a_t)}[r_t-\hat Q (a_t)]$
$\textbf{end for}$&lt;/h2&gt;
&lt;p&gt;这一流程采取增量式更新，时间，空间复杂度均为O(1)(推导容易)
接下来写一个实现伯努利分布多臂老虎机的类&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;import numpy as np

import matplotlib.pyplot as plt

class BNLbandit:

    def __init__ (self,k:int)-&amp;gt; None:

        self.K=k

        self.probs=np.random.uniform(0,1,size=k)

        self.max_idx=np.argmax(self.probs)

        self.max_prob=self.probs[self.max_idx]

    def step(self,action):

        if np.random.rand()&amp;lt;self.probs[action]:

            return 1

        else:

            return 0

class Solver:

    def __init__(self,bandit:BNLbandit) -&amp;gt; None:

        self.bandit=bandit

        self.counts=np.zeros(bandit.K)

        self.regret=0.

        self.regrets=[]

        self.actions=[]

    def run_one_step(self)-&amp;gt;int:

        raise NotImplementedError

    def update_regret(self,action:int):

        self.regret+=self.bandit.max_prob-self.bandit.probs[action]

        self.regrets.append(self.regret)

    def run(self,n_steps:int):

        for _ in range(n_steps):

            action=self.run_one_step()

            self.update_regret(action)

            self.actions.append(action)

            self.counts[action]+=1

  

def plot_results(axes,solvers,solver_names):

    for idx,solver in enumerate(solvers):

        time_list=range(len(solver.regrets))

        axes.plot(time_list,solver.regrets,label=solver_names[idx],alpha=0.8)

    axes.set_xlabel(&quot;Time steps&quot;)

    axes.set_ylabel(&quot;Cumulative regrets&quot;)

    axes.legend()
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;2.&lt;/h2&gt;
&lt;p&gt;很经典的，我们需要找到探索与利用 的平衡点&lt;/p&gt;
&lt;p&gt;接下来一个一个算法进行分析&lt;/p&gt;
&lt;h3&gt;$2.1 \quad \epsilon - 贪婪算法$&lt;/h3&gt;
&lt;p&gt;每次以$\epsilon$的概率进行探索，以$1-\epsilon$的概率进行利用，即：&lt;/p&gt;
&lt;p&gt;$$
a_t = \begin{cases} \arg\max_{a \in A} \hat{Q}(a), &amp;amp; p = 1-\epsilon \\ \operatorname{random}_{a \in A}, &amp;amp; p = \epsilon \end{cases}
$$&lt;/p&gt;
&lt;p&gt;当然，我们可以令$\epsilon$随时间衰减，但是我们始终得到的是相对精确的期望，故$\epsilon$应该保证不为0&lt;/p&gt;
&lt;h3&gt;$2.2 \quad 上置信界算法（UCB）$&lt;/h3&gt;
&lt;p&gt;首先需要应用霍夫丁不等式：（大概大二上会学）&lt;/p&gt;
&lt;p&gt;$$
P(E[X] \geq \overline{x}_n + u) \leq e^{-2nu^2}
$$&lt;/p&gt;
&lt;p&gt;代入&lt;/p&gt;
&lt;p&gt;$$
\hat{Q}_n = \overline{x}_n
$$&lt;/p&gt;
&lt;p&gt;令上式中&lt;/p&gt;
&lt;p&gt;$$
u = \hat{U}(a_n)
$$&lt;/p&gt;
&lt;p&gt;代表不确定性度量。
记&lt;/p&gt;
&lt;p&gt;$$
p = e^{-2nu^2}
$$&lt;/p&gt;
&lt;p&gt;则&lt;/p&gt;
&lt;p&gt;$$
P(E[X] &amp;lt; \overline{x}_n + \hat{U}(a_n)) = 1-p
$$&lt;/p&gt;
&lt;p&gt;当$p$很小的时候，这件事情大概率发生。
故我们令期望奖励上界为&lt;/p&gt;
&lt;p&gt;$$
\hat{Q}_n + \hat{U}(a_n)
$$&lt;/p&gt;
&lt;p&gt;解得&lt;/p&gt;
&lt;p&gt;$$
\hat{U}(a) = \sqrt{\frac{-\log p}{2N(a_t)}}
$$&lt;/p&gt;
&lt;p&gt;此时，&lt;/p&gt;
&lt;p&gt;$$
a_t = \arg\max_{a \in A}\left[\hat{Q}(a) + c\hat{U}(a)\right]
$$&lt;/p&gt;
&lt;p&gt;其中，c为超参数，方便控制不确定比重&lt;/p&gt;
&lt;h3&gt;$2.3 \quad 汤普森采样$&lt;/h3&gt;
&lt;p&gt;汤普森采样，顾名思义，猜测概率分布，通过每个时间步$T$采样其概率取$argmax$
一般采用$Beta$分布，分布在$(0,1)$上，其中概率密度函数为：&lt;/p&gt;
&lt;p&gt;$$
f(x;\alpha,\beta)=\frac{x^{\alpha}(1-x)^{\beta}}{B(\alpha,\beta)}
$$&lt;/p&gt;
&lt;p&gt;$B(\alpha,\beta)$是归一化参数，为上部函数在$(0,1)$上的积分值&lt;/p&gt;
&lt;h2&gt;3.&lt;/h2&gt;
&lt;p&gt;最后，把这3种算法对应的solver以及main贴一下，看一下可视化效果&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;class EpsilonGreedy(Solver):

    def __init__(self,bandit:BNLbandit,epsilon:float=0.01,init_prob:float=1.0):

        super(EpsilonGreedy,self).__init__(bandit)

        self.epsilon=epsilon

        self.estimate=np.array([init_prob]*bandit.K)

    def run_one_step(self):

        if np.random.rand()&amp;lt;self.epsilon:

            k=np.random.randint(0,self.bandit.K)

        else:

            k=np.argmax(self.estimate)

        r=self.bandit.step(k)

        self.estimate[k]+=1./(self.counts[k]+2)*(r-self.estimate[k])#更稳定，否则一旦第一次roll出0，直接报废

        return k

  

class DacayingEpsilonGreedy(EpsilonGreedy):

    def __init__(self,bandit:BNLbandit,epsilon:float=0.1,init_prob:float=1.0):

        super(DacayingEpsilonGreedy,self).__init__(bandit,epsilon,init_prob)

    def run_one_step(self):

        self.epsilon=1/(len(self.regrets)+1)

        return super(DacayingEpsilonGreedy,self).run_one_step()

  

class UCB(Solver):

    def __init__(self, bandit: BNLbandit,ceof:float=1.0,init_prob:float=1.0) -&amp;gt; None:

        super(UCB,self).__init__(bandit)

        self.ceof=ceof

        self.estimate=np.array([init_prob]*bandit.K)

        self.tot_count=0

    def run_one_step(self)-&amp;gt;int:

        self.tot_count+=1

        ucb=self.estimate+self.ceof*np.sqrt(np.log(self.tot_count)/2/(self.counts+1))

        k=np.argmax(ucb)

        r=bandit.step(k)

        self.estimate[k]+=(r-self.estimate[k])/(1+self.counts[k])

        return k

  

class TompsonSampling(Solver):

    def __init__(self, bandit: BNLbandit) -&amp;gt; None:

        super(TompsonSampling,self).__init__(bandit)

        self.alpha=np.ones(bandit.K)

        self.beta=np.ones(bandit.K)

        self.tot_count=0

    def run_one_step(self) -&amp;gt; int:

        self.estimate=np.random.beta(self.alpha,self.beta)

        k=np.argmax(self.estimate)

        r=bandit.step(k)

        if r==1:

            self.alpha[k]+=1

        else:

            self.beta[k]+=1

        return k    

  

if __name__==&quot;__main__&quot;:

    np.random.seed(1)

    bandit=BNLbandit(k=10)

    print(f&quot;max={bandit.max_prob}&quot;)

    print(&quot;The probabilities of the arms are:&quot;,bandit.probs)

  

    plt.style.use(&apos;seaborn-v0_8-darkgrid&apos;)

    fig,ax=plt.subplots(2,2,figsize=(12,8))

    plt.suptitle(f&quot;{bandit.K}-armed bandit&quot;,fontsize=20)

  

    epsilons=[0.001,0.01,0.05,0.1,0.2,0.5]

    epsilon_solvers=[EpsilonGreedy(bandit,epsilon) for epsilon in epsilons]

    for solver in epsilon_solvers:

        solver.run(5000)

    epsilon_names=[f&quot;Epsilon-Greedy epsilon={epsilon}&quot; for epsilon in epsilons]

    plot_results(ax[0,0],epsilon_solvers,epsilon_names)

    decaying_epsilon_solver=DacayingEpsilonGreedy(bandit)

    decaying_epsilon_solver.run(5000)

    plot_results(ax[0,1],[decaying_epsilon_solver],[&quot;Decaying Epsilon-Greedy&quot;])

    UCB_Solver=UCB(bandit)

    UCB_Solver.run(5000)

    plot_results(ax[1,0],[UCB_Solver],[&quot;UCB&quot;])

  

    Tompson_Solver=TompsonSampling(bandit)

    Tompson_Solver.run(5000)

    plot_results(ax[1,1],[Tompson_Solver],[&quot;Tompson_Sampling&quot;])

    plt.savefig(&quot;MAB.png&quot;)

    plt.show()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;img src=&quot;/assets/img/notes/20260519-MAB/MAB.png&quot; alt=&quot;MAB.png&quot; /&gt;&lt;/p&gt;
&lt;p&gt;进一步的，我们引入上下文，可以得到上下文老虎机[[CB]]，动作可以影响决策，可以得到[[MDP]]，无法观测到真实的state，可以得到[[POMDP]],这些文章我也许后续会更新&lt;/p&gt;
</content:encoded></item><item><title>文物重构技术实践：基于点云的多碎片配准与可视化</title><link>https://tiany1yu.github.io/posts/writing/hw3/</link><guid isPermaLink="true">https://tiany1yu.github.io/posts/writing/hw3/</guid><pubDate>Sun, 12 Apr 2026 00:00:00 GMT</pubDate><content:encoded>&lt;h1&gt;文物重构技术实践：基于点云的多碎片配准与可视化&lt;/h1&gt;
&lt;p&gt;这篇记录的是一次基于点云的文物重构实验。目标很明确：先把一个完整文物的三维点云拆成多个碎片，再人为打乱碎片的位置和姿态，最后只依赖几何信息把它们重新对齐回去。整个过程不是做图像识别，也不是做语义推断，核心是点云配准、刚体变换估计和逐步迭代收敛。&lt;/p&gt;
&lt;p&gt;这份文章结合了 &lt;a href=&quot;%E6%96%87%E7%89%A9%E9%87%8D%E6%9E%84%E6%8A%80%E6%9C%AF%E4%BB%8B%E7%BB%8D.md&quot;&gt;文物重构技术介绍.md&lt;/a&gt; 和 &lt;a href=&quot;%E6%96%87%E7%89%A9%E9%87%8D%E6%9E%84%E5%8F%AF%E8%A7%86%E5%8C%96.ipynb&quot;&gt;文物重构可视化.ipynb&lt;/a&gt; 的实际输出，按实验流程完整讲一遍原理、步骤和结果。&lt;/p&gt;
&lt;h2&gt;1. 问题定义&lt;/h2&gt;
&lt;p&gt;文物碎裂后的重构，本质上是在做三件事：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;判断碎片来自同一个整体的哪些位置。&lt;/li&gt;
&lt;li&gt;估计每个碎片应该如何旋转和平移。&lt;/li&gt;
&lt;li&gt;让所有碎片在统一坐标系下尽量贴回目标形状。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;在这个实验里，输入不是照片，而是三维点云。点云可以理解为物体表面的离散采样点，每个点包含空间坐标。因为只处理几何坐标，所以这套方法不依赖纹理、颜色或拍摄光照，适合做一个纯几何版的重构演示。&lt;/p&gt;
&lt;h2&gt;2. 数据如何构造&lt;/h2&gt;
&lt;p&gt;实验先从完整目标点云出发，然后把它切成多个碎片，再对每个碎片施加随机刚体变换。这个过程模拟了真实文物碎裂后的散落状态。&lt;/p&gt;
&lt;h3&gt;2.1 先有完整目标&lt;/h3&gt;
&lt;p&gt;目标点云是原始文物的完整几何形态。 notebook 中既有单个示例，也有多文物批量实验；在多碎片主流程里，点数规模大约是 18000，碎成 5 片左右，足够展示配准效果和误差变化。&lt;/p&gt;
&lt;h3&gt;2.2 再切成碎片&lt;/h3&gt;
&lt;p&gt;碎片化不是简单裁切成规则块，而是沿着空间位置和随机掩码生成不规则片段，这样更接近真实断裂边界。每个碎片保留原始表面的一部分点，后续才有可能靠局部几何特征重新匹配回去。&lt;/p&gt;
&lt;h3&gt;2.3 打乱姿态&lt;/h3&gt;
&lt;p&gt;每个碎片都会被随机旋转和平移。这样得到的输入已经不再保留原来的空间关系，算法必须重新估计刚体变换。下面这张图就是散乱后的状态，目标物体在中间，碎片被分散到周围。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/assets/img/posts/20260412-hw3/output_images/1_multifragment_scattered.png&quot; alt=&quot;多碎片散乱状态&quot; /&gt;&lt;/p&gt;
&lt;h2&gt;3. 核心原理：SVD-ICP&lt;/h2&gt;
&lt;p&gt;这套重构方法的核心是 SVD-ICP。它把“找对应点”和“求刚体变换”这两件事结合起来，反复迭代，直到碎片和目标足够接近。&lt;/p&gt;
&lt;h3&gt;3.1 ICP 在做什么&lt;/h3&gt;
&lt;p&gt;ICP 的基本过程可以概括为：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;对当前碎片中的点，在目标点云中找最近邻。&lt;/li&gt;
&lt;li&gt;把当前碎片点和这些最近邻构成对应关系。&lt;/li&gt;
&lt;li&gt;在对应关系下估计最优的旋转和平移。&lt;/li&gt;
&lt;li&gt;用新的变换更新碎片位置。&lt;/li&gt;
&lt;li&gt;重复以上步骤，直到误差不再明显下降。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;这里的关键不是一次性算出完美答案，而是让每次迭代都比上一次更接近目标。&lt;/p&gt;
&lt;h3&gt;3.2 SVD 为什么能求刚体变换&lt;/h3&gt;
&lt;p&gt;当对应点已经确定后，问题就变成：给定两组点，如何找到一个旋转矩阵和平移向量，使两组点尽量重合。对这个问题，标准做法是：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;先减去各自质心，把问题转成纯旋转估计。&lt;/li&gt;
&lt;li&gt;计算协方差矩阵。&lt;/li&gt;
&lt;li&gt;对协方差矩阵做奇异值分解。&lt;/li&gt;
&lt;li&gt;根据分解结果构造最优旋转。&lt;/li&gt;
&lt;li&gt;再恢复平移量。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;这样得到的是一个刚体变换，不会引入剪切或缩放，符合文物碎片只能平移和旋转的实际设定。&lt;/p&gt;
&lt;h3&gt;3.3 KDTree 的作用&lt;/h3&gt;
&lt;p&gt;ICP 最耗时的部分之一是最近邻搜索。为了加速查询， notebook 中使用了 cKDTree。它把目标点云预处理成树结构，之后每次查询最近点都比直接暴力搜索快得多。&lt;/p&gt;
&lt;p&gt;更重要的是，目标树可以在一次 ICP 调用里复用，不必每一轮都重建。这样做既减少开销，也让迭代过程更稳定。&lt;/p&gt;
&lt;h3&gt;3.4 为什么要做 trimmed ICP&lt;/h3&gt;
&lt;p&gt;真实碎片和目标之间并不是完美一一对应，边缘点、遮挡点、离群点都会影响配准。如果把所有点都强行纳入对应关系，错误匹配会把结果拉偏。&lt;/p&gt;
&lt;p&gt;所以这里使用了 trimmed ICP 的思路：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;先找最近邻。&lt;/li&gt;
&lt;li&gt;按残差大小筛掉一部分最差的对应点。&lt;/li&gt;
&lt;li&gt;只用保留下来的部分去求 SVD 变换。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;这样做的好处是对离群点更鲁棒，尤其适合碎片边缘不完整、局部形状噪声较大的情况。&lt;/p&gt;
&lt;h2&gt;4. 单碎片与多碎片的重构策略&lt;/h2&gt;
&lt;h3&gt;4.1 先做多起点粗对齐&lt;/h3&gt;
&lt;p&gt;碎片初始姿态是随机的，直接从一个姿态开始跑 ICP 很容易卡在局部最优。所以 notebook 里用了多起点策略：先给碎片生成多个初始旋转候选，再分别跑 trimmed ICP，最后挑出误差最小的结果。&lt;/p&gt;
&lt;p&gt;这一步的作用是先把大方向找对，避免一开始就进入错误配准。&lt;/p&gt;
&lt;h3&gt;4.2 再按碎片大小顺序处理&lt;/h3&gt;
&lt;p&gt;多碎片重构时，较大的碎片通常保留了更多结构信息，形状约束更强，所以先处理它们更容易搭出一个稳定骨架。后续的小碎片再依附这个骨架逐步补齐。&lt;/p&gt;
&lt;p&gt;这和 notebook 中的排序逻辑一致：先按碎片点数从大到小排序，再逐个对齐。&lt;/p&gt;
&lt;h3&gt;4.3 再做逐轮细化&lt;/h3&gt;
&lt;p&gt;如果只做一次粗配准，碎片虽然已经大致归位，但局部边界往往还会有误差。所以重构完成后还会继续细化：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;根据当前已对齐结果重新划分目标区域。&lt;/li&gt;
&lt;li&gt;让每个碎片只对准自己附近的子目标。&lt;/li&gt;
&lt;li&gt;再执行一轮或多轮 ICP 微调。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;这个过程的作用是减少碎片之间的互相干扰，尤其适合多片同时拼接的情况。&lt;/p&gt;
&lt;h2&gt;5. 主流程结果&lt;/h2&gt;
&lt;p&gt;主实验的结果一共做了四类可视化：散乱状态、对齐后的残差图、每片误差柱状图，以及整体仪表盘式总结图。&lt;/p&gt;
&lt;h3&gt;5.1 散乱到对齐的整体变化&lt;/h3&gt;
&lt;p&gt;下面这张图展示了一个典型的多碎片重构过程。左边是初始散乱状态，右边是配准后的结果，颜色映射的是每个点到目标点云的残差。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/assets/img/posts/20260412-hw3/output_images/2_multifragment_aligned.png&quot; alt=&quot;多碎片对齐结果&quot; /&gt;&lt;/p&gt;
&lt;p&gt;可以看到，对齐后大部分点已经回到目标主体附近，残差热区主要集中在边缘和局部形状变化较大的区域。&lt;/p&gt;
&lt;h3&gt;5.2 每个碎片的误差&lt;/h3&gt;
&lt;p&gt;误差柱状图可以直接看出哪一片更难对齐。一般来说，碎片越大、几何信息越完整，误差越容易稳定；碎片越小或者越细长，误差越容易上升。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/assets/img/posts/20260412-hw3/output_images/3_multifragment_error_bar.png&quot; alt=&quot;多碎片误差柱状图&quot; /&gt;&lt;/p&gt;
&lt;h3&gt;5.3 收敛曲线&lt;/h3&gt;
&lt;p&gt;收敛曲线记录的是 trimmed ICP loss 随碎片顺序或迭代过程的变化。它能告诉我们：配准过程是不是在持续下降，还是已经进入平台期。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/assets/img/posts/20260412-hw3/output_images/5_multifragment_loss_curve.png&quot; alt=&quot;多碎片损失曲线&quot; /&gt;&lt;/p&gt;
&lt;h3&gt;5.4 综合仪表盘&lt;/h3&gt;
&lt;p&gt;这个图把输入、输出和误差放在一张图里，方便快速汇报。适合展示给老师或组员，能一眼看出“散乱状态、重构结果、误差排序”三件事。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/assets/img/posts/20260412-hw3/output_images/4_multifragment_dashboard.png&quot; alt=&quot;多碎片综合面板&quot; /&gt;&lt;/p&gt;
&lt;h3&gt;5.5 单帧误差分布&lt;/h3&gt;
&lt;p&gt;如果要更直观地看残差如何分布，可以看这一张残差图。颜色越偏红，说明该点到目标的距离越大，越偏蓝则越接近目标。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/assets/img/posts/20260412-hw3/output_images/3_error_distribution.png&quot; alt=&quot;单帧误差分布&quot; /&gt;&lt;/p&gt;
&lt;h2&gt;6. 动画结果&lt;/h2&gt;
&lt;p&gt;静态图能看最终结果，但看不出中间如何逐步收敛，所以 notebook 还导出了 GIF。动画里记录了每次 SVD-ICP 更新后的空间变化，能直接看到碎片从散乱位置一步步贴回目标。&lt;/p&gt;
&lt;h3&gt;6.1 整体装配过程&lt;/h3&gt;
&lt;p&gt;&lt;img src=&quot;/assets/img/posts/20260412-hw3/output_images/6_assembly_process.gif&quot; alt=&quot;装配过程动画&quot; /&gt;&lt;/p&gt;
&lt;h3&gt;6.2 多碎片重构的等轴测视角&lt;/h3&gt;
&lt;p&gt;这个 GIF 更适合看三维空间中的相对位置变化。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/assets/img/posts/20260412-hw3/output_images/6_multifragment_process_iso.gif&quot; alt=&quot;多碎片等轴测动画&quot; /&gt;&lt;/p&gt;
&lt;h3&gt;6.3 多碎片重构的俯视视角&lt;/h3&gt;
&lt;p&gt;从俯视角度看，更容易确认各碎片在平面内的平移和旋转趋势。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/assets/img/posts/20260412-hw3/output_images/7_multifragment_process_top.gif&quot; alt=&quot;多碎片俯视动画&quot; /&gt;&lt;/p&gt;
&lt;h2&gt;7. 多文物实验&lt;/h2&gt;
&lt;p&gt;除了主流程里的单个示例， notebook 还对多个不同形状的文物做了批量实验，包括高浮雕石碑、带把手的陶罐和装饰柱体。这样做的意义是验证方法不是只对某一个样本有效，而是能在不同几何结构上稳定工作。&lt;/p&gt;
&lt;h3&gt;7.1 ornate_column&lt;/h3&gt;
&lt;p&gt;这组样本的特征是形状比较规整，但局部曲率和边缘细节仍然丰富。它适合观察碎片是否能沿着整体轮廓回到正确位置。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/assets/img/posts/20260412-hw3/output_images/multi_artifacts/ornate_column_reconstruction_report.png&quot; alt=&quot;ornate_column 重构报告&quot; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/assets/img/posts/20260412-hw3/output_images/multi_artifacts/ornate_column_process_iso_v3.gif&quot; alt=&quot;ornate_column 过程动画等轴测&quot; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/assets/img/posts/20260412-hw3/output_images/multi_artifacts/ornate_column_process_top_v3.gif&quot; alt=&quot;ornate_column 过程动画俯视&quot; /&gt;&lt;/p&gt;
&lt;h3&gt;7.2 amphora_handles&lt;/h3&gt;
&lt;p&gt;这个样本带有把手结构，局部细长区域比较多，配准时更容易受到方向误差的影响。它能测试算法对复杂局部结构的稳定性。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/assets/img/posts/20260412-hw3/output_images/multi_artifacts/amphora_handles_reconstruction_report.png&quot; alt=&quot;amphora_handles 重构报告&quot; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/assets/img/posts/20260412-hw3/output_images/multi_artifacts/amphora_handles_process_iso_v3.gif&quot; alt=&quot;amphora_handles 过程动画等轴测&quot; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/assets/img/posts/20260412-hw3/output_images/multi_artifacts/amphora_handles_process_top_v3.gif&quot; alt=&quot;amphora_handles 过程动画俯视&quot; /&gt;&lt;/p&gt;
&lt;h3&gt;7.3 relief_stela&lt;/h3&gt;
&lt;p&gt;这组样本更接近大体块结构，碎片尺度差异更明显。它能体现“先大后小、逐步细化”的策略为什么有效。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/assets/img/posts/20260412-hw3/output_images/multi_artifacts/relief_stela_reconstruction_report.png&quot; alt=&quot;relief_stela 重构报告&quot; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/assets/img/posts/20260412-hw3/output_images/multi_artifacts/relief_stela_process_iso_v3.gif&quot; alt=&quot;relief_stela 过程动画等轴测&quot; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/assets/img/posts/20260412-hw3/output_images/multi_artifacts/relief_stela_process_top_v3.gif&quot; alt=&quot;relief_stela 过程动画俯视&quot; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/assets/img/posts/20260412-hw3/output_images/multi_artifacts/relief_stela_process_side_v3.gif&quot; alt=&quot;relief_stela 过程动画侧视&quot; /&gt;&lt;/p&gt;
&lt;h2&gt;8. 结果怎么理解&lt;/h2&gt;
&lt;p&gt;这套实验最重要的结论不是“把图拼回去了”这么简单，而是要看方法是否具备稳定的几何对齐能力。可以从三个角度判断：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;整体形状是否和目标一致。&lt;/li&gt;
&lt;li&gt;残差是否主要集中在边缘或局部缺失区域。&lt;/li&gt;
&lt;li&gt;不同文物、不同碎片大小下的误差是否仍然可控。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;从 notebook 的结果看，方法在多数碎片上都能恢复到合理位置，误差较大的地方也基本符合几何难点所在，而不是整块结构性失败。&lt;/p&gt;
&lt;h2&gt;9. 原理总结&lt;/h2&gt;
&lt;p&gt;如果只保留最核心的逻辑，这个流程可以概括成四步：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;先把完整点云拆成多个碎片，并随机打乱姿态。&lt;/li&gt;
&lt;li&gt;用多起点粗配准先找一个可行初值。&lt;/li&gt;
&lt;li&gt;在 KDTree 最近邻搜索和 SVD 刚体估计的基础上做 trimmed ICP 迭代。&lt;/li&gt;
&lt;li&gt;再按碎片大小和局部残差做逐轮细化，输出图、柱状图和 GIF。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;它的关键点不在于某一个单独技巧，而在于把“最近邻搜索、鲁棒筛选、刚体求解、逐步细化”串成了一条完整的流水线。&lt;/p&gt;
&lt;h2&gt;10. 小结&lt;/h2&gt;
&lt;p&gt;这次实验完成的不是一张漂亮的结果图，而是一套从碎片生成、随机打散、初始对齐、迭代配准到最终可视化的完整流程。对文物重构来说，真正重要的是：在只有几何信息的前提下，能不能稳定恢复出整体结构。&lt;/p&gt;
&lt;p&gt;如果后面继续扩展，这个方向还可以再做两件事：一是把碎片间的匹配关系做得更强，二是把多碎片的全局优化做得更严格。但就当前这份作业来说，SVD-ICP 加上分阶段细化，已经能比较完整地说明问题和方法了。&lt;/p&gt;
</content:encoded></item><item><title>基于矩阵分解的哈勃深空图像分析与重构</title><link>https://tiany1yu.github.io/posts/writing/hw2/</link><guid isPermaLink="true">https://tiany1yu.github.io/posts/writing/hw2/</guid><pubDate>Sat, 28 Mar 2026 00:00:00 GMT</pubDate><content:encoded>&lt;h1&gt;基于矩阵分解的哈勃深空图像分析与重构&lt;/h1&gt;
&lt;p&gt;&lt;strong&gt;摘要&lt;/strong&gt;：本项目旨在探索高级矩阵分解算法（主要包括奇异值分解 SVD、满秩分解、以及 Cholesky 三角分解）在超高分辨率计算机视觉任务中的应用。我们以哈勃太空望远镜拍摄的极高分辨率彩色星云图为研究对象，分别构建了“基于 SVD 的深空降噪模型”与“基于 ALS 的像素残缺修复（补全）模型”。本文档将详细阐述项目背后的数学原理与工程算法细节，以便团队成员快速理解核心思路并顺利参与后续开发。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;模块一：基于 SVD 的图像降噪与重构&lt;/h2&gt;
&lt;h3&gt;1. 核心问题背景&lt;/h3&gt;
&lt;p&gt;宇宙空间探测器传回的图像，往往伴随大量的光子噪声与宇宙射线辐射（通常呈现为高斯分布或椒盐噪声）。我们的任务是在尽量不破坏星系自然轮廓和星际尘埃细节的前提下，通过纯数学建模的方式滤除这些物理底噪。&lt;/p&gt;
&lt;p&gt;在计算机中，一张单色（灰度）图像可以被视为一个由亮度像素值构成的 $m \times n$ 的实数矩阵 $A$。对于彩色星云图（RGB），则是由三个这样的二维矩阵合并构成的三维张量。我们首先从二维矩阵讲起。&lt;/p&gt;
&lt;h3&gt;2. 数学原理深度剖析：SVD (奇异值分解)&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;SVD 的代数形式：&lt;/strong&gt;
线性代数学告诉我们，任意一个 $m \times n$ 的实矩阵 $A$ 都可以被分解为三个极具规律的矩阵的乘积：
$$A = U \Sigma V^T$$&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;$U$ (左奇异矩阵)&lt;/strong&gt;: 代表图像的“列基向量”（垂直方向特征空间）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;$V$ (右奇异矩阵)&lt;/strong&gt;: 其转置 $V^T$ 代表图像的“行基向量”（水平方向特征空间）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;$\Sigma$ (奇异值矩阵)&lt;/strong&gt;: 一个对角矩阵，对角线上的元素 $\sigma_i$ 被称为“奇异值”，默认按从大到小的顺序严格降序排列。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;从线性空间基变换的视角理解奇异值（核心）：&lt;/strong&gt;
在线性代数中，SVD 实质上是将原矩阵表示为 $r$ 个（$r$ 为矩阵的秩）秩为 1 的矩阵之和：$A = \sum_{i=1}^r \sigma_i u_i v_i^T$。其中每一项代表了原图像在某对相互正交的行向量和列向量所张成的一维子空间上的投影。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;巨大的前列奇异值&lt;/strong&gt;：这些奇异值携带了矩阵的主干结构（高度线性相关的大面积星云轮廓和渐变光谱）。这部分基向量构成了图像有效信息的主要子空间展开方向。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;微小的尾部奇异值&lt;/strong&gt;：这些极小的成分意味着其对应的基向量投影对整体矩阵的影响微乎其微。绝大多数独立且完全随机、无线性相关性的高斯噪点，由于无法通过少数几个基的线性组合来表达，它们的“坐标分量”会被迫均匀散布在这些微小奇异值长尾中。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;如何实现降噪？——投影到低秩子空间 (Truncated SVD)&lt;/strong&gt;
既然无关联的噪声全部分散于微小奇异值所对应的正交分量（基向量）上，我们可以采取一种强硬降维策略：人为地选取一个秩 $k &amp;lt; r$，强制只保留前 $k$ 个最大的奇异值。此时重构的秩为 $k$ 的近似矩阵 $A_k$ 为：
$$A_k = U \Sigma_k V^T = \sum_{i=1}^k \sigma_i u_i v_i^T$$
在这看似简单的截断背后，有着深刻的代数原理支撑——&lt;strong&gt;Eckart-Young-Mirsky 定理&lt;/strong&gt;。该定理保证了：在所有秩不超过 $k$ 的矩阵中，$A_k$ 是距离原矩阵 $A$ 最近的（即两者差值的弗罗贝尼乌斯范数 $|A - A_k|_F$ 最小）。通过丢弃后段的奇异值，我们在数学层面上相当于把原本含有庞乱杂散基向量的图像空间强行投影到了一个最具有代表性的 $k$ 维子平面上，从而在代数投影层面“过筛”掉了大部分不满足线性相关的随机噪点。&lt;/p&gt;
&lt;h3&gt;3. 工程化实现与调优基准&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;通道拆解与堆叠&lt;/strong&gt;：标准的 SVD 无法直接用于 RGB 带来的 3D 张量 ($m \times n \times 3$)。我们在代码层面采用&lt;strong&gt;分而治之&lt;/strong&gt;的策略，拆解为 R、G、B 独立子通道并行执行降噪，重组后再叠加并通过 &lt;code&gt;np.clip&lt;/code&gt; 截断防止亮度溢出。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;参数 $k$ 的艺术极值&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;若 $k$ 取得太大：导致降维不够，噪声依旧被原样重构。&lt;/li&gt;
&lt;li&gt;若 $k$ 取得太小：由于过分丢失高频信息，图片边缘变得平滑模糊。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;评价体系制定&lt;/strong&gt;：团队综合考量&lt;strong&gt;峰值信噪比(PSNR)&lt;strong&gt;与&lt;/strong&gt;压缩率指标&lt;/strong&gt;。我们通过脚本遍历探测发现：把 $k$ 固定在 $150$ 左右时，我们达到了“人类视觉最优临界点 (Visual Sweet Spot)”，即在高效压制噪声的同时原汁原味保全了星云层次。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&amp;lt;div align=&quot;center&quot;&amp;gt;
&amp;lt;img src=&quot;/assets/img/posts/20260328-hw2/image/3_psnr_compression_plot_FullRes.png&quot;&amp;gt;
&amp;lt;br&amp;gt;&amp;lt;i&amp;gt;图 1-1：PSNR 与压缩率随参数 $k$ 的变化曲线&amp;lt;/i&amp;gt;
&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;div align=&quot;center&quot;&amp;gt;
&amp;lt;img src=&quot;/assets/img/posts/20260328-hw2/image/1_Math_Best_PSNR_Blurry.webp&quot;&amp;gt;
&amp;lt;img src=&quot;/assets/img/posts/20260328-hw2/image/2_Visual_Best_Crisp.webp&quot;&amp;gt;
&amp;lt;br&amp;gt;&amp;lt;i&amp;gt;图 1-2：左图为数学最优 PSNR 结果，右图为人类视觉最优表现（保留了更多清晰边缘）&amp;lt;/i&amp;gt;
&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;SVD 降噪动态过程演示&lt;/strong&gt;
&amp;lt;div align=&quot;center&quot;&amp;gt;
&amp;lt;video controls autoplay loop muted width=&quot;80%&quot;&amp;gt;
&amp;lt;source type=&quot;video/mp4&quot; src=&quot;/assets/img/posts/20260328-hw2/image/svd_denoising_process.mp4&quot;&amp;gt;
&amp;lt;/video&amp;gt;
&amp;lt;br&amp;gt;&amp;lt;i&amp;gt;视频 1-1：随着奇异值保留个数 $k$ 的增加，图像从轮廓渐进至细节的完整重构过程&amp;lt;/i&amp;gt;
&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;模块二：基于 ALS 与 Cholesky 分解的图像大面积修复&lt;/h2&gt;
&lt;h3&gt;1. 破损图像填补问题定义&lt;/h3&gt;
&lt;p&gt;假设因太空异常辐射，接收到的信号导致画面发生极其严重的损坏，有高达 $60%$ 的离散像素彻底丢失。我们将这种状态抽象成一个观测掩码矩阵 $W$（1 代表像素完好，0 代表像素空洞）。
如何依靠仅仅剩余 $40%$ 的已知数据，自动“推理填补”出具有极深物理关联的原始星云图像？&lt;/p&gt;
&lt;p&gt;&amp;lt;div align=&quot;center&quot;&amp;gt;
&amp;lt;img src=&quot;/assets/img/posts/20260328-hw2/image/1_原始与残缺对比图.png&quot;&amp;gt;
&amp;lt;br&amp;gt;&amp;lt;i&amp;gt;图 2-1：哈勃星云图原始图像（左）与 60% 像素随机丢失后的状态（右）&amp;lt;/i&amp;gt;
&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;h3&gt;2. 数学原理深度剖析：通过满秩分解构造超定方程组&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;从图像的强相关性引出低秩假定：&lt;/strong&gt;
由于真实拍摄的照片中相邻像素色块间常具有连绵的梯度过渡，像素之间具备极强的线性空间相关性。因此，&lt;strong&gt;我们可以假定大尺度自然图像整体上非常接近于一个低秩矩阵&lt;/strong&gt;。
设含有空洞的残缺图为矩阵 $R$。根据线性代数的定义，若预设其潜藏着一个较低的近似秩 $k$，则意味着必定能将它近似拆解为两个满秩的瘦高矩阵相乘，即 $U \in \mathbb{R}^{m \times k}$ 与 $V \in \mathbb{R}^{n \times k}$：
$$R \approx U V^T$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;面对残缺数据建立最小二乘模型：&lt;/strong&gt;
因为图像残缺，我们仅能利用可观测像素的集合 $W$ 建立约束方程。由于能够提取出的有效方程个数远多于未知矩阵成分数量，这种求取 $U$ 和 $V$ 的过程实际上是在解一个&lt;strong&gt;超定方程组 (Overdetermined System)&lt;/strong&gt;。
针对无精准解的超定系统，我们会采用经典的&lt;strong&gt;最小二乘法 (Least Squares)&lt;/strong&gt;，寻找一组使其误差极小化的近似解：
$$\text{Min } e(U, V) = \sum_{(i,j) \in W} (R_{i,j} - u_i v_j^T)^2 + \lambda (|U|_F^2 + |V|_F^2)$$
说明：方程末尾补充项 $\lambda$ 的意义在于引入微小的对角线扰动。这能强制使得目标方程后续转化得到的格兰姆矩阵 (Gram Matrix) 保持严格的满秩状态，确保矩阵求逆具有绝对的唯一极小点解。&lt;/p&gt;
&lt;h3&gt;3. 工程算法攻坚战：ALS (交替最小二乘法)&lt;/h3&gt;
&lt;p&gt;由于上述误差方程中存在乘积项 $u_i \cdot v_j^T$，而 $U$ 和 $V$ 均是未知量，这种双变量共同主导的问题意味着它不能通过基础线性方程一次性结出解析解。&lt;/p&gt;
&lt;p&gt;此时解决该问题的代数方案是引入 &lt;strong&gt;ALS (交替最小二乘法)&lt;/strong&gt;，其核心思路就是将原本双元的方程转化为普通的多元一次方程：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;赋初值并假设其一常数&lt;/strong&gt;：首先人为给短阵 $V$ 初始化一组非零的常数矩阵。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;求解一侧未知量&lt;/strong&gt;：在 $V$ 是常量矩阵的前提下，原误差公式 $(R_{i,j} - u_i v^T)^2$ 便彻底退化成为了一个只有唯一未知变量 $U$ 的常规基础最小二乘问题。通过对偏导置 0 的普通代数解法，立刻便能算出当前局部最优参量 $U$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;参数身份对调&lt;/strong&gt;：解出全新的 $U$ 矩阵后，我们将这一结论反转视为固定的常量矩阵，将其代入公式作为已知数值，掉头去解剩下唯独缺失数据的 $V$ 矩阵，再一次求它的最小二乘解析解。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;交替向极小化演进&lt;/strong&gt;：持续循环迭代步骤 2 和 3。依靠这种交替式冻结某一侧的参数去求解另一变量，模型的总体代数计算误差将在迭代过程中逐步阶梯式削减，最终稳定收敛在一组相对纯净的近似极小值之下。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&amp;lt;div align=&quot;center&quot;&amp;gt;
&amp;lt;img src=&quot;/assets/img/posts/20260328-hw2/image/2_MSE收敛曲线.png&quot;&amp;gt;
&amp;lt;br&amp;gt;&amp;lt;i&amp;gt;图 2-2：交替最小二乘法 (ALS) 迭代过程中的 MSE 误差下降曲线&amp;lt;/i&amp;gt;
&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;ALS 修复动态过程演示&lt;/strong&gt;
&amp;lt;div align=&quot;center&quot;&amp;gt;
&amp;lt;video controls autoplay loop muted width=&quot;80%&quot;&amp;gt;
&amp;lt;source type=&quot;video/mp4&quot; src=&quot;/assets/img/posts/20260328-hw2/image/4_ALS修复过程.mp4&quot;&amp;gt;
&amp;lt;/video&amp;gt;
&amp;lt;br&amp;gt;&amp;lt;i&amp;gt;视频 2-1：模型在空洞处逐步“生长”出星云纹理的修复过程&amp;lt;/i&amp;gt;
&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;h3&gt;4. 避免矩阵求逆运算：引入 Cholesky 三角分解&lt;/h3&gt;
&lt;p&gt;这一步构筑了我们代码框架能够极速支撑大运算量的底层基石。
根据大学线性代数中最关键的&lt;strong&gt;最小二乘法结果公式&lt;/strong&gt;：在刚刚“假定 $V$ 已知”的系统中，为了算出最优解 $U$ 里的某行分量 $u_i$，等价于必须直接解出以下的&lt;strong&gt;正规方程组 (Normal Equations)&lt;/strong&gt;：
$$(V_{obs}^T V_{obs} + \lambda I) u_i = V_{obs}^T r_{obs}$$
如果我们将等号左侧的系数矩阵记作 $A$，核心难题即转变为求解大规模的线性方程组 $Ax = b$。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;常规矩阵求逆的瓶颈&lt;/strong&gt;：最简单的思路是在等式两边同乘 $A^{-1}$ 算出结果。但面对哈勃深空百万级别的像素矩阵，传统求解矩阵逆的计算复杂度极高（约 $O(N^3)$）。这不仅会导致运算极度缓慢，且由于浮点数舍入法则带来的限制，超大矩阵求逆运算极易引发严重的数值不稳定和巨大的累积误差。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;对称正定矩阵与分解代入（Cholesky 三角分解）&lt;/strong&gt;：观察我们的系数矩阵 $A = V_{obs}^T V_{obs} + \lambda I$，它不仅是一个对称矩阵，而且由于对角线加入了 $\lambda I$，它严格满足&lt;strong&gt;对称正定矩阵 (Symmetric Positive-Definite Matrix)&lt;/strong&gt; 的定义。
在线性代数中，对于解对称正定方程组脱困的最好办法就是采用 &lt;strong&gt;Cholesky 三角分解&lt;/strong&gt;。该定理保证，对称正定矩阵必定能被唯一地拆解为一个&lt;strong&gt;下三角矩阵 $L$&lt;/strong&gt;，以及它的&lt;strong&gt;转置上三角矩阵 $L^T$&lt;/strong&gt; 的乘积：
$$A = L L^T$$
有了上述分解，原来极其困难的求逆系统 $A x = b$，被轻巧地转换为了 $L L^T x = b$。这让我们彻底避开了对极大型防矩阵直接求逆操作，取而代之以两步极其快速的基础代入运算：&lt;/li&gt;
&lt;/ul&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;前向代入运算&lt;/strong&gt;：先解出过渡向量 $y$，使其满足 $L y = b$。由于 $L$ 是下三角结构，方程可以从第一行起按顺序单向递推，只涉及基础的一元方程求解，速度极快且误差极低。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;后向代入运算&lt;/strong&gt;：依据算出的 $y$，再反解 $L^T x = y$。同理，由于 $L^T$ 为上三角结构，只需从最后一行往上倒推，即可非常稳定地求出我们最终需要的答案序列。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;在工程代码中，我们直接采用了高度优化的底层数值算法库组件：&lt;code&gt;scipy.linalg.cho_factor&lt;/code&gt;（用于分解得出 $L$）与 &lt;code&gt;cho_solve&lt;/code&gt;（用于执行前后双向代入计算）。这让我们在底层核算中彻底告别了依靠庞大矩阵求逆指令死循环运算死角。在处理丢失率高达 60% 的极端数据损坏案例中，仅仅依靠不过十次的 ALS 循环迭代重铸，模型的均方误差 (MSE) 就展现了极快地断崖式收敛特征，最终在几乎没有任何卡滞感知的情况下，高保真地还原了哈勃深空星云震撼人心的繁复特征原貌。&lt;/p&gt;
&lt;p&gt;&amp;lt;div align=&quot;center&quot;&amp;gt;
&amp;lt;img src=&quot;/assets/img/posts/20260328-hw2/image/5_最终三图对比.webp&quot;&amp;gt;
&amp;lt;br&amp;gt;&amp;lt;i&amp;gt;图 2-3：最终修复成果大公开——由左至右分别为：Ground Truth (原图)、破损图、以及我们的 ALS+Cholesky 极限修复图。肉眼几乎无法分辨出人工修复的痕迹。&amp;lt;/i&amp;gt;
&amp;lt;/div&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;div align=&quot;center&quot;&amp;gt;
&amp;lt;img src=&quot;/assets/img/posts/20260328-hw2/image/3_最终原生高清修复图.webp&quot;&amp;gt;
&amp;lt;br&amp;gt;&amp;lt;i&amp;gt;图 2-4：经过算法重构后的单张超高清渲染大图展示，星云的高频细节与原图相比以假乱真。&amp;lt;/i&amp;gt;
&amp;lt;/div&amp;gt;&lt;/p&gt;
</content:encoded></item><item><title>人工智能通识的第一次作业</title><link>https://tiany1yu.github.io/posts/writing/%E4%BA%BA%E5%B7%A5%E6%99%BA%E8%83%BD%E9%80%9A%E8%AF%86%E7%9A%84%E7%AC%AC%E4%B8%80%E6%AC%A1%E4%BD%9C%E4%B8%9A/</link><guid isPermaLink="true">https://tiany1yu.github.io/posts/writing/%E4%BA%BA%E5%B7%A5%E6%99%BA%E8%83%BD%E9%80%9A%E8%AF%86%E7%9A%84%E7%AC%AC%E4%B8%80%E6%AC%A1%E4%BD%9C%E4%B8%9A/</guid><pubDate>Tue, 17 Mar 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&lt;em&gt;&lt;strong&gt;为展现PCA，kPCA与谱聚类等经典机器学习算法在人脸识别上的应用，我们选取了Olivetti人脸数据集进行分析，采用控制变量法，对PCA-&amp;gt;kmeans，KernelPCA-&amp;gt;kmeans，PCA-&amp;gt;谱聚类，KernelPCA-&amp;gt;谱聚类四种方法进行对比分析，并使用ARI与NMI两种方式评估结果。&lt;/strong&gt;&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;&lt;strong&gt;导入olivetti数据集，并导入numpy、sklearn、matplotlib库，设置可视化模板，给出所有可视化函数&lt;/strong&gt;&lt;/em&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;import numpy as np
import matplotlib.pyplot as plt
#这里我们导入了一个好看的模板
plt.style.use(&quot;seaborn-v0_8&quot;)

plt.rcParams.update({
    &quot;figure.dpi&quot;: 140,
    &quot;savefig.dpi&quot;: 300,
    &quot;font.size&quot;: 18,
    &quot;font.family&quot;: &quot;sans-serif&quot;,
    &quot;font.sans-serif&quot;: [&quot;Microsoft YaHei&quot;, &quot;DejaVu Sans&quot;],
    &quot;axes.titlesize&quot;: 13,
    &quot;axes.labelsize&quot;: 11,
    &quot;axes.unicode_minus&quot;: False,
    &quot;axes.spines.top&quot;: False,
    &quot;axes.spines.right&quot;: False,
    &quot;axes.grid&quot;: True,
    &quot;grid.alpha&quot;: 0.25,
})
from sklearn.datasets import fetch_olivetti_faces
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA, KernelPCA
from sklearn.cluster import KMeans, SpectralClustering
from sklearn.metrics import adjusted_rand_score, normalized_mutual_info_score
from sklearn.metrics import confusion_matrix
import seaborn as sns

#这里我们做了很多个可视化函数
def show_distinct_people(images, labels, max_people=40):
    unique_ids = np.unique(labels)
    n_show = min(max_people, unique_ids.size)
    cols = 8
    rows = int(np.ceil(n_show / cols))
    fig, axes = plt.subplots(rows, cols, figsize=(2.2 * cols, 2.3 * rows))
    axes = np.array(axes).reshape(-1)

    for i, person_id in enumerate(unique_ids[:n_show]):
        idx = np.where(labels == person_id)[0][0]
        axes[i].imshow(images[idx], cmap=&quot;gray&quot;)
        axes[i].set_title(f&quot;id:{person_id}&quot;)
        axes[i].set_xticks([])
        axes[i].set_yticks([])

    for ax in axes[n_show:]:
        ax.axis(&quot;off&quot;)

    fig.suptitle(f&quot;不同身份人脸总览 ({n_show}/{unique_ids.size})&quot;, y=1.02)
    plt.tight_layout()


def show_10_faces_of_subjects(images, labels, subject_ids):
    cols = 10
    rows = len(subject_ids)
    fig, axes = plt.subplots(rows, cols, figsize=(1.8 * cols, 1.9 * rows))
    axes = np.array(axes).reshape(rows, cols)

    for i, subject_id in enumerate(subject_ids):
        idx = np.where(labels == subject_id)[0]
        if idx.size == 0:
            continue
        for j in range(cols):
            use_idx = idx[j % idx.size]
            axes[i, j].imshow(images[use_idx], cmap=&quot;gray&quot;)
            axes[i, j].set_xticks([])
            axes[i, j].set_yticks([])
            axes[i, j].set_title(f&quot;id:{subject_id}&quot;, fontsize=9)
    fig.suptitle(f&quot;同一身份的 10 张图 &quot;, y=1.02)
    plt.tight_layout()


def plot_pca_embedding(Z, labels, n_people=10):
    n_points = min(Z.shape[0], n_people * 10)
    fig, ax = plt.subplots(figsize=(9, 7))
    sc = ax.scatter(
        Z[:n_points, 0],
        Z[:n_points, 1],
        c=labels[:n_points],
        s=14,
        cmap=plt.get_cmap(&quot;tab20&quot;, n_people),
    )
    ax.set_title(f&quot;PCA 2D 投影散点 ({n_people} 人)&quot;)
    ax.set_xlabel(&quot;PC1&quot;)
    ax.set_ylabel(&quot;PC2&quot;)
    fig.colorbar(sc, ax=ax)
    plt.tight_layout()


def plot_explained_variance(model_pca):
    ratio = model_pca.explained_variance_ratio_
    cum_ratio = np.cumsum(ratio)
    fig, axes = plt.subplots(1, 2, figsize=(12, 4.5))

    axes[0].plot(ratio, lw=1.8)
    axes[0].set_title(&quot;主成分方差比&quot;)
    axes[0].set_xlabel(&quot;Component&quot;)
    axes[0].set_ylabel(&quot;Explained variance ratio&quot;)

    axes[1].plot(cum_ratio, lw=2)
    axes[1].axhline(0.9, ls=&quot;--&quot;, lw=1.2, color=&quot;tab:red&quot;, label=&quot;90%&quot;)
    axes[1].set_title(&quot;累计方差比&quot;)
    axes[1].set_xlabel(&quot;Component&quot;)
    axes[1].set_ylabel(&quot;Cumulative ratio&quot;)
    axes[1].legend()
    plt.tight_layout()


def plot_mean_and_eigenfaces(model_pca, scaler, image_shape=(64, 64), n_show=20):
    fig, ax = plt.subplots(1, 1, figsize=(4, 4))
    # PCA is fitted on X_std, so map mean back to pixel space for human-readable visualization.
    mean_face = scaler.inverse_transform(model_pca.mean_.reshape(1, -1)).reshape(image_shape)
    mean_face = np.clip(mean_face, 0.0, 1.0)
    ax.imshow(mean_face, cmap=&quot;gray&quot;, vmin=0.0, vmax=1.0)
    ax.set_title(&quot;平均脸&quot;)
    ax.set_xticks([])
    ax.set_yticks([])
    plt.tight_layout()

    n_show = min(n_show, model_pca.components_.shape[0])
    cols = 10
    rows = int(np.ceil(n_show / cols))
    fig, axes = plt.subplots(rows, cols, figsize=(1.8 * cols, 1.9 * rows))
    axes = np.array(axes).reshape(-1)
    eigen_faces = model_pca.components_.reshape((-1, image_shape[0], image_shape[1]))

    for i in range(n_show):
        axes[i].imshow(eigen_faces[i], cmap=&quot;gray&quot;)
        axes[i].set_title(f&quot;eigen:{i}&quot;, fontsize=9)
        axes[i].set_xticks([])
        axes[i].set_yticks([])
    for ax in axes[n_show:]:
        ax.axis(&quot;off&quot;)

    fig.suptitle(f&quot;前 {n_show} 的特征脸&quot;, y=1.02)
    plt.tight_layout()


def plot_cluster_confusions(y_true, pred_dict, n_classes):
    fig, axes = plt.subplots(2, 2, figsize=(12, 10))
    axes = axes.ravel()
    labels = np.arange(n_classes)

    for ax, (name, y_pred) in zip(axes, pred_dict.items()):
        cm = confusion_matrix(y_true, y_pred, labels=labels)
        sns.heatmap(cm, ax=ax, cmap=&quot;Blues&quot;, cbar=False)
        ax.set_title(name)
        ax.set_xlabel(&quot;Predicted cluster label&quot;)
        ax.set_ylabel(&quot;True subject id&quot;)
    fig.suptitle(&quot;混淆矩阵热图&quot;, y=1.02)
    plt.tight_layout()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;em&gt;&lt;strong&gt;将数据归一化，去中心化&lt;/strong&gt;&lt;/em&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;data = fetch_olivetti_faces(shuffle=True, random_state=0)
X = data[&quot;data&quot;]
y = data[&quot;target&quot;]
images = data[&quot;images&quot;]
scaler = StandardScaler(with_mean=True, with_std=True)
X_std = scaler.fit_transform(X)
k = 65
c = int(np.unique(y).size)
seed = 0

show_distinct_people(images, y, max_people=40)
show_10_faces_of_subjects(images, y, subject_ids=[0, 5, 21, 24, 36])


&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;center&amp;gt;&amp;lt;img src=&apos;/assets/img/posts/20260317-人工智能通识的第一次作业/imgs/PCA 谱聚类_export_4_0.png&apos;&amp;gt;&amp;lt;/center&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;center&amp;gt;&amp;lt;img src=&apos;/assets/img/posts/20260317-人工智能通识的第一次作业/imgs/PCA 谱聚类_export_4_1.png&apos;&amp;gt;&amp;lt;/center&amp;gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;&lt;strong&gt;使用PCA与搭载高斯核的KernelPCA两种方式对数据进行降维，得到两种不同的主特征&lt;/strong&gt;&lt;/em&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;pca = PCA(n_components=k, random_state=seed)
Z_pca = pca.fit_transform(X_std)  # (n, k)
plot_explained_variance(pca)
plot_mean_and_eigenfaces(pca, scaler, image_shape=images.shape[1:], n_show=30)
plot_pca_embedding(Z_pca, y, n_people=10)

from sklearn.metrics import pairwise_distances
D2 = pairwise_distances(X_std, squared=True)
med = np.median(D2[np.triu_indices_from(D2, k=1)])
gamma0 = 1.0 / med
kpca = KernelPCA(n_components=k, kernel=&quot;rbf&quot;, gamma=gamma0, fit_inverse_transform=False)
Z_kpca = kpca.fit_transform(X_std)  # (n, k)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;center&amp;gt;&amp;lt;img src=&apos;/assets/img/posts/20260317-人工智能通识的第一次作业/imgs/PCA 谱聚类_export_6_0.png&apos;&amp;gt;&amp;lt;/center&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;center&amp;gt;&amp;lt;img src=&apos;/assets/img/posts/20260317-人工智能通识的第一次作业/imgs/PCA 谱聚类_export_6_1.png&apos;&amp;gt;&amp;lt;/center&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;center&amp;gt;&amp;lt;img src=&apos;/assets/img/posts/20260317-人工智能通识的第一次作业/imgs/PCA 谱聚类_export_6_2.png&apos;&amp;gt;&amp;lt;/center&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;center&amp;gt;&amp;lt;img src=&apos;/assets/img/posts/20260317-人工智能通识的第一次作业/imgs/PCA 谱聚类_export_6_3.png&apos;&amp;gt;&amp;lt;/center&amp;gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;&lt;strong&gt;分别采用k-means与谱聚类两种方式对上述两种主特征进行聚类分析，并使用ARI与NMI两种方式评估结果&lt;/strong&gt;&lt;/em&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;def eval_clustering(name, y_pred):
    ari = adjusted_rand_score(y, y_pred)
    nmi = normalized_mutual_info_score(y, y_pred)
    print(f&quot;{name:18s}  ARI={ari:.4f}  NMI={nmi:.4f}&quot;)
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;km1 = KMeans(n_clusters=c, random_state=seed, n_init=&quot;auto&quot;)
y_pca_km = km1.fit_predict(Z_pca)
eval_clustering(&quot;PCA -&amp;gt; KMeans&quot;, y_pca_km)

sp1 = SpectralClustering(
    n_clusters=c,
    affinity=&quot;nearest_neighbors&quot;,
    n_neighbors=10,
    random_state=seed,
    assign_labels=&quot;kmeans&quot;,
)
y_pca_sp = sp1.fit_predict(Z_pca)
eval_clustering(&quot;PCA -&amp;gt; Spectral&quot;, y_pca_sp)

km2 = KMeans(n_clusters=c, random_state=seed, n_init=&quot;auto&quot;)
y_kpca_km = km2.fit_predict(Z_kpca)
eval_clustering(&quot;kPCA -&amp;gt; KMeans&quot;, y_kpca_km)

sp2 = SpectralClustering(
    n_clusters=c,
    affinity=&quot;nearest_neighbors&quot;,
    n_neighbors=10,
    random_state=seed,
    assign_labels=&quot;kmeans&quot;,
)
y_kpca_sp = sp2.fit_predict(Z_kpca)
eval_clustering(&quot;kPCA -&amp;gt; Spectral&quot;, y_kpca_sp)

predictions = {
    &quot;PCA -&amp;gt; KMeans&quot;: y_pca_km,
    &quot;PCA -&amp;gt; Spectral&quot;: y_pca_sp,
    &quot;kPCA -&amp;gt; KMeans&quot;: y_kpca_km,
    &quot;kPCA -&amp;gt; Spectral&quot;: y_kpca_sp,
}
plot_cluster_confusions(y, predictions, n_classes=c)

fig, axes = plt.subplots(1, 2, figsize=(12, 5))
axes[0].scatter(Z_pca[:, 0], Z_pca[:, 1], c=y_pca_km, s=10, cmap=&quot;tab20&quot;)
axes[0].set_title(&quot;PCA features clustered by KMeans&quot;)
axes[0].set_xlabel(&quot;PC1&quot;)
axes[0].set_ylabel(&quot;PC2&quot;)

axes[1].scatter(Z_pca[:, 0], Z_pca[:, 1], c=y_pca_sp, s=10, cmap=&quot;tab20&quot;)
axes[1].set_title(&quot;PCA features clustered by Spectral&quot;)
axes[1].set_xlabel(&quot;PC1&quot;)
axes[1].set_ylabel(&quot;PC2&quot;)
plt.tight_layout()

&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;PCA -&amp;gt; KMeans       ARI=0.4163  NMI=0.7598
PCA -&amp;gt; Spectral     ARI=0.5245  NMI=0.8088
kPCA -&amp;gt; KMeans      ARI=0.4638  NMI=0.7897


kPCA -&amp;gt; Spectral    ARI=0.5314  NMI=0.8187
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;center&amp;gt;&amp;lt;img src=&apos;/assets/img/posts/20260317-人工智能通识的第一次作业/imgs/PCA 谱聚类_export_9_2.png&apos;&amp;gt;&amp;lt;/center&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;center&amp;gt;&amp;lt;img src=&apos;/assets/img/posts/20260317-人工智能通识的第一次作业/imgs/PCA 谱聚类_export_9_3.png&apos;&amp;gt;&amp;lt;/center&amp;gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;&lt;strong&gt;我们可以看到，PCA与kPCA两种方式得到的主特征在视觉上差异不大，但在聚类分析上，kPCA的表现明显优于PCA，说明核方法在捕捉数据的非线性结构方面具有优势。同时，谱聚类相较于k-means在PCA特征上的表现提升更为显著，说明谱聚类在处理复杂数据结构时更具适应性。&lt;/strong&gt;&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;&lt;strong&gt;总体而言，kPCA与谱聚类的结合在本次人脸识别任务中表现最佳，说明在处理高维且具有复杂结构的数据时，非线性降维与图论方法的结合能够更有效地揭示数据的内在模式。&lt;/strong&gt;&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;&lt;strong&gt;我想，对于小样本量的无监督学习来说，这样的ARI核NMI正确率已然不错，我们完美的完成了课堂任务，很好的运用了矩阵论知识以及机器学习算法，展现了PCA、核PCA与谱聚类在实际问题中的应用效果。&lt;/strong&gt;&lt;/em&gt;&lt;/p&gt;
</content:encoded></item><item><title>PCA/核PCA/谱聚类--关于《矩阵计算与优化》第一次组作业</title><link>https://tiany1yu.github.io/posts/writing/2026-03-14-ai-note/</link><guid isPermaLink="true">https://tiany1yu.github.io/posts/writing/2026-03-14-ai-note/</guid><pubDate>Sat, 14 Mar 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;center&amp;gt;&amp;lt;img src=&apos;/assets/img/posts/20260314-2026-03-14-ai-note/imgs/Screenshot 2026-03-14 165722.png&apos;&amp;gt;&amp;lt;/center&amp;gt;&lt;/p&gt;
&lt;p&gt;这周的矩阵计算通识课，上来就给我们当头一棒，面对不熟悉陌生的词语，以及半懂不懂的术语&lt;/p&gt;
&lt;p&gt;我们又该怎么应对？/(ㄒoㄒ)/~~&lt;/p&gt;
&lt;h2&gt;具体方案介绍&lt;/h2&gt;
&lt;p&gt;这次我想设计的任务很简单，以Olivetti faces数据集，做一个简单的人脸分类工作&lt;/p&gt;
&lt;p&gt;以PCA/核PCA  =&amp;gt;  kmeans聚类/谱聚类
共四种组合，对比其性能&lt;/p&gt;
&lt;h2&gt;不好理解？ 开始名词解释&lt;/h2&gt;
&lt;h3&gt;olivetti数据集是什么？&lt;/h3&gt;
&lt;p&gt;olivetti数据集是一个很经典的人脸数据集&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;40 个人&lt;/li&gt;
&lt;li&gt;每个人 10 张照片&lt;/li&gt;
&lt;li&gt;一共 400 张人脸图&lt;/li&gt;
&lt;li&gt;每张图是灰度图（黑白），大小 64×64&lt;/li&gt;
&lt;li&gt;所以每张图片有 4096 个像素（因为 64×64=4096）&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;我要做什么？&lt;/h3&gt;
&lt;p&gt;通过无监督学习(不给人工智能答案)，让人工智能通过四种不同方案，分别对人脸进行分类，对比ARI(adjusted rand index)正确率&lt;/p&gt;
&lt;h3&gt;先解释一下标准操作流程&lt;/h3&gt;
&lt;p&gt;64*64的图片已经很小了，但即使是这样，数据也有4096个（每个0-255之间）&lt;/p&gt;
&lt;p&gt;我们首先要将其展平成4096维向量&lt;/p&gt;
&lt;p&gt;那么问题来了，输入这么大，怎么提取出关键信息呢？&lt;/p&gt;
&lt;p&gt;PCA/核PCA这时候就来了（（kernel）Principal component analysis）&lt;/p&gt;
&lt;h3&gt;PCA/核PCA&lt;/h3&gt;
&lt;p&gt;我们要找出这个矩阵的主要成分，那有什么和矩阵相关的工具可以用呢🤔&lt;/p&gt;
&lt;p&gt;特征值将整个向量空间分成特征子空间的直和&lt;/p&gt;
&lt;p&gt;每个特征子空间都反映了这个空间在某个方向上的缩放，我们选取前k个，反映了这个矩阵的&lt;strong&gt;主要成分&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;这就是&lt;strong&gt;主要成分&lt;/strong&gt;分析&lt;/p&gt;
&lt;p&gt;首先是PCA，分为三步&lt;/p&gt;
&lt;p&gt;1.我们先把矩阵去中心化，也就是把这些人脸平均出来的平均脸减去，这样才能反映各个矩阵的差异&lt;/p&gt;
&lt;p&gt;也即&lt;/p&gt;
&lt;p&gt;$$
\tilde X = X - \mathbf{1}\mu^\top
$$&lt;/p&gt;
&lt;p&gt;2.我们要提取主成分，有两种方式&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;我们进行奇异值分解，这个方法对所有矩阵通用&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;$$
\tilde X = U\Sigma V^\top
$$&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;还记得上学期的线性代数吗，我们把矩阵及其转置矩阵相乘得到的是一个实对称矩阵，而实对称具有非常优良的性质：具有n个特征值，且每个特征值对应的特征向量正交！
那么这就可以得到n个特征子空间&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;3.我们选取其中数值最大的k个作为基，将每个向量对应与这k个基做内积，得到一个k维的向量，这个时候我们成功提取出了主成分！&lt;/p&gt;
&lt;p&gt;核PCA与这个类似，但是他是把空间映射到无穷维空间上（函数）&lt;/p&gt;
&lt;p&gt;因为PCA只能对成分进行线性组合，提取出k个主成分，但是非线性的成分似乎就不行了（例如一个环形的成分）&lt;/p&gt;
&lt;p&gt;这个时候映射到无穷维空间就有效果了&lt;/p&gt;
&lt;p&gt;但是无穷维怎么计算呢？&lt;/p&gt;
&lt;p&gt;我们考虑一个隐式的无穷维空间，用连续而非离散的函数将其映射到有限维&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;常用的是 RBF 核（高斯核）：&lt;/p&gt;
&lt;p&gt;$$
k(x_i,x_j)=\exp(-\gamma|x_i-x_j|^2)
$$&lt;/p&gt;
&lt;p&gt;再通过gram矩阵（内积空间基底转换）&lt;/p&gt;
&lt;p&gt;$$
K_{ij}=k(x_i,x_j)
$$&lt;/p&gt;
&lt;p&gt;来反映每个向量之间的联系&lt;/p&gt;
&lt;p&gt;其实步骤差不多，都是去中心化-&amp;gt;提取主成分k维-&amp;gt;将原向量映射到k维&lt;/p&gt;
&lt;h3&gt;kmeans聚类/谱聚类&lt;/h3&gt;
&lt;p&gt;现在可以开始聚类了，我们去除了原数据中可能的无关成分，得到了k个最精简的成分&lt;/p&gt;
&lt;p&gt;什么是kmeans？&lt;/p&gt;
&lt;p&gt;我们对选择K（这里K=40）个簇&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;先随便放 40 个“中心点”，然后每张脸归到最近的中心点；&lt;/li&gt;
&lt;li&gt;再把每一组的中心点更新成那组的平均值；&lt;/li&gt;
&lt;li&gt;重复直到稳定。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;这就实现了聚类&lt;/p&gt;
&lt;p&gt;什么是谱聚类？&lt;/p&gt;
&lt;p&gt;这块是我最不了解的地方，因为涉及到图论&lt;/p&gt;
&lt;p&gt;谱聚类很像：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;我把每张脸当作一个点（节点）&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;我用相似度把点连接成一张“图”（graph）&lt;br /&gt;
相似的脸连得更“紧”（边权更大）&lt;/p&gt;
&lt;p&gt;边权：&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;$$
W_{ij}=\exp\left(-\frac{|z_i-z_j|^2}{2\sigma^2}\right)
$$&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;我想把这张图切成 40 块，让：
&lt;ul&gt;
&lt;li&gt;同一块里面的边权尽量大（彼此相似）&lt;/li&gt;
&lt;li&gt;不同块之间的连接尽量小（彼此不相似）&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;怎么切？&lt;br /&gt;
它会算一个叫“拉普拉斯矩阵”的东西，然后做特征分解（又是矩阵特征值那一套）&lt;/li&gt;
&lt;li&gt;最后在特征向量空间里再用 KMeans 分组&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;这个拉普拉斯矩阵我还要再学习一下（）
贴一下&lt;/p&gt;
&lt;p&gt;$$
L_{\text{sym}}=I-D^{-1/2}WD^{-1/2}
$$&lt;/p&gt;
&lt;h3&gt;激动人心！！&lt;/h3&gt;
&lt;p&gt;这时候我们终于得到了 40类人脸&lt;/p&gt;
&lt;p&gt;我们通过ARI（Adjusted Rand Index），把我们分类出来的序号0-39 和原图标注的0-39一一对应，计算正确率&lt;/p&gt;
&lt;h2&gt;最后&lt;/h2&gt;
&lt;p&gt;这是我想的一个比较贴近的方式（）&lt;/p&gt;
&lt;p&gt;讲述什么的我不太擅长&lt;/p&gt;
&lt;p&gt;我希望大家能通过这个markdown了解名词，并且强烈推荐一下我想的这套工作模式&lt;/p&gt;
</content:encoded></item><item><title>写在前面</title><link>https://tiany1yu.github.io/posts/writing/%E5%86%99%E5%9C%A8%E5%89%8D%E9%9D%A2/</link><guid isPermaLink="true">https://tiany1yu.github.io/posts/writing/%E5%86%99%E5%9C%A8%E5%89%8D%E9%9D%A2/</guid><pubDate>Sat, 14 Mar 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;感觉身处AI时代，人很迷茫啊。作为本站第一条博客，我来讲讲自己写博客的动因。&lt;/p&gt;
&lt;h2&gt;为什么写？&lt;/h2&gt;
&lt;p&gt;陪伴了我很久的人在大一上期末选择了离开，我一下子感觉少了很多，又多了很多。&lt;/p&gt;
&lt;p&gt;少了些陪伴和倾诉，多的是压力和责任。&lt;/p&gt;
&lt;p&gt;温柔乡之外的问题开始凸显了……我似乎还是一个高中做题家思维的人，远没有成为一名大学生。&lt;/p&gt;
&lt;p&gt;于是最近开始系统性自学了，也想用文字写些随笔。&lt;/p&gt;
&lt;p&gt;我并不是一个擅长用文字表达的人，但此刻，我想试着用文字梳理心情，也记录下自己在技术路上的摸索。这个博客，就是我安放这些思考的地方。&lt;/p&gt;
&lt;p&gt;更新节奏随心情而定……&lt;/p&gt;
</content:encoded></item></channel></rss>