小yo 博客

周记 6.1-6.7

小yo — Sun, 07 Jun 2026 15:55:21 GMT

fuckZHS

这是一个智慧树的刷课脚本，可以用来刷马原的智慧树，挺好用的，可以在本地运行，也可以在服务器上，我在服务器上跑了一天就刷完了，推荐！

fuckZHS

马原“我来讲”校赛

周三晚上参加了马原课前“我来讲”的校赛，虽然只有优秀奖，但是 i 人站在台上脱稿讲完了 5 分钟真的已经很厉害了吧！表扬自己！

随想

近些日子面对大一同学们的提问，总是感到恼怒，不想认真回答，仔细思考了一下，自觉原因有三：

去年我大一的时候，面对不确定的信息，我的选择往往是去各大交流群查看别人的发言、前往官网阅读资料、在交流群小心发问等，有意思的是，我几乎没有私信过任何人去咨询问题。虽然在做事的时候我往往是独来独往的，但是我是相信群体智慧的，尤其是知识库的积累。很多问题去问一个人可能很难得到答复，但是在一个多人群聊里发问，往往会得到来自不同人的回答，而这些回答整理起来，便就形成了问题的答案。比如你问我“转专业时每个专业的报录比”，我很难回答你，因为我也只转过一次专业，也只转了一个专业，我自然是无暇了解其他专业的报录比。但是如果你在一个转专业交流群里问，那么来自各个专业的学长学姐都会分享自己专业的情况，整理起来，便就是你要的答案。但是你私信问我，我不会回答你。如果你在交流群里问，如果我看到了，我可能会在下方分享我所在专业的情况。这就是私信和群问的区别。也是我对于很多私信不回复或者草草回复的主要原因，我希望你能理解群体智慧。
提问的艺术。这或许是老生常谈了，很多同学的提问，就是直接给你抛过来一个问题，你可以很清楚的知道他对此没有任何思考，只是想到了，就丢给你了。比如，你问我“电信学部哪个专业好转”，有很多人都问过我这个问题，我不会给你任何答复，因为我认为你没有提供任何你的思考，你哪怕说“我了解过计算机和自动化可能相对火一些，而物联网和网安相对冷清一些”，我都会给你认真的分析和答复。还有些同学在看完我的答复之后就不见影了，我希望你至少说一句谢谢，不然我想我不会再回复你的问题了，虽然我想你也不会来提问了。
前两点都是在说他人的问题，我自己当然也有问题。这段时间各种事务压身，时间对我来说，唯恐不够。繁忙也导致了我的脾气趋于暴躁，无法静下心来和其他人对话，尤其是对于年龄比我小的大一同学，我展现出的像是年长者的自傲，我不否认。这一点我最近也在积极改正，有条不紊的处理事情，放下成功者的趾高气昂，是我现在追求的。

总之，希望我能静下心来好好对待吧，至少不辜负了那些认真提问的同学的期待。

崇实之光

又来看崇实的毕业晚会啦，虽然现在在仲英书院，但我的心始终是崇实的。

希望能够四年全勤，嘿嘿。

学长学姐们毕业快乐！

难抢的服务器

上周拿到了8张4090的服务器，开心死了。但是周五打算开始实验的时候，等了整整两天都没有一张卡空出来！急死我了，还好周六晚上 11 点终于等到了，开始美美跑实验了。舒服！

仓颉五子棋

神秘的计算概论大作业，用 AI 完成。感谢 codex 大人，两轮对话轻松完成！

以下是 github 链接，欢迎点个小 star 噢！

gobang_by_cangjie

写在最后

这就是这一周主要的一些事情了，感觉随笔记特别有意思，闲着没事就记录上一句话，回看也很有意思，希望保持下去！

五月记

小yo — Sun, 31 May 2026 18:35:20 GMT

整个五月好像特别不友好。

五一假期因为各种事情忙了五天，没来得及休息。美赛H奖，竹篮打水一场空。两周之内三场考试。概率论期中被误判，少统计了十分，若不是复查就只能吃哑巴亏。面向对象和算法设计都没有做完，算法设计更是考出了两年最差。gemini的pro会员被封了，白月光就这样离我而去。各种大小实验一个接一个。学校网络故障频发，各种事情效率都被极大拉低。科研一整个月也没有看不到任何进展。好不容易30号来到西电参加cmc的颁奖，本想等官方把照片发出来了再发朋友圈，可是等了一晚上也没有等到，或许命运就这样戏弄我吧。

想起去年五月，彼时我也同样寸步难行。四月底工创赛省赛决赛的失利使我与晋级国赛只一步之遥却失之交臂。彼时的我也在因为考试而发愁，更因为担心转专业失败而彻夜难眠。

可是去年六月，从六号收到工创赛因人退赛而递补到名额的消息开始，一切都在好转。考好了每一场试，转到了心心念念的专业，工创国赛虽有遗憾但也无悔。那之后的暑假是我过的最开心的暑假。

我不知道今年会怎么样，但总归，是熬到了五月的最后。

转专业经验分享帖

小yo — Wed, 20 May 2026 20:25:00 GMT

转专业经验分享帖

写在开头

今天恰逢5.20，距离上篇博客也正好过了一个月了，教务处又正好发布了2026年的转专业通知，有感而发，决定把很早就想写的经验帖写一下。

今天上午4h电工实习，下午又是4h数电实验，这对于我这个不擅长动手实践的人来说还真是噩梦。最近也是诸事不顺，整个五月没有一件可谓正反馈的事情，这不仅使得学业和科研停摆，我也深陷自我怀疑走不出来。近日又有一些同学来向我咨询转专业的事情，回想起去年的自己，那时也是持续的自我怀疑，好在最终坚持下来了。520 也没啥人可以表白，就写这样一篇博客，既是表白一年前的自己，也希望通过回忆过去的成功来汲取能量，帮助自己走出现在的迷茫吧。

当然作为经验分享帖，通过分享我的经历，希望能够为学弟学妹们提供一些参考。

个人背景

原专业：大数据管理与应用（管理类）
排名：转专业申请时没有公示的年级排名（正常分流的专业一般会有排名，但是去年管理类分流出现了一些意外所以没有排名）；在同转计算机专业的同学里是rk1（面试时名单上显示的）
均分：90+（这里不说具体的个位数了，一是90以上的话都差不多，二是我自己还没保研，还存在一些竞争关系）
竞赛：工创赛国二，CMC 省一
科研：无
英语：四级 540+（比较低的成绩了）
转入专业：计算机科学与技术（平转）

转专业前

关于政策

我在去年 9 月新生刚入学时做过一次转专业的分享，比较全面地解读了转专业的相关政策，以下是当时腾讯会议的录屏: https://meeting.tencent.com/crm/KnOe5QBBad

今年刚发布的政策与去年几乎没有区别，因此相关政策的解读就不在此展开了，有需要的读者可以自行去看录屏，有相关问题也可以评论留言或者私信我。

关于均分

向我询问转专业相关问题的同学大都绕不过一个问题：均分是否重要。一年前的我也同样有这样的疑问。现在从事后诸葛亮的角度看来，均分的重要性是不言而喻的。

以我个人的经历为例，转计算机在面试时，

纪念第十七届大学生数学竞赛

小yo — Sun, 19 Apr 2026 20:54:59 GMT

纪念第十七届大学生数学竞赛

启程

大一的我满怀雄心壮志报名了数学竞赛，也是初生牛犊不怕虎，一口气拿下了非数学 B 类的全校第十，陕西省一等奖，虽然没有进入决赛，但对于彼时只上了 2 个月大学的我来说，这是莫大的鼓舞。当时便写下了“明年肯定还是会继续参加的，如果事情一切顺利发展下去，或许要报名非数学 A 类了。经过一年的学习，面对更难的题目，会取得怎样的成绩呢，还是挺值得拭目以待的。”

后来事情果然顺利，经过一年的摸爬滚打，最终成功转入计算机专业。25 年 9 月，当数学竞赛开始报名时，我毅然选择了非数学 A 类，彼时的我给自己定下的目标，是在非数 A 里也要拿下省一。

可是从报名到省赛这段时间过得并不顺利。面对转专业的补课压力，突然的视角转化也开始让我认识到科研的重要性，我开始投入大量时间在科研和课内，面对一天天逼近的省赛，无动于衷。

省赛前夕，没有进行任何复习的我已经将目标降至随便混个省奖加加德育分就好了。省赛前一天夜里，用了 6 个小时2 倍速看完了高数上下册的期末速通视频，熬到凌晨 3 点。

省赛当天，险些起晚。急忙赶到考场，虽然只复习了一天，但是却异常顺利，一路势如破竹做到了最后两个题。用了很多时间在最后两个题上，可惜能力不足，最后只能伪证混分。

考完之后并没有多余的思考，我继续回到了日常的生活。突然就到了出分的日子，刚跑完 2km，打开手机发现可以查分了。92 分，全校第 9，这是我从来没有幻想过的成绩。随着决赛名额的出炉，我的旅程里，写下了成都——决赛场地。

可是从去年 12 月到今年 4 月的这段时间，这份惊喜并没有持续下去。我开始处处碰壁，在整整 4 个月的时间里，我每天都在忙碌，却一事无成。决赛的事情早已被我抛之脑后。

3 月 28，陕西省举办了决赛的模拟赛。不出所料，44 分，全省倒数第九，我仍在四处碰壁，保底的国三已经深深刻在了我的目标上。

进入 4 月，黑暗的隧道里似乎有了一点光亮。我想我再次遇到了我生命中的贵人，我好像开始走上一条正确的道路。清明+校庆的 5 天假期，我在图书馆待了 5 天，终于把开学以来积累的烂摊子处理的差不多了，我又想起来决赛，彼时距离决赛还有一周。

学校老师也给我发来了消息，说我模拟赛考的实在太差，希望我能够抽出一点时间来好好准备决赛。好吧，不争馒头争口气，起码争一下国二吧，哪怕时间已经不够，希望已经足够渺茫。

虽然有雄心壮志，但是各种琐事还是席卷而来。这一周的时间里，有马原、习概的汇报，有近十个课程 ddl，我只能勉强抽出不到 3 天的时间，再次把高数上下册、线性代数的期末速通视频 2 倍速看完，做了做前 5 年的真题，却发现 5 套题里没有一个大题是我能做完美的。

周三，隐约感觉有点感冒，我没有在乎。第二天，发烧如期而至，彼时距离决赛只有两天。周四睡了一天，不复习了。周五 11 点，如期坐上了前往成都的高铁。

算了，国三就国三吧，我认了。

考场之上

我很久没有如此平静地坐在考场上等待考试开始了。我对于我的水平心知肚明，最大的奢求就是能够把基础题中档题都做对，至于最后的难题，那不是我能奢求的。只要前边中档题全对，哪怕难题不得分，我也有冲击国二的机会。

试卷发到了手里，前边的题看起来很基础，这对我来说是机会，只要我能认真做下去，不出错，其他人总会有失误，这样我离国二就会越近。

一切顺利，我只用了一个小时便做完了前四题，并且有十足的信心保证这些题的正确率。剩下的两个小时，我开始尝试最后的三个大题。结果和我预想的一样，两个小时的时间，写满的答题卡上，是毫无逻辑的符号，充斥着伪证，和没有结果的空白。

看着倒数第二题，这是一个“新定义”的题目，我又回想起了我的高考。那时候也是最后三个题都没有做出来，那时候也有新定义，我害怕重蹈覆辙，让噩梦重现。

还好，只要前边不出错，国二应该是有机会的。

熊猫基地的放松

考完了，短暂休息之后便和好友来到了成都熊猫基地。虽然这里主要是大熊猫，但是我真的好喜欢小熊猫，在熊猫基地的路线是被小熊猫产房串联起来的。

一路上，好友在讨论着他们对于后三题的思路，他们有着他们的方法，得出了他们的答案。我没有参与讨论，我没有资格讨论，我只求我前边的题不要出错。

小熊猫实在太可爱了，在其中一个小熊猫活动场地里，我非常近距离（或者说它就在我脚边，并且没有任何阻拦）观察了一只小熊猫，它边走边吃草，悠哉悠哉。我相信我可以在这里看一天，只看这只小熊猫。我和好友打趣地说道，等 35 岁失业之后，我也要当一个小熊猫饲养员。

出分

从熊猫基地回到酒店，差不多六点半。感谢阅卷老师们的辛勤付出，上午考完的试，这时就出成绩了。

68 分，前四题一共只扣了 1 分，后三题得分分别是 4、2、1——显然，这是混分的成效，密密麻麻的伪证让老师给了我这些分数。

这和我预期的完全一样，前边的题全对，后边的题混到了几分，那么，国二应该有机会了吧——

吗？

虽然我的成绩没有任何意外，但是其他人的成绩让我大吃一惊。

68 分的成绩在陕西省的同学里排到了第 4 名——大家纷纷在前边的基础中档题折戟。送分的填空没有拿到满分、课内学过的伯努利方程纷纷挂零、甚至他们反复讨论的后三题也都没有取得如意的分数……

这样的惨象意味着，68 分不仅是稳国二的，连国一——这个我想都不敢想的荣誉，也近在咫尺。

我开始焦急地等待他们的复查结果和最终的划线，也在想是否是陕西省考的太差，其他省份的同学应该不至于如此……

国一，有机会吗？

深夜的电话

紧张弥漫在房间里，室友祈求他的失误不要把他拉下国一，我祈求我的稳健可以带我走到国一，

23 点 16 分，群友发出一个截图，有小道消息说非数 A 的国一线疑似是 64.5分。68>64.5，我反复确认着这个事实。

我只需要一个正式的通知。

23 点 57 分，室友接到了一个电话，他还没有来得及告诉我电话的内容，我的电话也响起了。

“你好，是西安交通大学的邹佳朔同学吗？恭喜你在第十七届全国大学生数学竞赛决赛中取得了全国一等奖的优秀成绩。”

近半年的压力在一瞬间烟消云散，这份喜悦让我彻夜难眠。

国一，我居然真的拿到了。

聚光灯下

早上六点半我就起床了，没有闹钟，我不知道我到底是醒了还是没睡。精心打扮一番，吃过早饭，我便坐上了前往颁奖典礼的大巴车。

颁奖典礼在四川大学举行，我无暇欣赏沿途的风景，我只想飞速登上领奖台。

来到颁奖现场，按照既定的座位号找到了我的位置，听着席南华院士等长辈们的讲话，我的心难以平静下来，与24 小时前考场上的我形成鲜明的反差。

先是数学类低年级组的颁奖，再是数学类高年级组，随后便是非数学 A 类，终于，志愿者叫到我们这排了——准备上台领奖。

颁奖台上，拿着国一的证书，聚光灯打在我们身上，看着台下的老师和同学们，我从未如此兴奋

——我真的站在了全国的领奖台上。

终点？

合照之后，我独自来到了武侯祠。我对三国的故事十分痴迷，对于诸葛武侯，更是充满敬畏。成都有很多好玩的地方，在仅有的两个小时剩余时间里，我想去拜一拜武侯。

在前往武侯祠的路上，兴奋逐渐褪去，我又想起来几天前的我。

短短几天以来，从国三保底到登上国一的领奖台，我仿佛发生了翻天覆地的变化。但——我真的变了吗？

自始至终我的想法都是把基础中档题的分数拿到，放弃难题。我倒也算是知行合一，最终的成绩也确实如此。

只是，在最开始，对于这种想法，我预期的结果是有微小的机会冲击国二，但是到了最后，是比较稳的排名的国一。

我开始思考这里的原因，我将原因理解为今年的后三题难度实在很大，使得大家都拿不出手，都难以取得一个满意的分数。而我，多谢前边的步步为营，没有出现任何失误，拉开了与他们的差距，而后三题他们并没有实现反超。所以国一选择了我，因为我前边实在稳健。

可是，这样真的就可以满意了吗？就可以高高在上了吗？

我想并不是这样的。

诚然，稳健、不失误是难得可贵的，是值得褒奖的。但是我在后三题花费了两个小时，举步维艰，没有做出任何有价值的思考，甚至没有与他们讨论的资本。他们在后三题进行了充分的思考，尽管没有得到如意的分数，但是他们敢于思考，能够思考，思考出来的东西可以与他人讨论，进行更有意义的探索。

很多时候，无论是在科研，还是在其他地方，我们面临的都是很难的题目，而这些题目没有标准答案，它不会轻易宣布你的失败。我们需要做的是不断地探索，进行有价值的思考，进行自己的创新。而我这种“把基础中档题的分数拿到，放弃难题”的做题思维是没有任何价值的，科研不会允许你随意放弃，让你去选择简单的问题，这样只会做一些毫无价值的工作。

我真正需要的，恰恰是国一成绩的反面——思考、创新，哪怕是错的。

关于梦想

走进武侯祠，回忆着武侯往事，想起武侯的理想，我又想到了自己……

不知道从何时起，数学成为了我最喜欢的学科。我开始将数学作为自己的优势，通过各种渠道去学习，沉浸在数学的世界里。

初三的时候，我了解到了高中数学联赛，也即数学奥赛。我告诉父母，我想学这个，我想打奥赛。

没有人支持，从家长到老师，全是反对的声音。县城资源的匮乏、家庭经济无法负担课程费用、中考的压力……一切都在抹杀这个刚萌发的念头。

他们赢了。

进入高中，逐渐通过互联网接触到了很多资源，可惜家长老师们没人相信互联网的资源，我将数竞作为笑谈，和长辈们和同学们嘲笑着无知的我，背地里仍不愿放弃，还是希望通过互联网进行间断的学习。

高二的时候学校分到了两个数竞名额，我迫切找到老师，表示自己希望参赛。可是我被拒了。理由是优先分配高三的学长。我理解老师的选择，可我的努力连展示的机会都得不到，我不甘心，但没有因此更加努力，我的心已经碎了。

到了高三，名额确实给到了我，但是彼时的我早已经被高考压的没了心力。遗憾省三落幕，我对不起三年前意气风发的自己，但是我没有办法。

高考数学同样失利，120 分的成绩宣告了我的平平无奇。报考西交的管理类专业，为了开学的选拔考试，我复习了整个暑假，而开学后，因为高考数学太低，“未获得笔试资格”，彻底击碎了我的自信。这种感觉我体验过，努力了很长时间却连展现自己的机会都没有。不同的是，这次我没有就此沉沦，为了转专业，我拼上了一切。

后来就有了非数 B 的全校第十，有了以第一名的成绩转入计算机，有了代表学校参加数学竞赛的决赛，有了站在全国的领奖台上……

虽然大学生数学竞赛远不如高中生数学联赛，但我想，这份荣誉，也可以安慰五年前那个失落的小孩了。

如今，被人工智能深深吸引的我，已不敢再说把数学作为梦想了。希望在探索人工智能的过程中，这段经历可以成为前进的动力，在迷茫之时，不要放弃。

梦想并没有消失，只是驶向了一个全新的方向。

为了理想鞠躬尽瘁，我走出了武侯祠……

最后，想分享小少焱的《关于梦想 2026》里的几段歌词，聊以慰藉

“我是不是对了是不是赢了赢的酣畅淋漓的那种”

“我十六岁的那场雨有很久没再提起曾写的第一首词已忘了是在几时今天来的有些迟但我觉得很值”

“你真蠢真笨总反应有些迟钝明明那么多疑问可一次你都没认”

“那年你二十一岁一直被说着不对……你心底那份骄傲经受着谩骂嘲笑什么你都做不到只能是仗着年少”

“从家人到网络到你听到的每个都劝着天高海阔无边的梦要少做”

“可你和别人不一样心脏是那么滚烫你总是不愿遗忘年少的一步不让那一夜你提起笔想写出一个也许你想要你的听众被一次次的感动”

“你真的到了台前也真的写了十年”

“所以我们赢了吗至少你赢了”

“所幸是坚定不移没显得那么多余你可以笑着慢慢提当年的那些质疑”

“走一步再走一步只要是别在原处如果是前方没了路就抬头看看高处”

“年少时的心愿不是惊鸿一现如果真有一把剑就再挥上个百遍”

“就别管什么对错至少是你曾来过就算它是个泡沫至少还有过颜色”

“至今日我还没败年少的骨头还在这玩意是好是坏至少是有人还爱小时候要走王道在当时是个玩笑可经了弯弯绕绕到长大后我还要”

“多年后是个玩笑去被人津津乐道亦或是一份荣耀去挡住那些聒噪不重要不重要是不重要的吵闹此刻我仍是年少仍沾着那份狂傲”

“对不起啊我笨不成了我是真恨儿时的那段笑谈用我这辈子来还我从未觉得多难而是觉得好燃”

“我看不到个终点那这里便是起点我不懂一个深浅只知道路要我选这风雪来的好绵都吹不到我身前我还能写个五十年且还是那个少年”

“恭喜啊那个意气风发的少年依旧意气风发”

——小少焱《关于梦想 2026》

《LagerNVS》论文精读

小yo — Fri, 10 Apr 2026 22:07:46 GMT

领域背景与前置概念

新视角合成（NVS）任务定义

简单来说，NVS 的任务是：给定几张从特定角度拍摄的场景照片，然后用 AI 推理并生成出一张从“全新角度”拍摄的该场景照片。

在数学上，这篇论文将其定义为一个函数映射：

给定 VVV 张源图像 I1,...,IVI_1, ..., I_VI1,...,IV 及其对应的源相机姿态 g1,...,gVg_1, ..., g_Vg1,...,gV，以及一个目标相机姿态 ggg。我们需要输出一张目标视角的图像 III：

I=f(g;I1,g1,...,IV,gV)I = f(g; I_1, g_1, ..., I_V, g_V)I=f(g;I1,g1,...,IV,gV)

两种3D 表征路线

显式 3D 表征

比如传统的 Mesh（多边形网格）、Point Cloud（点云）、或者是前几年大火的 NeRF（神经辐射场）和最近的 3 D Gaussian Splatting (3 DGS)。显式意味着，网络会在 3 D 坐标系 (x,y,z)(x, y, z)(x,y,z) 中结结实实地“建个模”，告诉你这个坐标点有没有东西、是什么颜色。

缺点：计算极度耗时，且往往需要针对每一个新场景单独优化。

潜空间几何

LagerNVS 放弃了在空间中老老实实建个 3D 模型的想法。它使用一个强大的 Transformer 编码器（基于 VGGT），将输入的几张图像直接编码成一堆一维的特征向量 (Tokens) z=(z1,...,zV)z = (z_1, ..., z_V)z=(z1,...,zV)。虽然这些 Token 在人类看来只是毫无意义的数字矩阵，但经过大规模训练后，这些特征向量内部其实包含了“3D 感知 (3D-aware)”的信息。随后，一个轻量级的 Decoder 直接利用这些特征“画”出新视角的图像。这就是为什么它的速度能达到 30 FPS+ 的实时级别。

相机模型

在深度学习做图像分类时，我们不在乎照片是在哪里拍的。但在 NVS 中，“相机在哪里”和“相机指向哪里”是决定性信息。要让网络知道这个相机的状态，需要回答三个问题：相机在哪里？相机的硬件属性是什么？这个世界的比例尺是多大？

外参

外参定义了相机在 3 D 世界坐标系中的位置和朝向。

平移向量 (Translation, ttt)：这是相机的绝对位置。它是一个 3 D 向量 t∈R3t \in \mathbb{R}^3t∈R3，告诉你相机镜头当前在空间的 (x,y,z)(x, y, z)(x,y,z) 坐标。
旋转 (Rotation, qqq)：相机放在了那个位置后，它是抬头、低头，还是向左偏？传统图形学喜欢用 3×33 \times 33×3 的旋转矩阵，但神经网络不喜欢，因为 9 个数字有冗余且不好优化。所以这篇论文（以及大部分深度学习 3D 任务）使用了单位四元数 (Unit Quaternion) q∈S3q \in \mathbb{S}^3q∈S3。你暂时不需要深究四元数的计算法则，只需把它当作一个 4 维向量，它能连续、无死角地表示 3D 空间中的任意旋转角度。

内参

内参和相机摆放在哪里无关，它只取决于相机本身的硬件设计。

在大部分 3 D 深度学习任务中，最核心的内参就是焦距 (Focal Length) 或视场角 (Field of View, FOV)。
论文中用 k∈R+2k \in \mathbb{R}^2_+k∈R+2 表示水平和垂直的视场大小。如果 FOV 很大，相当于挂了一个超广角镜头（画面装得下更多东西，但边缘会变形）；如果 FOV 很小，就相当于长焦镜头（画面有放大的效果）。

场景尺度

论文中特别引入了 www。这是因为在纯视觉 3 D 重建中，存在一个著名的尺度模糊 (Scale Ambiguity) 问题：画面里的一辆车，是 10 米外的一辆真车，还是 10 厘米外的一辆玩具车？单凭像素是无法区分的。

当你要进行新视角合成（NVS）时，如果你告诉网络：“请把相机向右移动 1 个单位。” 网络会很懵：这 1 个单位到底是 1 米（真实场景），还是 1 厘米（微缩模型）？如果它搞错了比例尺，渲染出来的画面就会发生严重的形变。因此，网络必须知道目标相机的移动距离与当前场景的比例关系。

为了解决这个问题，最理想的情况是用绝对物理单位（比如米），但作者提到，收集海量带有绝对物理尺度的训练数据太难了。于是，作者退而求其次，设计了两种“相对比例尺”：w1w_1w1 和 w2w_2w2。

w1w_1w1：基于最大平移

这是最常规、也最容易获取的一种比例尺。

定义： w1w_1w1 被定义为所有源相机相较于参考相机（第一台相机）的最大平移距离。用数学公式表示就是 w1=max⁡i(∣∣ti∣∣2)w_1 = \max_i(||t_i||_2)w1=maxi(∣∣ti∣∣2) 。
物理意义：假设你围着一个雕像拍了 5 张照片，你走动最远的那段距离，就是这个场景的基准长度（设为 1 个单位）。目标相机的移动，都是相对于你这一步跨度的百分比。
优点：只要有多张带姿态的照片，计算极其简单快速。
致命缺陷：如果你只有单张照片（Single-view NVS），或者你拿着相机站在原地仅仅是转了转头（相机光心重叠），你的移动距离就是 0，此时 w1=0w_1 = 0w1=0 。比例尺失效，网络直接崩溃。

w2w_2w2：基于平均深度点

为了弥补 w1w_1w1 在单图或原地旋转时的缺陷，作者引入了 w2w_2w2。

定义： w2w_2w2 被定义为从参考相机出发，到所有可见 3 D 空间点的平均距离。
物理意义：既然相机没动，那我就看看眼前的风景。如果我看到的大部分物体离我平均有 5 米远，那我就把这 5 米当作场景的基准长度（设为 1 个单位）。
优点：完美拯救了单视角输入的情况。只要画面里有东西（有深度），就能算出一个比例尺。这正是 LagerNVS 能够支持单图 NVS 平移渲染的核心秘密。

普吕克坐标系与射线

当 Decoder 要渲染目标视角的图像时，它怎么知道屏幕上的每个像素对应真实世界里的什么东西？这就涉及到光线投射 (Ray Casting)。相机的每一个像素，其实都可以看作是从相机中心射出的一条射线。

为了把这条射线输入进 Transformer Decoder，论文使用了 Plücker 坐标 (Plücker coordinates) 来表示这条射线。

为什么需要射线

计算机屏幕或生成的图像是一个 2 D 的像素网格。渲染 3 D 场景的过程，本质上就是从相机中心出发，穿过屏幕上的每一个像素，向 3D 世界射出一条“射线 (Ray)”。这条射线在 3 D 空间中打到了什么物体，屏幕上的这个像素就是什么颜色。

目标相机的分辨率是 H×WH \times WH×W，所以网络需要处理 H×WH \times WH×W 条射线。

为什么传统的直线方程行不通

在几何里，表示一条 3 D 直线最直观的方法是：一个起点 OOO 加上一个方向向量 ddd。直线上的任意一点可以写成：

R(t)=O+t⋅dR(t) = O + t \cdot dR(t)=O+t⋅d

但这在神经网络中有一个致命缺陷：表达不唯一。同一条直线，你可以选直线上的任意一点作为起点 OOO。神经网络如果发现同样的输入对象对应了无数种不同的数值表达，它在学习时就会非常痛苦（无法收敛）。

普吕克坐标系

普吕克坐标系通过一种巧妙的叉乘，给 3 D 空间中的每一条直线提供了一个唯一、连续的 6 维向量表达。一条射线在普吕克坐标系下被表示为 (rd,rm)(r_d, r_m)(rd,rm)：

方向向量 (Direction, rdr_drd)：这是一个 3 D 向量 rd∈R3r_d \in \mathbb{R}^3rd∈R3，表示射线的指向（通常会被归一化）。
力矩向量 (Moment, rmr_mrm)：这是一个 3 D 向量 rm∈R3r_m \in \mathbb{R}^3rm∈R3。它的计算公式是射线上的任意一点 OOO 与方向向量的叉乘：rm=O×rdr_m = O \times r_drm=O×rd。

神奇的几何性质来了：无论你在一条固定直线上选取哪一个点作为 OOO，它与方向向量 rdr_drd 的叉乘结果 rmr_mrm 永远是同一个常数向量（因为叉乘的几何意义是以这两条边为基础的平行四边形的面积和法向量，对于同一条直线，这个“面积”和法线方向是恒定的）。

因此，网络通过接收 6×H×W6 \times H \times W6×H×W 的普吕克特征（每个像素 6 个数字），就能确切、唯一地知道目标视角的每一根视线在 3 D 空间里是沿着什么轨迹穿梭的。这也是 LagerNVS 的 Decoder 最核心的输入。

参考视角

论文中明确指出，所有的相机参数 gig_igi 都是相对于第一台相机 g1g_1g1 来表达的。

网络会把第一张源图像拍摄时的位置和朝向，强行定义为这个 3 D 世界的绝对原点 (0,0,0)(0,0,0)(0,0,0) 和初始零旋转。
之后输入的第 2 张、第 3 张源图像相机，以及想求的目标相机 ggg，它们的平移 ttt 和旋转 qqq，描述的全部都是距离第一台相机有多远、偏转了多少度。这要分两种情况看：是在“训练模型（做题）”时，还是在“实际应用（考试）”时。

宏观架构设计

研究动机

在 NVS 领域，一直存在两个流派的相互博弈，而 LagerNVS 试图结合两者的优点：

传统显式 3D 重建（如 NeRF、3DGS）：效果极其惊艳，但痛点在于“慢”和“过拟合”。给你一个新场景，你需要花费几分钟甚至几个小时去专门为这一个场景进行梯度下降优化。它很难做到看一眼几张图，直接前向传播吐出新视角”。
纯神经网络直接生成（如 LVSM、SRT）：也就是端到端直接搞定。输入源图像，网络直接输出新图像，跳过 3 D 建模。速度极快，几毫秒搞定。但痛点在于，普通的神经网络（哪怕是强大的 Vision Transformer）缺乏“3D 空间想象力”，很容易把背面的、被遮挡的物体瞎画一通。

LagerNVS 的破局思路：既然直接预测缺乏 3 D 想象力，那我不用普通的骨干网络提取特征。我用一个经过严格 3 D 监督训练过的网络（也就是论文里的 VGGT）来作为 Encoder 。这样提取出来的特征，虽然表面上是一堆一维的 Token，但它们体内流淌着“3 D 感知（3 D-aware）”的血液。

核心 pipeline

整个网络的运行流程非常清晰，可以分为三步：

特征提取 (Encoder)：将 VVV 张源图像（可能包含对应的相机外参）输入到 VGGT Encoder 中。这里不输出任何深度图或点云，仅仅从 Transformer 的最后一层截取输出的特征向量。
潜空间几何 (3D-aware Latent Tokens)：这就是这篇论文题目中的 “Latent Geometry”。Encoder 输出的特征被称为 z=(z1,...,zV)z = (z_1, ..., z_V)z=(z1,...,zV) 。对于每张图像，网络提取出 PPP 个 Tokens（特征向量）。这些 Tokens 被打包在一起，作为整个 3D 场景的“隐式知识库”。
渲染生成 (Decoder)：将目标相机转化为射线 Tokens，把场景的 Latent Tokens 提取出来。通过 Transformer Decoder 的双向注意力机制进行信息检索，最终将特征重塑并投射成一张 512×512512 \times 512512×512 的新视角 RGB 图像。

架构对比

在设计处理多张输入图像的信息流时，不可避免地会遇到数据结构和信息瓶颈的权衡。论文重点对比了三种主流架构方案，并选择了 Highway Encoder-Decoder ：

Decoder-only（纯解码器）：

把所有的源图像特征和目标相机射线一股脑全塞进一个巨大的 Transformer 里进行注意力计算。
- 致命缺点： 冗余计算太严重。每次你要生成新视角（哪怕场景没变，只是相机挪了一厘米），整个庞大的网络都要重新跑一遍。
Bottleneck Encoder-Decoder（瓶颈架构）：为了加快速度，把特征提取（Encoder）和渲染（Decoder）分开。但是，无论输入 2 张还是 10 张源图像，Encoder 都会强制把特征压缩成固定数量的 Tokens（比如定死只有 256 个 Tokens）喂给 Decoder 。
- 致命缺点： 发生了严重的信息丢失（Information Loss）。输入的图像越多，反而越容易丢掉细节。
Highway Encoder-Decoder（LagerNVS 的最终选择）：打破瓶颈！输入 VVV 张图像，每张图提取 PPP 个 Tokens，那就把整整 V×PV \times PV×P 个 Tokens 全部一股脑、无损地传给 Decoder。
- 优势： 既保留了 Encoder-Decoder 分离带来的“一次编码，无限次快速渲染”的速度优势，又最大化保留了多视图带来的极高频的图像细节信息。

编码器剖析

Patchify

因为 VGGT 是基于 Vision Transformer (ViT) 的，因此在进入 VGGT 之前，需要先将图像切分为 patch。

切分为 ptach：当源图像（比如分辨率被调整为 518 x 518 ）输入网络时，第一件事就是把它切成固定大小的网格（比如 16 x 16 像素的方块）。
图像变 Token：假设切出了 PPP 个方块。网络会使用一个线性投影层，把每一个包含像素的方块，直接映射成一个一维的特征向量。此时，一张图片就变成了 PPP 个初始 Tokens。
VGGT 提取特征：接下来，这 PPP 个 Tokens 才会进入 VGGT 的 Embedder 和 Aggregator（也就是我们上一阶段说的那几十层 Transformer）。
维度不变的流动： Transformer 的神奇之处在于，无论经过多少层，Tokens 的数量 PPP 始终不变。网络只是在不断加深和丰富这 PPP 个 Tokens 内部的数值（通道维度）。
最终输出：所以，当 LagerNVS 从 VGGT 的最后一层“截胡”时，它拿到的依然是 PPP 个 Tokens 。这 PPP 个特征向量完美对应了原图最初被切分出的 PPP 个物理位置。

可选相机参数

11 维向量

论文明确指出，当输入相机参数时，相机参数被参数化为一个 11 维的向量 g=(q,t,k,w)g = (q, t, k, w)g=(q,t,k,w) 。这 11 个数字完美勾勒了相机的全部物理状态：

qqq (4 维) - 旋转 (Rotation)：使用单位四元数 (Unit Quaternion) 表示相机在 3 D 空间中的朝向（比如抬头、低头、偏转）。
ttt (3 维) - 平移 (Translation)：相机在 3 D 空间中的具体 (x,y,z)(x, y, z)(x,y,z) 坐标位置。
kkk (2 维) - 内参视场角 (Field of View)：分别代表相机的水平（Horizontal）和垂直（Vertical）视场角大小，决定了镜头是广角还是长焦。
www (2 维) - 场景尺度 (Scene Scale)：也就是我们在第一阶段提到的，为了解决尺度模糊问题而引入的辅助参数。由于存在两种不同的尺度归一化方式（一种基于相机最大平移距离，一种基于观测到的 3D 点平均距离），所以使用了 2 维来表示这两个维度的尺度因子。

输入网络

Transformer 只能看懂高维的 Token，看不懂这区区 11 个孤零零的数字。所以论文做了一个很工程化的处理：

升维投影：论文给 VGGT 加了一个小型的MLP（具体是两层线性层中间加一个 SiLU 激活函数）。这个 MLP 把 11 维的物理向量，强行投射成了一个 1024 维的特征 Token 。
融合进网络： VGGT 原本就有一个专门占位的“相机 Token”的初始值。这个升维后的 1024 维向量，会直接与原始的相机 Token 相加，然后和那 PPP 个图像 Tokens 一起送进 VGGT 网络里“炼丹” 。

可选

如果在实际应用中，你真的没有相机参数（比如就是随手在网上下载的几张照片），网络依然能工作：代码逻辑会极其简单粗暴地把这 11 维向量的前 9 维（也就是 q,t,kq, t, kq,t,k）全部设为 0（只保留尺度的归一化因子）。网络在训练时见过了大量这种“缺失相机信息”的数据，所以即使输入是 0，它的注意力机制也能强行通过对比图像内容来脑补出大概的 3D 结构。

VGGT

VGGT 本身是另一篇顶会论文提出的模型。它的原始设计目标就是：输入几张图，直接前向传播输出每张图的深度图和相机姿态等 3D 几何信息。

为了做到这一点，VGGT 的架构并不是普通的 Transformer，而是分为了两个非常特别的阶段：

图像嵌入器 (Embedder)

这是一个 24 层的 Transformer 。

作用：独立看世界。它把输入的 VVV 张照片当作完全不相关的图片，一张一张地提取特征。这个阶段，网络只是在理解“这儿有棵树”、“那儿有扇窗”，还没建立 3D 联系。

聚合器 (Aggregator)

这是一个 48 层的 Transformer，它的内部设计非常精妙，交替使用两种注意力机制：

局部注意力 (Local Attention)：只在单张图片内部寻找特征之间的联系。
全局注意力 (Global Attention)：打破图片的界限！让图 1 的某个特征去和图 2、图 3 的特征进行匹配和对比。
这种交替计算，本质上就是在做传统多视图几何里的特征匹配和立体视觉匹配。网络在这个阶段学会了：“图 1 左边这个角，对应图 2 右边那个角，所以这个物体应该是凸出来的”。

LagerNVS 中使用

LagerNVS 并没有使用 VGGT 最终输出的深度图或相机数据。它就像是一个半路打劫的黑客，直接在 VGGT 的网络深层“截胡”：它把 VGGT 最后一层局部注意力和最后一层全局注意力的输出向量直接拿了出来，把它们拼接在一起。这些截胡出来的 Tokens，就是蕴含了 3D 几何先验知识的 Latent Tokens。

解码器剖析

LagerNVS 的 Decoder 本质上是一个包含 12 层块（Blocks）的 Vision Transformer (ViT-B)。我们把这个过程拆解为三个步骤。

射线 token 化

目标视角的来源

这要分训练阶段和推理阶段考虑。

训练阶段

论文用的训练集（比如 RealEstate 10 k）其实是一段段的视频。

假设视频有 100 帧。训练时，我们可能随机挑第 1、5 帧作为源图像（输入给 Encoder），然后挑第 3 帧作为目标图像（用来算 Loss）。

在这个阶段，目标相机 ggg 的姿态是数据集自带的。现有的图形学算法（SfM，比如 COLMAP）早就把视频里每一帧相机的相对位置算得清清楚楚了。我们只是把第 3 帧的实际相机参数拿过来，作为目标视角喂给 Decoder，然后看它生成的图跟第 3 帧的真实照片像不像。

推理阶段

此时，目标视角 ggg 是完全由用户决定的。

当用鼠标在屏幕上拖拽（就像玩 3D 游戏那样转动视角），或者按键盘上的 W/A/S/D 前进后退时，前端程序会把你鼠标或键盘的移动，实时换算成一个包含旋转和平移的 11 维向量 g=(q,t,k,w)g = (q, t, k, w)g=(q,t,k,w)。
每动一下鼠标，程序就生成一个新的 ggg 喂给 Decoder。因为 Decoder 跑得极快（30 FPS+），所以看到的就是一个实时渲染的、可以在里面漫游的 3D 场景。

目标视角计算为射线

这就是经典的计算机图形学光线投射（Ray Casting）过程：

创建虚拟屏幕：首先，根据目标相机的分辨率生成一个 H×WH \times WH×W 的 2 D 像素网格。
像素转局部射线（用内参 kkk）：根据相机的视场角 kkk（决定了视锥体的张角），计算出每一条射线穿过像素点时，在相机自己的局部坐标系里的方向。比如屏幕正中心的像素，它的局部射线方向就是直直向前的 (0,0,1)(0, 0, 1)(0,0,1)。
局部射线转世界射线（用外参 q,tq, tq,t）：这一步最关键。刚才的射线只是在相机自己眼里的方向，我们需要把它放到以“相机 1”为中心的“世界”里。
- 用目标相机的平移 ttt，确定这根射线在世界里的起点。
- 用目标相机的旋转 qqq，对刚才的局部射线方向进行旋转，得到它在世界里的绝对方向。
转化为普吕克坐标：现在我们有了射线的世界起点 OOO 和世界方向 ddd。按照公式 rm=O×dr_m = O \times drm=O×d，算出每条射线的方向 rdr_drd 和力矩 rmr_mrm 。
拼装送入网络：把所有射线的 (rd,rm)(r_d, r_m)(rd,rm) 拼在一起，送给Transformer Decoder 进行计算。

目标视角 token 化

解码器拿到的目标相机特征是一个形状为 6×H×W6 \times H \times W6×H×W 的张量，需要把这个张量转化为一维的 Token 序列。

卷积降维压缩：论文使用了一个步长为 8 的卷积核（Stride = 8）。这意味着它把每 8×88 \times 88×8 的一束射线打包成了一个 Patch。这样一来，Token 的数量就大幅减少到了 HW/64HW / 64HW/64 个。
加入寄存器 (Register Tokens)：论文额外拼凑了 4 个特殊的“寄存器 Token”进去（这是一种近年在 ViT 中很流行的技巧，用来存放一些全局的、不需要和特定空间绑定的冗余信息，防止注意力机制乱套）。

我们将这 HW/64+4HW / 64 + 4HW/64+4 个代表目标相机射线的 Tokens 统称为集合 sss。

寄存器（Register Tokens）在使用 Vision Transformer (ViT) 处理图像时，研究人员发现了一个奇怪的现象： Transformer 在处理图像时，偶尔需要汇总一些全局信息（比如“这张图整体偏暗”、“这是一个室内的场景”）。但是，原版的 ViT 里只有对应着图像物理位置的 Patch Tokens。于是，网络会强行征用画面中那些最没有信息量、最平坦的背景区域（比如纯蓝的天空、纯白的墙壁）对应的 Tokens，把它们当成“全局信息存储罐”。这导致在可视化注意力地图（Attention Map）时，背景区域会莫名其妙地出现极其强烈的亮点（被称为 Attention Sinks），这会干扰模型对真正重要特征的提取。既然网络需要地方存全局信息，强行占用背景特征又会引发混乱，那怎么办？《Vision Transformers Need Registers》提出：直接给网络输入几个空白向量。

具体做法是：在输入序列的末尾，人为地拼接几个毫无物理意义的、全凭网络自由学习的空白向量（这就是 Register Tokens）。

这样一来，Transformer 在做自注意力计算时，就会乖乖地把那些全局的、不需要和特定空间绑定的特征信息，存放到这些寄存器里。原本的图像特征 Tokens 就能被解放出来，专心致志地处理纯粹的局部视觉信息。

双向交叉注意力机制

现在有两种输入：

sss (Target Camera Tokens)：计算得到的目标射线，它们是带着疑问来的（“我这条线上应该是什么颜色？”）。
zzz (Source Latent Tokens)：从 VGGT 编码器拿到的 V×PV \times PV×P 个带有 3D 感知信息的源图像特征（知识库）。

论文测试了两种注意力机制。

全注意力 (Full Attention)

把目标射线 sss 和源特征 z1,...,zVz_1, ..., z_Vz1,...,zV 全部拼接成一个超长的序列，然后做标准的自注意力计算：

q=k=v=(s,z1,...,zV)q = k = v = (s, z_1, ..., z_V)q=k=v=(s,z1,...,zV)

物理意义：所有人都在互相交流。射线在寻找特征，特征在互相印证，射线之间也在对齐。
致命缺陷： Transformer 的计算复杂度是输入序列长度的平方。源图像数量 VVV 越多，序列越长，计算量呈 O(V2)O(V^2)O(V2) 爆炸式增长。论文指出，这种方式最多只能支持 6 张输入图片保持 30 FPS 的实时渲染。

双向交叉注意力 (Bidirectional Cross-Attention)

为了提速，作者巧妙地修改了信息流动的方向（详见论文附录的 Alg 1），将其拆分为两步并行的交叉注意力：

射线询问特征：射线的 Token sss 作为 Query (q1q_1q1)，源特征 zzz 作为 Key 和 Value (k1,v1k_1, v_1k1,v1)。

物理意义： 射线精准地去源图像的特征库里检索自己穿过了什么物体、提取对应的颜色和几何信息。
特征感知射线：源特征 zzz 作为 Query (q2q_2q2)，射线的 Token sss 作为 Key 和 Value (k2,v2k_2, v_2k2,v2)。

物理意义： 3 D 知识库也会根据当前目标相机看的位置，动态调整自己的状态，把最重要的信息“推”给射线。

为什么这么快？因为在这个方案中，源特征 zzz内部不再互相计算自注意力了！那些成千上万的 V×PV \times PV×P 个特征，在 Decoder 阶段只负责和目标射线交流。这把复杂度从 O(V2)O(V^2)O(V2) 硬生生降到了 O(V)O(V)O(V)，使得模型可以在输入 9 张高清源图像时，依然保持 30 FPS+ 的实时运行速度。

渲染输出

经过 12 层 Transformer 块的层层淬炼，射线 Tokens sss 已经完全吸收了它们需要的信息。

最后一步非常干脆：

把源特征 Tokens zzz 和那 4 个辅助用的寄存器 Tokens 直接丢弃，只留下射线 Tokens。
把这些一维的射线 Tokens，通过一个简单的线性层，投影回 8×8×38 \times 8 \times 38×8×3 的 RGB 像素块。
把所有像素块按照原来的空间位置拼接回去，再套一个 Sigmoid 激活函数（确保颜色值在 0~1 之间），一张目标视角的全新图像 III 就输出了。

训练、优化与扩散模型扩展

确定性回归训练

损失函数

在训练阶段，LagerNVS 是一个纯粹的有监督回归模型。它的目标是让预测出的新视角图像，尽可能逼近真实拍摄的那张照片（Ground Truth）。

论文使用了一个非常经典的混合损失函数：

L=λ2L2+λpLp\mathcal{L} = \lambda_2 \mathcal{L}_2 + \lambda_p \mathcal{L}_pL=λ2L2+λpLp

L2\mathcal{L}_2L2 (均方误差 MSE)： 这是最基础的像素级对比。算一下预测像素和真实像素的颜色差值的平方和。
- 痛点： 纯用 MSE 会导致画面极其模糊。因为当网络“不确定”某个细节时（比如草地的纹理），为了让惩罚最小，它会干脆输出所有可能颜色的“平均值”。
Lp\mathcal{L}_pLp (感知损失 LPIPS)： 为了对抗模糊，引入了感知损失。它不是比对像素，而是把生成的图和真实图同时扔进一个预训练的图像分类网络（比如 VGG）里，比对它们在深层提取出来的“特征图”差异。这能逼迫网络生成更锐利、更符合人类视觉直觉的高频细节。

端到端微调

虽然 Encoder 是直接拿别人训练好的 VGGT 初始化的，但论文强调，必须把整个网络解冻，端到端一起训练。因为 VGGT 以前只关心“几何”（哪儿深哪儿浅），完全不关心“外观”（比如透明度、高光反射）。如果不微调，生成的画面就会像石膏模型一样缺乏真实的质感。

www 的处理

在训练时，针对每一个场景，网络理论上既能算出 w1w_1w1，也能算出 w2w_2w2。但是作者引入了随机掩码机制：

有 1/3 的概率，把 w1w_1w1 强行设为 0，只给 w2w_2w2（模拟单视角或原地旋转的情况）。
有 1/3 的概率，把 w2w_2w2 强行设为 0，只给 w1w_1w1（模拟常规多视角输入）。
有 1/3 的概率，两个都给。

结果：经过这种严苛的训练，Transformer 网络被迫变成了一个极具鲁棒性的系统。在推理阶段：

如果你给它好几张照片，它会自动提取 w1w_1w1，忽略 w2w_2w2 。
如果你只给它一张照片，算出 w2w_2w2 设为 1.0，把 w1w_1w1 设为 0 输入进去。网络一看 w1w_1w1 是 0，立刻心领神会：“哦，这是单图模式，我要根据平均深度来推算移动距离。”

确定性模型的问题

LagerNVS 的主体是一个确定性的模型：给固定的输入，永远吐出固定的输出。这就带来了一个致命的问题：遇到完全看不见的区域怎么办？

场景重现：假设源图像只拍到了一个沙发的正面。然后你让目标相机强行走到沙发背面去看。
网络的挣扎：网络翻遍了源图像的 V×PV \times PV×P 个特征，发现根本没有沙发背面的任何线索。但 MSE Loss 拿着鞭子逼它必须画点什么。
惨烈后果：网络只能硬着头皮“猜”。为了稳妥，它猜了一个最不容易出错的“模糊色块”（比如灰棕色的糊糊）。这就是所谓的“向均值回归（Regression to the Mean）” 。在遇到复杂的遮挡（Occlusion）和外推（Extrapolation）时，普通的 LagerNVS 会显得非常无力。

扩散模型扩展

既然普通的 Decoder 只能给出一个确定的死板答案，那我就把它变成一个生成模型，让它能够在面对未知区域时，根据学过的先验知识，合理地“幻觉 (Hallucinate)”出细节。

模型改造

冻结解码器：把 VGGT Encoder 完全冻结住。因为提取 3D-aware Latent Tokens 这项工作它已经做得很完美了。
输入加噪：
- 原本 Decoder 的输入（Patch Embedding 层）只接收 6 个通道的信息（就是 6×H×W6 \times H \times W6×H×W 的目标相机普吕克射线）。
- 改造后，强行给输入层增加了 3 个通道，用来接收被加了高斯噪声的 RGB 图像。
- 也就是说，现在的 Decoder 一次性接收 9 个通道 (3+6=93 + 6 = 93+6=9)的输入：射线告诉它“你看向哪里”，噪声图像告诉它“你要去噪的底稿是什么” 。
时间步注入：引入大模型中常用的 adaLN-zero 层，把去噪时间步（Timestep ttt）作为条件注入给 Decoder 的每一层。

去噪训练

在训练这个改造后的 Diffusion Decoder 时，作者采用了一套非常扎实且偏向于高分辨率图像生成的策略：

像素空间，拒绝潜空间：不同于 Stable Diffusion 这种把图片压缩到 Latent 空间去去噪的模型，LagerNVS 是极其直接地在像素空间进行去噪操作的。
直接预测干净图像 (x0x_0x0 Prediction)：大部分扩散模型是训练网络去预测“噪声（ϵ\epsilonϵ）”，然后用原图减去噪声。但 LagerNVS 训练模型直接预测那张完全干净的图像（即 x0x_0x0）。这在基于 Transformer 的扩散模型中能带来更好的细节表现。
DDIM 调度与高分辨率适配：
- 使用了 DDIM 调度器，设置了 1000 个训练时间步（Timesteps）。
- β\betaβ 调度是线性的，从 βstart=0.001\beta_{start}=0.001βstart=0.001 到 βend=0.02\beta_{end}=0.02βend=0.02 。
- 硬核 Trick：为了适应相对较高的分辨率（256×256256 \times 256256×256），他们使用了一个带位移（shifted with a ratio of 4）的 Zero-SNR 噪声调度器。这也是目前高分辨率扩散模型常用来防止画面灰暗发白的关键技术。
损失函数配置：在微调时，作者依然使用了组合拳，但权重有所调整：均方误差的权重为 1.0，感知损失的权重高达 4.0 。学习率设为很保守的 1×10−51 \times 10^{-5}1×10−5，仅仅微调了 6 万步就收敛了。

局限性

伪影与视频闪烁

这是隐式/神经渲染领域最臭名昭著的问题。

模糊与块状伪影： LagerNVS 的主体是一个确定性模型。当面对未观测到的区域（比如物体的背面），如果强行用确定性回归模型去推断，它无法生成高质量的“幻觉（Hallucination）”，只会吐出带有块状伪影的模糊画面。
视频漫游的灾难：很多 NVS 系统的最终目的是生成一段平滑的漫游视频。但如果用 LagerNVS 渲染视频，你会发现画面会产生严重的闪烁感。这种闪烁来自于网络对几何估计的不确定性、对未观测区域的瞎猜，以及源相机姿态本身可能估计得不准。
Diffusion 的尴尬：虽然作者引入了 Diffusion 模型来解决模糊和遮挡问题，但论文明确指出，这个 Diffusion 解码器只能生成独立的单张图片。如果你连续生成两帧视频，Diffusion 在面对缺失信息时，第一帧可能“脑补”出了一个红色的条纹，第二帧可能“脑补”成了蓝色的波点。帧与帧之间毫无时序一致性，如果强行连成视频，画面会像霓虹灯一样狂闪。

高频细节缺失

LagerNVS 在渲染大面积的平滑表面（如墙壁、天空、桌面）时效果极佳，但论文承认，遇到像草地或树叶这种具有大量高频细节的区域时，它的表现会系统性地变得非常糟糕。

背后的计算机科学原理：图像被 VGGT 提取成了 PPP 个 Tokens。这相当于把巨大的像素信息压缩到了一个极小的潜空间里。对于极其细碎、混乱且密集的草地纹理，这有限的 PPP 个特征向量根本“记不住”这么复杂的细节。
显式 3 D 的反击：相比之下，这恰恰是 3D Gaussian Splatting (3DGS) 这类显式表征的绝对主场。3DGS 可以简单粗暴地在草地上撒几百万个带有颜色的小高斯球，轻松还原每一根草的细节，而不用强行压缩成一维 Token。

理想化数据假设

深度学习模型永远受限于它的训练数据分布。LagerNVS 的训练集高度理想化：

拒绝动态：它的训练数据全是纯静态的场景，甚至连人类都没有包含在内。如果源图像里有一个正在走路的人，或者随风飘动的窗帘，VGGT 提取的 3D 几何特征会直接崩溃，因为它根本不理解什么是“运动”。它会把人当成一个奇怪的、被拉扯变形的静态雕像。
拒绝镜头畸变：论文使用的是完美的针孔相机模型（11 维参数）。训练数据中没有包含鱼眼镜头（Fish-eye）等带有严重畸变的图像。如果在真实场景中用 GoPro 或安防监控器拍的图喂给它，射线的计算会完全偏离实际的物理轨迹，导致渲染出来的图像严重错位。

个人思考

对于使用扩散模型来渲染视频时，为了保证时序一致性，可以把第一帧作为第二帧的参考图像，当然这会导致计算量增加且需要重新跑编码器。这可能需要图像一致性的相关研究，对解码器进行一定的修改。

论文中使用的扩散模型解码器，看起来并不是很正宗的样子，无潜空间且直接预测图像，或许使用目前广泛使用的比如 FLUX 效果会更好？比如我也复刻一个 FLUX，用成熟的 FLUX 来初始化我的参数，我再额外注入视角信息来微调。

对于高频细节丢失，中先进的图像生成模型哪怕是通过 VAE 压缩又 PATCH 化，高频细节也很好。所以这个解码器如果使用先进的扩散模型的话，或许效果会好一些。

论文原文

《A Survey of Unified Multimodal Understanding and Generation》论文精读

小yo — Tue, 07 Apr 2026 17:17:46 GMT

宏观认知

为什么要统一理解与生成

很长一段时间内，研究人员选择独立开发多模态的理解和生成模型。综述指出，多模态模型的演进经历了三个阶段：从各个模型各司其职，到能力整合，再到未来愿景中的交错推理，即能够处理像“根据剧本生成连贯电影”这样复杂的现实任务。如今，打破理解和生成之间的界限，开发出能够无缝整合这两者的统一基础模型（UFM）已成为研究热点。

促使理解和生成走向统一的动机主要有两点：

相互促进：深度的语义理解是高质量生成的基础，而生成能力又能通过反馈循环帮助模型进行复杂的认知和推理。正如物理学家费曼所说：“我不能创造的，我就不能理解。”
解决高难度现实任务：现实世界中的复杂任务往往需要模型在理解长上下文的同时，迭代地生成高质量的多模态内容，这是孤立模型无法处理的。

统一基础模型（UFM）

在正式定义上，UFM 处理的任务集合必须同时包含多模态理解任务（如图像分类、视觉问答等）和生成任务（如文生图、图像修复等），而不是仅仅专注于其中一种。

传统独立模型

在具体探讨 UFM 之前，综述梳理了作为基石的传统独立模型：

多模态理解模型：主要分为判别式和生成式。判别式模型（如基于对比学习的 CLIP 和 SigLIP）通过区分正负样本来学习特征。生成式模型则多采用掩码图像建模（MIM）或自回归机制来捕获数据分布，通过生成数据来辅助理解。
多模态生成模型：综述列举了基于能量的模型、GAN、自编码器（VAE）以及当前最主流的两种范式：
- 扩散模型：通过前向加噪和反向去噪过程生成数据，特别是结合了 Transformer 架构的 DiT 模型，极大地提升了多模态生成模型的规模化潜力和表达能力。
- 自回归模型：以预测序列中下一个元素的方式生成内容。它的优势在于与现实世界的生成过程一致，非常适合生成长序列，但受限于依赖前置元素，推理速度相对较低，且存在误差累积的风险

多模态理解模型->生成模型 vs 多模态生成模型

可以通过根本目的维度来清晰地区分它们：

多模态理解模型->生成模型：生成是手段，理解是目的。

情况 A（自监督学习）：比如掩码图像建模（MIM，如 MAE 模型）。研究人员把一张小狗的图片遮住 75%，让模型去“生成（还原）”被遮住的部分。如果模型能成功还原，说明它在内部真正理解了小狗的结构。训练完成后，那个负责“生成像素”的解码模块往往就被丢弃了，我们只保留模型提取出的“特征”，用来做图像分类或目标检测。

情况 B（图文问答）：发一张图给模型问“图中有什么？”，模型生成了一段文本：“一只小狗在草地上跑”。这里的“生成文本”是为了证明：它看懂了这张图。

多模态生成模型：生成就是目的。

比如 Midjourney、Sora 或者 Stable Diffusion。你给一段提示词“一只在太空穿着宇航服的小狗”，模型从无到有地把这张图片或这段视频创造出来。它的核心使命就是产出多媒体内容。

核心架构与表征机制

框架与建模策略

要把语言大模型和生成模型结合起来，学术界探索了三种耦合程度由浅入深的路线。

外部专家集成

原理：大语言模型（LLM）作为“总控制器”，它自己不直接处理图像或声音。当收到任务时，它先做意图分析和任务规划，然后通过生成自然语言指令，去调用外部现成的“专家模型”（比如图像识别 API 或语音合成模块）。
特点：实现起来最简单，资源消耗低，不需要大规模重新训练（比如经典的 Visual ChatGPT 和 HuggingGPT）。但瓶颈也很明显：一切交流都靠文本，如果任务需要传递极其复杂的视觉细节，自然语言往往无法精准表达，导致外部专家“会错意”。

模块化联合建模

原理：把 LLM 和外部的生成模型（比如 Stable Diffusion）拼在一起。LLM 负责理解上下文，然后输出“提示词（Prompt）”或者“中间表征（Representation，即高维向量）”来指导后端的外部扩散模型生成目标模态。
特点：相比第一种路线联合得更紧密。尤其是采用“表征媒介（Representation-Mediated）”方式时，模型跳出了自然语言的限制，直接用高密度的连续向量沟通，能传递更丰富的结构和细节，生成质量很高。缺点是依然存在“拼盘”感，且模型能力上限受限于那个外部的生成器。

端到端统一建模

原理：这是目前学术界追逐的目标。理解和生成任务全部在一个统一的神经网络架构内部完成，不再依赖外部的生成模块，实现了真正意义上的深度耦合。

三大流派：

自回归（Autoregressive）：像语言模型“预测下一个词”一样，预测下一个图像块（比如 Emu 3）。优点是框架极其简单统一，缺点是生成高清图像时存在信息瓶颈，且推理速度慢。
扩散（Diffusion）：将生成和理解任务都放入扩散或流匹配的降噪过程中，生成质量极佳，但先天在复杂的逻辑推理和理解能力上偏弱。
自回归-扩散混合（AR-Diffusion Hybrid）：当前极具潜力的新星方向。用自回归处理文本等离散数据，同时引入扩散模型处理图像等连续数据（比如 Transfusion 和 Show-o 模型），兼顾了 LLM 的强推理优势和扩散模型的高清生成优势。

编码与解码

要把图像、视频和文本放在一起做端到端训练，就必须有一种统一的数据“语言”。编码就是把连续的多媒体信号变成模型能消化的数字特征，解码则是把特征变回可感知的图像/声音。综述里梳理了三种表征体系。

连续表征

将图像编码成一串连续的、包含小数的实数向量（通常使用 CLIP 的 ViT 或 VAE）。

优势：最大程度保留了丰富的语义信息和全局结构，非常适合视觉问答这种需要深度理解的任务。
劣势：LLM 习惯处理像单词这样的离散符号，强行输入连续向量有时容易造成语义未对齐。

离散表征

通过向量量化（Vector Quantization, VQ）技术，把图像切分，然后像查字典一样，把每个图像块强制转换成一个“离散的词 ID”（Visual Token）。

优势：完美契合 LLM 的自回归架构，文本和图像共享同一个词表。
劣势：这种强制的量化压缩会不可避免地丢失底层像素细节（比如图像变糊或丢失局部纹理），导致生成图像的质量受限。

混合表征

结合了前两者的优点，试图既保留连续表征的丰富语义，又利用离散表征来做好底层重建。

很多最新的架构会采用“双分支（Dual-Branch）”结构：一条独立路径提取高级语义（供理解任务使用），另一条独立路径提取像素细节（供生成任务使用），最后再将它们融合。

架构与表征组合

表征（连续/离散）和生成框架（自回归/扩散）绝对不是随意的自由组合，它们之间存在强烈的“数学与架构绑定”关系。在设计统一多模态模型时，研究人员通常会遵循以下几种经典的“黄金搭档”组合。

自回归架构+离散表征

大语言模型底层采用的是自回归机制。它在数学上做的事情是：从一个固定大小的“词表”中，计算出下一个词的概率分布，然后挑出概率最高的那一个。这种计算天然只支持离散的、有限的类别。

因此，必须用向量量化技术（如 VQ-VAE、VQGAN）把图像切块，并强行转换成一个个离散的Visual Tokens。这样图像就变成了和文本一样的离散符号序列，LLM 就可以像续写文章一样，逐个预测下一个“图像单词”来生成图片。

扩散框架+连续表征

扩散模型的数学原理是逐步添加和去除高斯噪声。加噪和去噪的过程是在一个平滑的、连续的实数空间中进行的。如果你给它离散的整数 ID，它根本无法计算梯度的微小变化。

使用标准的变分自编码器（VAE）将图像压缩成连续的特征向量。扩散模型在这个连续的特征空间中进行复杂的去噪生成，生成完毕后，再用解码器将这些连续特征还原为高清像素。

混合组合

随着研究的深入，学术界也开始尝试打破这些经典绑定，这就是我们在综述中会看到的一些“混合/创新架构”。

自回归框架 + 连续表征
- 难点：LLM 习惯做离散分类，怎么让它输出连续的无限可能的小数？
- 解法：修改大模型的“输出头”。不再让它做词表预测，而是让大模型在输出端外接一个回归头或者一个小型的扩散模型头，直接输出连续的特征向量。这保留了 LLM 强大的逻辑推理能力，同时避免了离散化带来的图像失真。
混合框架
- 解法：既然文本天生离散，图像天生连续，不如“因材施教”。在一个统一的模型中：文本部分使用自回归预测离散 Token，图像部分使用扩散去噪预测连续变量。两者共享底层的 Transformer 注意力机制。
- 代表模型：综述中提到的 Transfusion 就是这种思路的典型代表，这也是目前非常有前景的大一统路线。

模型训练周期

传统的单一模型训练相对简单，但大一统模型（UFM）既要学理解又要学生成，它的训练生命周期通常分为两个关键阶段。

统一预训练

目标：让模型掌握海量的世界知识，并在不同模态（图、文、音）之间建立基础的对齐关系。就像是让小孩广泛地阅读、看世界、听声音，建立最基本的常识。
难点：如何把不同模态的训练目标统一起来？综述中提到，通常会混合多种目标，比如让模型同时做自回归预测（预测下一个词或下一个图像块）、掩码重建（遮住一部分图像或文本让它还原），以及对比学习（判断某段文本和某张图片是否匹配）。

数据格式

在 UFM的统一预训练阶段，模型需要在一个框架内同时学习理解和生成等多种任务。为了让模型在处理序列时能够明确区分当前需要执行的“训练目标”或“任务类型”，研究人员通常采用以下几种核心机制：

结构化的指令模板

为了实现更精确的跨模态对齐，研究人员广泛采用基于指令的数据构造策略，使用结构化的模板将异构的模态数据转换为统一的序列表示。通过自然语言指令或提示词来直接指定期望的任务或响应。例如，理解任务的指令可能是“描述图像中的物体：<image>”，而生成或编辑任务的指令可能是“将照片中的草地替换为沙子：<image>” 。

引入任务引导的特殊Token

在模型架构层面，通过在模型词表中扩展引入新的、可训练的特殊 Token，可以有效实现模态区分和任务引导。

显式行为引导：例如 LLMBind 模型引入了特定的任务 Token（如 <gen> 代表生成，<edit> 代表编辑）来直接引导模型的行为。
任务范式指定：Unified-IO 2 使用了 [R] 和 [S] 这样的标记来指定具体的任务范式。
统一提示技术：在自回归与扩散混合架构的代表模型 Show-o 中，研究人员引入了一种统一的提示技术，使用 [MMU]（多模态理解）和 [T 2 I]（文生图）等特殊 Token 来显式地指定不同的任务类型。

模态边界与类型标识

为了配合任务目标的区分，模型还需要准确识别当前处理的数据属于什么模态。主流的多模态指令数据通常采用标准化的分隔符系统，例如使用 <text>、<image>、<video> 等标签来包裹对应的 Token 序列。在具体实现中，还会引入像 <imgbos>（图像开始）和 <imgend>（图像结束）这样的特殊 Token 来显式标定多模态数据流中图像 Token 序列的边界。这有助于模型在执行生成、编辑或分割任务时，准确识别出图像的边界范围，从而更好地适应特定模型的需求。

任务监督与对齐

目标：预训练出来的模型虽然懂得多，但不一定听人类的话。这一步是为了让模型的行为符合人类的指令和价值观。
监督微调（SFT）：给模型喂大量高质量的“指令-回复”数据。比如，“请把这张草图渲染成赛博朋克风格（生成）”或者“图中这个人为什么在笑？（理解）”。
偏好对齐（Alignment）：采用 RLHF（基于人类反馈的强化学习）或 DPO（直接偏好优化）等算法。对于多模态模型来说，不仅要对齐文本回答的安全性，还要对齐生成图像的美观度、是否符合物理规律、是否包含有害视觉内容等。

数据工程与评测基准

多模态数据工程

构建 UFM 需要极其庞大且高质量的交错数据。综述梳理了数据工程的几个关键环节。

数据来源：
- 网络抓取：从网页中提取图文交错的 HTML 数据，这是获取海量知识的主要来源。
- 合成数据：因为互联网上高质量、带有精准描述的图像/视频太少了。现在的常规操作是利用现有的强大多模态理解模型（比如 GPT-4V），让它去给海量的无标签图片或视频自动生成极其详尽的描述，再拿这些合成数据去训练新的统一模型。
数据过滤与清洗：
- 去重：剔除互联网上大量重复的图片。
- 质量过滤：使用专门的打分模型过滤掉模糊、带有大面积水印、或者纯粹是广告的图片。对于生成模型来说，还需要用“美学评分模型”来筛选出最具美感的数据。
- 图文对齐过滤：很多网页上的图片和旁边的文字根本毫无关联（比如文章讲的是宏观经济，配图却是一张风景照）。需要用 CLIP 等计算图文相似度，剔除不匹配的数据。

Benchmark

论文将现有的 Benchmark 严格划分为三大类：理解任务评测、生成任务评测，以及专为 UFM 设计的混合模态生成评测。

理解任务评测基准 (Benchmark for Understanding)

这部分主要评估模型理解输入信息的能力。论文根据输入模态（图像、视频、音频等）进行了细分，其中图像理解的评测维度最为丰富。

基础感知与认知：从早期的 VQA v 2.0，发展到了如今追求全面评价的大型多项选择题基准（如 MME、MMBench、SEED-Bench 系列）。此外，还出现了专门用来诊断模型“视觉缺陷/盲区”的基准（如 MMVP）。
世界知识 (World Knowledge)：考察模型是否具备跨学科的专家级知识。代表基准是 MMMU（涵盖大学级别的艺术、科学、工程等多学科问题）以及 ScienceQA。
推理与数学：不仅要求看懂，还要求多步逻辑推理。代表如 MathVista 和 MATH-Vision，专门测试模型对复杂图表、几何图形的数学解题能力。
特定能力与安全性：包括对长文本/文档的阅读理解（OCRBench, DocVQA）、模型“幻觉”检测（POPE, MMHAL-BENCH，专门测试模型是否会“一本正经地胡说八道”），以及对偏见和安全性的评估（MOSSBench）。

在视频理解方面，除了基础的动作识别和时序问答（Video-MME），目前的评测焦点正在向长上下文理解转移，比如测试模型对长达几小时的视频或第一人称视角视频的记忆和推理能力（如 LVBench, EgoSchema）。

生成任务评测基准 (Benchmark for Generation)

这部分评估模型生成多媒体内容的能力：

图像生成：
- 文生图：重点考察生成的图像与文本提示的对齐度（比如属性是否泄漏、位置是否正确）以及美学质量。代表基准有 GenEval、WISE 等。
- 图像编辑：要求模型在保留原图特征的基础上，根据指令进行精准修改。代表基准有 MagicBrush、PIE-Bench 等。
视频生成：除了图像的清晰度，更强调时序连贯性和动作的物理合理性。代表基准如 VBench。

混合模态生成评测基准 (Benchmark for Mix Modality Generation)

这是论文特别强调的、针对UFM的最前沿评测方向。传统的基准往往把理解和生成割裂开来单独打分，而混合基准（如交错生成 Interleaved Generation）要求模型在同一个任务流中同时调用这两种能力。

代表基准：SEED-Bench-2、MMIE、MME-Unify、RealUnify 等。
考察形式：例如，输入一段包含图片和文字的悬疑故事（理解长篇交错上下文），要求模型不仅要用文本推理出故事的结局（理解），还要画出对应的最终场景（生成）。或者在几何题中，模型需要先生成正确的辅助线（生成），再基于辅助线计算出结果（理解）。
核心意义：这种评测直接触及了 UFM 的终极愿景——“交错推理 (Interleaved Reasoning)”，它测试的是生成与理解是否能够相互促进，而不仅仅是简单地拼凑在一起。

应用

论文的第 10 章详细探讨了多模态大一统模型（UFM）在五大核心领域的下游应用场景。这些应用不再仅仅局限于传统的图文问答，而是深入到了物理世界的交互与预测中。

机器人与具身智能

在机器人领域，基于视觉-语言-动作（VLA）的模型能够根据观察和指令生成未来的规划动作。目前的挑战在于如何处理多模态的动作分布，这通常需要引入额外的扩散头等特殊结构。

强化推理能力：像 LCB、DexVLA 和 ChatVLA 这样的模型通过构建文本推理数据集，让模型在输出具体动作指令之前，先进行显式的文本分析和推理。
视觉与动态预测：SEER 模型引入了辅助的扩散模型来预测目标的动作图像，从而捕捉真实的物理动态。GR-2 则通过在海量网络视频上预训练视频生成，来学习通用的世界动态机制。

自动驾驶

自动驾驶系统正朝着端到端的方向发展，旨在将传感器输入直接映射为车辆的运动轨迹。UFM 将未来场景生成与运动规划相结合，提升了模型对动态环境的建模能力。

多模态联合预测：DrivingGPT 采用离散自回归建模，联合预测交错的未来画面和运动 Token 。Epona 则结合了自回归和扩散模型，实现了高分辨率的长期预测。
3D 与空间感知：Hermes 模型能够根据当前图像跨传感器预测未来的 LiDAR 点云。OccLlama 和 Occ-LLM 利用占用网络的空间体素表示，通过驾驶 VLA 模型来预测未来的空间占用情况。

世界模型

世界模型旨在根据历史观察和可替代动作来推断未来可能的世界状态，是通向自主智能的重要途径。由于纯 2D 的视觉输入往往难以维持时空连贯性和遵守物理约束，统一模型正推动其向基于物理的预测发展。

迈向 4D 预测：Aether 训练了一个基于扩散的 4D 世界模型，在统一框架内联合预测视频、深度和相机姿态。
物理交互模拟：TesserAct 构建了 4D 具身世界模型，不仅预测视频和深度，还预测法线贴图（Normal maps），使其能够准确模拟抓取物体或打开抽屉等逼真的 3D 物理交互。在驾驶场景中，GEM 和 DiST-4D 等模型也实现了带有精确控制条件和多视角的 4D 驾驶世界模拟。

泛视觉任务

UFM 正在将各种零散的视觉感知和生成任务统一到同一个大模型框架下。

2D 视觉感知：LLMBind 和 VisionLLM v 2 将特定任务的视觉模型作为外部解码器，处理目标检测、语义分割和姿态估计等高级视觉任务。UniWorld-V 1 则直接利用 UFM 的生成能力输出结构化的标签图，摆脱了对特定任务视觉模型的依赖。
3D 几何与生成：LLAMA-Mesh 巧妙地利用了纯文本的 OBJ 格式（包含顶点坐标和面定义）与 LLM 结合，实现了 3 D 网格的生成和理解。VGGT 更是作为统一的几何基础模型，能够直接从任意视角推断相机的参数、密集点云和深度图等所有关键的 3D 属性。

医疗健康

医疗被论文特别指出是多模态智能最具潜力的应用领域之一。UFM 在联合执行多模态数据（如医学影像和诊断报告）的理解与生成方面，展现出了极大的应用潜力和临床价值。

未来方向

论文在第 11 章将未来工作主要归纳为四个核心方向。

模型策略与结构

综述指出，未来的架构探索将集中在如何更好地将大语言模型的自回归特性与扩散模型相结合。纯粹的自回归或扩散模型在处理混合任务时存在一定局限，因此混合架构是关键的突破口。同时，利用混合专家模型（MoE）结构来更高效地整合理解和生成能力，也是一个极具潜力的架构演进方向。

统一 tokenizer

目前模型在不同模态间转换时仍面临信息冗余和丢失的问题。未来的目标是设计出可扩展的统一分词器，以减少表征冗余并提升通用性。特别是在视频领域，迫切需要设计出能保留更丰富语义的视频分词器，从而在底层的 Token 空间里同时支持高质量的视频理解和生成。

模型训练

训练范式的演进将沿着两条主线展开：

模态交错数据：数据构建将从简单的“图文配对”全面转向深度的“模态交错”语料。例如，对视频进行多粒度的时序分解，并与文本在动作、实体和因果关系上进行细粒度对齐。这种复杂的数据构造能大幅提升模型对过程、行为和复杂时序结构的深度理解。
偏好对齐训练：未来的模型优化将超越传统的监督微调（SFT），转向整合强化学习（如 DPO 和 GRPO）与人类偏好对齐的统一框架。当前的核心挑战在于，如何设计出能够精确捕捉和平衡“理解”与“生成”双重任务偏好的统一奖励模型。

评测基准

现有的评测基准大多将“理解”和“生成”割裂开来单独打分，缺乏对两者相互促进能力的直接测试。未来的统一评测基准需要做出以下改变：

在生成提示中嵌入更丰富的语义和世界知识要求，迫使模型的生成动作必须建立在完全正确理解输入的前提之上。
要求模型在生成视觉内容后，基于该内容进行逻辑推理（例如，先画出几何辅助线，再解答几何题），以此测试“生成”如何反哺“理解” 。
在评估手段上，学术界可能会采用混合协议：使用大模型作为裁判（MLLM-as-Judge）来评估中间输出的有效性，同时结合客观规则或参考标准来评估最终结果。

论文原文

《Understanding World or Predicting Future》论文精读

小yo — Mon, 06 Apr 2026 09:55:41 GMT

世界模型概念与演进脉络

核心争议与分类定义

目前学术界对“世界模型”的定义还在争论中，这篇综述将其高度概括为两大核心功能或流派：

理解世界

构建内部表示来理解世界的运行机制。早期的强化学习研究侧重于此，即把复杂的外部世界抽象成简单的潜在变量，目的是为了更好地做决策。

这类模型的目标是“降维打击”。它们认为世界太复杂、像素级的信息存在太多冗余，因此它们倾向于过滤掉无关的细节，将外部世界抽象成精简的潜在表示。这就好比你过马路时，脑子里不需要预测每一片树叶的飘动，只需要理解“车速”和“距离”这两个抽象概念就能做出决策。

预测未来

预测未来的状态来模拟和指导决策。Yann LeCun 认为世界模型不仅要感知世界，还要能想象未来的可能状态。如今像 Sora 这样的视频生成模型，就是通过生成符合物理规律的视频来模拟未来演变，更偏向这一流派。

这类模型的目标是“全真模拟”。它们不仅需要理解底层的物理和因果规律，还需要把这种理解显式地渲染出来，生成包含时间动态和空间一致性的视觉序列（比如 Sora 生成的视频）。

跨学科起源与心理学基础

人工智能领域中的世界模型概念，有着极其深厚的心理学根基，主要源自心理学中的心智模型理论。

1943 年，苏格兰心理学家 Kenneth Craik 在其著作《解释的本质》中首次提出，人类的心智会构建一个“现实的缩小版模型”来预测和理解外部事件。他认为，人类认知的根本运作方式就是创建内部表示，以此捕捉外部世界的核心结构和动态，从而实现预测性推理和适应性行为。

到了 20 世纪 80 年代，英国心理学家 Philip Nicholas Johnson-Laird 进一步系统化了这一概念。他指出，人类的推理（无论是演绎、归纳还是反事实思考）都是通过构建和操作心智模型来实现的。

Johnson-Laird 确立了几个与今天 AI 世界模型高度契合的原则。心智模型是对可能无限领域的有限表示，它们捕捉的是结构关系而非表面细节，并且它们能够实现对替代方案的预测性模拟。

关键技术发展史

世界模型的演进有一条清晰的时间线：

前深度学习与 MBRL

在基于模型的强化学习（MBRL）中，智能体会构建环境的动态模型。2018 年，Ha 和 Schmidhuber 提出了一个基于循环神经网络的隐式模型，真正带火了“世界模型”这个词，它让智能体可以在脑海中“做梦”并据此做决策。这个模型通过以下机制运行：

环境抽象压缩：它不是直接让智能体对着原始的像素画面做决策，而是先通过一个自编码器-潜在状态管道（autoencoder-latent-state pipeline）来重构图像。这一步将复杂的外部世界抽象成简化的元素。
RNN 预测未来：智能体接收来自真实环境的反馈，这些反馈被转化为训练模型的输入序列。接着，模型使用循环神经网络（RNN）来学习这些潜在表示随时间的演变。RNN 的作用就是根据当前的状态和即将执行的动作，预测下一个状态会是什么样。
在“梦境”中决策：通过这种方式，模型实际上创建了一个关于未来世界可能如何演变的心理模拟，智能体则是基于对这些预期结果的预测来做出最终决策的。

JEPA

2022 年，Yann LeCun 提出了联合嵌入预测架构（JEPA）。它的核心思想是让机器像人的大脑一样，分为直觉反应的“系统 1”和深思熟虑、会调用世界模型预测未来的“系统 2” 。它不预测像素级的细节，而是预测抽象的潜在空间（Latent space），过滤掉无用的冗余信息。

它的核心机制和亮点可以总结为以下几点：

模块化结构

它包含一个“感知模块”（也就是编码器，负责处理感官数据），紧接着是一个“认知模块”（预测器，负责评估这些信息），这构成了世界模型的实体。

自监督学习范式

这是 JEPA 最大的创新之一。传统的深度学习往往需要海量的人工标注数据（比如标出哪张图是猫、哪张是狗），而 JEPA 能够不依赖大量标注数据，通过自监督的方式学习到丰富的世界表征。

在 JEPA 的具体实现中，它通常采用一种掩码预测的思想：

给定一段视频或一张图像，模型会故意遮住其中的一部分（比如遮住视频的后半段，或者图像的右半边）。
模型的“感知模块”处理未被遮挡的部分，然后交给“预测器”去推测被遮挡部分的内容。
注意，这里针对的不是像素，而是特征向量。目标数据（被遮住的真实部分）也会通过一个编码器，提取出一个高维的数学表示。Loss 函数（比如 L2L_2L2 距离）的任务就是最小化“预测出的特征向量”与“真实的特征向量”之间的差距。

双系统认知

JEPA 巧妙地融入了类似人类“快思考”与“慢思考”的双系统概念。

系统 1（快思考）：在代码层面，这就是一个标准的前馈神经网络或策略网络。智能体接收到当前的环境状态输入，通过一层层的网络参数进行前向传播，直接输出一个动作。这个过程极快，没有任何对未来的展开和推演，属于无需显式查询世界模型的本能反应。
系统 2（慢思考）：这就是世界模型大显身手的地方。系统2会调用 JEPA 中的预测器。在决定当前怎么做之前，它会在那个抽象的潜空间里把时间展开。比如，它会假设“如果我执行动作 A，未来的状态向量会变成怎样；如果执行动作 B，又会变成怎样”。它超越了即时的感官输入，通过自监督表示来模拟潜在的未来场景（比如预测房间里接下来十分钟的事件）。在工程实现上，像 V-JEPA 2 这样的模型，会结合模型预测控制（MPC），在潜空间中广泛采样可能的动作轨迹，并通过能量优化来选择最优解。

潜空间构造

在传统的基于重构的模型（如自编码器 VAE）中，潜在空间是被像素级重建任务‘逼’出来的，模型不仅要提取当前画面的特征，它的损失函数还强迫它必须能把原来的画面重新‘画’出来。而 JEPA 则完全抛弃了这条路线，它不预测像素空间中的原始感官输入，而是直接在潜在的嵌入空间中学习预测抽象的表征。

JEPA 构造潜空间的主要机制是：

编码器映射：输入的数据（比如图像块）经过神经网络，被压缩成一组高维向量（例如一个 1024 维的浮点数组）。这个多维空间就是潜空间。
语义距离度量：在这个空间里，模型遵循的法则是“语义相近的内容，在空间中的距离越近”。例如，“一只奔跑的狗”在第一秒和第二秒的特征向量，在潜空间里的距离应该非常近；而它与“一辆停着的车”的特征向量，距离应该很远。
避免表示坍塌：这是非像素重建方法最大的技术难点。如果只要求预测的向量和目标的向量一致，模型很容易找到一个捷径——无论输入什么，它都输出同一个常数向量（比如全是 0），这样 Loss 直接变成 0。为了防止这种情况，JEPA 等架构在训练策略上做了大量精巧的设计（通常包含不对称的网络结构，例如目标编码器的参数不是通过梯度下降更新，而是作为预测编码器的指数移动平均 (EMA) 来缓慢更新，或是引入基于能量的正则化）。通过这种纯数学向量空间中的距离约束，JEPA 强迫网络去提取像“位置、形状、速度、类别”这样高级别的语义特征，从而完美避开了算力黑洞。

大语言模型

通过海量的文本训练，LLM 自然地获得了关于空间、时间和现实场景运作的“隐性世界知识”。

视频与 3D 生成

像 Sora 和互动 3 D 场景生成技术的出现，让世界模型从隐式抽象走向了显式的视觉序列生成，它们不仅画面逼真，还展现出了对时间动态、空间一致性和物理定律的理解。

综述的分类体系

作者正是基于上述的演进，将整篇论文的后续技术章节划分为：

外部世界的隐式表示：侧重决策制定和世界知识。
物理世界的未来预测：侧重视听觉上的视频生成和具身环境模拟。

外部世界的隐式表示

这一流派的核心理念是：世界模型不需要把未来的画面一帧帧渲染出来，而是要把外部的复杂现实转化为一种极其精简的潜在变量。这样做只有一个终极目的——为了做出更好的决策。

作者将隐式世界模型分为了两条清晰的技术主线。

决策中的世界模型

当一个智能体需要做决策时，它必须先理解环境。论文指出了两种利用世界模型做决策的范式：

基于模型的强化学习

MDP

在强化学习中，为了让计算机能够处理现实世界的决策问题，我们必须把环境抽象成一个数学模型。论文中指出，决策问题通常被表述为一个马尔可夫决策过程（MDP）。

MDP 假设了“未来只与现在有关，与过去无关”。在论文中，MDP 被定义为一个由五个元素组成的数学元组 (S,A,M,R,γ)(S, A, M, R, \gamma)(S,A,M,R,γ) ：

SSS (State Space)：状态空间，即智能体在环境中可能处于的所有状态的集合。
AAA (Action Space)：动作空间，智能体可以采取的所有合法动作的集合。
MMM (Transition Dynamics)：状态转移概率（动态方程）。它定义了在当前状态 sss 下执行动作 aaa 后，环境变成下一个状态 s′s's′ 的概率。
RRR (Reward Function)：奖励函数。它定义了智能体在状态 sss 执行动作 aaa 后，环境会反馈给它的即时奖励分数。
γ\gammaγ (Discount Factor)：折扣因子。介于 000 到 111 之间，用来衡量“未来的奖励”相对于“现在的奖励”有多重要。由于绝大多数任务的目标（奖励函数 RRR）是预先定义好的，所以“世界模型”的核心任务就是去学习和逼近那个状态转移概率 MMM。只要智能体精准掌握了 MMM（即知道了“我这么做，世界会怎么变”），它就拥有了完美的世界模型。

MPC

当我们有了一个优秀的“世界模型”（也就是知道了 MMM）之后，我们怎么用它来控制机器人或自动驾驶汽车呢？模型预测控制 (Model Predictive Control, MPC) 给出了一种极其直接且有效的方案。

MPC 的核心思想是“向未来看多步，但只走眼前这一步”（也叫滚动时域控制 / Receding Horizon Control）。论文中给出了它的核心优化公式：

max⁡at:t+τEst′+1∼p(st′+1∣st′,at′)[∑t′=tt+τr(st′,at′)]\max_{a_{t:t+\tau}} \mathbb{E}_{s_{t'+1} \sim p(s_{t'+1}|s_{t'},a_{t'})} \left[ \sum_{t'=t}^{t+\tau} r(s_{t'}, a_{t'}) \right]maxat:t+τEst′+1∼p(st′+1∣st′,at′)[∑t′=tt+τr(st′,at′)]

具体执行步骤如下：

推演未来：在当前时间步 ttt，智能体利用它的世界模型 p(st′+1∣st′,at′)p(s_{t'+1}|s_{t'},a_{t'})p(st′+1∣st′,at′) 向未来预测 τ\tauτ 个时间步长（τ\tauτ 即 planning horizon，规划层级）。
序列优化：在这些可能的未来中，寻找一条能在未来 τ\tauτ 步内获得最大累积奖励 ∑r\sum r∑r 的动作序列。
只执行第一步：找到了这条最优的动作序列后，智能体只执行这个序列中的第一个动作。
重新观测与循环：执行动作后，真实世界进入了新的状态 t+1t+1t+1。智能体舍弃掉刚才规划的后续动作，在新的真实状态下，再次向未来推演 τ\tauτ 步，重新规划。

这种机制使得 MPC 具有极强的鲁棒性，即使世界模型的预测稍微有一点偏差，它也能通过每走一步就重新观测真实环境来及时纠正。

MCTS

如果说 MPC 是一种线性的推演，那么蒙特卡洛树搜索 (Monte Carlo Tree Search, MCTS) 则是在庞大且离散的决策空间中进行的一场“树状探索”。论文指出，MCTS 通过维护一棵搜索树来运作，其中每个节点代表一个由预定义价值函数评估的状态。MCTS 是 AlphaGo 和 AlphaGo Zero 在离散动作空间中解决决策问题的核心。

MCTS 利用世界模型进行模拟，通常包含四个循环往复的专业步骤：

选择：从代表当前真实状态的根节点出发，根据某种策略（通常是 UCB 算法，用于平衡“探索未知”和“利用已知”），一路向下选择子节点，直到走到一个还未完全展开的叶子节点。
扩展：在这个叶子节点上，利用世界模型生成一个或多个可能的合法动作，从而在树上创建新的子节点。
模拟：从这个新节点开始，让世界模型进行一次快速的、半随机的推演，来评估这个节点的好坏。
回溯：将模拟得到的结果（输赢或得分）沿着刚才走过的路径向上反向传播，更新途径的所有节点的统计数据（比如节点的访问次数和平均胜率）。

通过成千上万次这样的循环，搜索树会在那些真正有潜力的决策分支上长得极其茂盛。最终，智能体会选择那条被探索次数最多、价值评估最高的分支作为实际执行的动作。

LLM/MLLM

随着大模型时代的到来，语言本身成为了一种通用的表示形式。LLM 凭借其强大的理解能力，成为了构建世界模型的新基座：

直接生成动作：LLM 可以直接作为大脑，接收视觉和文本信息，直接输出下一步的动作指令。
模块化结合：更高级的做法是，把 LLM 当作一个环境模拟器（世界模型模块），然后再外接一个专门的规划算法（比如前面提到的 MCTS）来进行推演。这样可以有效弥补大模型有时“逻辑推理不严密”的缺陷。

大语言模型学到的“世界知识”

如果说强化学习是在特定任务（比如下棋、玩游戏）中现学现卖，那么大语言模型（LLM）则是在海量的预训练文本中，把整个世界的运行法则“压缩”进了神经网络的权重里。

论文非常系统地将 LLM 里的这些“世界知识”基于“对象”和“空间范围”这两个关键维度划分为三个层次。

全局物理世界

此时的空间范围最宏大（通常是地球、城市规模，甚至是经纬度坐标），对象是宏观的地理实体。

研究发现，LLM 内部居然存在“空间神经元”和“时间神经元”，它们不仅仅是在统计词频，而是真正学到了多尺度的空间和时间线性表示。

局部物理世界

此时的空间范围急剧缩小，聚焦于特定房间、街道或迷宫；对象变成了具体的家具、障碍物或目标物体。因为这里是人类日常生活和执行大多数真实世界任务的主要环境，所以对局部物理世界的建模，是构建完整世界模型更为关键的课题。

就像人类脑海中会构建“认知地图”来导航一样，研究者发现类似结构也存在于大语言模型中，这使得模型能够在复杂的局部空间（比如 Minecraft 游戏或室内导航）中理解空间关系并执行任务。

认知地图

认知地图最初是心理学家（如 Edward Tolman 在研究老鼠走迷宫时）提出的概念，主要用来解释人类和动物的学习过程。它是指人类为了导航和理解周围环境而在脑海中形成的“心智表征”，里面包含了诸如空间关系、相对距离和关键地标等重要信息。简单来说，就是你闭上眼睛，脑海里浮现出的从宿舍走到食堂的“3D 脑内导航图”。研究人员惊讶地发现，虽然大语言模型只是在预测下一个词，但它们内部那些表示概念宇宙的高维向量中，竟然也自发形成了类似认知地图的大脑结构。研究人员正是利用这些深刻的见解，来提升人工智能模型学习和理解物理世界的效率与性能。

在智能体的训练中，认知地图发挥着巨大作用。例如，在一项简化版 Minecraft 游戏的研究中，通过视觉预测编码，智能体能够纯粹从像素中一点点构建出空间认知地图。一旦这个地图训练成型，这张位于潜在空间的地图就能编码它到任何目标的度量距离。这意味着智能体不仅“看”到了画面，还在心里“建”了模，从而能够极其准确地推演未来的观测结果，指导自己下一步往哪走。

人类社会

此时对象彻底从“没有生命的物理环境”转变为“具备心智的人类”。空间范围退居其次，核心在于理解人类社会底层运行的隐式规则、文化差异、以及推断他人的心理状态（即前文提到的“心智理论”）。

目前的研究正在疯狂测试大模型是否真的具备这种能力，比如它们能否理解虚假信念、识别反讽，甚至是模拟宏观的经济趋势和资源分配法则。

物理世界的未来预测

如果说上一阶段的“隐式表示”是在脑海里做抽象的数学推演，那么这一阶段的“未来预测”就是把推演的结果显式地渲染出来。论文将这一流派主要分为两个进阶方向。

世界模型作为视频生成

早期的世界模型通常只预测离散或静态的未来状态，但通过引入视频生成技术，现在的模型能够捕捉环境中连续的空间和时间动态。

Sora

Sora 是这类模型目前的典型代表，它能够根据多模态输入生成长达一分钟的高质量、时间一致的视频，其画面常常看起来符合现实世界的物理原理（如光线反射）。

但是，论文尖锐地指出了它的局限性：首先是缺乏因果推理能力，它目前更多是被动地生成序列，而不是主动预测动作如何改变事件。其次，它在严格遵守物理定律方面经常翻车，比如在模拟复杂的物理现象（如受力、流体动力学或光相互作用）时常常失效。

被动的序列生成：综述提到，Sora 在理解和模拟外部世界方面存在显著局限性，它只能被动地生成视觉序列，而无法主动预测“特定的动作将如何改变事件的发展”。
“基于案例”而非“基于规则”：研究（如 Kang 等人）表明，当不断扩大扩散模型的规模时，虽然模型在训练数据分布内能生成极其逼真的画面，但一旦面对分布外或复杂的组合测试时，模型就会崩溃。这说明模型依赖的是“基于案例”的泛化，而不是真正学到了“基于规则”的泛化。
物理规律的崩塌：正因如此，Sora 很难一致地重现正确的物理定律，在模拟物体受力、流体动力学或光线相互作用等复杂物理现象时常常会失败。 2026 年 3 月底，OpenAI 宣布将全面关停 Sora 的消费者应用和 API。证明了“试图靠纯粹的像素数据暴力去模拟真实物理世界”在当前的工程与商业上撞到了南墙。虽然大众娱乐应用被关停，但 OpenAI 官方明确表示，Sora 研究团队将继续专注于世界模拟的研究，以推进能够解决现实物理任务的机器人技术。这完美印证了综述第四章和第五章的核心观点：生成式世界模型的真正发力点不是拍电影，而是构建支持具身智能交互的虚拟训练环境。

理想视频世界模型应具备的四大能力

为了真正用于模拟外部世界，后续研究需要攻克以下能力：

长期预测能力：不能只生成几秒的连贯画面，需要长时间保持动态一致。
多模态整合：不仅听懂文本，还要融合图像和动作指令。
交互性：这是最关键的突破点！模型不仅要能生成逼真的画面，还必须允许用户输入动作，并模拟这些动作产生的后果，从而支持动态决策。
多样化环境：能够适应自然环境、自动驾驶、游戏等各种场景的模拟。

世界模型作为具身环境

单纯看视频是不够的，智能体需要在环境中摸爬滚打。因此，现在的焦点正转向创建完全交互式和具身的模拟。它们不再仅仅表示视觉元素，而是融入了空间表示和物理交互。

论文将当前的具身环境世界模型分为了三大类。

室内环境

这类环境主要模拟家庭、办公室等封闭空间，代表作有 AI 2-THOR、iGibson、Habitat 等。

特点：通常基于现有的 3 D 资产和物理引擎构建，强调精细的物理交互。
优点：
- 物理规则严密：物体有明确的碰撞体积，重力、摩擦力计算精确。
- 交互深度高：智能体可以执行“打开微波炉”、“拿起苹果放进冰箱”等复杂的细粒度操作。
缺点：
- 多样性受限：由于需要人工建模，房间的数量、家具的种类非常有限，容易让智能体产生过拟合（换个没见过的沙发就不认识了）。
- 真实感不足：渲染出来的画面往往带有明显的“游戏塑料感”，导致在模拟器里训练好的机器人，放到真实世界中会因为视觉差异而失效。
适应性：最适合训练家用服务机器人、机械臂的抓取与操作，以及室内视觉导航。

室外环境

这类环境的尺度大幅扩张，涵盖城市街道、大自然，甚至像 Minecraft（我的世界）这样的开放沙盒世界。代表作有 CARLA（自动驾驶神级模拟器）、MetaUrban、MineDOJO。

特点：场景宏大，包含复杂的动态元素（如其他车辆、行人、天气变化）。
优点：
- 任务复杂度高：能够测试智能体的长视距规划能力，比如在城市中从 A 点导航到 B 点，或者在野外收集资源生存。
- 多智能体博弈：包含了海量的其他动态 NPC，环境是不断变化的。
缺点：
- 计算开销极其庞大：实时渲染一座城市的物理光影和海量实体的运动，需要巨大的算力。
- 长尾场景模拟难：传统的室外模拟器很难穷尽现实中的极端情况（比如马路上突然窜出一只骆驼），导致自动驾驶系统的安全性验证遇到瓶颈。
适应性：最适合自动驾驶算法的验证、无人机无碰撞飞行训练，以及开放世界游戏 AI 的开发。

动态生成环境

这是目前最前沿的世界模型探索方向。它抛弃了传统的 3 D 建模，直接用大模型（如 Diffusion Models）通过纯数据驱动的方式“脑补”出环境。代表作有 UniSim、Pandora。

特点：输入文本提示或动作指令，神经网络直接生成对应的视频帧作为环境反馈。
优点：
- 无限的场景多样性：只要互联网上有过这种数据，它就能生成。它可以轻易生成火灾现场、暴风雪中的街道等传统引擎极难搭建的极端长尾场景。
- 超高的真实感：生成的画面是照片级的，极大地缩小了 Sim-to-Real 的视觉差距。
缺点：
- 物理幻觉：目前最大的痛点。因为它本质上是在猜像素，所以经常会生成“穿模”的画面，或者物体凭空消失、违背几何透视原理。
- 缺乏底层 3D 结构：它往往只生成了 2D 的画面流，没有真实的 3D 碰撞箱，智能体很难在里面进行极其精确的物理抓取操作。
- 长期记忆差：智能体在这个生成的环境里转了一圈回到原地，模型可能已经把原来的房间生成成了别的样子。
适应性：非常适合让智能体在海量、极端、不可预测的场景中进行泛化性测试，以及用于自动驾驶的纯视觉感知训练
近期改善方案：为了缓解动态生成时的“穿模”和不符合物理规律的问题，近期研究开始在视频生成中融入几何和物理特征。例如，Aether 引入相机轨迹作为条件；TesserAct 加入了法线贴图；Roboscape 整合了深度图和关键点动态。这些方法显著提升了动态生成环境的真实感和物理依从性。

落地应用与前沿挑战

四大核心落地应用

生成式游戏

现状：传统的游戏需要程序员和美术写死所有的代码和贴图。而现在的世界模型（如 Google 的 Genie 或是最近爆火的 Oasis）可以直接从无标签的互联网视频中学习。
应用：玩家只需要给出一张草图或者输入动作指令，模型就能实时生成下一帧的游戏画面，并且保证角色的动作和背景的物理交互是合理的。它本质上是在“边玩边生成”整个游戏世界。

自动驾驶

痛点：在真实马路上训练自动驾驶汽车太危险，且很难遇到极端的“长尾场景”（比如前方大卡车突然掉下几十只鸭子）。
应用：世界模型（如 Wayve 的 GAIA-1）可以通过输入“天气变恶劣”、“前车急刹”等文本提示或操作指令，生成极度逼真的第一人称/鸟瞰图（BEV）驾驶视频。这相当于给自动驾驶系统打造了一个绝对安全的“终极驾校”。

机器人与具身智能

痛点：直接让机器人在现实中试错，很容易把昂贵的机械臂搞坏。
应用：机器人可以在世界模型构建的“梦境”中进行千万次的抓取、导航模拟。论文中提到了诸如 DayDreamer 这样的算法，让机器人在虚拟的物理沙盒中学会了复杂的控制策略。

社会模拟

现状：不仅是模拟物理法则，大语言模型的崛起让模拟“人类社会法则”成为可能。
应用：在著名的“斯坦福生成式小镇”实验中，多个基于 LLM 的智能体被放入一个沙盒社区中。它们不仅拥有记忆，还会互相交流、举办派对、甚至传播八卦。这种包含了“心智理论”的世界模型，未来会被大量应用于经济学政策的推演、社会学的群体行为研究。

世界模型的两大部署角色

从系统架构和交互方式来看，世界模型的功能可以被高度抽象为两种主要角色：

作为云端环境：通常表现为视频生成系统，利用海量算力生成高质量、海量的多模态数据。它的作用是作为“数据引擎”来扩充真实数据，或者作为强化学习的“虚拟训练场”和策略评估器，让智能体在其中无风险地试错。
作为端侧大脑：通常不需要生成底层的视觉像素，而是在潜在空间（latent space）中压缩世界状态（如 V-JEPA 2）。它们部署在智能体内部，通过内部推演进行实时、低延迟的动作规划与决策。

前沿挑战与未解之谜

尽管世界模型看起来无所不能，但论文非常坦诚地指出了目前阻碍其走向通用人工智能的几座大山。

物理规则与反事实模拟

核心痛点：世界模型的一个关键目标是捕捉环境的因果结构和底层物理规则，以便能够进行数据分布外的反事实推理（例如“如果发生从未见过的极端情况会怎样”）。然而，目前纯数据驱动的大规模生成模型（如 Sora）虽然能生成极其逼真的画面，但在重力、流体动力学等物理法则上经常失效。这表明它们依赖的是“基于案例”的泛化，而非真正学到了“基于规则”的底层物理定律。
未来方向：学术界越来越看好“混合架构”。即把基于第一性原理的传统物理引擎与生成模型结合起来（例如 Genesis 和 PhysGen 框架），或者在扩散模型训练时加入偏微分方程（PDE）等物理知识的软约束。这种“硬结合+软约束”的设计可以在不牺牲逼真度的前提下，提升模型对物理规律的遵循能力和可解释性。

丰富社会维度

核心痛点：一个高级的世界模型仅能模拟物理环境是不够的，人类行为和社会交互在诸多重要场景（如城市环境）中同样起着决定性作用。然而，如何让智能体模拟出全面且真实的人类行为和社会互动，仍是一个未解之谜。
未来方向：未来的研究需要将人类行为模式和认知过程的相关理论，融入到大语言模型智能体的工作流设计中。此外，目前评估生成人类行为的真实性仍然高度依赖主观的人工评估，这种方式很难扩展到大规模的世界模型中。因此，开发可靠且可扩展的评估方案是另一个重要方向。

基准测试的混乱与统一

核心痛点：目前评估世界模型非常困难，因为学术界在目标（学习内部表示 vs. 预测未来世界）、技术路线（LLM 智能体 vs. 视频扩散模型）以及应用领域上存在巨大分歧，导致缺乏统一的标准任务或评估指标。
现有探索与未来方向：业界正在积极构建更细致的测试集，主要分为三类：
1. 以视频为中心的模拟：如 VBench-2.0，试图将“看起来真实”与“内在遵循物理和常识”区分开来评估。
2. 物理与空间推理：如 Physics-IQ，发现模型在流体、光学等五大物理领域的理解能力与其视觉逼真度存在严重脱节。
3. 具身决策：如 EAI 和 RoboScape，评估智能体在模拟环境中的任务分解能力，以及策略从模拟迁移到现实时的性能损耗。未来需要建立更加标准化、跨模态的统一基准测试。

通过具身智能连接模拟与现实

核心痛点：在物理世界中训练机器人成本高昂且充满风险。世界模型被视为开发具身智能的关键，因为它能作为一个强大的模拟器，构建全面的环境元素并模拟它们之间的真实关系。
未来方向：必须持续提升生成式 AI 模型的多模态、多任务和 3D 能力。同时，解决长期存在的“模拟到现实差距”至关重要。未来的一个有趣方向是建立生成式世界模型与具身智能体之间的“自我强化循环”——智能体在现实中收集细粒度感知数据反哺模型，模型生成更高质量的虚拟环境再用于训练智能体。

模拟效率

核心痛点：对于无人机控制等复杂应用，高帧率的实时模拟是刚需。但目前大多数大型生成模型（尤其是基于 Transformer 的自回归模型）由于每次只能生成一个 Token，推理速度极慢，成为了算力瓶颈。
未来方向：需要在算法层面上探索大/小模型的结合使用、模型蒸馏技术以及请求的最优调度策略。同时，对于经典的物理模拟，可以探索利用图神经网络等轻量级深度学习模型来高效近似物理系统。最终，要实现实质性的速度飞跃，离不开从底层硬件到编程平台再到 AI 模型的全面协同优化。

伦理与安全隐患

数据隐私：大规模生成模型的训练数据往往庞大且不透明，存在推断和泄露个人隐私信息的风险（特别是在视频生成领域）。未来需要提高模型生命周期的透明度以符合 GDPR 等隐私法规。
模拟不安全场景：生成式 AI 可能会被恶意用户通过“对抗性提示”误导，用于模拟有害场景，从而降低他们策划非法或不道德活动的成本。为世界模型设置强大的安全防护网是当务之急。
问责制：生成超逼真视频和图像的能力加剧了“深度伪造”问题，导致虚假信息的泛滥。由于世界模型能生成连贯的多维输出，检测这些 AI 生成内容的难度将成倍增加。未来需要大力发展数字水印等技术，并配合法律手段，以确保使用世界模型时的可追溯性和问责制。

个人思考

论文中提到学术界越来越看好“混合架构”，即把基于第一性原理的传统物理引擎与生成模型结合起来。这在目前看来，或许是一个看起来非常有效的方法，但是从 The Bitter Lesson 的角度来看，这其实是反 The Bitter Lesson 的。

Rich Sutton 在《The Bitter Lesson》中提出：人类把领域知识（比如物理规律）硬编码进系统，短期内会有效，但长期来看，唯一能持续带来突破的只有算力的提升和基于大数据的通用学习算法。然而，这篇综述通过引用大量近期研究（如 Kang 等人和 Physics-IQ 的评估），指出：“现有的证据表明，单纯依靠数据驱动的规模扩张，不足以恢复稳健的物理定律。”研究人员为了解决自动驾驶和机器人训练的燃眉之急，只能实用主义地选择反 The Bitter Lesson，把物理规则硬加回来。

从更长远的角度来看，导致这个问题的原因我认为主要有两点：

数据本身缺失：2D 视频像素里本来就存在维度坍塌，丢失了 3D 物理的受力、质量等关键因果信息。光靠看视频，数据本身就不包含完整的物理信息，所以必须加入 3D 几何或物理引擎约束。
架构不完善：并不是 Scaling Law 失效了，而是目前的架构（如仅仅为了拟合像素的 Diffusion 架构）或者交互方式不对。如果在未来，智能体在具身环境中产生了海量的“交互-物理反馈”闭环数据，并利用类似 JEPA 这种真正在潜空间做因果推演的架构进行千百倍的扩展，AI 终究有一天能像婴儿一样，不需要写任何偏微分方程，自己通过大数据“摸爬滚打”出牛顿定律。

就目前而言，在那个终极的“通用物理学习架构”出现之前，引入物理先验的混合架构是走向现实应用不可避免且最有效的桥梁。

观《独家对话谢赛宁：逃离硅谷》有感

小yo — Sat, 04 Apr 2026 00:00:05 GMT

世界模型与 LLM

语言只是人类文明的高级产物，它是一种被高度压缩、抽象过的“交流工具”，而非世界的本质。真正的智能或者说世界模型，应该是从真正的世界中学习，而非语言。

但是这个真实的世界，我们需要一种媒介作为输入，视频或许是一个很好的选择，因为视频一定程度是真实世界原貌的客观反映，但是同样的，视频能够蕴含的信息仍然有限，它并不是真实的世界。

同时，虽然是从真实的世界中学习，但是他不应该对同一时刻的所有信息予以相同的注意力，应该有选择地关注与“任务”相关的信息，这也是一种“抽象”，某种程度上也是一种对世界的“表征”。

LLM 并不是 The Bitter Lesson。在我利用 AI 搜索“The Bitter Lesson”的解释的时候，AI 给的举例之一便是 LLM 或者说 NLP 的成功，尤其是 Transformer 或者 ChatGPT。但是正如前边所说，语言本身就是人类的高级产物，而 The Bitter Lesson 本身强调的是，人类“引以为傲”的先验知识，在机器大量的学习面前，不值一提。正如围棋中阿尔法狗的成功一样，研究者曾试图把围棋特有的形状和策略编入程序。但后来的 AlphaGo 及其后继者 AlphaZero，仅仅依靠通用的自我博弈和蒙特卡洛树搜索，辅以海量算力，就彻底颠覆了人类几千年的围棋知识。LLM 之于理想中的世界模型也如此，人类语言就相当于围棋特有的形状和策略，他不是围棋本身，而是基于围棋进一步抽象或者发展出来的高级产物，而理想的世界模型的输入则相当于围棋本身，也即围棋的规则，而世界模型会基于这个规则下，不需要形状和策略等高级产物，而学习出自己的智慧。

即，真正的世界模型，其输入不应是被人类语言高度过滤后的“二手知识”，而应当是连续的、高维的、充满噪音的真实物理世界信号。

LLM 或者说语言模型应该是世界模型的一个部分，或者说一个输出的接口。当世界模型基于真实的世界学习到了真实的表征之后，如果要实现一个语言模型，只需要将这些表征与人类语言进行对齐，作为这些表征一个输出即可。这样这里的语言模型是有对真实世界的认知的，它是对真实的世界的描述，只不过将这些描述“翻译”为了人类语言。而我们现在所使用的 LLM，它的任务或许更像是“搜索引擎”，它可以用来搜索互联网上已有的内容，但无法对真实世界进行描述。

“一个 4 岁小孩看过的视频，量级比所有训练语言大模型的 token 还要大。”这正是我经过弯弯绕绕最终还是选择要尝试世界模型的原因。2023 年暑假，在北大暑期学堂，朱松纯教授关于通用人工智能的讲座我至今无法忘记。当时朱教授讲到，机器可以完成很多人类难以完成的任务（在 2023 暑假 LLM 并不是很火，至少对于高中生的我，这是一个完全未知的事物，所以教授选择的描述是“机器”），但是对于人类儿童在几岁时就能理解的事情，比如一个杯子放在桌边，他可能会掉下来摔碎，机器却无法理解。那时朱教授还为我们展示了一个视频，是两个小球，在“互相追逐打闹”，这在人类看来是这样的，可是实际上，这只是几个像素点在移动，是人类的“大脑”赋予了这些移动的意义。这非常深刻地震撼到了我，激发了我对这种研究的好奇，尽管这些好奇曾一度消磨，但正如谢赛宁说的：“世界模型是所有人会抵达的终点。”

真正的科研

在我初学深度学习的时候，当学习到 ResNet 的时候，我曾极其崇拜何恺明，认为那是天才般的“灵光一现”，是极强直觉带来的完美降维打击。但谢赛宁对何恺明及其自身科研经历的描述，让我意识到我错了。

“如果一个工作最后的呈现和你最初设想的 idea 一模一样，那这往往是一篇最差的、最无聊的论文。”在观看这个视频之前的我看来，科研就是：提出一个绝妙的 idea -> 一步步完美实现它 -> 发表惊世骇俗的 paper。但是谢赛宁的描述说明了这并不是科研的常态。真正的科研从来不是线性的 A 到 B。在长达 6 个月的项目周期里，可能前 5 个月都在不断地试错、推翻、重建，真正的突破往往是在最后几周的迷雾中爆发的。

科研的常态，是在一个大方向下，通过海量的阅读和实验，去进行无尽的“随机梯度下降”。这个过程绝不是直线的。我曾以为大神的成功靠的是灵感，但实际上，正如谢赛宁回忆中的何恺明：他有着极其恐怖的专注力，每天除了思考这一个问题不作他想；他有着极致的工程执行力，为了探究底层的真理，他会亲手搭建 TPU 的基础设施，甚至用精细的 Excel 表格来严控每一个实验变量，从失败的实验中榨取梯度的信号。

“Research 的求索过程，本身就是在一个暗无天日的地方摸索。当你看不见光亮的时候，总是会感到迷茫和沮丧。” 科研是一场反脆弱的游戏，沮丧和试错可能占据了日常的 95%。在这个漫长而苦涩的梯度下降过程中，灵光一现固然重要，但在迷雾中坚定地搭好脚手架、保持对真理的极致渴望与热爱，才是推动我们抵达全局最优解的唯一动力。

《AlignedGen》论文精读

小yo — Tue, 10 Mar 2026 22:38:15 GMT

前置知识与研究背景

Flux

虽然学术界依然习惯性地把 Flux、SD3 这些模型统称为“扩散模型”，但是它们的底层逻辑早就完成了换血。

从最原始的 DiT 到现在的 FLUX，主要发生了两大根本性的跃迁：

数学逻辑的跃迁

原始 DiT：基于 DDPM

我们熟悉的原始 DiT，其背后的数学框架是马尔可夫链。在 DDPM 中，把一张清晰的图片变成纯噪声，是一步一步加高斯噪声的过程。这个过程受到复杂方差表的控制，它在数据空间中划出的是一条充满随机性的、弯曲的轨迹。因此，计算公式里必然带有 αˉt\sqrt{\bar{\alpha}_t}αˉt 和 1−αˉt\sqrt{1 - \bar{\alpha}_t}1−αˉt 这样的非线性项。

FLUX：基于Rectified Flow/流匹配

FLUX 抛弃了马尔可夫链，转而采用了常微分方程 (ODE) 的视角。 Rectified Flow 的核心哲学非常暴力且优雅：既然我们要从噪声走到图像，为什么非要走弯路？直接用一条绝对笔直的直线把纯噪声分布和真实图像分布连起来就好了。

因此，FLUX 的前向过程就是极其简单的线性插值：

xt=t⋅ϵ+(1−t)⋅x0x_t = t \cdot \epsilon + (1-t) \cdot x_0xt=t⋅ϵ+(1−t)⋅x0

模型训练的目标也不再是“预测噪声”，而是直接预测这条直线上的“速度矢量 ”。

采样器工作流程：

起点：采样器首先从标准高斯分布中随机抽取一个纯噪声点 (xTx_TxT)。
预测速度：将当前的噪声点和时间步 ttt 输入给 FLUX 模型，模型会预测出一个指向目标图像的“速度”或“方向”。
迈出一步：采样器利用数值 ODE 求解器（如最简单的欧拉方法 Euler Method），顺着模型预测的速度方向，向前迈出一步，得到一个稍微清晰一点的潜变量 (xt−1x_{t-1}xt−1)。
循环迭代：重复上述过程，直到走完全部的时间步，最终抵达清晰的图像 (x0x_0x0)。

采样步骤：因为 Rectified Flow 的路径被“整流”得非常直，采样器在顺着速度方向前进时不容易偏离轨道。相比于传统 DDPM 动辄需要 100 甚至 1000 步才能保证图像质量，Rectified Flow 允许采样器迈出更大的步伐（更大的 Step Size）。因此，在保证极高图像质量的前提下，可以大大提升推理速度。

架构设计的跃迁

原始 DiT：模态隔离

在原始的 DiT 中，文本和图像在模型内部是相对隔离的。Transformer Block 主要处理图像 token 的自注意力，而文本条件通常是作为额外的控制信号，通过 AdaLN（自适应层归一化）或者单独的交叉注意力注入进去。

FLUX：多模态统一

FLUX 采用了 MM-DiT（Multi-Modal DiT）架构，实现了真正的模态融合。它把文本和图像全都拉平变成一维的 token，然后直接在序列维度上拼接起来，送入统一的多模态注意力模块（MM-Attention）里混合计算。

多模态注意力机制

输入表示：模型同时接收潜在图像 token 序列 X∈RN×dX \in \mathbb{R}^{N \times d}X∈RN×d 和文本条件 token 序列 C∈RM×dC \in \mathbb{R}^{M \times d}C∈RM×d 。
特征投影：图像和文本 token 会通过各自的投影矩阵进行映射，得到对应的 Query、Key 和 Value 。具体公式如下：

{Q,K,V}img=Wimg{Q,K,V}X,{Q,K,V}img∈RN×dk\{Q, K, V\}_{img} = W_{img}^{\{Q, K, V\}}X, \quad \{Q, K, V\}_{img} \in \mathbb{R}^{N \times d_k}{Q,K,V}img=Wimg{Q,K,V}X,{Q,K,V}img∈RN×dk

{Q,K,V}txt=Wtxt{Q,K,V}C,{Q,K,V}txt∈RM×dk\{Q, K, V\}_{txt} = W_{txt}^{\{Q, K, V\}}C, \quad \{Q, K, V\}_{txt} \in \mathbb{R}^{M \times d_k}{Q,K,V}txt=Wtxt{Q,K,V}C,{Q,K,V}txt∈RM×dk
统一计算：接着，这些投影后的特征会在序列长度维度上拼接在一起，形成完整的 QQQ、KKK 和 VVV，维度变为 (M+N)×dk(M+N) \times d_k(M+N)×dk 。最后进行标准的注意力计算：

Attention(Q,K,V)=Softmax(QKTdk)VAttention(Q, K, V) = Softmax(\frac{QK^T}{\sqrt{d_k}})VAttention(Q,K,V)=Softmax(dkQKT)V

核心推论：在 MM-Attention 中，图像和文本信息在注意力计算阶段就深度混合在了一起。

Double Block vs. Single Block

同时，Flux 模型里包含Double Block 和 Single Block 两种模块，如我们在 CharaConsist 里讨论的一样，并且这种架构差异对 AlignedGen 的效果产生了决定性的影响。

在论文的消融实验（Ablation Study）部分，作者为了寻找植入 AlignedGen 方法的最佳位置，将 Flux.1-dev 的区块划分为了三个组。

Group 1：前 19 个 Double Blocks（对应层数 [0, 19)）。
Group 2：前 19 个 Single Blocks（对应层数 [19, 38)）。
Group 3：剩余的 19 个 Single Blocks（对应层数 [38, 57)）。

作者通过实验发现，扩散模型中不同的层承担着不同的功能职责。

负面影响：如果将注意力共享机制应用在 Group 1（即 Double Blocks）中，不仅没有效果，反而会破坏风格一致性。
正面影响： Group 2（早期的 Single Blocks）对于捕捉风格信息最为关键。
最终方案（层选择性应用）：为了在“文本-图像对齐”和“风格一致性”之间取得最佳平衡，AlignedGen 最终决定完全避开 Double Blocks，独占性地将方法应用在所有的 Single Blocks（即 Group 2 和 Group 3，对应层数 [19, 57)）中

2D 旋转位置编码 RoPE

Transformer 架构本身是“排列不变”的，它不知道 token 在序列中的先后顺序或空间位置，因此必须显式地注入位置信息。

论文中提到 RoPE 为单张图像的 h×wh \times wh×w 潜在网格中的每个 token 提供了唯一的空间坐标 (i,j)(i, j)(i,j)。在处理二维图像时，2D RoPE 的核心思想是将一维的 RoPE 分别独立地应用在图像的 YYY 轴（高度）和 XXX 轴（宽度）上。

坐标注入过程

假设一个 token 的空间坐标为 (i,j)(i, j)(i,j)，其对应的 Query 向量为 q∈Rdq \in \mathbb{R}^dq∈Rd。具体注入坐标的过程如下：

第一步：特征维度拆分

将 ddd 维的向量 qqq 平分为两半，前一半 qy∈Rd/2q_y \in \mathbb{R}^{d/2}qy∈Rd/2 用于编码高度信息（行坐标 iii），后一半 qx∈Rd/2q_x \in \mathbb{R}^{d/2}qx∈Rd/2 用于编码宽度信息（列坐标 jjj）。

第二步：定义基础旋转频率

定义频率序列，其中 k∈[0,d/4−1]k \in [0, d/4 - 1]k∈[0,d/4−1]：

θk=10000−2kd/2\theta_k = 10000^{-\frac{2k}{d/2}}θk=10000−d/22k

第三步：分别应用二维旋转

对于 YYY 轴的向量 qyq_yqy，我们使用行坐标 iii 作为一个标量位置，对向量中相邻的特征对 (qy,2k,qy,2k+1)(q_{y, 2k}, q_{y, 2k+1})(qy,2k,qy,2k+1) 进行二维旋转矩阵相乘：

(q~y,2kq~y,2k+1)=(cos⁡(iθk)−sin⁡(iθk)sin⁡(iθk)cos⁡(iθk))(qy,2kqy,2k+1)\begin{pmatrix} \tilde{q}_{y, 2k} \\ \tilde{q}_{y, 2k+1} \end{pmatrix} = \begin{pmatrix} \cos(i\theta_k) & -\sin(i\theta_k) \\ \sin(i\theta_k) & \cos(i\theta_k) \end{pmatrix} \begin{pmatrix} q_{y, 2k} \\ q_{y, 2k+1} \end{pmatrix}(q~y,2kq~y,2k+1)=(cos(iθk)sin(iθk)−sin(iθk)cos(iθk))(qy,2kqy,2k+1)

同理，对于 XXX 轴的向量 qxq_xqx，我们使用列坐标 jjj 施加旋转：

(q~x,2kq~x,2k+1)=(cos⁡(jθk)−sin⁡(jθk)sin⁡(jθk)cos⁡(jθk))(qx,2kqx,2k+1)\begin{pmatrix} \tilde{q}_{x, 2k} \\ \tilde{q}_{x, 2k+1} \end{pmatrix} = \begin{pmatrix} \cos(j\theta_k) & -\sin(j\theta_k) \\ \sin(j\theta_k) & \cos(j\theta_k) \end{pmatrix} \begin{pmatrix} q_{x, 2k} \\ q_{x, 2k+1} \end{pmatrix}(q~x,2kq~x,2k+1)=(cos(jθk)sin(jθk)−sin(jθk)cos(jθk))(qx,2kqx,2k+1)

最后，将经过坐标 iii 旋转的 q~y\tilde{q}_yq~y 和经过坐标 jjj 旋转的 q~x\tilde{q}_xq~x 重新拼接起来，就得到了注入了二维空间坐标 (i,j)(i, j)(i,j) 信息的完整 Query 向量。

计算过程

从 1D RoPE 推导内积的相对性

为了清晰起见，我们先用 1D 序列（一维位置 mmm 和 nnn）来推导，随后再扩展到 2D。

在注意力机制中，核心操作是计算 Query 和 Key 的点积（内积）以获得注意力分数：Score=qTkScore = q^T kScore=qTk。

假设我们在位置 mmm 有一个 Query 向量 qqq，在位置 nnn 有一个 Key 向量 kkk。注入 RoPE 本质上是对向量乘以一个正交的旋转矩阵 RmR_mRm（这里的旋转角度由位置 mmm 和预设的频率 θ\thetaθ 决定）。

注入 RoPE 后的注意力分数计算如下：

Score=(Rmq)T(Rnk)Score = (R_m q)^T (R_n k)Score=(Rmq)T(Rnk)

根据矩阵转置的性质 (AB)T=BTAT(AB)^T = B^T A^T(AB)T=BTAT，上式展开为：

Score=qTRmTRnkScore = q^T R_m^T R_n kScore=qTRmTRnk

因为 RmR_mRm 是正交旋转矩阵，它的转置等于它的逆向旋转（即向反方向转），所以 RmTRnR_m^T R_nRmTRn 相当于先往回转 mmm 的角度，再往前转 nnn 的角度。在数学上，这完美等价于一个仅与相对距离 (n−m)(n - m)(n−m)相关的旋转矩阵 Rn−mR_{n-m}Rn−m：

Score=qTRn−mkScore = q^T R_{n-m} kScore=qTRn−mk

推论： 经过 RoPE 处理后，Query 和 Key 之间的注意力分数，仅仅取决于它们各自的内容（qqq 和 kkk）以及它们之间的相对位置差 (n−m)(n-m)(n−m)，而与它们所在的绝对位置无关。

扩展到 2D RoPE 的计算过程

在图像生成中，位置变成了二维坐标。假设 Query 的坐标是 (i,j)(i, j)(i,j)，Key 的坐标是 (u,v)(u, v)(u,v)。

正如我们前面提到的，2D RoPE 是将向量对半拆分，一半处理行坐标（Y轴），一半处理列坐标（X轴）。点积也自然地分成了两部分之和：

Score=qyTRu−iky+qxTRv−jkxScore = q_y^T R_{u-i} k_y + q_x^T R_{v-j} k_xScore=qyTRu−iky+qxTRv−jkx

这里，Ru−iR_{u-i}Ru−i 是由行坐标差值 Δy=u−i\Delta y = u - iΔy=u−i 决定的旋转矩阵，而 Rv−jR_{v-j}Rv−j 是由列坐标差值 Δx=v−j\Delta x = v - jΔx=v−j 决定的旋转矩阵。

2D RoPE 的意义： 模型在计算图像中任意两个 patch 的注意力时，会天然地感知到它们在垂直方向差了多少行（Δy\Delta yΔy），在水平方向差了多少列（Δx\Delta xΔx）。如果 Δy=0\Delta y = 0Δy=0 且 Δx=0\Delta x = 0Δx=0（即在同一个位置），旋转矩阵就会变成单位矩阵，此时注意力分数完全由内容相似度主导，并且往往会获得极大的权重加成。

StyleAligned

StyleAligned 是这篇论文直接对标的重要前置工作。

StyleAligned 是一种免训练的图像生成方法，最初是为基于 U-Net 架构的扩散模型（如 SDXL）设计的，目的是在给定相同风格提示词的情况下，保持生成图像序列之间的风格一致性。

它的核心原理可以概括为：在自注意力层中进行“注意力共享（Attention Sharing）。

参考与目标特征的定义

在生成过程中，StyleAligned 采用了“参考-目标（reference-target）”策略。它将其中一张生成的图像指定为“风格参考图像（Reference）”，并强制其余的“目标图像（Target）”在风格上与其对齐。

在自注意力层中，这就表现为区分两组特征：

参考特征： QrefQ^{ref}Qref, KrefK^{ref}Kref, VrefV^{ref}Vref
目标特征： QtarQ^{tar}Qtar, KtarK^{tar}Ktar, VtarV^{tar}Vtar

核心操作：自适应实例归一化 (AdaIN)

为了让目标图像的查询（Query）和键（Key）在统计分布上贴近参考图像，StyleAligned 引入了自适应实例归一化（Adaptive Instance Normalization, AdaIN）操作。

AdaIN 的数学定义如下，它的作用是将输入 xxx 的均值 μ\muμ 和标准差 σ\sigmaσ 强行对齐到目标 yyy 的分布上：

AdaIN(x,y)=σ(y)(x−μ(x)σ(x))+μ(y)AdaIN(x,y)=\sigma(y)\left(\frac{x-\mu(x)}{\sigma(x)}\right)+\mu(y)AdaIN(x,y)=σ(y)(σ(x)x−μ(x))+μ(y)

实例归一化（IN）：在图像特征图（Shape 通常为 [Batch, Channel, Height, Width]）中，实例归一化是独立地对每一个样本（Instance）的每一个通道（Channel）进行归一化。它计算单个通道内所有空间像素的均值和方差。在计算机视觉中，特征的“空间结构（Height, Width）”通常代表内容，而“通道的全局统计量（均值和方差）”通常代表风格（颜色、对比度、笔触纹理等）。因此，IN 常用于抹去图像的原始风格。

为什么 StyleAligned 使用 AdaIN？ 因为它的核心目标是风格对齐。通过对 Query 和 Key 应用 AdaIN，它在不改变目标图像空间内容的前提下，强行将目标图像的“风格分布”拉到了参考图像所在的特征空间。

注意力共享的数学重构

在生成目标图像的自注意力计算阶段，StyleAligned 对原始的 QtarQ^{tar}Qtar, KtarK^{tar}Ktar, VtarV^{tar}Vtar 进行了深度改造，这在本文中被称为“朴素注意力共享（Naive Attention Sharing）” 。

具体步骤如下：

重构 Query (QQQ)：通过 AdaIN 将目标 Query 的分布对齐到参考 Query，形成最终的查询矩阵 QFQ^{F}QF 。

QF=AdaIN(Qtar,Qref)Q^{F}=AdaIN(Q^{tar},Q^{ref})QF=AdaIN(Qtar,Qref)
重构 Key (KKK)：首先使用 AdaIN 处理目标 Key 得到 K^tar\hat{K}^{tar}K^tar，然后将其与参考 Key 在序列维度上进行拼接，形成最终的键矩阵 KFK^{F}KF 。

K^tar=AdaIN(Ktar,Kref)\hat{K}^{tar}=AdaIN(K^{tar},K^{ref})K^tar=AdaIN(Ktar,Kref)

KF=Concat(K^tar,Kref)K^{F}=Concat(\hat{K}^{tar},K^{ref})KF=Concat(K^tar,Kref)

为什么 K^tar\hat{K}^{tar}K^tar 还要再和 KrefK^{ref}Kref 拼接？这里有一个常见的直觉误区：K^tar\hat{K}^{tar}K^tar 里边并没有包含参考图像的“具体内容”或“局部特征”。

K^tar\hat{K}^{tar}K^tar 的本质是什么？它依然是目标图像的 Key 特征，只是它的“全局统计量（亮暗、色调）”被 AdaIN 修改得像参考图像了。如果目标图像画的是一棵树，K^tar\hat{K}^{tar}K^tar 编码的依然是树的轮廓和位置，只是披上了一层参考图像的“滤镜”。

为什么要拼接 KrefK^{ref}Kref？在注意力机制中，目标 Query (QFQ^FQF) 要去和 Key (KFK^FKF) 计算相似度，从而提取对应的 Value (VFV^FVF)。

为了维持自身内容：目标图像需要生成自己的文本描述内容（比如一棵树），所以 QFQ^FQF 必须去关注 K^tar\hat{K}^{tar}K^tar，从而提取目标图像自己的 VtarV^{tar}Vtar 。

为了借用极致的风格细节：仅仅靠分布对齐（AdaIN）是不够的，如果参考图像里有某种非常独特的细腻笔触、水彩的晕染边缘或者特定的几何纹理，目标图像必须能够直接去查询参考图像的具体像素位置。因此，必须把原汁原味的 KrefK^{ref}Kref（以及对应的 VrefV^{ref}Vref）拼接进去。

重构 Value (VVV)：直接将目标 Value 与参考 Value 在序列维度上进行拼接，形成最终的值矩阵 VFV^{F}VF 。

VF=Concat(Vtar,Vref)V^{F}=Concat(V^{tar},V^{ref})VF=Concat(Vtar,Vref)

实际应用

在目标图像的实际生成过程中，原本自注意力层应该使用的 Query、Key 和 Value 会被替换为上述重构后的 QFQ^{F}QF, KFK^{F}KF 和 VFV^{F}VF 。

这种机制的意义在于：目标图像在计算注意力时，不仅可以“看到”自己当前的特征，还可以直接“看到”并“借用”参考图像的 Key 和 Value。因为 Query 和 Key 的分布被 AdaIN 对齐了，目标图像的各个部分会自然而然地去关注参考图像中具有相似语义特征的区域，从而在不改变自身主体内容的前提下，将参考图像的“画风（纹理、色彩、笔触等）”搬运过来。

核心问题剖析

朴素注意力共享

我们在上一节讨论的 StyleAligned 中的注意力机制在论文中被称为“朴素注意力共享”，然而，这种设计是显式地针对 U-Net 的自注意力层（仅处理图像 token）开发的。当它被简单粗暴地移植到 DiT 架构的统一多模态注意力（MM-Attention）中时，它不仅在架构上不兼容，还会因为与 2D RoPE 产生的“位置冲突”，导致严重的伪影、文本控制力丧失以及完全的模式崩塌。

位置冲突

在前边我们推导过，2D RoPE 会根据 token 所在的二维坐标 (i,j)(i, j)(i,j) 来计算相对距离。当 AlignedGen 的作者尝试将“朴素注意力共享”直接应用到 DiT 时，他们发现了一个致命的逻辑漏洞：

坐标重叠： RoPE 为单张图像的潜在网格中的每个 token 提供独特的空间坐标 (i,j)(i, j)(i,j) 。但是，当我们将目标图像的特征和参考图像的特征直接拼接在一起时，朴素的共享方案无意中为两张图像中相同坐标 (i,j)(i, j)(i,j) 的 token 分配了完全相同的位置嵌入。
这种重合引发了严重的错误偏差。模型在计算注意力时发现两者的相对距离为零，于是强迫目标图像的 token 不成比例地去极度关注参考图像中空间位置完全相同的对应点。
结果：这种僵硬的空间绑定完全无视了图像本身的内容或文本提示词的引导。正如论文中图 2(c) 所示，生成的图像丧失了文本控制力，出现了严重的内容泄漏，所有的生成结果都变成了参考图像的完美复制品。论文图 4 中的定量分析也证实了这一点，RoPE 的注意力被死板地限制在了绝对相同的查询坐标点上。

核心创新机制

偏移位置编码（ShiftPE）

为了解决由坐标重合引起的冲突，作者提出了一种极其简单但极其优雅的解决方案：偏移位置编码(Shifted Position Embedding, ShiftPE)。

核心思想： 确保参考图像和目标图像占据完全不同且互不重叠的坐标空间。
具体操作： 在数学上，ShiftPE 相当于把参考图像虚拟地放置在目标图像的“旁边” 。如果图像的宽度是 www，它直接将参考图像的横坐标索引从 (i,j)(i, j)(i,j) 重新映射为 (i,j+w)(i, j+w)(i,j+w) 。
为什么有效？ 这个简单的加法操作彻底打破了空间依赖关系。现在，目标图像 (0,0)(0, 0)(0,0) 位置的 token 和参考图像原本 (0,0)(0, 0)(0,0) 位置的 token，相对距离变成了 Δx=w\Delta x = wΔx=w。空间坐标被解耦了，内容泄漏自然就被消除了。
注意力重塑： 如图 4 所示，ShiftPE 让模型不再死盯着单一的重合坐标点，而是允许注意力广泛地分布在更广阔、语义更相关的区域上。这使得注意力机制终于被“解放”出来，去关注真正具有高度语义和风格相关性的区域，而不是被死板的空间对应关系所束缚。

为什么选择线性加法操作

如果仅仅为了“打破重合”，理论上我们有很多种操作可以选择（比如给参考图像分配完全随机的坐标、或者干脆去掉它的位置编码）。但作者最终选择最简单的线性加法（将横坐标映射为 j+wj+wj+w），是因为这个操作在数学和物理意义上都达到了极其巧妙的平衡。我们可以从以下四个维度来理解为什么它是“最优解”：

完美保持参考图像的“内部结构”

RoPE 的核心在于相对距离。如果我们随机打乱参考图像的坐标，参考图像内部各个 token 之间的相对距离就会崩坏，模型就认不出那是一张完整的图了。

使用加法偏移 j+wj+wj+w，对于参考图像内部的任意两个像素 AAA 和 BBB 来说，它们的新坐标都加上了 www。当计算它们内部的相对距离时，这个 www 会被完美抵消掉（即 (jB+w)−(jA+w)=jB−jA(j_B + w) - (j_A + w) = j_B - j_A(jB+w)−(jA+w)=jB−jA）。这意味着参考图像内部的语义和空间结构被 100% 完好无损地保留了下来。

物理意义：模拟自然的“画幅拼接”

给横坐标加上图像的宽度 www，在物理意义上等价于将参考图像虚拟地放置在目标图像的“旁边” 。这就像是在一个更宽的画布上，左边画目标图像，右边贴着参考图像。预训练的 Flux 模型在训练时经常处理各种宽高比和尺寸的图像，它对这种“并排排列”的空间关系有着天然的适应能力。

避免触发“分布外 (OOD)”的注意力异常

你可能会想，为什么不加一个极大的数字，比如 j+10000j + 10000j+10000，让它们离得越远越好？

如果这样做，目标图像和参考图像之间的相对距离会变得异常巨大。预训练的 DiT 模型在训练阶段从未见过如此巨大的相对距离，这属于严重的“分布外（Out-of-Distribution）”数据。输入这样的距离会导致 RoPE 的旋转矩阵产生不可预知的行为，使得 Attention 计算出的相似度要么趋近于 0，要么产生极其诡异的极值，最终破坏特征的提取。紧贴着加一个 www，是一个模型绝对觉得“安全且熟悉”的距离。

极致的计算效率（免训练框架的初衷）

AlignedGen 作为一个“免训练”的方法，其最大的卖点就是在不增加额外模块或微调成本的情况下，直接利用现有的千亿参数大模型。加法操作在张量运算中几乎是零成本的，它不需要引入任何复杂的映射网络，兼顾了优雅与极速。

高级注意力共享（AAS）

解决了“位置冲突”这个最底层的架构 Bug 之后，AlignedGen 框架其实就已经可以跑通了。但是，为了追求极致的生成质量，作者并没有止步于此。

AAS 是一套专门为 DiT（如 Flux）量身定制的“精加工”技巧，包含三个核心操作。

痛点：正如我们前边讨论的，Flux 的 MM-Attention 会把文本 token 和图像 token 拼接在一起处理。如果我们像传统的注意力共享那样，把参考图像的所有 Key 和 Value 都无脑借过来，就会发生致命的提示词污染。

举个例子： 参考图像的提示词是“狗”，目标图像的提示词是“飞机”。如果把包含“狗”文本信息的 Key 也共享过去，目标图像在生成时就会精神错乱，原本该画飞机的地方可能会画出带有狗特征的奇怪物体。

解决方案：非常精准的“外科手术”。作者提出，仅仅共享来源于图像 token 的 Key 和 Value 。文本 token 各用各的。
数学表达：

经过选择性截断后，拼接公式变成了：

Q^imgtar=AdaIN(Qimgtar,Qimgref)\hat{Q}^{tar}_{img}=AdaIN(Q^{tar}_{img},Q^{ref}_{img})Q^imgtar=AdaIN(Qimgtar,Qimgref)

QF=Concat(Qtxttar,Q^imgtar)∈R(M+N)×dkQ^F = Concat(Q_{txt}^{tar}, \hat{Q}_{img}^{tar})\in \mathbb{R}^{(M+N) \times d_k}QF=Concat(Qtxttar,Q^imgtar)∈R(M+N)×dk

K^imgtar=AdaIN(Kimgtar,Kimgref)\hat{K}^{tar}_{img}=AdaIN(K^{tar}_{img},K^{ref}_{img})K^imgtar=AdaIN(Kimgtar,Kimgref)

KF=Concat(Ktxttar,K^imgtar,Kimgref)∈R(M+2N)×dkK^F = Concat(K_{txt}^{tar}, \hat{K}_{img}^{tar}, K_{img}^{ref})\in \mathbb{R}^{(M+2N) \times d_k}KF=Concat(Ktxttar,K^imgtar,Kimgref)∈R(M+2N)×dk

VF=Concat(Vtxttar,Vimgtar,Vimgref)∈R(M+2N)×dkV^F = Concat(V^{tar}_{txt}, V_{img}^{tar}, V_{img}^{ref}) \in \mathbb{R}^{(M+2N) \times d_k}VF=Concat(Vtxttar,Vimgtar,Vimgref)∈R(M+2N)×dk

这样一来，目标图像既能完美接收参考图像的“视觉风格”，又不会被参考图像的“文本语义”带偏。

通过 Key 缩放控制风格一致性 (Key Scaling)

痛点：有时候我们希望风格稍微弱一点，保留更多目标图像的自然感；有时候又希望风格极其强烈。我们需要一个“旋钮”来控制风格注入的强度。
解决方案：作者在拼接参考图像的 KimgrefK_{img}^{ref}Kimgref 之前，乘上了一个标量缩放因子 λ\lambdaλ 。
数学原理：注意力分数的计算是 Softmax(QKTdk)Softmax(\frac{QK^T}{\sqrt{d_k}})Softmax(dkQKT)。如果放大参考图像的 Key（即 λ>1\lambda > 1λ>1），那么在计算点积时，目标 Query 与参考 Key 的内积结果就会变大。经过 Softmax 操作后，模型就会被迫分配更多的注意力权重给参考风格。

KF=Concat(Ktxttar,K^imgtar,λ⋅Kimgref)K^F = Concat(K_{txt}^{tar}, \hat{K}_{img}^{tar}, \lambda \cdot K_{img}^{ref})KF=Concat(Ktxttar,K^imgtar,λ⋅Kimgref)

(论文的消融实验表明，通常将 λ\lambdaλ 设置为 1.1 可以在文本对齐和风格一致性之间取得最佳平衡。)

层选择性应用 (Layer-Selective Application)

痛点：扩散模型中不同的网络层有着明确的分工。如果把上述的注意力共享应用到所有的网络层，生成的图像会出现严重的语义伪影和不自然。
解决方案：通过大量实验，作者发现 Flux 的前 19 层（Double Blocks，组别 1）主要负责构建图像的全局几何结构和空间布局，强行在这里注入风格反而会破坏画面。而中间和靠后的层（Single Blocks，第 19 到 57 层）才是刻画颜色、纹理和风格细节的主战场。
实施：因此，AlignedGen 严格限制，只在 Flux 的 [19, 57) 层替换 MM-Attention 为 ShiftPE 和 AAS 模块。

特征提取过程

AlignedGen 的生成内核我们就完全拆解完毕了！ShiftPE 解决了底层架构的 Bug，而 AAS 则把生成的上限推到了极致。

不过，这里还有一个非常现实的工程挑战：如果作为“参考图像”的那张图，不是由 Flux 自己生成的，而是用户随便上传的一张图，我们该去哪里找它的 QQQ、KKK、VVV 特征呢？

作者在Algorithm 1 中展现了从外部图像提取并缓存特征的过程

输入 : 用户提供的参考图像 III，总推理步数 TTT 。
输出 : 缓存的注意力特征字典 cached_qkv 。

1: 初始化一个随机噪声: noise ~ N(0,1)
2: latent = vae_encode(I)
3: cached_qkv = {}
4: for t = T down to 0 do
5:     noise_input = (t/T) * noise + (1 - t/T) * latent  // 模拟加噪过程
6:     Q_t, K_t, V_t = DiT(noise_input, t, others)
7:     cached_qkv[t] = (Q_t, K_t, V_t)
8: end for
9: return cached_qkv

核心步骤详细拆解

步骤 1-2：降维与初始化

扩散模型并不是直接在像素空间运算的。算法首先使用 VAE (变分自编码器) 将用户提供的高清图像 III 压缩到潜空间，得到干净的潜在表示 latent 。同时，准备一个纯随机的初始噪声 noise 。
步骤 4-5：模拟前向加噪

目标图像的生成是一个从纯噪声 (t=Tt=Tt=T) 逐步降噪到清晰图像 (t=0t=0t=0) 的过程。为了匹配这个过程，算法对参考图像进行了一个反向的“时间匹配”。在任意时间步 ttt，它将初始噪声与干净的 latent 按照特定比例混合，得到一个处于中间状态的带噪潜变量 noise_input 。这个步骤完美模拟了参考图像在标准生成过程中经历的中间状态。
步骤 6-7：无梯度前向传播

这是最关键的一步。把刚刚模拟出来的带噪潜变量 noise_input，连同时间步 ttt 和文本提示词等条件，送入 DiT 模型（如 Flux）。这里不需要进行任何反向传播或模型训练。我们只让模型做一次前向推理，当数据流经我们之前确定的那几个关键层（例如前文提到的 Single Blocks [19, 57) 层）时，我们直接把模型计算出的 Qt,Kt,VtQ_t, K_t, V_tQt,Kt,Vt 截取下来，并存入字典 cached_qkv 中。

通过这个算法，它把参考图像从极其模糊 (t=Tt=Tt=T) 到逐渐清晰 (t=0t=0t=0) 的每一步的风格特征 (Kt,VtK_t, V_tKt,Vt) 都记录在了字典里。等目标图像真正开始一轮一轮降噪生成时，只需要去字典里查表：“我现在降噪到第 151515 步了，请把字典里第 151515 步的参考特征给我拼接一下。”

这种做法完美地绕过了微调网络的巨大计算开销，真正做到了“即插即用”。

实验设计与结果分析

实验设置

为了证明方法的泛化性和实用性，作者的实验设置非常标准化，这对于复现工作非常友好：

基座模型：作者选用了开源的 Flux.1-dev 作为核心骨干模型。结合我们前面学到的高级注意力共享（AAS），作者仅仅在模型的 Single Blocks（即第 [19,57)[19, 57)[19,57) 层）中，将原始的 MM-Attention 替换为了他们设计的 ShiftPE 和 AAS 模块。
采样参数：推理时，使用的是 Rectified Flow 采样器，采样步数（sampling steps）设为 30，无分类器引导比例（CFG scale）设为 3.5 。
- 思考： 这里的参数非常常规，没有为了刷榜而使用极端的采样步数。这意味着该方法具有真正的即插即用特性，计算开销极小，这对于算力资源受限的研究场景来说是个巨大的利好。
评测数据集：为了公平对比，作者直接复用了前置工作 StyleAligned 提供的 100 组提示词集（prompt sets）进行测试。

评价指标体系

做风格迁移或一致性生成，最难的就是“定量评估”，因为风格是一个相对主观的概念。作者使用了三个非常严谨的客观指标来构建评价体系：

文本对齐度 (StextS_{text}Stext)

测什么：生成的图像到底有没有听提示词的话？（比如提示词是飞机，有没有画成狗）。
怎么测：计算生成图像与输入提示词之间的 CLIP 余弦相似度。分数越高，说明图像内容越契合文本描述。

基于 CLIP 的风格一致性 (SstyS_{sty}Ssty)

测什么：同一组生成的几张图片，看起来是不是同一个画风？
怎么测：提取生成的这一组图像的 CLIP 视觉特征向量，然后计算它们两两之间的平均余弦相似度

基于 DINO 的风格一致性 (SdinoS_{dino}Sdino)

测什么：纯粹的视觉风格（笔触、纹理、色彩等），剥离语义内容的干扰。
怎么测：计算这一组图像的 DINO 特征向量的两两平均余弦相似度。
为什么要引入 DINO：作者指出，CLIP 是用“图像-文本对”进行监督训练的，它对物体的语义类别非常敏感。如果两张图都画了一只猫（即使一张是水彩，一张是 3D），CLIP 也可能因为“猫”这个语义标签而给出很高的相似度，这会成为风格评估的“作弊器” 。而 DINO 是通过自监督学习训练的，它不依赖类别标签，因此能更加敏锐、纯粹地捕捉到图像的底层视觉特征（如真实的绘画风格差异）。

DINO： DINO (DIstillation with NO labels) 是由 Meta AI 提出的一种针对视觉 Transformer (ViT) 的自监督学习 (Self-Supervised Learning) 方法。 DINO 完全不需要任何人工标注的标签（No labels）。它通过一种巧妙的“自我博弈”来学习图像的深层特征：

图像裁剪：取同一张图像，对其进行不同的数据增强，裁剪出“全局视角（大图）”和“局部视角（小图）”。

双网络架构：构建两个结构相同的网络——学生网络 (Student) 和老师网络 (Teacher)。

特征匹配：将不同的裁剪图像分别输入给这两个网络。模型强制要求学生网络去预测老师网络的输出分布。由于它们看的是同一张图的不同部分，模型被迫去理解图像内部深层次的纹理、结构和物体边界，而不是简单地记住某个类别。

动量更新：老师网络并不参与反向传播，它的权重是学生网络权重的指数移动平均 (EMA)，这保证了训练的稳定性。

对比实验

为了证明 AlignedGen 的强大，作者挑选了目前市面上最具代表性的 5 个 Baseline 进行了全方位的对比：

经典免训练法： StyleAligned (本文的直接优化对象) 。
主流 Adapter： IP-Adapter (专为 Flux 适配的版本) 。
单图微调法： B-LoRA (基于 LoRA 的微调) 。
大规模数据集驱动法： StyleShot 和 CSGO 。

定性分析 (Figure 8)：

IP-Adapter：难以有效捕捉风格，不仅生成的图像风格不一致，还出现了明显的内容泄漏。
B-LoRA：因为只用一张图训练 LoRA，训练难度极大，导致生成的图像很难抓住参考图的精髓。
StyleAligned：风格一致性尚可，但在大模型下生成的图像视觉质量很差，充满了伪影。
StyleShot & CSGO：虽然是基于大数据集训练的，但经常出现图像重复和视觉伪影的问题。
AlignedGen (Ours)：赢得很彻底，不仅风格高度统一，而且完美契合了文本提示词的要求。

定量分析 (Table 1)：

结合我们在前面讨论的三把评估指标：文本对齐度 (StextS_{text}Stext)、CLIP 风格 (SstyS_{sty}Ssty) 和 DINO 风格 (SdinoS_{dino}Sdino)。如表 1 所示，AlignedGen 在这三个指标上全面霸榜，拿下了最高分。这在数据层面实锤了它在“听懂提示词”和“稳住画风”之间找到了最优解。

消融实验

证明了自己比别人强之后，作者需要回答：“我的模型到底是怎么变强的？”。消融实验 (Table 2) 逐一验证了我们在第二阶段拆解过的核心模块。

为什么要用选择性注意力共享 (SAS)？

做法：对比 Table 2 中的 (k) 组 (无 SAS) 和 (l) 组 (有 SAS) 。
数据结果：拿掉 SAS 后，不仅 SstyS_{sty}Ssty 和 SdinoS_{dino}Sdino 掉了下来，更重要的是 StextS_{text}Stext 也没有提升。
视觉直观 (Figure 9)：如图 9 所示，如果不做选择性共享，提示词污染就会发生。比如明明要求画飞机，模型却被参考图带偏，画出了奇怪的非飞机物体。

为什么要挑层？为什么选 [19, 57)？

作者把 Flux 的网络层分成了三组：Group 1 [0, 19) 的 Double Blocks，Group 2 [19, 38) 的 Single Blocks，和 Group 3 [38, 57) 的 Single Blocks 。

数据发现：
- Group 2 对于捕捉风格是最核心的。
- 千万不能碰 Group 1！把方法用在 Group 1 (Double Blocks) 上不仅没用，反而会破坏风格一致性。
- 最终定稿：同时应用在 Group 2 和 Group 3 (即所有的 Single Blocks) 能在文本对齐和风格一致性上达到最佳平衡。
视觉直观 (Figure 6)：图 6 清晰地展示了，如果在全层应用或者错误层应用，画面结构会扭曲；只有在 [19, 57) 层应用，生成的番茄、骑士才既有原图的线条风格，又保持了正常的物理结构。

缩放因子 (λ\lambdaλ) 到底设多少合适？

核心矛盾： Table 2 显示，随着 λ\lambdaλ 的增大，画风会越来越像参考图 (Ssty,SdinoS_{sty}, S_{dino}Ssty,Sdino 升高)，但代价是不太听提示词的话了 (StextS_{text}Stext 下降) 。这在图 5 中也有直观体现。
最终定稿：大量实验表明，将 λ\lambdaλ 设定为 1.1 是一个“甜点位 (Sweet Spot)”，达到了最佳的平衡。

泛化性与兼容性

作者在最后一部分向学术界展示了 AlignedGen 的工程潜力和通用性，证明了这不仅仅是一个为了发论文而强行凑出来的“特例”。

跨模型泛化： AlignedGen 的核心逻辑（解决 2D RoPE 的位置冲突）并非 Flux 独有。作者将这套方法直接套用到了同样基于 DiT 架构的 Stable Diffusion 3 (SD3) 和 SD3.5 上。正如论文图 10 和图 12 所示，它在这些模型上同样实现了完美的风格一致性迁移。
与其他工具的无缝兼容 (Compatibility with Existing Tools)：作为一个完全免训练的即插即用模块，AlignedGen 可以和现有的各种图像生成控制技术叠加使用。
- 比如结合 Dreambooth 进行主体驱动生成（图 13），不仅能保持主体一致，还能统一特定画风。
- 结合 Depth Control (深度控制)（图 14），在控制物理空间深度的同时，依然死死咬住参考图的艺术风格。

总结与研究启发

AlignedGen 最迷人的地方在于它全程没有更新大模型的任何一个参数。在计算资源极其有限的环境下，去卷庞大的数据集或者昂贵的微调是非常吃亏的。这篇论文指明了一条极其高性价比的科研路径：去深度剖析开源模型（如 Flux）底层的注意力矩阵和位置编码。

当你发现模型底层的数学逻辑（比如 RoPE 的位置重合导致内容泄漏）存在盲区时，只需要像 ShiftPE 那样加一个简单的偏移量 www ，就能撬动千亿参数大模型的惊人潜力。

《CharaConsist》论文精读

小yo — Tue, 10 Mar 2026 00:20:08 GMT

前置知识与基线

FLUX.1 核心架构

CharaConsist 是首个基于 Text-to-Image DiT模型的免训练一致性生成方法。它主要基于 FLUX.1 展开。

多模态 Transformer 架构

与以往的 UNet 架构（如 SDXL）分别处理自注意力和交叉注意力不同，FLUX.1 采用了一种多模态 Transformer 架构。它将文本 Token 和图像 Token 拼接成一个单一的序列，然后进行全局注意力计算。在原始的 DiT 中，文本信息（通常是类标签或经过 CLIP 编码的全局文本向量）和时间步信息是通过 adaLN-Zero 注入到模型中的。这种方式本质上是对图像特征进行全局的缩放和平移，文本特征并没有作为独立的 Token 参与到注意力机制的序列计算中。 FLUX.1 采用的是多模态 Transformer 架构。它使用 T5 编码器对文本进行编码，使用 VAE 对图像进行编码。它的核心区别在于序列拼接：FLUX.1 不再使用 adaLN-Zero 来注入文本信息，而是将海量的文本 Token 序列和图像 Token 序列直接首尾拼接，融合成一个超长的单一序列。在后续的自注意力计算中，这个长序列会进行全局的注意力交互。

T5 编码器： T5 是 Google 推出的大型语言模型（LLM），它是纯粹在海量文本数据上训练出来的，专精于自然语言处理。要理解为什么最新的 DiT 模型（如 FLUX.1、SD3）纷纷转向 T5，我们需要先明白 CLIP 的强项与致命弱点。

CLIP的局限性： CLIP 擅长抓取“全局语义”（比如知道图片里有“猫”和“草地”），但它的语法理解能力极差。如果你输入“一个红色的方块在一个蓝色的圆球上面”，CLIP 生成的特征往往会把颜色和物体搞混（生成蓝色的方块和红色的圆球），而且它很难理解复杂的空间关系和超长提示词。

T5 的优势： T5 拥有极其强大的语法解析、上下文理解和长文本处理能力。它能精准理解“红色属于方块，蓝色属于圆球”这种属性绑定。 FLUX.1 采用 T5 编码器来处理文本 Token 。不同于 CLIP 试图自己完成图文对齐，FLUX.1 让 T5 专注于提取最深度的纯文本语义，然后将这些 T5 Token 与图像 Token 直接拼接。真正的图文对齐任务被交给了 Multimodal Transformer 自己。模型通过在海量数据上计算这两段序列的自注意力，自己学会了图像像素和文本单词之间的精准映射。

优势： 这种架构允许图像的局部 Patch 直接与文本序列中的特定单词进行细粒度的 Attention 交互（这就是为什么 CharaConsist 能够通过公式提取出精确的“前景/背景 Mask” ），而不仅仅是接受一个全局的文本条件约束。

Double Block vs. Single Block

FLUX.1 包含两种 Transformer 块，这两种 Block 承担着不同阶段的特征处理任务，并且结构上有所区别。 Double Block（双流块）：

位置与作用：位于模型的前期阶段，起到类似编码器的作用，负责对输入的噪声潜变量进行初步编码。
结构特点：虽然文本和图像 Token 拼接在一起进行了全局注意力计算，但由于文本和图像属于完全不同的模态，初始特征分布差异极大。因此，在 Double Block 中，注意力计算后的文本 Token 和图像 Token 会被分开送入各自独立的 MLP和 LayerNorm 层进行处理。这种“注意力共享，MLP 分离”的设计，有助于模型在对齐模态的同时，保留各自模态的独特特征。 Single Block（单流块）：
位置与作用：位于模型的后期阶段，起到类似解码器的作用，负责将融合后的特征解码为最终输出。
结构特点：经过前面多层 Double Block 的处理，文本和图像模态已经高度对齐。因此在 Single Block 中，文本和图像 Token 不仅共享注意力机制，还共享同一个 MLP 网络。它们被完全视作同一种东西（统一的特征序列）进行处理。 与 CharaConsist 的联系： 作者发现，只需要对后期的 Single Block进行操作，就能提供足够的一致性，如果强行修改所有 Block，反而会导致图像质量下降或出现重影等伪影。

RoPE 机制

传统正余弦位置编码（绝对位置编码）： 像最早的 Transformer 那样，传统的正余弦位置编码是在网络最开始，将位置向量直接相加到 Token 的特征向量上（即 Input=Feature+PositionInput = Feature + PositionInput=Feature+Position）。

痛点：随着网络层数的加深，经过无数次的线性映射和非线性激活，这种相加进去的绝对位置信息会被语义特征“稀释”和破坏。在深层网络中，模型很难再精准感知两个 Token 之间的精确相对距离。 RoPE（旋转位置编码）： RoPE 的核心思想是用绝对位置的旋转操作，来隐式地表达相对位置。它不再是加法，而是乘法（旋转矩阵）。在 FLUX.1 中，RoPE 不是只在第一层加一次，而是在每一个注意力层的 Query (Q) 和 Key (K) 上应用。
数学机制：当给定一个 Token 的绝对位置 mmm 时，RoPE 会通过乘以一个由 mmm 决定的旋转矩阵，在多维空间中将该 Token 的特征向量“旋转”一个特定的角度。
相对位置：当计算 Query 和 Key 的注意力得分（即点积 Q⋅KTQ \cdot K^TQ⋅KT）时，奇妙的数学特性出现了：两个经过 RoPE 旋转的向量的点积，最终化简后仅依赖于它们相对位置的差值 (m−n)(m - n)(m−n)，而与它们的绝对位置无关。

ConsiStory

在论文中，ConsiStory 经常被拿来作为直接对比的免训练基线方法。

核心机制：像 ConsiStory 和 StoryDiffusion 这样的方法，主要是通过在生成一批图像时，将相邻图像的 Key 和 Value 拼接到当前图像的注意力机制中，实现跨图像的信息共享。
DIFT 匹配的失效： ConsiStory 为了增强特征，依赖于一种叫做 DIFT 的相似度特征注入技术。DIFT 能够通过比较 UNet 在特定时间步的中间层特征，来找到图像间的语义对应关系。
为什么在 DiT 上行不通？作者在实验中发现，把这种套路直接搬到 FLUX.1上会失效。FLUX.1 中间 Transformer 块的输出只能匹配到相同空间位置的点（缺乏语义对应），而注意力层的输出波动又极其剧烈，根本无法提供稳定的匹配。这迫使 CharaConsist 必须设计一套全新的跨层平均匹配策略。

DIFT

DIFT（Emergent Correspondence from Image Diffusion）是 2023 年 NeurIPS 的一篇重量级工作。它在 ConsiStory 等免训练一致性方法中扮演了核心角色。

核心发现： DIFT 揭示了一个令人惊叹的现象：预训练的文本到图像扩散模型（如 Stable Diffusion）本身就是一个极其强大的、零样本（Zero-shot）的特征提取器。即使不进行任何微调，它中间层的特征图也包含了极其丰富的语义对应关系。
技术原理：
1. 给定两张不同的图片（比如一张实拍的猫，一张手绘的狗）。
2. 给它们加上特定时间步 ttt 的噪声。
3. 把加噪后的图像送入预训练的 UNet。
4. 提取 UNet 解码器中特定层的特征图。
5. 计算两张图片特征图之间的余弦相似度。结果是：模型能极其精准地把猫的左眼和狗的左眼在像素级别上匹配起来。
为什么能做到？扩散模型在训练去噪的过程中，为了还原图像，被迫在网络的不同深度学习了不同层级的特征。高噪声阶段学到了高级的全局语义；低噪声阶段学到了低级的边缘和纹理。DIFT 就是把这些隐藏的语义特征直接“白嫖”出来用了。

PhotoMaker

了解 PhotoMaker，是为了看清 CharaConsist 这种免训练方法在整个技术生态里的位置。

技术路线： PhotoMaker 属于基于参考图的身份保持方法。它需要引入预训练的图像编码器，并训练额外的投影模块，硬生生地把身份信息嵌入到生成过程中。
优缺点对比：这类方法通过庞大的数据集训练，能很好地维持人脸的固定特征。但是，它会“过拟合”到这张脸上，根本无法保证角色的衣服、背景场景的一致性。
CharaConsist 的互补性： CharaConsist 作为免训练方法，优势在于精细的背景和服装控制。正如作者在论文局限性中所探讨的，最理想的状态是将 PhotoMaker 等训练模型的“面部保持能力”与 CharaConsist 的“背景服装一致性能力”结合起来。

局部性偏见

在 FLUX.1 中，RoPE 是在每一个注意力层直接应用的。当同一个角色在两张图片中的位置发生大幅变动时，模型会表现出明显的“局部性偏见”——它倾向于把注意力分配给空间上相近的区域，而不是语义上对应的区域。既然 RoPE 是在注意力计算时才加上去的，作者巧妙地提取了没有任何位置编码的原始 Key（K0K^0K0），然后强制用新图像中的目标坐标对其重新进行 RoPE 编码（Kfg,id′=RoPE(Kfg,id0,Cfg,frm)K'_{fg,id} = RoPE(K^0_{fg,id}, C_{fg,frm})Kfg,id′=RoPE(Kfg,id0,Cfg,frm)）。这直接在底层拉平了位置偏移带来的影响。

核心数学机制推导

流程设定与数学符号

两阶段生成

为了实现前后一致的生成，CharaConsist 将整个生成任务明确划分为了两个阶段：

第一阶段：身份图像生成
- 做法：这一步就是完全使用原生的 FLUX.1 模型生成一张基准图（也就是要保持一致的那个“角色”或“场景”），不加任何修改。
- 暗箱操作：虽然生成过程没变，但模型在后台悄悄保存了特定时间步和特定层的中间变量。这些变量主要包括注意力机制中的键（Keys, KKK）、值（Values, VVV）以及注意力输出。
第二阶段：帧图像生成
- 做法：当需要生成这个角色的新动作或新场景时（即“帧图像”），模型会去“读取”第一步保存的那些中间变量，强行干预当前的生成过程，从而实现一致性。核心优势：之前的免训练方法（比如 StoryDiffusion 或 ConsiStory）通常需要把 2 到 4 张图片放在一个 Batch 里并行生成，让它们互相参考，这极其消耗显存。而 CharaConsist 凭借强大的追踪机制，只需要单张身份图像作为参考，彻底摆脱了并行生成的显存噩梦。

数学符号

因为 FLUX.1 的架构比较复杂，为了方便用公式表达，作者在 3.1 节对注意力机制做了一个极其精简的“统一数学抽象”。 序列拼接 ：无论什么 Block，核心都是把文本 Token 和图像 Token 拼在一起。- 设文本 Token 的长度为 lll 。

设图像的特征分辨率为 h×wh\times wh×w（在 FLUX.1 中，这是原图分辨率的 1/16）。
那么多模态拼接后的总输入序列 XmmX_{mm}Xmm 就被定义为：Xmm=cat[Xt,Xi]X_{mm}=cat[X_t,X_i]Xmm=cat[Xt,Xi] 。这里的 catcatcat 代表拼接，ttt 代表文本，iii 代表图像，mmmmmm 代表多模态 标准注意力计算：接着，通过线性映射得到用来算注意力的三个核心矩阵：Q,K,VQ,K,VQ,K,V（Query, Key, Value）。
计算注意力权重矩阵 WmmW_{mm}Wmm ： Wmm=Qmm⋅KmmTdW_{mm}=\frac{Q_{mm}\cdot K_{mm}^{T}}{\sqrt{d}}Wmm=dQmm⋅KmmT （ddd 是注意力头的维度）
最后，经过 Softmax 激活并乘以 VmmV_{mm}Vmm，得到统一的注意力输出 HmmH_{mm}Hmm，这个输出又可以拆分回文本特征 HtH_tHt 和图像特征 HiH_iHi ： Hmm=Softmax(Wmm)⋅Vmm=cat[Ht,Hi]H_{mm}=Softmax(W_{mm})\cdot V_{mm}=cat[H_t,H_i]Hmm=Softmax(Wmm)⋅Vmm=cat[Ht,Hi] 下标维度：在 CharaConsist（以及 FLUX.1 的官方实现）中，变量的下标严格对应了它的序列长度：
带有 mm 下标（Multimodal，多模态）：
- 序列长度：l+hwl + hwl+hw （文本和图像拼在一起）
- 代表变量：XmmX_{mm}Xmm, QmmQ_{mm}Qmm, KmmK_{mm}Kmm, WmmW_{mm}Wmm, HmmH_{mm}Hmm
- 出现场景：只要是在 Transformer Block 内部做全局 Attention 计算的输入和输出，都是这个完整的超长序列。
带有 i 下标（Image，图像）：
- 序列长度：hwhwhw （纯图像 Token）
- 代表变量：XiX_iXi, HiH_iHi, Ai2tA_{i2t}Ai2t
- 出现场景：当我们算完 Attention 后，把前面的 lll 个文本 Token 砍掉，只保留后面的图像特征时。
带有 fg 或 bg 下标（Foreground / Background，前景 / 背景）：
- 序列长度：NfgN_{fg}Nfg 或 NbgN_{bg}Nbg （仅包含掩码抠出来的那部分像素）
- 代表变量：HfgH_{fg}Hfg, KfgK_{fg}Kfg, CfgC_{fg}Cfg
- 出现场景：进一步用坐标索引（比如 CfgC_{fg}Cfg）从 hwhwhw 里面切片取出来的时候

跨层点匹配

背景

CharaConsist 的计划是，把“身份图像”生成时算出来的 KKK、VVV 和 HiH_iHi 偷偷存下来。在生成“帧图像”时，把帧图像的 QQQ 拿去和存下来的 KKK 算注意力，从而把身份图像里的细节“搬运”过来。但这里有一个巨大的鸿沟，也是这篇论文要解决的核心数学问题：如果帧图像里的人举起了手，或者跑到屏幕左边去了，原坐标就对不上了（这就是前面提到的 RoPE 带来的局部性偏见）。所以，在进行上面说的“搬运”之前，模型必须先解决两件事：

点匹配：找出帧图像里的“手”对应身份图像里的哪个位置。
掩码提取：把前景（人物）和背景（环境）剥离开来，分别控制。

相似度矩阵

接下来我们首先讨论点匹配的实现。 目标： 对于当前生成的“帧图像”中的每一个点，我们需要在“身份图像”中找到与其语义上最对应的点。比如，新图里人物的手，得精准对应到原图里人物的手。挑战： 作者在 FLUX.1 上测试发现，如果直接取注意力层的输出算相似度，匹配点会在不同层、不同时间步甚至不同样本之间发生极其剧烈的波动，根本无法稳定匹配。 破局点（公式 4 与 5）： 既然单层的数据在“跳舞”，但整体的相似度分布特征是相对一致的，作者就简单粗暴但极其有效地对同一个时间步下的所有层的余弦相似度求了平均： S∗=1N∑nHi,frm,n⋅Hi,id,nT∣∣Hi,frm,n∣∣2⋅∣∣Hi,id,n∣∣2S^{*}=\frac{1}{N}\sum_{n}\frac{H_{i,frm,n}\cdot H_{i,id,n}^{T}}{||H_{i,frm,n}||_{2}\cdot||H_{i,id,n}||_{2}}S∗=N1∑n∣∣Hi,frm,n∣∣2⋅∣∣Hi,id,n∣∣2Hi,frm,n⋅Hi,id,nT

Hi,frm,nH_{i,frm,n}Hi,frm,n 和 Hi,id,nH_{i,id,n}Hi,id,n 分别代表帧图像和身份图像在第 nnn 层的图像注意力输出。
NNN 是总层数。
这个公式计算了图像之间 Token 的余弦相似度，并进行了跨层累加平均，得到了稳定的相似度矩阵 S∗S^{*}S∗ 。

最大值

有了这个稳定的矩阵，接下来就是找最大值了： map∗,Smax∗=arg⁡max⁡(S∗),max⁡(S∗)map^{*}, S_{max}^{*}=\arg\max(S^{*}), \max(S^{*})map∗,Smax∗=argmax(S∗),max(S∗)

map∗(j)=kmap^{*}(j)=kmap∗(j)=k 的物理意义非常明确：它告诉你帧图像里的第 jjj 个点，死死锁定在了身份图像的第 kkk 个点上。
Smax∗S_{max}^{*}Smax∗ 则是这对匹配点之间的平均余弦相似度得分，它反映了这次匹配的“置信度” （这个得分在后面的 Token 融合中会起到大作用）。

公式详解

我们先看 S∗S^{*}S∗ 是什么。假设帧图像有 hwhwhw 个 Token，身份图像也有 hwhwhw 个 Token。那么经过前面公式的计算，S∗S^{*}S∗ 就是一个大小为 hw×hwhw \times hwhw×hw 的二维矩阵。

矩阵的行：代表帧图像中的第 jjj 个 Token。
矩阵的列：代表身份图像中的第 kkk 个 Token。
矩阵里的每一个值，就是这两个 Token 之间的平均余弦相似度。现在，我们要为帧图像里的每一个 Token jjj，在身份图像里找一个最匹配的 Token kkk：
map∗=arg⁡max⁡(S∗)map^{*} = \arg\max(S^{*})map∗=argmax(S∗)： 这是在做索引定位。它顺着 S∗S^{*}S∗ 的每一行，去找最大值所在的列号 kkk。得到的 map∗map^{*}map∗ 就像一本字典（或者说是一个长度为 hwhwhw 的一维数组），比如 map∗(j)=kmap^{*}(j) = kmap∗(j)=k，意思是：帧图像里的第 jjj 号点，对应着身份图像里的第 kkk 号点。
Smax∗=max⁡(S∗)S_{max}^{*} = \max(S^{*})Smax∗=max(S∗)： 这是在提取置信度得分。光知道“谁匹配谁”还不够，还得知道匹配得有多像。它把刚才找到的最大相似度数值给抽出来。得到的 Smax∗S_{max}^{*}Smax∗ 也是一个长度为 hwhwhw 的一维数组，里面的值介于 [−1,1][-1, 1][−1,1] 之间，代表这对匹配点的可信度。在后续的自适应 Token 融合时，如果匹配得分太低，这个权重就会把那些“强行匹配但其实不像”的噪点给压制住。

掩码提取

目标： 在实际应用中，我们有时候只换动作不换背景，有时候又要换背景。为了实现前背景的解耦控制，模型必须自动把人物（前景）的 Mask 抠出来。 技巧： 这个提取策略非常巧妙，它纯粹依赖于图像 Token 对不同文本 Token 的注意力权重差异。 前置设定： 作者要求写提示词时必须按套路出牌：先写背景，再写前景。比如：“In a modern gym（背景），a muscular man…（前景）” 。这样我们就知道了背景文本的长度 lbgl_{bg}lbg 和前景文本的长度 lfgl_{fg}lfg 。

提取图文注意力权重

Ai2t=Softmax(Wmm[l:,:lbg+lfg])A_{i2t}=Softmax(W_{mm}[l:, :l_{bg}+l_{fg}])Ai2t=Softmax(Wmm[l:,:lbg+lfg])

模型只截取了图像作为 Query、文本作为 Key 的那部分注意力权重 WmmW_{mm}Wmm 。
注意，这里只在实际文本序列长度内做 Softmax 操作，这是为了排除掉图像 Key 以及特殊文本 Key <s> 带来的干扰。

为什么必须是 l:？因为在 FLUX.1 的多模态拼接机制中，完整的输入序列是先把长度为 lll 的文本 Token 放在前面，再把长度为 hwhwhw 的图像 Token 紧接着拼在后面。

当我们计算整个大注意力矩阵 WmmW_{mm}Wmm 时，它的尺寸是 (l+hw)×(l+hw)(l+hw) \times (l+hw)(l+hw)×(l+hw) 。

我们现在只关心图像 Token 作为 Query，去关注文本 Token (Key) 的情况。

图像 Token 在序列的后半段，所以行的索引必须从 lll 开始，也就是 l: 。

文本 Token 在序列的前半段，所以列的索引是 :l_{bg}+l_{fg} 。

抑制波动，双重平均

和点匹配一样，图文注意力权重在不同层之间也波动剧烈。因此，作者分别在背景文本段和前景文本段内求平均，同时也在所有层 NNN 之间求平均：

图像对背景的平均注意力： Ai2bg∗=1N×lbg∑n∑j=0lbg−1Ai2t,n[:,j]A_{i2bg}^{*}=\frac{1}{N\times l_{bg}}\sum_{n}\sum_{j=0}^{l_{bg}-1}A_{i2t,n}[:,j]Ai2bg∗=N×lbg1∑n∑j=0lbg−1Ai2t,n[:,j]
图像对前景的平均注意力： Ai2fg∗=1N×lfg∑n∑j=lbglbg+lfg−1Ai2t,n[:,j]A_{i2fg}^{*}=\frac{1}{N\times l_{fg}}\sum_{n}\sum_{j=l_{bg}}^{l_{bg}+l_{fg}-1}A_{i2t,n}[:,j]Ai2fg∗=N×lfg1∑n∑j=lbglbg+lfg−1Ai2t,n[:,j]

二值化掩码

有了这两个平均得分，生成 Mask 就变成了极其简单的大小比较： M=Ai2fg∗>Ai2bg∗∈{0,1}hwM=A_{i2fg}^{*}>A_{i2bg}^{*}\in\{0,1\}^{hw}M=Ai2fg∗>Ai2bg∗∈{0,1}hw

对于图像上的每一个像素 Token，如果它对前景文字的关注度大于对背景文字的关注度，我们就认为它是前景（值为 111），否则就是背景（值为 000）。在附录中作者提到，提取出来的原始 Mask 可能会有一些孤立的噪点或空洞。为了解决这个问题，他们在原始掩码上应用了形态学操作：先用 3×33\times33×3 的核进行腐蚀，接着用 5×55\times55×5 的核进行膨胀。使用更大的膨胀参数是为了防止丢失前景的边缘信息。

腐蚀：做减法，去噪点

操作机制：定义一个滑动窗口（也就是核，Kernel），比如论文里用的 3×33\times33×3 核。让这个小窗口在整张 Mask 上逐像素滑动。

严苛的规则：只有当这个 3×33\times33×3 窗口覆盖的 9 个像素全部都是白色时，中心像素才保持白色；只要窗口里混进了一个黑色像素，中心像素就立刻变成黑色。

直观效果：所有的白色区域都会“瘦一圈”。那些原本就极其微小的白色孤立噪点，因为填不满整个 3×33\times33×3 的窗口，会被这个规则瞬间“抹杀”掉。这样背景就干净了。膨胀：做加法，补空洞

操作机制：同样是用一个核在图像上滑动，论文里作者换了一个更大的 5×55\times55×5 核。

宽容的规则：只要这个 5×55\times55×5 窗口覆盖的 25 个像素中有任何一个是白色，中心像素就变成白色。只有全黑才保持黑色。

直观效果：所有的白色区域都会向外扩张。这不仅能填补人物内部那些细小的黑色空洞，还能把人物的轮廓放大。这种“先腐蚀后膨胀”的连招，在图像处理中有一个专门的名字，叫做开运算（Opening Operation）。作者这里的参数设计非常巧妙：

先用 3×33\times33×3 腐蚀：无情地干掉背景里那些烦人的孤立噪点。但代价是，我们想要保留的真实人物前景，也被硬生生“刮掉了一层皮”，变瘦了。

再用更大的 5×55\times55×5 膨胀：不仅要把刚才人物“瘦掉”的那圈肉补回来，还要让它再多胖一点！

为什么核要变大？论文解释得很清楚，使用更大的膨胀参数，是为了防止丢失前景的边缘信息。因为人的头发丝、衣服的毛边往往很细微，如果在腐蚀阶段被擦掉，用同样大小的核膨胀可能补不回来。用 5×55\times55×5 的大核，能确保生成一个比实际人物稍微大一圈的“安全保护罩”，把所有属于人物的特征都死死地框在前景里。

AAA 矩阵维度的全景梳理

为了不被绕晕，我们把每一个 AAA 的形状单独拿出来看。假设文本总长度 l=512l=512l=512，图像 Token 数量 hw=1024hw=1024hw=1024。背景词长度 lbg=10l_{bg}=10lbg=10，前景词长度 lfg=5l_{fg}=5lfg=5。

Ai2tA_{i2t}Ai2t (图像对文本的原始注意力)：
- 维度：hw×(lbg+lfg)hw \times (l_{bg}+l_{fg})hw×(lbg+lfg)
- 它是一个 1024×151024 \times 151024×15 的矩阵。每一行代表图像上的一个点，每一列代表它对这 15 个具体单词的关注程度。
Ai2bg∗A_{i2bg}^{*}Ai2bg∗ (图像对背景的平均关注度)：
- 操作：我们把 Ai2tA_{i2t}Ai2t 的前 lbgl_{bg}lbg 列（也就是前 10 列）拿出来，在列方向上求个平均。
- 维度：变成了一个长度为 hwhwhw 的 1 D 向量（尺寸：102410241024）。
- 图像上的每个点，对整个“背景描述”的综合关注度得分。
Ai2fg∗A_{i2fg}^{*}Ai2fg∗ (图像对前景的平均关注度)：
- 操作：我们把 Ai2tA_{i2t}Ai2t 剩下的 lfgl_{fg}lfg 列（后 5 列）拿出来，同样在列方向上求平均。
- 维度：也是一个长度为 hwhwhw 的 1 D 向量（尺寸：102410241024）。
- 图像上的每个点，对整个“前景描述”的综合关注度得分。
MMM (最终的前景掩码)：
- 操作：直接拿两个 1D 向量做逐元素的逻辑比较（大于号 >）。
- 维度：依然是一个长度为 hwhwhw 的 1D 向量（尺寸：102410241024），只不过里面的值全变成了 000 或 111 。

点追踪注意力

核心痛点： 之前我们提到过，FLUX.1 里的 RoPE（旋转位置编码）会带来局部性偏见。如果同一张脸在第一张图的左边，在第二张图的右边，模型就会觉得它们相距甚远，拒绝给足注意力权重。 绝妙的破解之法（公式 10 到 17）： 首先，我们要拿出前面算好的两样东西：前景掩码 MMM 和匹配字典 map∗map^{*}map∗。

提取索引

我们要知道帧图像（新图）里的前景都在哪些位置，记作 Cfg,frmC_{fg,frm}Cfg,frm 。 Cfg,frm=nonzero(Mfrm)C_{fg,frm}=nonzero(M_{frm})Cfg,frm=nonzero(Mfrm)

具体过程：前面我们算出 MMM 是一个长度为 hwhwhw 的一维数组，里面的值只有 000（背景）和 111（前景）。nonzero() 是深度学习框架（如 PyTorch）中的一个标准函数，它的作用就是把数组中所有不为 000 的元素的位置下标挑出来。
物理意义：假设特征图有 1024 个点，其中第 5、8、12 个点是人物（值为 1），那么 Cfg,frmC_{fg,frm}Cfg,frm 就是一个列表 [5, 8, 12]。它相当于一份“坐标白名单”，告诉模型：“只管这几个位置，其他的别动”。然后顺着字典查出，这些点在身份图像（原图）里对应的位置是哪些，记作 Cfg,idC_{fg,id}Cfg,id。 Cfg,id=map∗(Cfg,frm)C_{fg,id}=map^{*}(C_{fg,frm})Cfg,id=map∗(Cfg,frm)

获取纯粹的语义信息

根据查到的位置 Cfg,idC_{fg,id}Cfg,id，我们把身份图像里对应的 Key (KKK) 和 Value (VVV) 抽取出来。最关键的是，我们抽取的 Key 是没有任何位置编码的原始版本，记作 K0K^{0}K0 。它只包含“长什么样”的语义，不包含“在哪儿”的信息。 如何抽取 K0K^{0}K0：

传统模型 vs. FLUX.1：在以前的模型（比如早期的 ViT 或 SD 1.5 的 UNet）中，绝对位置编码是在网络的最输入端直接加到图像特征上的。一旦加进去，就“融为一体”了，后续很难再把位置信息干净地剥离出来。
FLUX.1 的 RoPE 机制： FLUX.1 使用的是旋转位置编码（RoPE）。最关键的是，RoPE 是在每一个注意力层内部、在进行点积之前才“临时”应用上去的。
截取过程：在注意力层的最开始，输入的特征 XXX 会先经过一个线性层映射成 QQQ、KKK、VVV。在这个瞬间，映射出来的 KKK 是纯粹的语义特征，完全没有位置信息，这就是我们要找的 K0K^{0}K0 。代码实现上，只需要在 K0K^{0}K0 被送进 RoPE 函数进行旋转变换之前，把它拦截并克隆一份存下来即可。

为什么当前的 K0K^{0}K0 不会带有之前层注入的 RoPE 位置信息？这是 Transformer 架构设计中一个非常隐蔽但极其巧妙的细节。要理解这个，我们必须把注意力机制的内部数据流拆开来看。在 FLUX.1 的某一个注意力层内部，数据先后经历：

线性映射产生 Q、K、V：上一层的输出特征（纯语义特征）进入当前层后，首先经过线性映射层，生成了 QQQ（Query）、K0K^{0}K0（纯语义 Key）和 VVV（纯语义 Value）。

RoPE 只作用于 Q 和 K：接下来，RoPE 函数仅仅对 QQQ 和 K0K^{0}K0 进行了旋转矩阵乘法，得到了带有位置信息的 Q′Q^{\prime}Q′ 和 K′K^{\prime}K′

计算注意力得分：模型用带有位置信息的 Q′Q^{\prime}Q′ 和 K′K^{\prime}K′ 进行点积（Q′⋅(K′)TQ^{\prime} \cdot (K^{\prime})^TQ′⋅(K′)T），算出注意力权重矩阵。

与 V 相乘产生输出：这个算出来的注意力权重矩阵，最终是乘在了 VVV 上面的，而 VVV 是从来没有经过 RoPE 旋转的。

进入下一层：注意力机制的输出（本质上是 VVV 的加权求和）经过前馈网络（MLP）和残差连接后，传递给下一层。因为 RoPE 只参与了 QQQ 和 KKK 的点积，而没有参与与 VVV 的相乘，所以被搬运到下一层的潜变量里，并没有被硬编码进上一层的旋转位置矩阵。当下一层再次对这个潜变量进行线性映射时，提取出来的 K0K^{0}K0 不会带有之前层注入的位置信息。

重新编码 RoPE

我们把刚刚抽出来的纯语义 Key (Kfg,id0K_{fg,id}^{0}Kfg,id0)，强行用新图的空间坐标 (Cfg,frmC_{fg,frm}Cfg,frm) 给它打上新的 RoPE 烙印。 Kfg,id′=RoPE(Kfg,id0,Cfg,frm)K_{fg,id}^{\prime}=RoPE(K_{fg,id}^{0},C_{fg,frm})Kfg,id′=RoPE(Kfg,id0,Cfg,frm) 这一招直接欺骗了注意力机制：模型以为这个特征本来就在新位置上，彻底消除了距离带来的注意力衰减。

组装与注意力计算

接着，我们把新图自己的特征、重现编码的身份特征、以及背景特征拼接在一起，作为最终的 Key 和 Value 。在算注意力时，再用一个对角线掩码 M∗M^{*}M∗ 限制一下：只让前景看前景，背景看背景。

信息拼接

假设每个注意力头的特征维度是 ddd。当前图像总共有 l+hwl + hwl+hw 个 Token（包含了文本和图像的长度），其中前景抠出来了 NfgN_{fg}Nfg 个 Token，背景抠出来了 NbgN_{bg}Nbg 个 Token。 Kfrm∗=cat[Kmm,frm,Kfg,id′,Kbg,id]K_{frm}^{*}=cat[K_{mm,frm}, K_{fg,id}^{\prime}, K_{bg,id}]Kfrm∗=cat[Kmm,frm,Kfg,id′,Kbg,id]

这里的 cat 是在序列长度这个维度上进行的拼接。
Kmm,frmK_{mm,frm}Kmm,frm：这是当前帧图像（新图）原原本本的 Key。它的维度是 (l+hw)×d(l + hw) \times d(l+hw)×d。
Kfg,id′K_{fg,id}^{\prime}Kfg,id′：这是我们刚才从身份图像（旧图）里抽出来的纯语义前景 Key，并且已经用新图的坐标重新做过 RoPE 旋转了。它的维度是 Nfg×dN_{fg} \times dNfg×d。
Kbg,idK_{bg,id}Kbg,id：这是从身份图像里抽出来的背景 Key。这部分是可选的，取决于用户是否想要保持背景不变。它的维度是 Nbg×dN_{bg} \times dNbg×d。
拼接后的 Kfrm∗K_{frm}^{*}Kfrm∗ 的维度变成了 (l+hw+Nfg+Nbg)×d(l + hw + N_{fg} + N_{bg}) \times d(l+hw+Nfg+Nbg)×d。

计算注意力得分矩阵

Wfrm∗=Qmm,frm⋅Kfrm∗Td+log⁡(M∗)W_{frm}^{*}=\frac{Q_{mm,frm}\cdot K_{frm}^{*T}}{\sqrt{d}}+\log(M^{*})Wfrm∗=dQmm,frm⋅Kfrm∗T+log(M∗)

Qmm,frmQ_{mm,frm}Qmm,frm：当前帧图像正在生成的内容（Query）。
Kfrm∗TK_{frm}^{*T}Kfrm∗T：这是作者精心拼接的新 Key 矩阵。里面包含了当前帧自己的 Key、刚才重新编码过位置的 K′K^{\prime}K′、还有背景的 Key。
前半部分 Q⋅KTd\frac{Q \cdot K^T}{\sqrt{d}}dQ⋅KT：这是常规的相似度计算。分数越高，说明 Query 越应该关注这个 Key。
后半部分 +log⁡(M∗)+\log(M^{*})+log(M∗) (掩码)：这是深度学习里非常经典的 Attention Mask 技巧。
- M∗M^{*}M∗ 是一个矩阵，规定了谁能看谁（比如强制要求：新图的前景只能看旧图的前景，不能看背景）。
- 如果允许看，对应的 M∗M^{*}M∗ 值为 111，那么 log⁡(1)=0\log(1) = 0log(1)=0，得分不变。
- 如果不允许看（禁止连接），对应的 M∗M^{*}M∗ 值为 000，那么 log⁡(0)→−∞\log(0) \to -\inftylog(0)→−∞。
- 结果就是，不该有关联的区域，其注意力得分变成了负无穷大。
得到的注意力得分矩阵 Wfrm∗W_{frm}^{*}Wfrm∗ 的维度是 (l+hw)×(l+hw+Nfg+Nbg)(l + hw) \times (l + hw + N_{fg} + N_{bg})(l+hw)×(l+hw+Nfg+Nbg) 。

生成最终的追踪特征

Hmm,frm∗=Softmax(Wfrm∗)⋅Vfrm∗H_{mm,frm}^{*}=Softmax(W_{frm}^{*})\cdot V_{frm}^{*}Hmm,frm∗=Softmax(Wfrm∗)⋅Vfrm∗

Softmax(Wfrm∗)Softmax(W_{frm}^{*})Softmax(Wfrm∗)：把刚才的得分矩阵变成概率分布（加起来等于 1）。刚才那些被标为 −∞-\infty−∞ 的地方，经过 Softmax 后会直接变成 e−∞=0e^{-\infty} = 0e−∞=0。这就彻底切断了前景和背景之间错误的特征流动。
⋅Vfrm∗\cdot V_{frm}^{*}⋅Vfrm∗：最后，把算好的概率权重乘以上下文信息（Value 矩阵）。
Hmm,frm∗H_{mm,frm}^{*}Hmm,frm∗ 的维度是 (l+hw)×d(l+hw) \times d(l+hw)×d 经过这两步，输出的 Hmm,frm∗H_{mm,frm}^{*}Hmm,frm∗ 里，新图的前景区域就完美、干净地填满了来自旧图对应前景的高保真语义信息。

自适应 Token 融合

重新编码虽然解决了长距离注意力衰减的问题，但它粗暴地打乱了像素原本的排列，会破坏局部的几何结构。而且，前面的点匹配 map∗map^{*}map∗ 毕竟是用余弦相似度估算的，肯定有匹配不准的噪点。为了把丢失的信息补回来，作者直接对注意力层的输出（HHH）进行了插值融合。 Hfg,frm∗∗=(1−αSmax∗)Hfg,frm∗+αSmax∗Hfg,id′H_{fg,frm}^{**}=(1-\alpha S_{max}^{*})H_{fg,frm}^{*}+\alpha S_{max}^{*}H_{fg,id}^{\prime}Hfg,frm∗∗=(1−αSmax∗)Hfg,frm∗+αSmax∗Hfg,id′

时间衰减参数 α\alphaα：它随着时间步的推进而逐渐减小。因为生成前期（去噪刚开始）定的是大框架和身份特征，需要多参考身份图像；生成后期主要是在画衣服纹理和背景细节，就不需要过多干预了。

α\alphaα 与 ttt (时间步) 的函数关系是什么？论文正文中并没有给出一个极其严密的数学方程式,而是给出了它的变化原则和作用范围：定性衰减关系：论文明确指出，α\alphaα 是一个在 [0,1][0, 1][0,1] 之间的超参数，并且随着生成过程中的时间步推移而衰减。具体实施区间：在附录的实现细节中，作者提到，FLUX.1 默认采样 50 步。他们从第 1 步就开始引入这个自适应融合模块，一直用到第 40 步。最后 10 步直接停用了这个模块（α\alphaα 相当于降为 0），因为最后阶段对一致性没有显著影响，只专注画质。

置信度守门员 Smax∗S_{max}^{*}Smax∗：这就是我们之前在匹配时求出的“最大余弦相似度得分” 。如果某个点匹配得非常勉强（得分很低），那么 αSmax∗\alpha S_{max}^{*}αSmax∗ 就会趋近于 0，模型就会拒绝融合这个不可靠的特征，防止把错误的特征引进来。

详解维度变化

Hfg,frm∗∗=(1−αSmax∗)Hfg,frm∗+αSmax∗Hfg,id′H_{fg,frm}^{**}=(1-\alpha S_{max}^{*})H_{fg,frm}^{*}+\alpha S_{max}^{*}H_{fg,id}^{\prime}Hfg,frm∗∗=(1−αSmax∗)Hfg,frm∗+αSmax∗Hfg,id′ 这里的各种 HHH 确实容易看花眼，但只要我们带入维度，它们就会变得非常清晰。假设当前图像依然有 hwhwhw 个像素 Token（例如 1024），每个 Token 的特征维度是 ddd。前景抠出来了 NfgN_{fg}Nfg 个点（例如 300 个点）。 第一步：提取当前帧（新图）的前景特征 Hfg,frm∗H_{fg,frm}^{*}Hfg,frm∗ Hmm,frm∗→拆分cat[Ht,frm∗,Hi,frm∗]H_{mm,frm}^{*} \xrightarrow{\text{拆分}} cat[H_{t,frm}^{*}, H_{i,frm}^{*}]Hmm,frm∗拆分cat[Ht,frm∗,Hi,frm∗]

网络把这个大杂烩从中间切开。我们丢掉前面的文本部分 Ht,frm∗H_{t,frm}^{*}Ht,frm∗，只保留后面的图像部分 Hi,frm∗H_{i,frm}^{*}Hi,frm∗。
此时，Hi,frm∗H_{i,frm}^{*}Hi,frm∗ 的维度就变成了干净的 hw×dhw \times dhw×d 。这代表整张新图（包含前景和背景）的所有像素特征 Hfg,frm∗=Hi,frm∗[Cfg,frm]H_{fg,frm}^{*}=H_{i,frm}^{*}[C_{fg,frm}]Hfg,frm∗=Hi,frm∗[Cfg,frm]
我们并不想动背景，所以我们根据前景坐标 Cfg,frmC_{fg,frm}Cfg,frm（长度为 NfgN_{fg}Nfg），把属于前景的那部分特征切片单独提取出来，这就是 Hfg,frm∗H_{fg,frm}^{*}Hfg,frm∗ 。
维度是 Nfg×dN_{fg} \times dNfg×d（即 300×d300 \times d300×d）。它代表新图里人物经历过注意力机制后，当下的特征状态。 第二步：提取身份图像（旧图）的对应前景特征 Hfg,id′H_{fg,id}^{\prime}Hfg,id′
在第一阶段生成身份图时，我们存下了一个原始的注意力输出 Hi,idH_{i,id}Hi,id 。它的维度也是 hw×dhw \times dhw×d。
重排与提取（公式 18）：这是极其关键的一步。我们不能直接把旧图的前景切下来，因为人的动作变了，点对不上。我们必须根据字典 map∗map^{*}map∗ 查到的对应坐标 Cfg,idC_{fg,id}Cfg,id，去旧图的输出里把对应点的特征抓过来，并按照新图的顺序排好。提取和重排后得到的矩阵，在论文公式 (18) 中记为 Hfg,idH_{fg,id}Hfg,id，而在融合公式 (20) 中为了区分加上了撇，记作 Hfg,id′H_{fg,id}^{\prime}Hfg,id′ 。
维度也是 Nfg×dN_{fg} \times dNfg×d。它代表了旧图中最纯正的参考特征，并且已经被像拼图一样，拼成了新图人物现在的姿势。 第三步：置信度 Smax∗S_{max}^{*}Smax∗
它是我们在点匹配时算出的“最大余弦相似度”，维度是 **Nfg×1N_{fg} \times 1Nfg×1。
如果某个点匹配得非常完美，得分接近 1，那么 αSmax∗\alpha S_{max}^{*}αSmax∗ 就会比较大，模型就会大胆地把旧图特征 Hfg,id′H_{fg,id}^{\prime}Hfg,id′ 融入进来。如果某个点匹配得分很低（比如旧图里根本没有新图里的手），分数接近 0，那么权重就变成了 000，模型就会彻底抛弃旧图特征，保留新图自己的特征 (1−0)Hfg,frm∗(1-0)H_{fg,frm}^{*}(1−0)Hfg,frm∗ 。这就完美防止了错误特征的污染。 第四步：终极融合 Hfg,frm∗∗H_{fg,frm}^{**}Hfg,frm∗∗
把上面两个 Nfg×dN_{fg} \times dNfg×d 的矩阵，用 (1−权重)(1 - 权重)(1−权重) 和权重权重权重进行逐元素相加。
得到的 Hfg,frm∗∗H_{fg,frm}^{**}Hfg,frm∗∗（维度依然是 Nfg×dN_{fg} \times dNfg×d）就是一个既包容了新动作、又完美继承了旧身份和旧纹理的“完美潜变量”。
最后，用这个融合后的完美前景特征，替换掉原来的 Hi,frm∗H_{i,frm}^{*}Hi,frm∗ 中的对应位置，继续往下传给后续的神经网络层。

实验评估与对比

实验设置

评估数据集

现有的基准测试缺乏适合评估角色和环境一致性的特征。因此，作者使用 GPT-4 生成了一系列专门针对这种应用场景的文本到图像（T2I）提示词。提示词格式：所有的提示词都遵循 “[环境], [角色], [动作].” (“[Environment], [Character], [Action].”) 的固定格式。数据量：每组包含 5-8 个提示词，总共为这两个任务生成了超过 200 个 T2I 提示词。

两大评估任务

背景保持任务 (Background maintaining)：在这一组提示词中，“[环境]” 和 “[角色]” 保持一致，只有 “[动作]” 发生变化。这用来测试模型在人物乱动时，能不能稳住背景。
背景切换任务 (Background switching)：在这一组中，只有 “[角色]” 保持不变（环境和动作都变）。这用来测试模型能不能在完全不同的场景下，依然认出并画出同一个人。

对比方法

作者挑选了两类最具代表性的基线方法来进行擂台比拼：

免训练一致性方法：StoryDiffusion 和 ConsiStory 。这是同赛道的直接竞争对手。
依赖训练的身份参考方法：IP-Adapter 和 PhotoMaker 。为了让这类方法能跑起来，作者先用提示词里的 “[角色]” 部分生成头部照片，然后用 RetinaFace 裁剪出面部区域，作为这些方法的输入参考图。

评估指标

为了准确衡量什么是“细粒度（Fine-grained）”的一致性，作者除了使用常规指标，还引入了非常巧妙的解耦指标。

常规指标

使用 CLIP 文本-图像相似度 (CLIP-T) 来衡量生成的图像和文本提示词是否对齐，使用成对的 CLIP 图像相似度 (CLIP-I) 来衡量全图的整体一致性。

CLIP-T

物理意义：衡量生成的图像与你输入的文本提示词（Prompt）有多契合。
计算本质：利用 OpenAI 预训练的 CLIP 模型，分别提取文本特征和图像特征，然后计算这两个高维向量在同一特征空间中的余弦相似度。
数学抽象：假设 CLIP 的文本编码器提取的向量为 EtextE_{text}Etext，图像编码器提取的向量为 EimageE_{image}Eimage，则： CLIP-T=Etext⋅Eimage∣∣Etext∣∣2×∣∣Eimage∣∣2CLIP\text{-}T = \frac{E_{text} \cdot E_{image}}{||E_{text}||_{2} \times ||E_{image}||_{2}}CLIP-T=∣∣Etext∣∣2×∣∣Eimage∣∣2Etext⋅Eimage 得分越接近 111，说明图文越匹配。

CLIP-I

物理意义：衡量生成的一批图像（比如同一组 prompt 生成的 5 张图）之间的全图一致性。
计算本质：只使用 CLIP 的图像编码器。将同一组内生成的图像两两配对，计算它们图像特征向量的余弦相似度，最后求整个组的平均值。
数学抽象：对于一组生成的 MMM 张图像，计算所有互异对 (i,j)(i, j)(i,j) 的相似度平均： CLIP-I=2M(M−1)∑i=1M−1∑j=i+1MEimg_i⋅Eimg_j∣∣Eimg_i∣∣2×∣∣Eimg_j∣∣2CLIP\text{-}I = \frac{2}{M(M-1)} \sum_{i=1}^{M-1} \sum_{j=i+1}^{M} \frac{E_{img\_i} \cdot E_{img\_j}}{||E_{img\_i}||_{2} \times ||E_{img\_j}||_{2}}CLIP-I=M(M−1)2∑i=1M−1∑j=i+1M∣∣Eimg_i∣∣2×∣∣Eimg_j∣∣2Eimg_i⋅Eimg_j

解耦的 CLIP-I

这是评估体系的一大亮点。为了分别评估前景和背景的一致性，作者引入了 CLIP-I-fg（前景）和 CLIP-I-bg（背景）。他们使用 SAM (Segment Anything) 模型对每张生成的图像进行前景分割，然后对遮罩后的前景和背景图像分别计算 CLIP 相似度。 计算流程 ：

先用 SAM (Segment Anything) 大模型把生成的每张图的前景人物精确地抠出来，得到一个二值掩码（Mask，MfgM_{fg}Mfg）。
用原始图像乘以掩码（Image⊙MfgImage \odot M_{fg}Image⊙Mfg）得到只有前景的纯净图像（背景全黑）；用原始图像乘以反向掩码（Image⊙(1−Mfg)Image \odot (1 - M_{fg})Image⊙(1−Mfg)）得到只有背景的图像。
把这些抠好的纯前景图和纯背景图分别送入 CLIP 算图像特征。
对纯前景特征算一遍公式 2，就是 CLIP-I-fg；对纯背景算一遍，就是 CLIP-I-bg。

身份相似度

为了评估面部身份的一致性，使用 RetinaFace 和 FaceNet 计算面部嵌入的相似度。

物理意义：专门用来“刷脸”，测试人物的面孔是不是同一个人。因为 CLIP 模型看全身比较准，但对极细微的面部特征不敏感。
计算流程 ：
1. 使用 RetinaFace 检测出图像中的人脸边界框并裁剪。
2. 送入专门做人脸识别的预训练模型 FaceNet，提取专门的人脸特征嵌入（Facial Embedding）。
3. 同样使用余弦相似度公式，计算同一组图像中人脸特征的成对相似度平均值。

图像质量指标

使用 Q-Align 计算图像质量得分 (IQS) 和图像美学得分 (IAS)。

物理意义：衡量生成的图像画质好不好（IQS，有没有模糊、噪点）以及美不美（IAS，构图、色彩分布）。
计算本质：这不是一个简单的数学公式可以算出来的。论文使用了 Q-Align 模型。这通常是一个大型的多模态大语言模型（VLM），它被训练成像人类考官一样，直接“看”图并给出一个连续的评分。

对比实验

在表 1 中，作者展示了在“背景保持”和“背景切换”两大任务下的得分。

对比免训练同行 (StoryDiffusion, ConsiStory)： CharaConsist 在绝大多数一致性指标上都取得了最优成绩，尤其是在解耦的 CLIP-I-bg (0.916) 和 ID Sim (0.647) 上遥遥领先。这证明了依靠精确的 Mask 和点追踪，它不仅能稳住人物，还能完美锁定背景细节。
对比需要训练的方法 (IP-Adapter, PhotoMaker)：在 CLIP-I-fg 和 CLIP-I-bg 上，CharaConsist 显著优于这些依赖训练的方法。原因很简单，PhotoMaker 它们眼里只有那张“脸”，根本不管衣服和背景是不是变了。合理的劣势：在 ID Sim (身份相似度) 上，CharaConsist 没有超过 PhotoMaker (0.647 vs 0.891) 。但作者坦言，这并不矛盾。人家是拿成千上万张人脸专门训练出来的，而咱们是免训练的即插即用方法。

审稿人看这篇论文时肯定会问一个极其尖锐的问题：“你用了最新的 FLUX.1，别人用的是老旧的 SDXL，你的效果好，是不是纯粹因为 FLUX.1 画质好？” 作者在表 2 中用“增量对比 (Consistency increments comparison)”完美反击：

作者直接测试了未经任何修改的 FLUX.1 原生模型的生成一致性。结果发现，FLUX.1 的原生一致性得分（比如 CLIP-I）其实比基于 SDXL 的基线模型还要低。
但是，一旦加上了 CharaConsist 的魔法，它的增量是所有方法中最大的。比如 ID Sim 直接提升了 +0.171（相比之下 ConsiStory 只提升了 +0.130）。这铁证如山地表明：优异的效果源于作者提出的点追踪和自适应融合算法，而不是抱了 FLUX.1 的大腿。

消融实验

为了证明自己没有写一句废代码，作者把系统一层层剥开：

Baseline (纯 T2I)：没有任何一致性保护。
- (a) 点追踪注意力：加上这一步后，CLIP-I 和 ID-Sim 都有了显著提升（ID-Sim 从 0.476 飙升到 0.572）。这证明了打破 RoPE 局部性偏见是极其有效的。
- (a, b) 叠加自适应 Token 融合：指标进一步攀升（ID-Sim 达到 0.645）。这说明插值融合成功兜底了点追踪带来的几何破坏和匹配噪点。
- (a, b, c) 叠加前背景 Mask：此时 CLIP-I-bg 达到了最高的 0.916 。这证明了解耦控制对稳定背景起到了决定性作用。
同时，加入这些模块后，IAS 和 IQS (图像质量得分) 几乎没有下降，稳定在 0.985 左右，证明这套方法是无损的。

视觉定性对比

跳出冷冰冰的数据，作者在图 2、图 10-13 中展示了生成的效果图。

摆脱“复制粘贴”：其他免训练方法为了保持一致性，经常会把人物“卡死”在一个姿势，完全忽略了文本里要求的动作变化（比如要求“拿手机”、“拍照”，模型根本不理会）。
细粒度之王：CharaConsist 不仅能让人物做出大幅度的新动作（比如举手、跑步），还能极其变态地保持细微背景的一致（比如图 11 中咖啡馆背景里黑板上的粉笔字，都做到了惊人的保持）。

局限性与未来探索

核心局限

论文的自白：作为一个专注于“免训练（Training-free）”的一致性生成方法，CharaConsist 的强项在于根据文本提示词（Prompt）凭空捏造出一个前后一致的角色和场景，但它无法接受外部输入的真实身份图片作为参考。
本质原因：因为整个系统没有引入任何额外的图像编码器（如 CLIP Image Encoder）或投影层，所有的特征都来源于第一阶段原生 FLUX.1 生成的“身份图”。如果你想输入一张你自己的真实自拍照，让模型生成你打篮球的动作，CharaConsist 是做不到的。

破局思路

在论文的最后，作者非常坦诚地指出了一个极具潜力的未来探索方向：将训练驱动的“身份参考模型”与 CharaConsist 结合起来。

Identity-reference 方法（如 PhotoMaker, IP-Adapter）的优势：它们擅长接受外部输入，能牢牢抓住人脸的特征（Facial similarity），保持极高的面部逼真度。
CharaConsist 的优势：能够精准控制背景环境（Background environments）和人物服装（Character clothing）的一致性，且不受大动作偏移的影响。
完美互补：如果让 IP-Adapter 负责“画脸”，让 CharaConsist 负责“画衣服和背景”，就能在保持真实身份的同时，实现高保真的细粒度场景控制。

《StoryDiffusion》论文精读

小yo — Wed, 04 Mar 2026 19:50:02 GMT

前置知识与背景

LDM

StoryDiffusion 是直接构建在 Stable Diffusion（SD 1.5 和 SD XL）之上的即插即用模块。原始的 DDPM 是直接在原图的像素空间 RH×W×3\mathbb{R}^{H \times W \times 3}RH×W×3 上预测噪声，计算量极大。LDM 的核心突破是引入了一个低维的潜空间表示 z∈Rh×w×cz \in \mathbb{R}^{h \times w \times c}z∈Rh×w×c 中。所有的扩散过程都在这个极小、极密集的潜空间中完成，最后再由 VAE 的 Decoder 将潜变量还原为像素图像。这种降维使得模型可以在消费级显卡上运行。

交叉注意力

在 U-Net 中，文本提示词首先经过 CLIP Text Encoder 变成词嵌入向量。然后，U-Net 在其网络层中穿插了交叉注意力模块。在这里，图像的潜变量特征作为 Q，而文本嵌入作为 K 和 V。这使得图像在生成时 2 能够关注到文本的语义指导。

PhotoMaker

PhotoMaker 是近期非常火的一种专门针对“身份保留（ID-Preservation）”的定制化生成技术，也是这篇论文重点对比的基线方法. 传统的人物定制方法（如 LoRA 或 DreamBooth）需要消耗显存和时间对 U-Net 的参数进行微调。PhotoMaker 采用了一种免微调 (Tuning-free) 的范式：不改模型权重，而是直接在文本输入端动手脚，创造一个极度富含人物特征的“超级词汇”。

核心机制：堆叠 ID 嵌入 (Stacked ID Embedding)

它的底层逻辑是将多张人物参考图压缩、融合，最后替换掉 Prompt 中的类别词。

编码器与架构实现步骤

双编码器特征提取：
- Image Encoder：使用预训练的视觉模型（如 CLIP ViT）分别提取出用户传入的 NNN 张参考图的图像特征向量。
- Text Encoder：使用 CLIP Text Encoder 提取用户 Prompt 中类别词（如 “man”、“woman”）的文本特征向量。
特征融合 (Fusion)：单纯的图像特征缺乏语义方向。PhotoMaker 通过一个多层感知机 (MLP) 或交叉注意力机制，将“类别词文本特征”与“每一张照片的图像特征”进行融合，得到 NNN 个既有精确长相、又有明确语义标签的融合向量。
维度拼接与堆叠 (Stacking)：这是最核心的一步。网络会将这 NNN 个融合向量沿着序列长度 (Sequence Length) 维度首尾相接，拼接在一起。如果一个普通词汇的 Embedding 长度是 1，那么这个“堆叠 ID”的长度就是 NNN。
注入 U-Net 交叉注意力 (Cross-Attention)：系统会将用户 Prompt（如 “A photo of a [man] in a cyberpunk city”）中的 [man] 这个词的特征，强行替换为上面生成的超长 Stacked ID Embedding。当文本条件进入 U-Net 的 Cross-Attention 层时，模型会像对待普通句子一样去 Attention 这个 ID 序列。因为这个堆叠的序列中包含了同一人物多角度、多表情的极高密度特征，模型能够在不改变网络权重的情况下，直接“抄袭”这些面部细节，生成高保真的新图像。这就是为什么论文中提到，PhotoMaker 虽然擅长保脸，但因为它的特征是通过文本通道（Cross-Attention）注入的，这种全局性的特征广播很难精准控制局部的场景和衣服（Attires），进而给 StoryDiffusion 的自注意力（Self-Attention）魔改留下了施展空间。

视频扩散模型

StoryDiffusion 不仅生成一致性图片，还能将其转化为视频。

3D 卷积

2 D 卷积：处理的是单张静态图像。它的输入张量形状通常是 [Batch, Channel, Height, Width]（对应 nn.Conv2d）。卷积核是一个二维矩阵，在图像的宽高平面上滑动，提取边缘、纹理等空间特征。
3 D 卷积：引入了第三个维度：时间（Temporal）或帧数。输入张量的形状变成了 [Batch, Channel, Time, Height, Width]（对应 nn.Conv3d）。此时，卷积核变成了一个三维的“小立方体”。它不仅在画面的宽高上滑动，还在时间轴（连续的视频帧）上滑动。这意味着它可以同时捕捉到画面内的空间特征，以及物体在前后帧之间的运动轨迹（时间特征）。

视频扩散模型的演进

早期尝试（全 3D 架构）：早期的视频扩散模型（如 VDM）非常直接，他们把图像 U-Net 里的 2D 卷积全部替换成 3D 卷积来实现视频生成。这在数学逻辑上很自然，但计算量和显存占用会呈指数级爆炸，极难训练。
主流解法（空时解耦）：为了降低计算成本，后来的架构（如 MagicVideo、AnimateDiff，以及 StoryDiffusion 借鉴的预训练模块）采取了妥协策略。它们保留了 U-Net 原始的 2D 卷积和空间自注意力层（专门负责画质和空间结构），然后在这些层之后插入一维的时间注意力（Temporal Attention）模块。这种解耦设计既利用了图像扩散模型的强大先验，又相对轻量地解决了帧间连贯性问题。

时间注意力

在视频扩散模型（如 AnimateDiff）中，纯 3D 卷积会导致计算量呈指数级爆炸，且极难训练。时间注意力的核心思想是“空时解耦”（Spatial-Temporal Decoupling）：在原本只处理空间特征的 2D U-Net 中，硬插入一个专门处理时间（帧与帧之间）特征的 1D Transformer 模块。理解时间注意力的关键在于数据在网络中传递时，形状（Shape）是如何重组的。假设当前特征图的形状为 [B,C,F,H,W][B, C, F, H, W][B,C,F,H,W]，即 [批次大小, 通道数, 帧数, 高度, 宽度]。

在空间自注意力 (Spatial Attention) 阶段：张量会被 Reshape 为 [(B×F),(H×W),C][(B \times F), (H \times W), C][(B×F),(H×W),C]。此时，时间维度 FFF 被折叠进了 Batch 中。模型会把它当成 B×FB \times FB×F 张独立的单张图片，在每一帧内部的各个物理像素之间计算注意力，提取画面细节。
在时间注意力 (Temporal Attention) 阶段：张量会被重新排列（Permute/Reshape）为 [(B×H×W),F,C][(B \times H \times W), F, C][(B×H×W),F,C]。此时，空间维度被折叠成了 Batch。这意味着，模型是在跨越时间序列 F，专门针对不同帧的同一个物理坐标计算相关性。比如，专门观察像素点，专门针对不同帧的同一个物理坐标计算相关性。比如，专门观察像素点，专门针对不同帧的同一个物理坐标计算相关性。比如，专门观察像素点(x, y)$ 从第 1 帧到第 16 帧的变化轨迹，从而确保运动的平滑和物理规律。 模块架构：一个标准的时间注意力模块（如 AnimateDiff 中的 Motion Module）通常包含以下组件：

输入与相对位置编码：序列进入模块后，首先会被加上时间位置编码 (Temporal Positional Encoding)，告诉模型哪一帧在前、哪一帧在后。
1 D Multi-Head Self-Attention：沿着帧数 FFF 维度进行标准的多头自注意力计算。
残差连接 (Residual Connection)：计算结果通过残差加回原始的网络流中（Output=Input+Attention(Input)Output = Input + Attention(Input)Output=Input+Attention(Input)）。在初始化阶段，时间注意力层最后的输出投影权重会被初始化为全零（Zero-initialization）。这意味着在未经训练时，它对原视频帧没有任何影响（完美退化回 Stable Diffusion 原本的图像生成状态），从而最大程度保留了预训练图像基座的强大画质先验。

研究背景与动机

现有方法的局限性

强引导导致的失控

IP-Adapter 通过提取参考图像的特征并作为条件注入模型，能很好地生成相似图像。但是，由于图像条件的引导力太强，会显著削弱用户通过文本提示词控制生成内容（如动作、场景）的能力。虽然IP-Adapter 确实暴露了一个 scale 权重参数（即你提到的 λ\lambdaλ）来控制图像特征的注入强度。但论文中提到的“引导力太强导致文本可控性降低” ，实际上是一个底层架构层面的特征冲突问题。

注入机制冲突： IP-Adapter 的核心设计是新增了一路交叉注意力层，将图像特征和文本特征一起作为条件注入到 U-Net 中。
特征密度的压制：图像提取出的特征向量通常极其稠密，包含了大量低级的视觉细节；而文本特征相对稀疏且抽象。当它们共同在交叉注意力中竞争时，稠密的图像特征很容易“喧宾夺主”，掩盖掉文本原本的指令。
两难的 Trade-off：如果你把 λ\lambdaλ 调低，文本的控制力（比如让人物“奔跑”或“喝水”）确实回来了，但参考图中人物的脸部细节和身份也就跟着模糊和丢失了。这是一个典型的零和博弈。

服装与场景的割裂

PhotoMaker，它专注于身份 (ID) 的控制。虽然脸长得一样，但它无法保证角色在不同图像中的服装 (attires) 和场景的连贯性，这对于“讲故事”来说是致命的缺陷。论文指出，PhotoMaker 专注于控制人物身份，确实能保证脸部长得一样。但是，对于连环画或视频这种需要叙事的场景来说，它无法保证人物在第一张图和第二张图里的服装（Attire）和所处场景是一致的。可以参考论文图 4 中的园丁例子，PhotoMaker 生成的三张图虽然脸一样，但穿的工装裤细节和帽子款式完全变了。

视频过渡差

现有的过渡视频生成方法 (如 SEINE 和 SparseCtrl) 仅仅依赖图像潜空间中的时间网络来预测中间内容。论文指出，这种方法在处理角色大幅度运动等复杂过渡时表现很差。

核心动机

论文的目标是寻找一种极其轻量级的方法，最好是零样本 (Zero-shot) 和免训练的。它既要保持人物身份和服装的绝对一致，又要最大化文本的控制力。针对 IP-Adapter 的问题，StoryDiffusion 为了跳出这个困局，选择完全不去动交叉注意力（把条件控制权100%还给文本），而是去魔改原生的自注意力，让同一个 Batch 内的图片互相“参考”，从而在零样本的情况下既保持了身份一致，又没有削弱文本的控制力。而PhotoMaker 虽然擅长保脸，但因为它的特征是通过文本通道（Cross-Attention）注入的，这种全局性的特征广播很难精准控制局部的场景和衣服（Attires），进而给 StoryDiffusion 的自注意力魔改留下了施展空间。

核心架构

论文通过两个极其优雅的模块，分别解决了一致性图像生成和过渡视频生成的问题。

一致性自注意力

在之前的工作中，U-Net 中的 Cross-Attention 负责文本控制，而 Self-Attention 负责图像内部的全局结构。StoryDiffusion 的作者非常巧妙地想到：如果在计算自注意力时，能让模型不仅只关注当前图片，还能与同批次（Batch）里的其他图片建立联系，就能保持一致性。

Batch 图像

在传统的 DDPM 或标准的 Stable Diffusion 训练和推理中，Batch 里的图像确实是互相独立的，它们被打包在一起仅仅是为了吃满 GPU 的算力，做并行计算。但在 StoryDiffusion 中，Batch 的语义被彻底改变了。

从“独立样本”变成了“故事序列”：在生成时，StoryDiffusion 会将一个完整的故事文本拆分成多个提示词，并在同一个 Batch 中同时生成这些提示词对应的图像。也就是说，这个 Batch 里的图天生就是一组需要具备逻辑关联的连环画分镜。
具体是如何实现关联的？核心机制就是通过修改 U-Net 中的自注意力层。在计算单张图片 IiI_iIi 的自注意力时，模型会使用随机采样函数（RandSample）跨越 Batch 的限制，把 Batch 内其他图片（I1,I2,...,Ii−1,Ii+1,...,IBI_1, I_2, ..., I_{i-1}, I_{i+1}, ..., I_BI1,I2,...,Ii−1,Ii+1,...,IB）的特征提取出来一部分（即采样 Token SiS_iSi）。然后，把这些从其他图片借来的 Token 和当前图片的 Token 拼在一起参与计算。这就强制打破了 Batch 内图像的独立性，让它们在生成过程中互相“参考”，从而实现了角色的长相和服装统一。

理论与公式推演

传统的 Self-Attention：对于单张图像的特征 IiI_iIi，原本是独立进行的，通过线性映射生成查询 QiQ_iQi、键 KiK_iKi 和值 ViV_iVi 。随后进行注意力计算： Oi=Attention(Qi,Ki,Vi)O_i = \text{Attention}(Q_i, K_i, V_i)Oi=Attention(Qi,Ki,Vi)
引入外部参考 (Sampling)： Consistent Self-Attention 会从批次内的其他图像特征中随机采样一部分 token，记为 SiS_iSi ： Si=RandSample(I1,I2,...,Ii−1,Ii+1,...,IB)S_i = \text{RandSample}(I_1, I_2, ..., I_{i-1}, I_{i+1}, ..., I_B)Si=RandSample(I1,I2,...,Ii−1,Ii+1,...,IB)
特征拼接与计算：将这些采样来的 SiS_iSi 与当前图像的特征 IiI_iIi 组合成新的集合 PiP_iPi 。请注意这里的核心细节：原始的查询向量 QiQ_iQi 保持不变**，只对组合后的 PiP_iPi 进行线性映射得到新的键 KPiK_{Pi}KPi 和值 VPiV_{Pi}VPi 。然后进行全新的自注意力计算： O=Attention(Qi,KPi,VPi)O = \text{Attention}(Q_i, K_{Pi}, V_{Pi})O=Attention(Qi,KPi,VPi) 这种跨图像的特征交互，能够促使模型在生成过程中收敛出一致的角色、面部和服装，而且完全不需要额外的训练。

线性映射当我们把当前图像特征 IiI_iIi 和其他图像采样来的 SiS_iSi 拼接成新的集合 PiP_iPi 后，确实需要对 PiP_iPi 进行线性映射来生成键 KPiK_{Pi}KPi 和值 VPiV_{Pi}VPi 。但是，这里使用的线性映射权重（Q-K-V weights），完全是直接拿 Stable Diffusion 原本就训练好的权重来用的。所以说一致性注意力是免训练的。

Algorithm 1 伪代码详解

def ConsisentSelfAttention(images_features,sampling_rate,tile_size):
	"""
	images_token: [B, C, N]
	sampling_rate: Float (0-1)
	tile_size: Int
	"""
	output = zeros(B,N,C),count = zeros(B,N,C),W = tile_size
	for t in range(0,N - tile_size+1):
		# Use tile to override out of GPU memory
		tile_features = images_tokens[t:t + W,:,:]
		reshape_feature = tile_feature.reshape(1,W*N,C).repeat(W,1,1)
		sampled_tokens = RandSample(reshape_feature,rate=sampling_rate,dim=1)
		
		# Concat the tokens from  other images with the original tokens
		token_KV = concat([sampled_tokens,tile_features],dim=1)
		token_Q = tile_features
		
		# perform attention calculation:
		X_q,X_k,X_v = Linear_q(token_Q),Linear_k(token_KV),Linear_v(token_KV)
		output[t:t+W,:,:] += Attention(X_q,X_k,X_v)
		count[t:t+W,:,:] += 1
		
	output = output/count
	return output

首先，我们不得不质疑作者在这个伪代码里出现一个笔误：作者定义了输入的维度：images_tokens: [B, N, C]。然后，作者写了那个切片操作：tile_features = images_tokens[t:t+W, :, :] 。这里的切片是发生在第一个维度（索引为 0 的维度）上，也就是Batch 维度 (BBB)。但作者写的循环条件：for it in range(0, N - tile_size + 1): 。他用代表单图 Token 数量的 NNN 去减窗口大小，这在张量维度上是完全说不通的。结合论文正文中提到的“沿时间维度的滑动窗口”，这里正确的逻辑应该是： for t in range(0, B - tile_size + 1):

认识到这个笔误之后，我们开始逐行解读。

初始化与滑动窗口

output = zeros(B, N, C), count = zeros(B, N, C), W = tile_size
for t in range(0, B - W + 1): # 修正了原论文的 N 为 B
    tile_features = images_tokens[t:t + W, :, :]

假设我们生成一个 B=10B=10B=10 张图的故事，窗口 W=3W=3W=3。第一轮循环（t=0t=0t=0），我们把第 1、2、3 张图的特征（tile_features，形状为 [3,N,C][3, N, C][3,N,C]）切出来。第二轮（t=1t=1t=1），切第 2、3、4 张图。这就形成了重叠的滑动窗口。

构建“共享特征池” (Pooling Features)

    reshape_feature = tile_features.reshape(1, W*N, C).repeat(W, 1, 1)

这一步非常巧妙。模型先用 .reshape(1, W*N, C) 把这 WWW 张图的所有 Token 全部倒进一个大池子里，摊平成一个超长的序列（长度为 W×NW \times NW×N）。
然后用 .repeat(W, 1, 1) 把这个大池子复制 WWW 份。为什么？因为当前窗口里有 WWW 张图，我们要保证这 WWW 张图里的每一张，都能拿到一模一样的、包含了大家所有特征的完整大池子。此时张量形状变成 [W,W×N,C][W, W \times N, C][W,W×N,C]。

随机采样 (Random Sampling)

    sampled_tokens = RandSample(reshape_feature, rate=sampling_rate, dim=1)

如果把所有图的特征全用来算 Attention，计算量太大了。所以在这个包含 W×NW \times NW×N 个 Token 的池子里，我们按照 sampling_rate（比如 0.5）随机抽样一部分 Token 出来。
这就相当于：第 1 张图不仅有自己的特征，还随机抽取了第 2 张和第 3 张图的一部分特征。

组装 Q、 K、V 的原材料

    token_KV = concat([sampled_tokens, tile_features], dim=1)
    token_Q = tile_features

这是点睛之笔。
对于查询 (Query)：token_Q 只用当前图片自己的特征（tile_features）。
对于键 (Key) 和值 (Value)：token_KV 把其他图的采样特征和当前图像的特征拼在了一起。

免训练的注意力计算 (Training-Free Attention)

    X_q, X_k, X_v = Linear_q(token_Q), Linear_k(token_KV), Linear_v(token_KV)
    output[t:t+W, :, :] += Attention(X_q, X_k, X_v)
    count[t:t+W, :, :] += 1

用 SD 模型原有的线性层权重（预训练好的），分别映射出 Q,K,VQ, K, VQ,K,V 进行标准的自注意力计算。
因为我们的窗口是重叠滑动的（步长为 1），同一张图（比如第 2 张图）会在多个窗口中被重复计算。所以需要用 output 把每次算出来的特征累加起来，并用 count 记录它到底被算了几次。

收尾平均

output = output / count
return output

循环结束后，把累加的特征除以计算次数。这种重叠平均极其有效地平滑了不同窗口之间的特征差异，保证了整个长篇故事从头到尾的绝对一致。

语义运动预测器

生成了一系列具有一致性的静态图（例如连环画的分镜）后，作者又将它们转化为流畅的过渡视频。

现有的过渡视频生成方法与时间网络的局限

在探讨 StoryDiffusion 为什么要做改变之前，我们需要看看现有的基线模型是怎么做的。

代表性方法：论文中主要对比了目前最前沿的两种过渡视频生成方法：SEINE 和 SparseCtrl 。SEINE 在训练时通过随机掩码视频序列，让模型学习预测两帧之间的过渡；而 SparseCtrl 则是引入了一个稀疏控制网络，使用稀疏控制数据来合成控制信息指导视频生成。
“潜空间的时间网络”：这两个方法在预测中间帧时，完全依赖于图像潜空间中的时间网络。这种时间模块通常是 1D 的注意力机制，它是独立地在每个空间位置的像素上运行的。
致命痛点：因为时间模块只盯着固定坐标点 (x,y)(x,y)(x,y) 随着时间的变化，它在推断中间帧时对整体空间位置信息的考量是不充分的。这就导致它很难对长距离和具有物理意义的大幅度运动进行建模。比如人物从左边大跨步走到右边，原有的像素点直接做时间插值就会出现画面崩坏。

在“语义空间”预测运动

为了解决上述问题，StoryDiffusion 选择在更高级的“语义空间”而非“像素/潜空间”来规划运动轨迹。大体思路如下：

特征编码 (Encoding)：不直接使用线性层，而是利用预训练的 CLIP 图像编码器 (EEE)，将给定的起始帧 FsF_sFs 和结束帧 FeF_eFe 压缩到图像语义空间中，得到编码空间信息的向量 KsK_sKs 和 KeK_eKe 。 Ks,Ke=E(Fs,Fe)K_s, K_e = E(F_s, F_e)Ks,Ke=E(Fs,Fe)
运动预测：在语义空间中，首先执行线性插值，将 KsK_sKs 和 KeK_eKe 扩展为长度为 LLL（所需视频长度）的序列 K1,K2,...,KLK_1, K_2, ..., K_LK1,K2,...,KL 。随后，将该序列送入一系列 Transformer Block (BBB) 中预测过渡帧： P1,P2,...,PL=B(K1,K2,...,KL)P_1, P_2, ..., P_L = B(K_1, K_2, ..., K_L)P1,P2,...,PL=B(K1,K2,...,KL)

线性插值：标准的线性插值（LERP）的数学计算公式如下： Ki=Ks+i−1L−1(Ke−Ks)K_i = K_s + \frac{i-1}{L-1}(K_e - K_s)Ki=Ks+L−1i−1(Ke−Ks) 其中，iii 表示当前需要计算的中间帧索引（取值范围从 111 到 LLL）。

Transformer Block 的具体架构：根据论文附录 B 的说明，这里的 Semantic Motion Predictor 包含了 8 个 Transformer 层，隐藏维度被设置为 1024，并配备了 12 个注意力头。它使用的图像特征提取器是 OpenCLIP ViT-H-14 预训练模型。输入与输出维度（结合论文图 3）：

初始输入：首尾两帧经过 Image Encoder 后，提取出的维度表示为 2×N×C2 \times N \times C2×N×C 。这里 222 代表起始和结束两帧，NNN 代表 ViT 模型切分出的图像 Token 数量，CCC 就是通道数（即上文提到的 1024）

插值后输入：经过语义空间插值（Semantic Space Interpolation）后，序列被扩展为目标帧数 FFF（对应前文公式中的 LLL），输入进 Transformer Block 的张量维度变成了 F×N×CF \times N \times CF×N×C 。

预测输出：经过 8 层 Transformer Block 处理后，输出的预测过渡嵌入依然保持 F×N×CF \times N \times CF×N×C 的维度。最终，这 FFF 帧的语义嵌入序列会被送入视频扩散模型的 U-Net 中，作为交叉注意力的控制信号，逐帧指导视频的生成。

特征注入解码 (Decoding)：受到图像提示 (Image Prompt) 方法的启发，这些预测出的语义嵌入会被当作控制信号。在视频扩散模型进行解码时，对于每一帧的视频特征 ViV_iVi，模型会将文本嵌入 TTT 与预测的图像语义嵌入 PiP_iPi 拼接起来，并在 U-Net 的交叉注意力中进行计算： Vi=CrossAttention(Vi,concat(T,Pi),concat(T,Pi))V_i = \text{CrossAttention}(V_i, \text{concat}(T, P_i), \text{concat}(T, P_i))Vi=CrossAttention(Vi,concat(T,Pi),concat(T,Pi)) 通过将图像编码到语义空间以整合空间位置关系，Semantic Motion Predictor 能够更好地对运动信息进行建模，从而成功生成包含大幅度平滑运动的过渡视频

实验设计与评估

数据集

StoryDiffusion 需要训练模型理解“如何根据起点和终点，预测中间符合物理规律的运动”，这需要海量真实的视频数据来让模型学习真实世界物体移动、镜头平移的先验知识。论文中明确提到，在训练过渡视频模型（Semantic Motion Predictor）时，他们使用了 WebVid-10M 数据集。 WebVid-10M（全称 WebVid-10 Million）是目前学术界进行文本到视频（Text-to-Video）生成研究最常用的开源大规模数据集之一（由 Bain 等人在 2021 年提出）。顾名思义，它包含了大约 1000 万个短视频片段（通常是几秒钟到十几秒的素材视频，带有水印），并且每个视频都配有详细的自然语言描述。

图像一致性评价指标

在评估一致性自注意力模块时，论文使用了两个核心指标：文本-图像相似度 (Text-Image Similarity) 和角色相似度 (Character Similarity) 。它们的底层核心都是 CLIP Score。 CLIP 是 OpenAI 提出的一个图文匹配模型。它包含一个图像编码器和一个文本编码器，能把图片和文本映射到同一个高维特征空间里。如果一段文字和一张图片描述的是同一个东西，它们在这个空间里的向量夹角就会非常小（余弦相似度接近 1）。

计算公式（余弦相似度，Cosine Similarity）：假设我们提取出了特征向量 AAA 和特征向量 BBB： Similarity(A,B)=A⋅B∥A∥∥B∥=∑i=1nAiBi∑i=1nAi2∑i=1nBi2\text{Similarity}(A, B) = \frac{A \cdot B}{\|A\| \|B\|} = \frac{\sum_{i=1}^{n} A_i B_i}{\sqrt{\sum_{i=1}^{n} A_i^2} \sqrt{\sum_{i=1}^{n} B_i^2}}Similarity(A,B)=∥A∥∥B∥A⋅B=∑i=1nAi2∑i=1nBi2∑i=1nAiBi

Text-Image Similarity：AAA 是提示词的文本向量，BBB 是生成图像的图像向量。分数越高（↑\uparrow↑），说明生成的图越听文本的话。
Character Similarity：AAA 和 BBB 分别是同一个 Batch 里生成的两张不同图片的图像向量（用来特指人物脸部区域）。分数越高（↑\uparrow↑），说明这两张图里的人长得越像。

过渡视频连贯性评价指标

在评估视频生成质量时，单看一帧是不够的，核心是要看帧与帧之间的关系。论文使用了 LPIPS 和 CLIPSIM，并且分别计算了 -first 和 -frames 两种变体。

LPIPS (Learned Perceptual Image Patch Similarity)

这是计算机视觉中用来衡量两张图片感知差异（视觉特征上的差异）的标准指标。传统指标（如 MSE）只计算像素差，而 LPIPS 利用预训练好的神经网络（如 VGG）提取深层特征来比较，更符合人类眼睛的直观感受。

指标特性：这是一个距离度量，数值越低越好（↓\downarrow↓）。数值越低，说明两张图在人眼看来差异越小、过渡越平滑。
计算公式：给定两张输入图像 xxx 和 x0x_0x0，将它们送入预训练网络，提取第 lll 层的特征 y^l\hat{y}^ly^l 和 y^0l\hat{y}_0^ly^0l： d(x,x0)=∑l1HlWl∑h,w∥wl⊙(y^hwl−y^0hwl)∥22d(x, x_0) = \sum_l \frac{1}{H_l W_l} \sum_{h,w} \| w_l \odot (\hat{y}_{hw}^l - \hat{y}_{0hw}^l) \|_2^2d(x,x0)=∑lHlWl1∑h,w∥wl⊙(y^hwl−y^0hwl)∥22 (简单来说：就是把两张图塞进神经网络，算出每一层特征图的差值的平方和，再加权求总。)

CLIPSIM (CLIP Similarity)

与 LPIPS 侧重于底层/中层的视觉感知不同，CLIPSIM 还是基于上面提到的 CLIP 余弦相似度，但在这里它是用来衡量视频帧之间的高层语义连贯性。

指标特性：数值越高越好（↑\uparrow↑）**。

“-first” 与 “-frames” 的区别

为了全面评估视频不闪烁、不崩坏，论文对 LPIPS 和 CLIPSIM 分别测了两种跨度：

-first (首帧对比)：计算第 111 帧与第 222 帧、第 111 帧与第 333 帧… 第 111 帧与第 LLL 帧的相似度平均值。这反映了视频的整体连续性。如果视频后面彻底跑题变样了，这个分会很差。
-frames (相邻帧对比)：计算第 111 帧与第 222 帧、第 222 帧与第 333 帧的相似度平均值。这反映了帧与帧之间的连续性。如果视频有突然的闪烁或动作卡顿，这个分数会很差。

对比实验

图像一致性对比

在连环画和故事生成中，一个完美的模型需要做到“既要、又要、还要”：既要主角长得一样，又要衣服一致，还要完美服从 Prompt 的动作指令。 定性分析 论文精心挑选了 IP-Adapter 和 PhotoMaker 作为对手，并组合了不同的角色和动作提示词。

IP-Adapter 的“失控”：在“Stargazing with a telescope”的例子中，IP-Adapter 生成的图像直接丢失了“望远镜” ；在“A focused gamer…”的例子中，它在第二张图丢失了“狗”，第三张图丢失了“扑克牌” 。这完美印证了之前讨论的痛点：图像条件太强，导致文本控制力下降。
PhotoMaker 的“换装秀”： PhotoMaker 虽然成功生成了符合文本的动作，但能明显看到同一行里人物的服装出现了巨大的差异（比如工装裤和草帽的款式完全变了），它无法保持服装（attire）的一致性。
StoryDiffusion 的全面碾压：论文的方法在保持相同面部和相同服装的同时，还能精准符合提示词的描述。
定量分析： 这不仅是视觉感受，数据也支持这一点。
Text-Image Similarity ：衡量图片是否听从文本指令。StoryDiffusion 拿到了 0.6586，超过了 IP-Adapter (0.6129) 和 PhotoMaker (0.6541) 。
Character Similarity ：衡量人物是否长得一样。StoryDiffusion (0.8950) 依然是第一名。
核心结论：即使在零训练的情况下，StoryDiffusion 依然在文本可控性和主体相似度上取得了最好的表现。

过渡视频生成对比

接下来看 Semantic Motion Predictor 的威力。这部分对比了目前最前沿的 SEINE 和 SparseCtrl。 定性分析： 这部分的对比非常惨烈。

SEINE：在“两人水下接吻”的例子中，中间帧直接损坏，然后突兀地跳到最后一帧；在第二个例子中，生成了损坏的手臂。
SparseCtrl：虽然连续性稍微好一点，但中间帧依然包含损坏的图像（比如出现了无数只手），且无法保持外观的连贯性。
StoryDiffusion：生成了非常平滑的运动，没有损坏的中间帧，并且严格遵守了物理空间关系，而不是仅仅在过渡中改变外观。这就印证了“语义空间”预测比“潜空间”插值更懂物理世界的运动规律。 定量分析： 评价视频质量主要看两个维度：画面的流畅度 (LPIPS) 和语义的连贯性 (CLIPSIM) 。
LPIPS-first / LPIPS-frames (越低越好)： 衡量首帧与其他帧的差异，以及相邻帧的差异。StoryDiffusion 分别取得了 0.3794 和 0.1635 的最佳成绩。
CLIPSIM-first / CLIPSIM-frames (越高越好)： 衡量整体连续性和帧间连续性。StoryDiffusion 分别取得了 0.9606 和 0.9870，全面领先对手。

除此之外，论文还做了一个用户调研，在图像生成上 72.8% 的用户偏好 StoryDiffusion，而在视频生成上，这个比例高达 82% 。

局限性与思考

重新审视注意力机制

Self-Attention 的本质扩展：在 DiT 中，作者直接用 Transformer Block 替换了传统的 U-Net，证明了 Self-Attention 在捕捉图像内部全局结构上的强大能力。而 StoryDiffusion 的巧妙之处在于，它证明了 Self-Attention 的“感受野”不必局限于单张图片。通过简单的张量拼接操作，它将 Self-Attention 的作用域扩展到了图像之间，实现了特征的跨图流动。
解耦控制的哲学：很多的改进工作（如 IP-Adapter）喜欢在 Cross-Attention 上做文章来注入条件，但这往往会导致图像条件和文本条件的“神仙打架” 。StoryDiffusion 给出了一个优雅的解耦方案：Cross-Attention 专心听文本的话，Self-Attention 专心负责画面的结构和人物统一。这种不增加额外参数（免训练）的即插即用设计，非常值得在未来的算法架构设计中借鉴。

局限性

在论文的附录 C 中，作者非常坦诚地指出了 StoryDiffusion 目前面临的两个核心瓶颈，这也是未来值得继续研究的方向。

细微特征的失忆

尽管 Consistent Self-Attention 能很好地保持角色的面部和整体服装款式，但在一些非常细微的服装细节上（例如领带的样式、衣服上的小图案），依然会出现前后不一致的情况。这和现有的其他先进方法（如 IP-Adapter）面临的困境相似。作者提到，在面对这种情况时，模型需要依赖更加详尽的文本提示词，来强制 Cross-Attention 去关注并修正这些细节。

长视频生成的短视

为了支持长故事的生成并防止显存溢出，论文在时间维度上引入了滑动窗口机制。这虽然消除了峰值显存对输入文本长度的依赖，使得生成长故事成为可能。但是，滑动窗口本质上是一种局部优化策略。当需要生成非常长的视频时，由于缺乏全局的信息交换，首尾帧之间或者相隔较远的帧之间，可能会逐渐失去连贯性，产生状态漂移。因此，该方法目前还不能完美胜任超长视频的生成。

《IP-Adapter》论文精读

小yo — Tue, 03 Mar 2026 23:32:35 GMT

前置知识基石

LDM

IP-Adapter 是构建在预训练的文本到图像扩散模型基础之上的，论文中使用的是 Stable Diffusion v1.5。相较于 DDPM，SD 的核心改进在于引入了潜在空间：

它首先使用一个预训练好的 Autoencoder（如 VQ-VAE）将大尺寸图像压缩成低维的特征矩阵。
扩散过程全部在这个低维的 latent 空间中进行，这就大大降低了计算复杂度。
最后，再用 Autoencoder 的 Decoder 将去噪后的 Latent Code 还原成像素图像。 IP-Adapter 并没有改变这个宏观的扩散过程，它冻结了 SD 原本的 U-Net，只在里边增加了一些新结构。

交叉注意力

在 SD 中，我们需要根据文本生成图像，这就需要用到 Cross-Attention 层把文本信息喂给 U-Net。在 SD 的 U-Net 中，图像的 Latent 隐变量提取出 Query，而文本特征提取出 Key 和 Value。注意力计算公式为： Z′=Attention(Q,K,V)=Softmax(QK⊤d)VZ^{\prime}=Attention(Q,K,V)=Softmax(\frac{QK^{\top}}{\sqrt{d}})VZ′=Attention(Q,K,V)=Softmax(dQK⊤)V 而这正是这篇论文动刀子的地方。以前的文本生成图像是用文本特征做 KKK 和 VVV ；现在我们要用图像做 Prompt，把图像特征变成 KKK 和 VVV 融合进去。

CLIP 模型

论文中反复提到 CLIP Text Encoder 和 CLIP Image Encoder。 CLIP 是一个通过对比学习训练出来的多模态模型，它包含一个文本编码器和一个图像编码器。它的神奇之处在于：它把一张图片和这张图片的描述文字，映射到了同一个特征空间里。本篇论文使用冻结的预训练 CLIP 图像编码器来提取参考图像的特征。因为 CLIP 提取出的图像特征天然和文本特征在同一个维度空间，这就为替换或融合文本特征提供了基础。

CFG

在条件扩散模型中，为了让生成的图像更强烈地贴合我们的条件（比如给定的文本），通常会使用无分类器引导。

训练时：有一定的概率（比如 10%）把条件（文本或图像）扔掉（置空），让模型同时学习“有条件生成” ϵθ(xt,c,t)\epsilon_{\theta}(x_{t},c,t)ϵθ(xt,c,t) 和“无条件生成” ϵθ(xt,t)\epsilon_{\theta}(x_{t},t)ϵθ(xt,t) 。
推理时：通过一个权重 www（Guidance Scale）来放大条件的影响力： ϵ^θ(xt,c,t)=wϵθ(xt,c,t)+(1−w)ϵθ(xt,t)\hat{\epsilon}_{\theta}(x_{t},c,t)=w\epsilon_{\theta}(x_{t},c,t)+(1-w)\epsilon_{\theta}(x_{t},t)ϵ^θ(xt,c,t)=wϵθ(xt,c,t)+(1−w)ϵθ(xt,t) 本篇论文在训练 IP-Adapter 时同样使用了随机丢弃图像条件的方法，以支持推理时的 CFG。

研究背景与动机

当前文生图模型的痛点

目前像 Stable Diffusion 这样强大的扩散模型，主要是用文本来生成图像的。但文本有很明显的局限性：

难以精准描述：写出能生成理想内容的优质文本 prompt 并不容易，往往需要复杂的提示词工程
信息量瓶颈：文本在表达复杂场景或抽象概念时显得不够丰富，这成了内容创作的阻碍。俗话说“一图胜千言” 。比起绞尽脑汁去描述一个人物的五官、打光、画风，直接扔给模型一张参考图显然是最直观、最自然的选择。

Image Prompt

Image Prompt（图像提示）指的是提供“全局语义、内容和风格”的参考图像。它的作用类似于文本提示词，就像你说“画一只水彩风格的小狗”，Image Prompt 则是直接丢给模型一张水彩小狗的图片，告诉模型：“我要这种画风、这种氛围、这种主体内容”。论文中明确指出，Image Prompt 使用的是预训练 CLIP 图像编码器提取的全局图像嵌入（global image embedding），这种特征包含了图像丰富的风格和内容信息，并且天然与文本描述对齐。

这里的 Image Prompt 与 ContorlNeXt 里的空间控制信号不同。边缘图（Canny）、深度图（Depth）或者骨骼关键点等，属于结构/空间控制。它们的作用是“像素级”对齐的，也就是严格规定了生成的图像在这个位置必须有这个轮廓或结构。而在 IP-Adapter 以及类似的论文中，Image Prompt（图像提示）指的是提供“全局语义、内容和风格”的参考图像。

提取图像特征时，什么时候用卷积，什么时候用 CLIP？决定用 CLIP 还是用卷积，取决于是想控制全局语义和风格，还是想控制局部空间和结构。

用卷积块：当你输入的是边缘图、深度图、人体骨架或语义分割图时。需要模型生成的图像在特定的 (x,y)(x, y)(x,y) 坐标上，严格遵循你给定的轮廓或姿势。卷积神经网络的核心优势是保留空间分辨率。一张输入图经过几层卷积后，仍然是一个带有高度和宽度的特征图。ControlNeXt 会把这些空间特征直接通过加法注入到 UNet 对应的残差块中，实现精准的空间对齐。

用 CLIP：当你输入的是一张普通的参考图，想告诉模型“给我生成一只长这样的狗”或者“使用梵高的星空画风”时。你不在乎狗在画面的左边还是右边，你只在乎它的“长相”和“氛围”。 CLIP 是一个多模态模型，它在训练时就已经把“狗的图片”和“狗的文本描述”映射到了同一个高维特征空间里。既然扩散模型的 Cross-Attention 是为了接收文本特征设计的，那使用和文本同构的 CLIP 图像特征自然是最顺理成章的。 IP-Adapter 默认使用的是 CLIP 提取出的全局图像嵌入个过程会把整张图片压缩成一个一维的特征向量，这就故意丢弃了具体的空间位置信息，只保留了最纯粹的语义和风格

前人工作的局限性

为了让纯文本扩散模型支持图像提示，在 IP-Adapter 出现之前，具体做法有两种，且都有致命缺陷。

方式一：直接替换并全局微调（如 SD Image Variations）直接用 CLIP 提取出的图像特征替换掉原来的文本特征，然后把整个扩散模型重新训练（微调）一遍。这确实是做交叉注意力，但代价是算力成本极高，而且一旦微调完，这个模型就“丧失”了原本听懂文本的能力，再也无法兼容常规的文本提示词了。
方式二：特征拼接后共用注意力层（如早期的简单适配器）如果不微调原模型，前人（比如 T2I-adapter 的 style adapter 或是 Uni-ControlNet 的全局控制器）的做法是：把 CLIP 提取出的图像特征经过一个小网络映射后，直接与文本特征拼接在一起构成一个更长的特征向量。然后把这个拼合的特征喂给原扩散模型 UNet 里的交叉注意力层。这篇论文一针见血地指出了拼接方式的缺陷：原来扩散模型里的交叉注意力层，它的投影权重矩阵（比如 Key 和 Value 的权重矩阵）是专门为了适应文本特征而训练出来的。如果强行把图像特征塞进这个为文本量身定制的注意力层里，图像特征就不得不去向文本特征“妥协对齐”，这就导致图像特有的、细粒度的信息在计算过程中丢失了，最终只能实现非常粗糙的风格控制。

核心架构设计

整体设计原则

冻结基座，即插即用：在训练阶段，预训练的文本到图像扩散模型（U-Net）的参数是完全冻结的。
只训练新增模块：只有新添加的模块（投影网络和解耦交叉注意力层中的参数）会被训练。这就保证了模型原有的文本生成能力丝毫不受破坏。

图像特征处理

提取全局特征：IP-Adapter 使用了一个预训练且冻结的 CLIP 图像编码器来从图像提示中提取特征。具体来说，它使用的是 CLIP 的全局图像嵌入，因为这个嵌入很好地对齐了图像的字幕，能够代表图像丰富的风格和内容。
特征维度对齐：提取出来的特征不能直接用，作者引入了一个小型的可训练投影网络（由一个线性层和层归一化 Layer Normalization 组成）。这个网络的作用是将全局图像嵌入投影成一个长度为 NNN（本研究中 N=4N=4N=4）的特征序列，并且让它的维度与预训练扩散模型中的文本特征维度保持一致。

因为原始的 Cross-Attention 机制是为处理一系列文本 Token 设计的。将单一的全局图像特征投影成 4 个 Token 的序列，是为了模拟文本输入的序列格式，使其能顺利进行注意力矩阵计算。

解耦交叉注意力机制

原版 SD 的交叉注意力

在原版 SD 冻结的 UNet 中，图像的潜在特征作为 Query，我们称之为 ZZZ 。输入的文本特征作为条件，我们称之为 ctc_tct 。原版交叉注意力的输出 Z′Z^{\prime}Z′ 公式如下： Z′=Softmax(QK⊤d)VZ^{\prime}=Softmax(\frac{QK^{\top}}{\sqrt{d}})VZ′=Softmax(dQK⊤)V

Q=ZWqQ=ZW_qQ=ZWq (从图像空间特征提取 Query)
K=ctWkK=c_tW_kK=ctWk (从文本特征提取 Key)
V=ctWvV=c_tW_vV=ctWv (从文本特征提取 Value) 这里面的 WqW_qWq、WkW_kWk、WvW_vWv 都是 SD 模型在海量图文对上预训练好的权重矩阵。它们已经记住了如何处理文本特征。如果像以前的方法那样，把图像特征直接拼接到 ctc_tct 里面扔进去，这些权重矩阵就会“水土不服” 。

IP-Adapter 的解耦设计

为了不干扰原来处理文本的 WkW_kWk 和 WvW_vWv，IP-Adapter 决定给图像特征 cic_ici 单独开辟一个通道。作者在 UNet 的每一个交叉注意力层里，新增了一个只负责处理图像特征的交叉注意力层。这个新层的输出 Z′′Z^{\prime\prime}Z′′ 公式如下： Z′′=Softmax(Q(K′)⊤d)V′Z^{\prime\prime}=Softmax(\frac{Q(K^{\prime})^{\top}}{\sqrt{d}})V^{\prime}Z′′=Softmax(dQ(K′)⊤)V′

这里的投影矩阵变了：

K′=ciWk′K^{\prime}=c_iW_k^{\prime}K′=ciWk′ (从图像特征提取专门的 Key)
V′=ciWv′V^{\prime}=c_iW_v^{\prime}V′=ciWv′ (从图像特征提取专门的 Value) 值得注意的是，在计算 Z′′Z^{\prime\prime}Z′′ 时，使用的 QQQ 和文本注意力层使用的 QQQ 都是 Q=ZWqQ=ZW_qQ=ZWq。这意味着：UNet 当前正在生成的图像空间特征（Query），同时向“文本”和“参考图”发出了同样的询问：“我现在在这个像素位置该画什么？” 文本给出了它的回答，参考图也给出了它的回答。

最终的特征融合

既然分成了两路算，最后怎么合在一起喂给 UNet 的下一层呢？极其简单粗暴——直接相加。

Znew=Softmax(QK⊤d)V+Softmax(Q(K′)⊤d)V′Z^{new}=Softmax(\frac{QK^{\top}}{\sqrt{d}})V+Softmax(\frac{Q(K^{\prime})^{\top}}{\sqrt{d}})V^{\prime}Znew=Softmax(dQK⊤)V+Softmax(dQ(K′)⊤)V′

这就是这篇论文最核心的数学公式。在这个过程中，由于原始的 UNet 模型是冻结的，所以上面的公式里只有 Wk′W_k^{\prime}Wk′ 和 Wv′W_v^{\prime}Wv′ 这两个矩阵是可训练的。为了加快模型收敛速度，也为了在训练初期让图像提示分支的输出尽可能贴近原本的文本分支，从而保证训练过程的稳定性，这两个新矩阵在初始化时，直接使用了原来文本矩阵 WkW_kWk 和 WvW_vWv 的权重。

核心优势

因为原有的模型基座完全没有被改变，这种即插即用的轻量级设计带来了极高的灵活性：

参数量极小：因为原版 UNet 是被冻结的，所以在整个庞大的扩散模型中，需要训练的仅仅只是每一层新增的那两个小矩阵：Wk′W_k^{\prime}Wk′ 和 Wv′W_v^{\prime}Wv′ ！这外加一个极小的图像特征投影网络，总共才引入了约 22M 的可训练参数。
模型通用性：在基础扩散模型上训练好的 IP-Adapter，可以直接拿去用在从同一个基础模型微调出来的其他自定义模型上（比如动漫风、真实风模型）。
生态兼容性：它完美兼容 ControlNet，可以同时用边缘图控制动作，再用 IP-Adapter 控制长相和画风。
多模态融合：因为文本和图像的注意力层是解耦的，可以同时输入文本 Prompt 和 Image Prompt，实现真正的多模态图像生成。

训练策略与推理控制

我们刚才推导了 Znew=Ztext+ZimageZ^{new} = Z_{text} + Z_{image}Znew=Ztext+Zimage，但这带来了一个实际应用中的问题：如果既给了文本提示，又给了图像提示，模型最后生成的图，到底该多听文本的，还是多听参考图的？

推理时的权重调节

为了实现灵活的控制，作者在推理阶段对我们刚才推导的那个加法公式做了一个极其微小但至关重要的改动。作者引入了一个权重因子 λ\lambdaλ（论文公式 8）： Znew=Attention(Q,K,V)+λ⋅Attention(Q,K′,V′)Z^{new}=Attention(Q,K,V)+\lambda \cdot Attention(Q,K^{\prime},V^{\prime})Znew=Attention(Q,K,V)+λ⋅Attention(Q,K′,V′)

如果 λ=0\lambda=0λ=0，后面那一项就没了，模型退化成了完全只听文本的原版 Stable Diffusion。
如果 λ=1.0\lambda=1.0λ=1.0，这就是我们之前推导的标准 IP-Adapter，文本和图像的权重是平起平坐的。
如果把文本置空（空字符串），且 λ=1.0\lambda=1.0λ=1.0，模型就完全变成了“只看图说话”的生成器。
在实际做多模态生成时，我们可以通过调高或调低 λ\lambdaλ，来寻找画风（图像）和场景描述（文本）之间的完美平衡点。

训练时的随机丢弃

为了让模型在推理时能够支持无分类器引导，并且能自由地应对“只有文本”、“只有图像”或“既有文本又有图像”的各种情况，作者在训练时设计了非常巧妙的随机丢弃策略：

像往常一样，以 0.05（5%）的概率把文本条件丢弃（置空）。
同样，以 0.05 的概率把图像条件丢弃（把 CLIP 图像特征全置为 0）。
再以 0.05 的概率把文本和图像同时丢弃。通过这种“强迫”模型在部分信息缺失的情况下还要努力生成图像的训练方式，模型就学会了如何在推理时根据权重 www 和 λ\lambdaλ 来放大这些条件信号。

实验设计与结果

训练配置

训练数据

作者使用了两个非常著名的开源大规模图文对数据集：LAION-2B 和 COYO-700M，总共挑了大约 1000万对图文数据来训练。

LAION-2B：它是 LAION-5B 数据集的一个英文子集，包含了约 20 亿（2 Billion）个通过爬取网页并经过清洗过滤的“图像-文本”对。它是绝大多数开源文生图模型（包括 Stable Diffusion）进行预训练的基石。
COYO-700M：由 Kakao Brain 开源，包含了 7 亿（700 Million）个高质量的图文对。它同样来源于网页爬取，但采用了一套独立的清洗规则，数据质量非常高。

模型基座与特征提取

基于 Stable Diffusion v1.5 。使用了 OpenCLIP ViT-H/14 作为提取图像特征的编码器。

训练代价

作者在 SD 的 16 个交叉注意力层中都加了新的图像交叉注意力层。整个 IP-Adapter 只有约 22M 的可训练参数。他们用了 8 张 V100 显卡跑了 100 万步就训完了。

评估指标

在文本到图像领域，很难用一个绝对客观的数字来衡量一幅画的美丑，但我们需要衡量它“有多听话”。作者选用了 COCO2017 验证集（包含 5000 张带文字描述的图片）来进行定量评估。他们主要使用了两个极其核心的指标：CLIP-I, CLIP-T。

COCO 2017 验证集

MS COCO (Microsoft Common Objects in Context) 是计算机视觉领域最权威的基准测试集之一。它主要包含人们日常生活中复杂的场景，每张图片里通常有多个物体。

为什么用它：COCO 的特点是每张图像都配有高质量的人工标注文本描述（Captions）。这使得它成为测试“图文对齐”和“语义理解”能力的完美基准。
论文中的用法：作者使用了 COCO 2017 的验证集，里面包含 5000 张图像及其对应的描述文本。为了进行公平的定量比较，针对这 5000 个样本，作者以它们为图像 prompt，为每个样本生成了 4 张图片，总共得到了 20,000 张生成的图像用于后续的指标计算。

CLIP-I

衡量生成的图像与作为 Prompt 的参考图像之间的相似度。

计算逻辑：将生成的图片 IgenI_{gen}Igen 和参考图片 IpromptI_{prompt}Iprompt 分别输入 CLIP 的图像编码器 EIE_IEI，提取出两个全局特征向量。
核心公式：CLIP-I=EI(Igen)⋅EI(Iprompt)∣∣EI(Igen)∣∣×∣∣EI(Iprompt)∣∣CLIP\text{-}I = \frac{E_I(I_{gen}) \cdot E_I(I_{prompt})}{||E_I(I_{gen})|| \times ||E_I(I_{prompt})||}CLIP-I=∣∣EI(Igen)∣∣×∣∣EI(Iprompt)∣∣EI(Igen)⋅EI(Iprompt) 得分越接近 1，说明生成的图和参考图在画风、内容上越相似。

CLIP-T

衡量生成的图像与“参考图像原本对应的文本描述”之间的匹配程度。

计算逻辑：将生成的图片 IgenI_{gen}Igen 输入 CLIP 图像编码器得到图像特征，将原始真实的文本标注（Caption）输入 CLIP 文本编码器得到文本特征。
核心公式：计算这二者的余弦相似度（学术界计算 CLIPScore 时通常还会乘以一个常数权重 www 作为缩放）：CLIP-T=w×max⁡(cos⁡(EI(Igen),ET(Caption)),0)CLIP\text{-}T = w \times \max(\cos(E_I(I_{gen}), E_T(Caption)), 0)CLIP-T=w×max(cos(EI(Igen),ET(Caption)),0) 这个指标能证明模型不仅抄了原图的画风，而且真的理解了画面的核心语义。

对比实验

为了证明自己厉害，作者找了三类对手来 PK，并在论文的 Table 1 中展示了结果：

从头训练的模型（如 Versatile Diffusion）。
彻底微调的模型（如 SD Image Variations，参数量高达 860M）。
前人的拼接适配器（如 T2I-Adapter style、Uni-ControlNet）。
PK 结果：仅仅只有 22M 参数的 IP-Adapter，其 CLIP-T 指标达到了 0.588，CLIP-I 达到了 0.828，远超其他适配器，并且媲美甚至超越了那些参数量几百兆的全面微调模型。这就证明了“解耦交叉注意力”的威力。 ![](‘/assets/images/IP-Adapter/Pasted image 20260303230710.png’)

强大的泛化与兼容性

这也是 IP-Adapter 现在能在业界爆火的根本原因。作者做了丰富的定性实验（看生成的图）：

无缝兼容社区模型：在官方 SD v1.5 上训好的这 22M 参数，可以直接套用在 Anything v4（二次元）、Realistic Vision V4.0（写实风）等社区微调模型上，甚至向下兼容 SD v1.4 。
完美兼容 ControlNet：可以用 ControlNet 提取的人体骨架图（结构控制），同时叠加 IP-Adapter 输入的参考图（画风/长相控制），两者互不干扰。
多模态融合 (Multimodal Prompts)：可以同时输入文字和图片。比如给一张普通马的参考图，再输入文本“在雪地里”，模型就能生成这匹马站在雪地里的画面。

消融实验

在论文最后，作者必须回答两个可能被审稿人质疑的问题，以证明自己的设计是唯一的最佳选择：

证明必须“解耦”：作者做了一个没有解耦的“简单适配器”（就是把图像和文本特征像前人那样强行拼接在一起）。对比发现，IP-Adapter 生成的图片质量更高，也更贴合参考图。
证明必须用“全局特征”：这就印证了我们之前聊过的那个神仙细节。作者尝试了不提取 CLIP 的全局特征，而是提取带有一定空间信息的“网格细粒度特征” 。结果发现，模型不仅学到了画风，连参考图里人物的姿势都学过去了，这大幅降低了生成图像的多样性。这也反面证明了，要想把图像当作纯粹的 Prompt，全局特征才是最佳选择。

全局特征 (Global Image Embedding)：这是 IP-Adapter 默认使用的特征。ViT 在处理完所有的图像小块后，会输出一个统合了所有信息的特殊向量（通常是 [CLS] token）。它把整张图片压缩成了一个高度浓缩的特征向量，包含了极其丰富的画风和内容信息，但故意丢弃了所有的空间位置信息。正因如此，生成的图像才不会死板地照抄原图的姿势，从而保持了极好的多样性。

空间细粒度特征 (Grid/Fine-grained Features)：在论文的 4.4.2 节，作者尝试提取了 CLIP 图像编码器倒数第二层的“网格特征” 。这些特征对应着图像切分后的各个二维小块（比如它知道狗的头在左边，身子在右边）。虽然用细粒度特征生成的图像和参考图在视觉上更一致，但它同时也让模型学到了参考图的“空间结构信息”，导致生成的图像在姿势和构图上非常死板，降低了模型生成的多样性。这也反向证明了：如果只是想把图像当成 Prompt，全局特征是更好的选择。

个人思考与启发

很多时候，解决复杂问题不需要用大锤（比如前人耗费巨大算力去全局微调整个庞大的模型）。IP-Adapter 的美妙之处在于其数学表达上的克制与优雅。面对“特征污染”的问题，作者没有设计极其复杂的特征隔离网络，而是仅仅利用了矩阵加法分配律的思想——既然大家都要乘以同样的查询向量 QQQ，那我就单独算 Q(K′)⊤Q(K^{\prime})^{\top}Q(K′)⊤ 再相加。这种以极小代价（仅仅 22M 参数）撬动巨大收益的思路，非常值得借鉴。

《ControlNeXt》论文精读

小yo — Mon, 02 Mar 2026 21:12:51 GMT

前置知识与研究动机

扩散模型基础回顾

LDM

最原始的 DDPM直接在像素级别上加噪和去噪会导致计算量极大。而这篇论文中大量使用的 Stable Diffusion(SD)系列模型，是基于 LDM 的。 核心区别：LDM 首先用一个 VAE 将高维的像素图像压缩到一个低维的“潜空间”中，然后在潜空间里进行 DDPM 扩散和去噪过程，最后再用 VAE 解码会图像。

文本条件注入

文本特征提取

模型并不会直接处理文字，当输入提示词时，系统会使用预训练的语言模型（比如 CLIP 的 Text Encoder）将文本转化为高维的文本嵌入向量（Text Embedding）。在本文的公式里，文本条件通常被表示为 ctc_tct 。

文本嵌入向量文本嵌入向量是一个序列（类似二维矩阵），以 SD 1.5 为例，它使用 CLIP 文本编码器。当输入一段提示词时，它会做如下处理：

分词：把文本切成一个个 Token。SD 固定输入 77 个 Token。编码器会在实际的 token 后面加上一个特殊的结束符<end-of-text> ，然后用预设的填充符 <pad> 把序列硬凑到 77 的固定长度。

在标准的 Transformer 架构中，会使用注意力掩码（Attention Mask）。它会在计算 Softmax 之前，将这些 <pad> token 对应的注意力权重设为极小的负数（负无穷大），这样 Softmax 之后它们的权重就是 0，完全不会干扰图像的生成。不过，在 Stable Diffusion 的具体工程实现中，有时即使没有严格屏蔽，模型在海量数据训练下也已经学会了将这些 <pad> 向量的注意力权重降到极低，视其为“无用信息”。

向量化：每个 Token 会被映射成一个高维向量。在 SD 1.5 中，这个维度是 768。

最终维度：所有，提示词经过编码后，输出的张量维度是 77×76877 \times 76877×768 （长度为 77 的序列，每个元素是 768 维的向量）。

文本特征注入

在基于 U-Net 的 Stable Diffusion 中，文本向量并不像时间步 t 那样简单相加。它主要是通过交叉注意力机制（Cross-Attention）交叉注意力注入到模型内部的。可以把图像当前的视觉特征当做 Q，把文本嵌入向量当做 K 和 V。这样，图像在不断去噪的过程中，不同的空间位置就能关注到与之相对的文本语义。

CFG

CFG 无分类器引导（CFG）的核心机制是在训练时，同时训练模型预测有条件噪声 ϵ^(xt,t,ct)\hat{\epsilon}(x_t, t, c_t)ϵ^(xt,t,ct) 和无条件噪声 ϵ^(xt,t,∅)\hat{\epsilon}(x_t, t, \emptyset)ϵ^(xt,t,∅) （做法是在训练中随机把一部分文本向量替换为空向量）。在推理时，通过外推公式放大文本的影响力： ϵ~=ϵ^(xt,t,∅)+w⋅(ϵ^(xt,t,ct)−ϵ^(xt,t,∅))\tilde{\epsilon} = \hat{\epsilon}(x_t, t, \emptyset) + w \cdot (\hat{\epsilon}(x_t, t, c_t) - \hat{\epsilon}(x_t, t, \emptyset))ϵ~=ϵ^(xt,t,∅)+w⋅(ϵ^(xt,t,ct)−ϵ^(xt,t,∅)) 这里的 www 就是引导尺度，用于控制生成图像与文本的契合程度。论文中明确提到了 ControlNeXt 的设计在与 CFG 结合使用时尤其有利，能够获得最佳的生成结果。

主流空间可控生成方法及其痛点

标准的 Diffusion 模型只能通过文本提示词来控制生成的画面。但如果我们需要精确的空间控制（比如让人摆出特定的姿势、或者根据线稿生成图像），单纯的文字就无能为力了。为了解决这个问题，业界之前提出了两种主流方案：ControlNet 和 T2I-Adapter。

空间控制信号

与文本这种一维序列不同，空间控制信号本身就是 2D 的图像结构。论文中展示了四种控制条件。

Mask（掩码）

用来约束物体的形状和位置。通常是黑白图或者多色图，比如论文中展示的例子（下图），目标区域（女生的吊带和短裤）是白色的，背景是黑色的。它告诉模型“在这个白色轮廓里生成指定的东西”。

Depth（深度图）

用来表示场景的三维空间层次。深度图通常是一张灰度图或伪彩色图，像素颜色的深浅代表了物体距离相机的远近（比如近处的物体亮，远处的物体暗）。它能让模型生成具有正确透视关系的图像。

Pose（姿态）

用来精确控制人物的动作。通常使用 OpenPose 等姿态估计算法提取，画面上是一堆像“火柴人”一样的彩色骨骼线段，标记了人体的头部、肩膀、手肘、膝盖等关键点。

Canny（边缘）

用来提取图像的硬轮廓和线条边界。Canny 是一种经典的边缘检测算法，提取出来的就是一张线稿（黑底白线），非常适合做风格迁移，比如论文中将普通的风景照通过 Canny 线稿生成出特定风格的图像。

ControlNet

原理

它将预训练好的基础大模型完全冻结，然后复制一份主 U-Net 的全部下采样块（Encoder）以及中间的瓶颈层作为平行的控制分支。
控制图输入到这个复制的控制分支中进行前向传播。
控制分支的每一层下采样输出，以及瓶颈层的输出，都会先经过一个“零卷积”。

零卷积：为了防止新增的随机权重破坏基础模型的生成能力，ControlNet 使用了权重初始化为 0 的 1×11 \times 11×1 卷积作为桥梁。

然后，这些特征会通过加法，直接加到主 U-Net 对应层的解码器的跳跃连接上。

特征融合的过程：

特征对齐：假设主 U-Net 编码器传过来的跳跃连接特征通道数是 CCC 。ControlNet 复制出来的控制分支，在经过“零卷积”输出时，其通道数也会被强制映射为 CCC。

融合方式： ControlNet 将这两部分特征进行相加：xmain+xcontrolx_{\text{main}} + x_{\text{control}}xmain+xcontrol。因为是逐元素相加，融合后的通道数依然是 CCC。

进入解码器：随后，这个融合后的特征（通道数为 CCC）会和主 U-Net 解码器上一层上采样过来的特征进行常规的通道拼接。假设上采样特征通道数也是 CCC，那么送入下一层解码器模块的总通道数就是 2C2C2C。

痛点

由于复制了半个 U-Net，它引入了极大的参数量和计算延迟。此外，零卷积会导致训练初期模块无法获得准确梯度，出现“突然收敛”现象——即模型要训练很久才能突然学会受控。

T2I-Adapter

原理

为了降低成本，它不复制庞大的 U-Net ，而是单独训练一个小型的适配器（Adapter）网络来提取多尺度控制特征，然后注入到冻结的基础模型中。 Adapter： Adapter 最初来自自然语言处理领域的 PEFT （参数高效微调）技术。它的核心思想是：与其微调整个庞大的预训练模型，不如在模型外部或层与层之间，插入几个很小的神经网络模块（即 Adapter），只训练这些小模块。 T2I-Adapter 架构非常简单，且完全独立于主 U-Net。

全卷积特征提取：对于深度图、Canny 边缘等 2D 空间条件，Adapter 本质上是一个小型的前馈卷积神经网络。它通常由 4 个特征提取模块组成，每个模块主要包含简单的卷积层（Conv）或残差块（ResNet block）以及下采样层。
多尺度输出：如果输入一张 512×512512 \times 512512×512 的条件图，Adapter 会像阶梯一样，依次提取出尺寸为 1/81/81/8、1/161/161/16、1/321/321/32 和 1/641/641/64 的特征图。这刚好对应了 SD U-Net 编码器的四个不同分辨率的中间阶段。
注入位置： T2I-Adapter 把这些多尺度的控制特征，逐元素相加到了主 U-Net 编码器对应的中间特征层上。
兵分两路：相加融合之后的这个“新特征”，接下来会兵分两路：
1. 向下（走编码器）：作为输入，喂给编码器的下一层，继续进行下采样和特征提取。
2. 向右（走跳跃连接）：直接通过 U-Net 的跳跃连接，原封不动地传递给对面对应的解码器层。

痛点

T2I-Adapter 牺牲了控制能力来换取效率。它只有几十兆（M）的参数，且在特征刚进入 U-Net 编码器阶段就早早注入了。由于主 U-Net 是完全冻结的，这些微弱的控制信号在深层网络的前向传播中很容易被原有的强大生成能力“稀释”掉，所以在面对复杂任务（如视频生成）时显得力不从心。

核心动机

论文作者认为，基础的大型生成模型本身已经足够强大，完全可以直接学习如何受控，而不需要像 ControlNet 那样外挂一个庞大且沉重的辅助组件。

参数冗余问题：ControlNeXt 抛弃了复制网络的做法，只使用了一个轻量级的卷积模块来注入控制信号，并通过选择性地微调基础模型的一小部分参数，就减少了高达 90% 的可学习参数。
零卷积灾难：在 ControlNet 中，为了不让新加入的控制分支在训练初期破坏预训练模型的能力，它使用了“零卷积”作为桥梁。但这会导致收敛非常慢，因为在训练刚开始时，这些模块很难接收到正确的梯度，从而产生一种模型训练很久后才突然学会控制的“突然收敛”现象。
ControlNeXt 的解法：论文提出了一种叫 Cross Normalization 的技术来替代零卷积，通过对齐数据分布来让模型在初期就能获得稳定的梯度，从而实现更快的收敛。

核心网络架构设计

在前文，我们明确了 ControlNet 的痛点（太重、外挂太多）和 T2I-Adapter 的痛点（太轻、控制力弱）。在论文的 3.2 Architecture 节中，作者提出了一个非常反直觉但绝妙的思路：为什么非要外挂一个网络？基础大模型本身已经见识过几十亿张图片（比如 LAION-5B 数据集），它足够强大，完全可以直接学习如何控制自己。

ControlNet 的数学表达

在论文公式 (5) 中，作者给出了 ControlNet 的前向传播公式： yc=Fm(x)+Z(Fcn(x,c;Θcn);Θz)y_{c}=\mathcal{F}_{m}(x)+\mathcal{Z}(\mathcal{F}_{cn}(x,c;\Theta_{cn});\Theta_{z})yc=Fm(x)+Z(Fcn(x,c;Θcn);Θz)

xxx：输入的潜空间图像特征。
ccc：输入的控制信号。
Fm(x)\mathcal{F}_{m}(x)Fm(x)：这是被完全冻结的预训练基础模型主分支。
Fcn(x,c;Θcn)\mathcal{F}_{cn}(x,c;\Theta_{cn})Fcn(x,c;Θcn)：这就是那个庞大的“外挂”——复制出来的 ControlNet 控制分支。Θcn\Theta_{cn}Θcn 代表它那海量的可学习参数。
Z(⋅;Θz)\mathcal{Z}(\cdot;\Theta_{z})Z(⋅;Θz)：这是零卷积层，它负责把控制特征加回到主模型中。可以清楚的看到，主模型 Fm\mathcal{F}_{m}Fm 啥都没学，所有的控制压力全压在了新加的 Fcn\mathcal{F}_{cn}Fcn 身上，这就导致了参数量暴增和计算延迟。

ControlNeXt 的数学表达

接下来，我们看论文给出的 ControlNeXt 核心公式 (6)： yc=Fm(x,Fc(c;Θc);Θm′)y_{c}=\mathcal{F}_{m}(x, \mathcal{F}_{c}(c; \Theta_{c}); \Theta_{m}^{\prime})yc=Fm(x,Fc(c;Θc);Θm′) 这个公式非常简洁，但蕴含了论文最重要的两个创新：

抛弃庞大分支，改用极轻量卷积模块 Fc(c;Θc)\mathcal{F}_{c}(c; \Theta_{c})Fc(c;Θc)

作者直接砍掉了ControlNet 复制的半个 U-Net，仅仅使用了一个非常小型的卷积模块（只包含几个卷积块）来处理控制条件 ccc。这个模块的参数 Θc\Theta_{c}Θc 非常少（ Θc≪Θd\Theta_{c} \ll \Theta_{d}Θc≪Θd ，即远小于主模型的参数量）。它唯一的作用，仅仅是把控制信号提取出来并进行对齐，而不是像 ControlNet 那样还要负责庞大的特征融合计算。

Θm′\Theta_{m}^{\prime}Θm′（部分微调 Partial Tuning）

论文明确指出 Θm′⊆Θm\Theta_{m}^{\prime} \subseteq \Theta_{m}Θm′⊆Θm，也就是主模型参数的一个子集。 ControlNeXt 不再完全冻结基础大模型，而是“解冻”了其中极小的一部分参数（比如注意力模块中的线性层）让它们参与训练。解冻之后，便可以让大模型自己去适应控制信号，因为绝大多数参数还是冻结的，所以不会发生“灾难性遗忘”（也就是不会破坏原本强大的画图能力）；同时，因为直接微调了主模型，它的控制力比仅仅加在编码器外围的 T2I-Adapter 要强大得多，特别适合处理视频生成这种复杂任务。

控制信号注入时机

作者在实验中发现，如果把控制特征直接和带有强噪声的输入 xxx 混在一起，会导致“训练崩溃” 。这是因为控制信号和去噪特征重叠在一起，模型直接“懵了”。为了让模型尽早感知到控制信息，作者选择在第一个 Block（Block 0）之后注入控制信号，并且加入了一个残差连接来保护主干网络的完整性。结合论文的 Figure 2 来看：控制条件（control condition）经过轻量级模块（Light-Weight Module）后，在主模型的 Block 0 之后，通过一个加号 + 与主干特征融合，然后一起送入后续的 Block 1…N 。这就完美解决了当前主流方法“既要轻量，又要控制力强”的矛盾。

核心数学创新

训练崩溃的原因

在微调大型预训练模型时，如果直接把新初始化的模块加进去，会导致训练直接崩溃。为了解决这个问题，ControlNet 引入了零卷积，但是也引发了”突然收敛“现象。作者深入思考了训练崩溃的原因，他们认为，训练崩溃的元凶其实是数据分布不匹配：

主模型特征：预训练大模型由于在海量数据上训练过，它的中间特征已经形成了非常稳定、具有一致均值和标准差的数据分布。
控制条件特征：新引入的控制模块通常是随机初始化的（比如高斯初始化）。它输出的特征分布是混乱的，与主模型的特征分布天差地别。
把这两个分布完全不同的张量直接相加，瞬间就打破了原有的稳定，导致模型崩溃。

交叉归一化

既然问题出在分布不匹配，那最直接的解法就是：把控制特征的分布，强行拉平到和主模型特征一样的分布。这就引出了论文 3.3 节的公式推导。设主模型的去噪特征为 xmx_mxm，轻量级卷积模块提取的控制特征为 xcx_cxc 。xcx_cxc 和 xmx_mxm 的维度均是 Rh×w×c\mathbb{R}^{h \times w \times c}Rh×w×c 。步骤一：计算主模型特征的统计量首先，计算主干分支特征 xmx_mxm 的通道级均值 μm\mu_mμm 和方差 σm2\sigma_m^2σm2 ： μm=1n∑i=1nxm,i\mu_m = \frac{1}{n}\sum_{i=1}^n x_{m,i}μm=n1∑i=1nxm,i σm2=1n∑i=1n(xm,i−μm)2\sigma_m^2 = \frac{1}{n}\sum_{i=1}^n (x_{m,i} - \mu_m)^2σm2=n1∑i=1n(xm,i−μm)2 这里的 n=h×w×cn = h \times w \times cn=h×w×c，即特征图上所有元素的总数。步骤二：对控制特征进行“交叉归一化” 接下来，这是最关键的一步。作者没有使用 xcx_cxc 自己的均值和方差，而是借用主模型的均值 μm\mu_mμm 和方差 σm2\sigma_m^2σm2 来对控制特征 xcx_cxc 进行归一化： x^c=xc−μmσm2+ϵ∗γ\hat{x}_c = \frac{x_c - \mu_m}{\sqrt{\sigma_m^2 + \epsilon}} * \gammax^c=σm2+ϵxc−μm∗γ

ϵ\epsilonϵ 是一个极小的常数，防止分母为 0（数值稳定性）。
γ\gammaγ 是一个可学习的缩放参数。步骤三：平滑注入经过 Cross Normalization 处理后，x^c\hat{x}_cx^c 的数据分布已经与主模型特征 xmx_mxm 高度一致。此时，将它们直接相加（xm+x^cx_m + \hat{x}_cxm+x^c），不仅不会引起训练崩溃，而且因为去掉了零卷积，梯度从第一步开始就能顺畅地反向传播。

通过这个极其优美且计算量极小的 Cross Normalization，ControlNeXt 彻底抛弃了零卷积，使得模型只需几百步就能开始收敛，大大缩短了训练时间，并一举解决了“突然收敛”的难题。

实验结果与性能

破解”突然收敛“

在论文的 4.1 节，作者直接用图表（Figure 3）甩出了 Cross Normalization 的威力。 对比结果：在同样的控制条件（比如 Canny 边缘或 Pose 姿态）下，传统的 ControlNet 因为零卷积的拖累，需要训练大约 20,000 步才能让图像完全贴合控制条件。而 ControlNeXt 仅仅在 400 步左右就已经完美收敛，准确生成了符合条件的图像。 科研启发：这意味着在有限的算力下，采用Cross Normalization 对齐特征分布，可以极大地节约炼丹的时间成本，模块一开始就能吃满梯度，迅速学会控制。

极致的参数与推理效率

在4.3 节的Table 5 中，作者详细对比了可学习参数量。

数据碾压：以极其庞大的 SDXL 模型为例，传统的 ControlNet 引入了高达 1251M 的可学习参数。而 ControlNeXt 因为抛弃了复制网络，仅仅引入了 108M 的可学习参数。参数量锐减了 90% 以上。
推理速度：在 Table 6 中，ControlNeXt 的推理时间相比于完全没有控制的基础模型，仅仅增加了 10.4% 的延迟（SD1.5 从 0.22s 增加到 0.24s），而 ControlNet 增加了 41.9% 。

泛化性与即插即用

跨架构支持：在 4.2 节，作者证明了ControlNeXt 可以无缝接入 SD1.5、SDXL（高分辨率生成）、SD3 甚至是 SVD（视频生成）。尤其是在视频生成这种对算力要求极高、时序一致性要求极严苛的任务中，它依然能稳定发挥。
无缝兼容 LoRA：在 4.4 节，作者展示了 ControlNeXt 作为一个极其独立的轻量级模块，可以直接与社区里现有的各种 LoRA 权重结合使用，完全不需要重新训练（training-free）。这意味着可以用它控制姿态，同时用 LoRA 控制画风（比如图 8 展示的二次元风格、机甲风格等）。

training-free 免训练”
LoRA 结合时免训练。ControlNeXt 模块本身（轻量卷积模块的参数 Θc\Theta_cΘc 和主干解冻的少量参数 Θm′\Theta_m'Θm′）是必须要在成对数据集上预先训练好的。它的强大在于，一旦训练完成，利用交叉归一化对特征分布的动态对齐，它就能和社区里任意的画风 LoRA 直接像搭积木一样叠加使用，不会发生特征冲突。

个人思考与启发

DiT是用的 adaLN+Zero，这个零初始化能否改成交叉归一化？

AI解答：

1. 两者的核心目的极其相似

它们都是为了解决**“在预训练大模型中引入新条件时，如何保证训练初期的稳定性，避免破坏原始生成先验”**这个问题。

adaLN-Zero：让 DiT Block 在初始化时退化为恒等映射（Identity Mapping），主干特征该怎么走还怎么走。
Cross Normalization：让新加入的控制特征的数据分布强行向主干特征看齐，防止因为分布差异引发的训练崩溃。

2. 但它们处理的“对象”维度不同

DiT 的 adaLN-Zero 处理的是全局条件（如时间步 ttt 和文本标签 ccc）。它是把这些 1D 的条件向量映射成缩放和平移参数（γ\gammaγ 和 β\betaβ），去调制主干特征。由于它是对主干特征进行操作，把初始化的映射权重设为 0，刚好等价于“暂时不调制”。
ControlNeXt 的 Cross Normalization 处理的是空间结构条件（如 2D 的深度图、骨骼图）。因为空间控制通常是以独立分支提取特征（即你的 xcx_cxc），然后与主干特征（xmx_mxm）进行逐元素相加的。

3. 结论与实操建议

直接把处理时间步和文本的 adaLN-Zero 换成交叉归一化是不合适的，因为 adaLN 本身已经是一个归一化层了，Zero 初始化在处理 1D 全局变量调制时已经非常高效且收敛很快。

但是（这里是重点）！

如果你要在 DiT 架构上做空间可控生成（比如为 DiT 加上骨骼控制，类似于给 DiT 做一个 ControlNet），你需要把 2D 的骨骼图打成 Patch 序列并提取特征。当你要把这个骨骼特征序列加到 DiT 主干的 Patch 序列上时，绝对可以使用交叉归一化来替代零初始化（Zero Linear）！

事实上，这篇论文在 Table 2 和 Table 4 中，就在 SD3 和 Open-Sora-Plan（这两个都是基于 DiT 架构的模型）上成功应用了 ControlNeXt。他们本质上就是用交叉归一化对齐了空间控制特征和 DiT 主干特征。

《Scalable Diffusion Models with Transformers》论文精读

小yo — Sun, 01 Mar 2026 20:23:48 GMT

核心前置理论

隐空间扩散模型（LDM）

原始的 DDPMDDPM是直接在像素级别上加噪和去噪的。对于高分辨率图像，这种方式的计算成本非常高。隐空间扩散模型（LDM）通过引入两阶段的方法解决了这个问题。

压缩（Encode）：首先训练一个预训练的自编码器（通常是 VAE），利用其编码器 EEE 将高维的像素图像压缩到空间维度更小、但通道数更密集的隐空间表示 z=E(x)z = E(x)z=E(x) 。
扩散：接下来的所有扩散过程（加噪、去噪）都在这个隐空间 zzz 上进行，而不再是处理原始图片。这样做能在保留极高生成质量的同时，将 Gflops 降低到原来的几分之一。
解码（Decode）：在生成时，扩散模型先在隐空间去噪出一个特征变量 zzz ，最后通过 VAE 的解码器 x=D(z)x = D(z)x=D(z) 将其还原为像素图像。

Gflops： Gflops 指的是“十亿次浮点运算”，在论文中被用来衡量模型前向传播的计算复杂度。传统上，人们喜欢用“参数量”来衡量模型的大小，但作者指出这在图像生成领域具有误导性，因为参数量无法体现“图像分辨率”带来的巨大计算压力。

DiT 本质上就是一个工作在隐空间的扩散模型，论文中提到，一张 256×256×3256 \times 256 \times 3256×256×3 的图像，会先被 VAE 压缩成 32×32×432 \times 32 \times 432×32×4 的隐变量。DiT 的网络结构接收的就是这个 32×32×432 \times 32 \times 432×32×4 的张量。

无分类器引导（CFG）

条件扩散模型需要接收额外的信息（如类别标签 ccc ）来控制生成结果。CFG 是一种在推理阶段大幅提高条件生成图像质量和条件匹配度的核心采样技术。

训练阶段：模型需要同时学习有条件预测 ϵθ(xt,c)\epsilon_\theta(x_t, c)ϵθ(xt,c) 和无条件预测。具体做法是，在训练时有一定概率（例如随机 dropout 掉条件 ccc ）用一个可学习的“空嵌入”（null embedding ∅\emptyset∅）来代替真正的标签。
推理阶段：模型在每一个去噪布，都会分别计算一次有条件输出和一次无条件输出，然后按以下公式进行外推： ϵ^θ(xt,c)=ϵθ(xt,∅)+s⋅(ϵθ(xt,c)−ϵθ(xt,∅))\hat{\epsilon}_\theta(x_t, c) = \epsilon_\theta(x_t, \emptyset) + s \cdot (\epsilon_\theta(x_t, c) - \epsilon_\theta(x_t, \emptyset))ϵ^θ(xt,c)=ϵθ(xt,∅)+s⋅(ϵθ(xt,c)−ϵθ(xt,∅)) 这里的 s>1s > 1s>1 就是引导尺度。 (ϵθ(xt,c)−ϵθ(xt,∅))(\epsilon_\theta(x_t, c) - \epsilon_\theta(x_t, \emptyset))(ϵθ(xt,c)−ϵθ(xt,∅)) 代表了“加入分类条件后，噪声预测发生改变的方向”，我们把这个方向放大 sss 倍，就能让生成的图像更强烈地贴合我们给定的标签。 DiT 能够取得惊艳的生成效果，极大地依赖于这种引导技术。

学习方差

在原始的 DDPM 中，作者在实验后发现，把逆向过程的方差 Σθ\Sigma_\thetaΣθ 固定为常数工程简化：固定方差，模型依然可以生成很好的图像。因此最原始的 DDPM 只需要一个预测噪声的网络 ϵθ\epsilon_\thetaϵθ 。但是在后续的“improved DDPM”工作中，研究人员发现预测方差可以让模型在推理阶段以更少的步数达到同样的生成质量，所以后来的高级扩散模型普遍会把方差作为可学习的参数。

预测方差

在扩散模型中，逆向过程的真实方差在理论上有一个固定的上限 βt\beta_tβt 和一个下限 β~t\tilde{\beta}_tβ~t（即 1−αˉt−11−αˉtβt\frac{1-\bar{\alpha}_{t-1}}{1-\bar{\alpha}_t} \beta_t1−αˉt1−αˉt−1βt）工程简化：固定方差。既然方差被夹在这两个值之间，我们便可以让神经网络去预测一个插值系数。神经网络的方差预测头实际上输出的是一个与图像维度相同的张量 vvv。为了数值计算的稳定性，插值是在对数空间（Log Space）中进行的。最终模型预测的协方差公式为： log⁡Σθ=vlog⁡βt+(1−v)log⁡β~t\log \Sigma_\theta = v \log \beta_t + (1-v) \log \tilde{\beta}_tlogΣθ=vlogβt+(1−v)logβ~t

损失函数

为了让模型学习到逆向过程的协方差 Σθ\Sigma_\thetaΣθ ，只用简单的 MSE 损失是不够的，必须去优化包含完整 KL 散度的损失项。具体的组合和训练策略如下：

噪声预测使用简单损失：网络预测的噪声 ϵθ\epsilon_\thetaϵθ 依然使用简单的均方误差进行训练： Lsimple(θ)=∥ϵθ(xt)−ϵt∥22\mathcal{L}_{simple}(\theta) = \|\epsilon_\theta(x_t) - \epsilon_t\|_2^2Lsimple(θ)=∥ϵθ(xt)−ϵt∥22
方差预测使用完整损失：网络的方差预测部分 Σθ\Sigma_\thetaΣθ 则是使用完整的 L\mathcal{L}L 推导标准答案进行训练。
组合与“停止梯度”技巧：实际上，总的损失函数是这两个损失的加权和（通常表示为 Lhybrid=Lsimple+λLvlb，λ=0.001\mathcal{L}_{hybrid} = \mathcal{L}_{simple} + \lambda \mathcal{L}_{vlb}，\lambda = 0.001Lhybrid=Lsimple+λLvlb，λ=0.001 ）。但是这里有一个极其关键的工程技巧：在计算完整的 VLB 损失时，会对预测噪声的均值部分施加“停止梯度”操作。
结论：Lsimple\mathcal{L}_{simple}Lsimple 只负责更新网络中用于预测噪声的权重；而完整的 Lvlb\mathcal{L}_{vlb}Lvlb 损失传导回来的梯度，只负责更新网络中用于预测方差的权重。

DiT 核心架构与创新

图像的 Token 化

既然要用纯 Transformer ，第一步就是要把原本具有空间维度的特征图变成一维的序列。DiT 完全借鉴了 ViT 的做法。

切分与展平：DiT 接收来自 VAE 的空间特征张量 zzz（例如 256×256×3256 \times 256 \times 3256×256×3 的图像，此时 zzz 的形状是 32×32×432 \times 32 \times 432×32×4）。第一层被称为 “Patchify”，它通过一个线性层将输入转换为长度为 TTT、隐藏层维度为 ddd 的 Token 序列。紧接着，应用标准的基于频率的位置编码位置编码。
计算复杂度：序列长度 TTT 是由 Patch 大小 ppp 决定的，公式为 T=(I/p)2T=(I/p)^2T=(I/p)2 。这是 DiT 调控计算量（Gflops）最关键的旋钮。如果将 ppp 减半（例如从 4 变成 2），序列长度 TTT 将变为原来的 4 倍，从而导致 Transformer 的总 Gflops 至少增加 4 倍。

条件信息的特征对齐

无论采用哪种条件注入方案，必须要把时间步 ttt 和类别标签 ccc 对齐到相同的维度（通常就是 Transformer 的隐藏层维度 ddd )。

关于 ttt ：论文附录中提到，模型先用一个 256 维的频率编码来处理 ttt，然后再让它穿过一个带有 SiLU 激活函数的两层 MLP，最终输出的维度刚好等于 Transformer 的隐藏层维度。

SiLU激活函数：论文中明确提到了使用 SiLU (Sigmoid Linear Unit，也常被称为 Swish) 作为多层感知机的激活函数。

SiLU 的公式： f(x)=x⋅σ(x)=x1+e−xf(x) = x \cdot \sigma(x) = \frac{x}{1 + e^{-x}}f(x)=x⋅σ(x)=1+e−xx

与 ReLU的区别： ReLU 的公式是 f(x)=max⁡(0,x)f(x) = \max(0, x)f(x)=max(0,x)。ReLU 的问题在于它在 x=0x=0x=0 处不可导，并且对于所有负数输入，梯度直接变成了死寂的 0（Dead ReLU 问题）。相比之下，SiLU 是一个平滑的、非单调的函数。当 xxx 是一个较小的负数时，它允许少量的负面信息流过，并且处处可导。

为什么选择 SiLU：在现代扩散模型中，SiLU 已经成为了事实上的标配激活函数。在极深的网络中，SiLU 的平滑特性和非零负梯度能让反向传播时的梯度流动更加稳定，极大地帮助了生成模型的收敛。

关于 ccc ：模型通常会使用一个标准的 Embedding 层来提取类别标签，并将其映射到同样的隐藏层维度。

Embedding 层：这里的 Embedding 层其实就是一个标准的、可学习的查表操作。对于这篇在 ImageNet 上训练的论文，类别总数是 1000。但为了实现无条件引导，模型需要一个额外的“空标签”。所以，这个 Embedding 层实际上包含 1001 个词条，每一个词条对应一个维度为 ddd（Transformer 隐藏层维度）的向量。

条件注入机制

作者极其严谨地测试了四种微调标准 ViT Block 的方案。

上下文条件

直接把 ttt 和 ccc 的 Embedding 向量当作两个额外的 Token，追加到图像 Token 序列的末尾，就像 ViT 里的 cls token 一样。这种方法几乎不增加 Gflops 。

交叉注意力

交叉注意力机制

自注意力：相当于“自己看自己”。特征序列自己生成 Query (Q)、Key (K) 和 Value (V)。图像的每个 Patch 都在寻找与其他 Patch 的关联。
交叉注意力：相当于“带着问题去找答案”。它的核心在于 Q 和 K、V 来源于不同的输入。在条件生成的场景下（比如给定类别生成图片）：
Query (Q)：来自于正在生成的图像特征。
Key (K) 和 Value (V)：来自于条件信息（比如这篇论文里的时间步 ttt 和类别标签 ccc）。图像特征（Q）会去跟条件特征（K）计算相似度打分，然后把对应的条件信息（V）提取过来，融合到自己的特征中。

DiT 中的使用

作者把 ttt 和 ccc 拼成一个长度为 2 的独立序列，然后在 Transformer 的自注意力层之后，额外加一层多头交叉注意力层。这种方法增加了约 15% 的 Gflops 额外开销，是所有方案中最昂贵的。

自适应层归一化（adaLN)

自适应归一化

要想理解“自适应”，我们得先回顾一下普通的归一化（比如 Layer Norm）。普通的 Layer Norm：在标准的 Transformer 中，Layer Norm 会把输入特征 hhh 处理成均值为 0、方差为 1 的状态，然后再乘以一个缩放参数 γ\gammaγ ，加上一个平移参数 β\betaβ 。公式如下： Output=γ⋅h−μσ+βOutput = \gamma \cdot \frac{h - \mu}{\sigma} + \betaOutput=γ⋅σh−μ+β

在普通的网络中，这里的 γ\gammaγ 和 β\betaβ 是模型的可学习参数。也就是说，无论输入什么图片，这两个参数的值在推理阶段都是固定的。自适应归一化 (Adaptive Norm / adaLN)：自适应归一化的巧妙之处在于：γ\gammaγ 和 β\betaβ 不再是固定的参数了，而是根据输入的“条件”实时计算出来的。

DiT 中的使用

在 DiT 论文中，这里的“条件”就是时间步 ttt 和类别标签 ccc 的嵌入向量之和。因为前面一步我们已经把 ttt 和 ccc 映射成了两个长度同为 ddd 的一维向量，所以可以直接把它们加在一起：Condition=Vectort+VectorcCondition = Vector_t + Vector_cCondition=Vectort+Vectorc 。得到相加后的条件向量后，adaLN 层会将这个向量送入一个 SiLU 激活函数，紧接着经过一个线性层。这个线性层会直接输出当前 Transformer 块所需要的缩放参数 γ\gammaγ 和平移参数 β\betaβ。这种方法计算效率最高，增加的 Gflops 最少。

adaLN-Zero

这是 DiT 的灵魂设计。除了 γ\gammaγ 和 β\betaβ，它还回归出一个维度级别的缩放参数 α\alphaα，在任何残差连接之前应用。同时，它将输出这些参数的 MLP 初始化为输出零向量。这导致在训练最开始时，整个 DiT Block 实际上是一个“恒等映射” 。这种初始化极大地提升了大规模网络的训练稳定性，以极小的 Gflops 代价换取了最好的生成效果。

缩放参数 α\alphaα

在标准的 Transformer 块中，残差连接的公式通常是：Output=Input+SubBlock(Input)Output = Input + SubBlock(Input)Output=Input+SubBlock(Input) （这里的 SubBlock 可能是自注意力层或前馈神经网络层）。论文提到，α\alphaα 是一个维度级别的缩放参数，它被应用在DiT 块内任何残差连接之前。结合 adaLN-Zero，完整的公式如下：

先生成参数：通过前面的 MLP 回归出 γ\gammaγ、β\betaβ 和 α\alphaα。
应用自适应归一化： h=γ⋅LayerNorm(x)+βh = \gamma \cdot \text{LayerNorm}(x) + \betah=γ⋅LayerNorm(x)+β
应用 α\alphaα 进行缩放并加入残差： xnew=x+α⋅SubBlock(h)x_{new} = x + \alpha \cdot \text{SubBlock}(h)xnew=x+α⋅SubBlock(h) 这里的 α\alphaα 控制了网络当前这个子模块（SubBlock）的输出能在多大程度上加回到原始输入 xxx 上。

初始化为零

这是深度学习中一个极其经典且优雅的调参技巧。论文中明确写道：“我们将 MLP 初始化为对所有的 α\alphaα 输出零向量；这会将整个 DiT 块初始化为恒等映射（identity function）” 。 原理解析：结合我们上面的公式： xnew=x+α⋅SubBlock(h)x_{new} = x + \alpha \cdot \text{SubBlock}(h)xnew=x+α⋅SubBlock(h) 如果在训练的最开始，我们将生成 α\alphaα 的神经网络权重初始化为 0，那么初始状态下 α\alphaα 就会是一个零向量。此时公式变成了： xnew=x+0⋅SubBlock(h)=xx_{new} = x + 0 \cdot \text{SubBlock}(h) = xxnew=x+0⋅SubBlock(h)=x 这意味着，在训练的第 0 步，无论这个 Transformer 块内部有多复杂，它对数据的处理效果就相当于什么都没做，输入什么就输出什么。 为什么这很有用？ 论文提到，这是借鉴了 ResNet 的经验。在极深的网络中，如果一开始权重是随机的，信号经过几十层复杂的变换很容易彻底丢失（梯度消失）或爆炸。如果一开始所有的层都是“恒等映射”，信号就能完美、无损地直接从网络第一层传递到最后一层。这极大地保证了网络在训练初期的稳定性，使得模型可以从一个极其稳定的状态开始，一点点“缓慢而安全”地学习如何改变特征。

Transformer 解码器与输出

经过 NNN 层 DiT Block 处理后，我们需要将这些一维的 Token 变回特征图，并输出预测的噪声和方差。 DiT 使用一个标准的线性解码器，对每个 Token 应用最终的归一化，并将其线性解码为一个形状为 p×p×2Cp \times p \times 2Cp×p×2C 的张量。这里的 2C2C2C 个通道：一半通道用来输出预测的噪声 ϵθ\epsilon_\thetaϵθ，另一半用来输出对数方差的插值系数 vvv 预测方差。最后，将这些解码后的 Token 重新排列回原始的空间布局。通过在一开始注入的位置编码，Transformer 记住了每个 Token 的绝对二维坐标，因此最后可以直接按序重组回原始的网格形状而不乱套。

实验解析与 Scaling Law

实验设置

训练设置

数据集与分辨率：模型在 ImageNet 数据集上训练，分别测试了 256×256256 \times 256256×256 和 512×512512 \times 512512×512 两种高分辨率图像生成。
优化器与超参数：使用了深度学习中最常用的 AdamW 优化器。学习率固定在 1×10−41 \times 10^{-4}1×10−4 ，并且没有使用权重衰退，批量大小设定为 256 。数据增强仅仅使用水平翻转。
摒弃 Transformer 的“传统依赖”：以往在训练 ViT 时，通常需要精心设计学习率预热和各种正则化手段来防止模型崩溃。但是作者发现，DiT 的训练极度稳定，完全不需要这些技巧，也没有出现常见的损失值剧烈波动。
EMA 模型评估：这也是生成模型训练的标准操作EMA。作者在训练过程中维护了模型权重的指数移动平均（EMA），衰减率设定为 0.9999。论文中汇报的所有结果，都是基于这个更加平滑、稳定的 EMA 模型得到的。

扩散与潜空间设置

直接用 VAE：为了节省算力并专注于扩散部分的研究，作者没有自己训练 VAE，而是直接使用了 Stable Diffusion 中现成的、经过预训练的 VAE 模型。这个 VAE 的下采样率是 8，完美地将 256×256×3256 \times 256 \times 3256×256×3 的图像压缩成了 32×32×432 \times 32 \times 432×32×4 的隐变量空间。
继承前人的参数：在扩散过程的超参数上，作者几乎完全照搬了 ADM 模型的设置，比如 tmax=1000t_{max} = 1000tmax=1000 的线性方差调度（从 1×10−41 \times 10^{-4}1×10−4 到 2×10−22 \times 10^{-2}2×10−2）前向过程参数调度，以及 ADM 处理协方差参数化的方法预测方差。这种严格的控制变量做法，能说明性能的跃升完全来自于 DiT 架构本身，而不是调参的功劳。

评估指标

在生成模型的评测上，作者选用了多种指标。

FID

这是评估图像生成质量的黄金标准。也是该论文中的核心指标。简单来说，它通过预训练的图像分类网络提取真实图像和生成图像的特征，然后计算这两个特征分布之间的距离。FID 数值越小，说明生成的图像越逼真、分布越接近真实世界。FID 论文中主要汇报的是 FID-50K，意思是模型生成了 50000 张图像来和验证集进行对比，采样步数设定为标准 250 步 DDPM 采样。

为什么采样步数是 250 步而不是 1000 步？

固定方差的“短视”：原始的 DDPM 必须使用 1000 步，因为它把方差固定为了常数。如果在采样时强行减少步数，这个固定的方差假设就会奔溃，导致生成质量断崖式下跌。原始 DDPM 假设走 1000 步，每一步的跨度极小。在数学推导中，单步逆向过程 q(xt−1∣xt,x0)q(x_{t-1}|x_t, x_0)q(xt−1∣xt,x0) 的真实方差 β~t\tilde{\beta}_tβ~t 是极其微小的。模型把方差固定为这个极小值是没问题的，因为 1000 步的密集采样足以覆盖整个分布。但是，如果想加速采样，比如从 1000 步直接跨到 990 步（一次跨了 10 步的距离），此时真实的“跨步方差”在数学上会急剧变大。如果依然使用原始 DDPM 那个基于“单步微小位移”推导出的固定极小方差，模型就会因为方差过小、缺乏足够的随机性（不确定性范围）而无法覆盖跨步带来的误差。

学习方差的“自适应”能力：当模型通过预测插值系数 vvv 来学习方差 Σθ\Sigma_\thetaΣθ 时，它实际上是在学习当前去噪步的不确定性。在 Improved DDPM 和 DiT 中，网络具备了输出较大方差的能力。当强行跳步采样时，网络可以通过预测更大的 vvv 值来输出一个更宽广的方差分布。这个变大的方差可以很好地吸收减少步数带来的离散化截断误差，从而赋予了模型“跨大步”依然能平稳落地的能力。

行业标准：也是为了在算力开销和评测准确度之间取得平衡，250 步已经成为了使用学习方差的扩散模型计算 FID 跑分的标准操作。

特别需要注意的是，在进行基础的Scaling Law 分析时，为了反映模型最真实的性能，作者在这里汇报的 FID 跑分均没有使用 CFG 引导技术，除非在后续对比最强模型时特别声明。

辅助指标

在评估生成模型的时候，FID 不是万能的，所以作者补充了一些次级指标。

Inception Score (IS)

IS 是早期 GAN 时代非常流行的指标，它看重生成图像的清晰度和多样性。IS 越高越好。IS

sFID

常规 FID 在计算时需要把图片扔进 InceptionV3 分类网络中，提取最后一层全局池化后的特征向量。但这会丢失大量的空间分布和纹理细节。 sFID 取的是池化之前的特征图，将其空间维度展平，作为局部特征集合来计算 Fréchet 距离。它的核心公式与 FID 完全一致，只是统计的对象变了：

sFID=∥μr−μg∥22+Tr(Σr+Σg−2(ΣrΣg)1/2)sFID = \|\mu_r - \mu_g\|_2^2 + Tr(\Sigma_r + \Sigma_g - 2(\Sigma_r \Sigma_g)^{1/2})sFID=∥μr−μg∥22+Tr(Σr+Σg−2(ΣrΣg)1/2)

μr,Σr\mu_r, \Sigma_rμr,Σr：真实图像空间特征的均值向量和协方差矩阵。
μg,Σg\mu_g, \Sigma_gμg,Σg：生成图像空间特征的均值向量和协方差矩阵。
它对图像的底层空间结构、边缘和纹理更加敏感。

Precision & Recall

这一对指标将生成模型的评估拆分成了两个独立的维度：

Precision：衡量的是“模型生成的图片中，有多少落在了真实数据分布的范围内”。Precision 越高，说明模型生成的废图越少，肉眼看着越真实。
Recall：衡量的是“真实世界的数据分布中，有多少被模型生成的图片覆盖到了”。Recall 越高，说明模型没有发生“模式崩溃”，能生成各种各样不同的猫、狗、风景，而不是只会画同一种脸。论文特别指出 DiT-XL/2 在这个指标上超越了之前的 LDM 模型。这两个指标不假设数据是高斯分布，而是利用k-近邻 (k-NN) 在高维特征空间中构建真实图像和生成图像的“流形边界”。首先，对于特征空间中的任何一个真实样本 xrx_rxr，我们找到它的第 kkk 个最近邻的真实样本，它们之间的距离设为半径。所有真实样本周围这个半径内的空间，就构成了真实图像的流形空间 Φr\Phi_rΦr。同理可以构建生成图像的流形空间 Φg\Phi_gΦg。
Precision 公式： Precision=1Ng∑j=1NgI(xg(j)∈Φr)Precision = \frac{1}{N_g} \sum_{j=1}^{N_g} \mathbb{I}(x_g^{(j)} \in \Phi_r)Precision=Ng1∑j=1NgI(xg(j)∈Φr)
- NgN_gNg 是生成图像的总数。
- I\mathbb{I}I 是指示函数（落入区间为 1，否则为 0）。
- 计算生成的图片中，有多少张（比例）落在了真实图片的流形空间内。只要落进去了，就算作一张好图。它不关心是否生成了所有种类的图，只关心生成的图是不是看起来像真的。
Recall 公式： Recall=1Nr∑i=1NrI(xr(i)∈Φg)Recall = \frac{1}{N_r} \sum_{i=1}^{N_r} \mathbb{I}(x_r^{(i)} \in \Phi_g)Recall=Nr1∑i=1NrI(xr(i)∈Φg)
- NrN_rNr 是真实图像的总数。
- 计算真实的图片中，有多少张（比例）被生成的图片的流形包围了。如果模型发生了模式崩溃，那么真实世界里的图片就会落在生成流形之外，Recall 就会变得很低。

条件注入消融实验

作者在这里固定了模型大小（使用了最大的 DiT-XL/2），分别用四种不同的条件注入机制条件注入机制训练了四个模型，并比较了它们的 FID 和 Gflops。

FID：实验结果显示，adaLN-Zero 在训练的各个阶段，FID 得分都远低于交叉注意力和上下文条件。
Gflops：adaLN 和 adaLN-Zero 增加的算力最少（均为 118.6 Gflops），In-context 略高（119.4 Gflops），而 Cross-Attention（交叉注意力）的算力开销最大（高达 137.6 Gflops，增加了约 15% 的额外计算）。
零初始化：最令人惊讶的是 adaLN 和 adaLN-Zero 的对比。两者的网络结构和算力开销完全一模一样，唯一的区别就在于 adaLN-Zero 把输出缩放参数的 MLP 权重初始化为了 0。结果证明，仅仅是这一个初始化的改变，极大地加速了模型的收敛，最终的 FID 显著降低。这个实验最终确定：条件注入机制不仅影响算力，更致命地影响模型生成质量；而良好的初始化是训练大模型的关键。

控制变量实验

控制 Patch Size 不变

假设固定 ppp为 8/4/2 其中一个。此时随着模型从 S 变到 B、L、XL（也就是 Transformer 的层数更深、隐藏层更宽），算力逐渐增加。结果：FID 曲线完美地呈现出阶梯状下降。模型越大，生成质量越好。

控制模型大小不变

假设固定架构大小不变（例如 DiT-B）。此时将 Patch size 从 8 缩小到 4，再缩小到 2。结合公式 T=(I/p)2T = (I/p)^2T=(I/p)2，Patch 减半意味着 Token 数量直接翻 4 倍，计算量也随之暴增图像的 Token 化。结果：同样地，ppp 越小，FID 曲线越低，图像质量越好。

核心结论：Gflops 才是硬通货

过去大家习惯用“参数量”来衡量生成模型强不强。但是 DiT 证明了这是错的。比如，当模型大小固定时，把 Patch size 从 8 缩小到 2，模型的总参数量其实根本没有增加（甚至因为位置编码变长而让线性映射层的参数微调，整体几乎不变），但是 Gflops却翻了十几倍。在图 8 中，作者把这 12 个模型放在一张图里，横坐标是前向传播的 Gflops，纵坐标是最终的 FID-50K。结果发现它们极其完美地拟合在了一条直线上（皮尔逊相关系数高达 -0.93） 核心结论：不管通过“加深/加宽网络”来增加算力，还是通过“切分更小的 Patch”来增加算力，只要最终的 Gflops 是一样的，它们的 FID 得分就极其相似（比如图中的 DiT-S/2 和 DiT-B/4）。这就是 DiT 揭示的 Scaling Law 核心！

大模型 vs 小模型

算力效率之争

既然算力那么关键，那如果小模型训练时间足够长，消耗同样的算力，能不能追上大模型？

总训练算力

作者为了比较不同模型的“算力性价比”，提出了估算总训练算力 (Total Training Compute) 的公式：训练算力=模型前向Gflops×批次大小(BatchSize)×训练步数(TrainingSteps)×3训练算力 = 模型前向 Gflops \times 批次大小 (Batch Size) \times 训练步数 (Training Steps) \times 3训练算力=模型前向Gflops×批次大小(BatchSize)×训练步数(TrainingSteps)×3

模型前向 Gflops：这是模型处理单张图片进行一次前向传播（也就是从输入到输出算出预测噪声）所需要的浮点运算次数。
批次大小 ×\times× 训练步数：这两项乘起来，代表了模型在整个训练过程中，一共处理了多少张图片。比如 Batch Size 是 256，训练了 400K 步，就意味着模型一共处理了 256×400,000256 \times 400,000256×400,000 张图。
乘数因子 3：神经网络的训练包含前向传播（算误差）和反向传播（算梯度并更新权重）。在深度学习框架的底层实现中，根据经验估算，计算一次反向传播所需的算力大约是前向传播的两倍。所以，前向 (1) + 反向 (2) = 总消耗是前向传播的 3 倍。这个公式将时间、硬件规模和模型规模统筹在了一个统一的维度下，科学地量化了算力的消耗量。

结论

作者发现，大模型（比如 XL/2）在相同的训练算力消耗下，FID 远低于小模型。即“一个小模型训练很久”不仅效果打不过“一个大模型只训练一小会儿”，而且在算力利用率上也是极其低效的。这告诉我们，如果手头有足够的算力，直接上大模型是最经济的选择。

采样算力能否弥补模型算力

扩散模型可以在推理时增加去噪步数来提高图片质量，那么如果用一个小模型在推理时采样 1000 步，能否打败大模型只跑 128 步？在图 10 中，作者做了极其详尽的对比。比如拿 DiT-L/2 跑 1000 步，和 DiT-XL/2 跑 128 步对比。尽管 L/2 跑 1000 步消耗的“总采样算力（80.7 Tflops）”是 XL/2 跑 128 步（15.2 Tflops）的 5 倍多，但 XL/2 的 FID 依然吊打 L/2。结论：模型算力是硬伤。如果模型本身没学到足够好的数据分布，再多的采样算力也没用。采样算力的增加，永远无法弥补模型算力的先天不足。

最终成绩：SOTA

在完成 Scaling Law 的验证后，作者将算力最大的模型 DiT-XL/2 继续训练到了 700 万步，并开启了 CFG。

吊打 U-Net 架构：在 ImageNet 256×256256 \times 256256×256 的条件生成任务上，DiT-XL/2 取得了 2.27 的 FID 得分，远低于之前基于 U-Net 架构的最强模型 LDM（FID 3.60）和 ADM。
算力性价比极高：相比于在像素空间计算、极其昂贵的 ADM（1120 Gflops），DiT-XL/2 仅用了 118.6 Gflops 就取得了更好的成绩。
历史意义：这个结果无可辩驳地证明了：在扩散模型领域，U-Net 的归纳偏置并非不可替代。纯粹的 Transformer 架构不仅能做扩散模型，而且能在规模化后做得比 U-Net 更好。这也为后来 Sora 等视频生成大模型全面拥抱 DiT 架构奠定了基础。

DiT 的历史地位与局限性

DiT 的历史贡献

大一统的曙光：DiT 证明了在生成模型领域，Transformer 完全可以取代 U-Net。这让计算机视觉和自然语言处理在底层架构上进一步走向了统一。
极强的可预测性：它的 Scaling Law 极其优美。只要你有钱、有算力，你就可以闭着眼睛扩大模型规模（增加 Gflops），且你可以非常确定地知道生成质量一定会提升。这种“大力出奇迹”的稳定性，是工业界（比如后来的 Sora 模型全面采用 DiT）最看重的。

DiT 的局限性

平方级复杂度：Transformer 的 Self-Attention 计算复杂度是关于序列长度 TTT 成平方关系 O(T2)O(T^2)O(T2) 的。即使 DiT 在隐空间工作，但如果要生成 1024×10241024 \times 10241024×1024 甚至更高分辨率的图像，或者生成长视频，Token 数量会呈指数爆炸，导致算力开销变得极其恐怖。这也是为什么很多后续工作都在研究 Linear Attention（线性注意力）或 Mamba 等架构来替代标准 Transformer。
并非“纯粹”的 Transformer：DiT 依然重度依赖基于 CNN 训练的 VAE 来进行特征压缩和解码。它并没有完全摆脱卷积的影子。如何训练一个真正端到端（End-to-End）的纯 Transformer 像素级扩散模型，依然是一个挑战。
缺乏空间归纳偏置：相比于 U-Net（卷积网络天生懂得“相邻的像素大概率是相关的”），Transformer 一开始是一张白纸，它必须通过消耗海量的数据和算力，才能自己慢慢“悟”出图像的二维空间结构。所以它在小数据集上极其容易过拟合，是一个真正的“算力巨兽”。

《Denoising Diffusion Probabilistic Models》论文精读

小yo — Wed, 25 Feb 2026 17:32:14 GMT

前置数学知识

高斯分布的运算法则与重参数化技巧

独立高斯分布的线性组合

假设有两个相互独立的随机变量都服从高斯分布：

X∼N(μ1,σ12)X \sim \mathcal{N}(\mu_1, \sigma_1^2)X∼N(μ1,σ12) 和 Y∼N(μ2,σ22)Y \sim \mathcal{N}(\mu_2,\sigma_2^2)Y∼N(μ2,σ22)

则对于线性组合起来的新变量 Z=aX+bYZ=aX+bYZ=aX+bY (其中 a,ba, ba,b 是常数)，则 Z 依然服从高斯分布，其均值和方差遵循以下规则：

Z∼N(aμ1+bμ2,a2σ12+b2σ22)Z \sim \mathcal{N}(a \mu_1 + b \mu_2,a^2 \sigma_1^2 + b^2 \sigma_2^2)Z∼N(aμ1+bμ2,a2σ12+b2σ22)

在 DDPM 中的作用：前向扩散过程就是不断往图像中按比例加独立的高斯噪音。

重参数化技巧

在深度学习里，直接从一个带有参数 μ\muμ 和 σ\sigmaσ 的分布 N(μ,σ)\mathcal{N}(\mu,\sigma)N(μ,σ) 中采样一个数据点 xxx 是不可导的，梯度无法反向传播。

因此，将采样拆为：

首先，从标准正态分布中采样一个基础噪声: ϵ∼N(0,1)\epsilon \sim \mathcal{N}(0, 1)ϵ∼N(0,1)
然后，通过线性变换得到我们想要的 x:x=μθ+σθ⋅ϵx: x=\mu_{\theta}+\sigma_{\theta} \cdot \epsilonx:x=μθ+σθ⋅ϵ
这样一来， xxx 对 μθ\mu_{\theta}μθ 和 σθ\sigma_{\theta}σθ 的关系就变成了完全确定的数学函数，梯度就可以正常传播：
- xxx 对 μθ\mu_{\theta}μθ 的偏导数是 1。
- xxx 对 σθ\sigma_{\theta}σθ 的偏导数是 ϵ\epsilonϵ。
这样梯度就能通过计算图，神经网络的权重 θ\thetaθ 就能顺利得到更新了。

马尔可夫链

定义：马尔可夫链描述了一系列状态的演变，具有“无记忆性”假设——系统的下一个状态只有当前状态有关，而与过去的任何状态都无关。即：

P(xt∣xt−1,xt−2,...,x0)=P(xt∣xt−1)P(x_t|x_{t-1},x_{t-2},...,x_0)=P(x_t|x_{t-1})P(xt∣xt−1,xt−2,...,x0)=P(xt∣xt−1)

在 DDPM 中的作用：

前向过程：论文将逐渐加噪的过程定义为马尔可夫链 q(x1:T∣x0):=∏t=1Tq(xt∣xt−1)q(x_{1:T}|x_0) := \prod_{t=1}^T q(x_t|x_{t-1})q(x1:T∣x0):=∏t=1Tq(xt∣xt−1)。即第 ttt 步的加噪图像 xtx_txt 只依赖于第 t−1t-1t−1 步的图像 xt−1x_{t-1}xt−1
反向过程：模型要学习的去噪过程也是一个马尔可夫链 pθ(x0:T):=p(xT)∏t=1Tpθ(xt−1∣xt)p_{\theta}(x_{0:T}):=p(x_T)\prod_{t=1}^Tp_{\theta}(x_{t-1}|x_t)pθ(x0:T):=p(xT)∏t=1Tpθ(xt−1∣xt)。即去噪恢复出 xt−1x_{t-1}xt−1 只依赖于当前的 xtx_txt。

数学符号解读：

关于 1:T1:T1:T

表示从 1 到 TTT 的一个连续的序列。例如 x1:Tx_{1:T}x1:T 就是 x1,x2,x3,...,xTx_1,x_2,x_3,...,x_Tx1,x2,x3,...,xT 这一连串变量的集合缩写

关于 :=:=:=

这个符号读作“定义为”，表示“我此刻人为规定左边的符号等于右边的内容”。

KL散度

KL 散度的通用公式：

对于两个连续的概率分布 P 和 Q，衡量 PPP 和 QQQ 差异的 KL 散度定义为一个积分公式：

DKL(P∣∣Q)=∫−∞∞p(x)log⁡(p(x)q(x))dxD_{KL}(P || Q) = \int_{-\infty}^{\infty} p(x) \log \left( \frac{p(x)}{q(x)} \right) dxDKL(P∣∣Q)=∫−∞∞p(x)log(q(x)p(x))dx

我们要让神经网络去模仿真实的去噪过程，我们就需要一把尺子来衡量网络当前的模仿和真实的去噪过程之间的差异，这把尺子就是 KL 散度。

在 DDPM 中的关键作用：数学上有一个性质：计算两个高斯分布之间的 KL 散度，是有确定的闭式解的。

闭式解：在数学建模和优化中，如果一个复杂的方程或积分能够通过有限步的基本数学运算（加减乘除、指数、对数等）直接写出一个精确的代数表达式，我们就说它有“闭式解”或“解析解”。

两个单变量高斯分布 P∼N(μ1,σ12)P \sim \mathcal{N}(\mu_1, \sigma_1^2)P∼N(μ1,σ12) 和 Q∼N(μ2,σ22)Q \sim \mathcal{N}(\mu_2, \sigma_2^2)Q∼N(μ2,σ22) 之间的 KL 散度积分可以直接简化为一个纯代数公式：

DKL(P∣∣Q)=log⁡(σ2σ1)+σ12+(μ1−μ2)22σ22−12D_{KL}(P||Q)=\log \left(\frac{\sigma_2}{\sigma_1} \right) + \frac{\sigma_1^2+(\mu_1-\mu_2)^2}{2\sigma_2^2} - \frac{1}{2}DKL(P∣∣Q)=log(σ1σ2)+2σ22σ12+(μ1−μ2)2−21

积分号消失了。这意味着在构造损失函数时，我们只需要提取出预测分布和真实分布的均值和方差，代入这个简单的算术公式即可。论文中提到，所有的 KL 散度都是高斯分布之间的比较，因此可以用闭式解直接计算。

极大似然估计与变分推断

极大似然估计（MLE）

假设真实数据集分布是 q(x0)q(x_0)q(x0)，我们的模型分布是 pθ(x0)p_\theta(x_0)pθ(x0)。MLE 的核心思想是：调整模型参数 θ\thetaθ，使得真实数据在我们模型中出现的概率最大化。

目标函数（取对数方便求导）： max⁡θEq(x0)[log⁡pθ(x0)]\max_\theta \mathbb{E}_{q(x_0)}[\log p_\theta(x_0)]maxθEq(x0)[logpθ(x0)]。

在机器学习中，我们通常把最大化问题变成最小化问题，即最小化负对数似然： min⁡θE[−log⁡pθ(x0)]\min_\theta \mathbb{E}[-\log p_\theta(x_0)]minθE[−logpθ(x0)]

Eq(x0)[log⁡pθ(x0)]\mathbb{E}_{q(x_0)}[\log p_\theta(x_0)]Eq(x0)[logpθ(x0)]:

q(x0)q(x_0)q(x0)：代表的是真实世界（也就是训练集）的客观数据分布。

假设训练集里有 NNN 张真实的图片，分别记为 x(1),x(2),…,x(N)x^{(1)}, x^{(2)}, \dots, x^{(N)}x(1),x(2),…,x(N)。

连乘：模型认为这 NNN 张真实图片同时存在的总概率，是它们各自概率的连乘： pθ(x(1))⋅pθ(x(2))…pθ(x(N))p_\theta(x^{(1)}) \cdot p_\theta(x^{(2)}) \dots p_\theta(x^{(N)})pθ(x(1))⋅pθ(x(2))…pθ(x(N))

取对数：因为连乘很容易导致数值下溢，我们通常取对数，把连乘变成连加 ∑i=1Nlog⁡pθ(x(i))\sum_{i=1}^N \log p_\theta(x^{(i)})∑i=1Nlogpθ(x(i))

求平均：为了让损失函数不受数据集大小 NNN 的影响，我们通常除以 NNN，求个平均值： 1N∑i=1Nlog⁡pθ(x(i))\frac{1}{N} \sum_{i=1}^N \log p_\theta(x^{(i)})N1∑i=1Nlogpθ(x(i))

所以， Eq(x0)[log⁡pθ(x0)]\mathbb{E}_{q(x_0)}[\log p_\theta(x_0)]Eq(x0)[logpθ(x0)] 的意思就是：“从真实训练集 q(x0)q(x_0)q(x0) 里抓取一张图片 x0x_0x0，喂给模型，让模型算出一个对数概率 log⁡pθ(x0)\log p_\theta(x_0)logpθ(x0)，然后把所有真实图片算出来的这个分值求个平均。”

变分推断

问题：在扩散模型中， pθ(x0)p_\theta(x_0)pθ(x0) 实际上是由纯噪声 xTx_TxT 经过 TTT 步降噪得来的。要计算出 pθ(x0)p_\theta(x_0)pθ(x0)，必须把所有可能的中间状态 x1:Tx_{1:T}x1:T 全部积分掉： pθ(x0)=∫pθ(x0:T)dx1:Tp_\theta(x_0) = \int p_\theta(x_{0:T}) dx_{1:T}pθ(x0)=∫pθ(x0:T)dx1:T。这个积分在千万维的图像空间是根本算不出来的。

pθ(x0)=∫pθ(x0:T)dx1:Tp_\theta(x_0) = \int p_\theta(x_{0:T}) dx_{1:T}pθ(x0)=∫pθ(x0:T)dx1:T:

下标 θ\thetaθ：

在深度学习的数学表达里， θ\thetaθ 永远代表神经网络中所有可学习的权重参数。

如果不带 θ\thetaθ 的 ppp 或 qqq，通常指代自然界固有的规律，或者我们人为写死的、不需要训练的规则（比如前向加噪过程）

带着 θ\thetaθ 的 pθp_\thetapθ，意思是“这个概率是由我正在训练的神经网络算出来的”。我们要不断调整网络参数 θ\thetaθ，来改变这个概率分布的形状

x0x_0x0：代表最终的真实观测数据

x1:Tx_{1:T}x1:T：代表一系列的潜变量序列，即 x1,x2,…,xTx_1, x_2, \dots, x_Tx1,x2,…,xT

pθ(x0:T)p_\theta(x_{0:T})pθ(x0:T)：代表观测数据 x0x_0x0 和所有潜变量 x1:Tx_{1:T}x1:T 的联合概率分布马尔可夫链

∫…dx1:T\int \dots dx_{1:T}∫…dx1:T：这是一个高阶多重积分，将这个符号完全展开：

∫…dx1:T≡∫∫ ⁣⋯∫⏟T次…dx1dx2…dxT\int \dots dx_{1:T} \equiv \underbrace{\int \int \dots \int}_{T \text{次}} \dots dx_1 dx_2 \dots dx_T∫…dx1:T≡T次∫∫⋯∫…dx1dx2…dxT

在概率论中，这个积分操作对应着求边缘概率密度——假设我们有一个联合概率密度函数 f(x,y)f(x, y)f(x,y)，如果我们只想知道 xxx 的概率分布，而不在乎 yyy 取什么值，数学上的做法是对 yyy 积分： f(x)=∫f(x,y)dyf(x) = \int f(x, y) dyf(x)=∫f(x,y)dy。对应到这个积分操作中:

被积函数是联合分布 pθ(x0,x1,…,xT)p_\theta(x_0, x_1, \dots, x_T)pθ(x0,x1,…,xT)。

∫…dx1:T\int \dots dx_{1:T}∫…dx1:T 的数学动作，就是将联合概率密度函数对所有的潜变量 x1x_1x1 到 xTx_TxT 进行积分。

通过这种操作，我们把一个定义在 RD×(T+1)\mathbb{R}^{D \times (T+1)}RD×(T+1) 空间上的联合分布，投影到了只包含 x0x_0x0 的 RD\mathbb{R}^DRD 空间上，从而得到边缘分布 pθ(x0)p_\theta(x_0)pθ(x0)。

思想：既然直接算算不出来，那么可以找一下界——找到一个一定比 log⁡pθ(x0)\log p_\theta(x_0)logpθ(x0) 小，但是可以被计算的公式，这个公式就是 ELBO（证据下界），则当我们最大化这个下界时，相当于简洁地最大化了目标概率。

在 DDPM 中的应用：利用 Jenson 不等式，得到了以下 ELBO：

E[−log⁡pθ(x0)]≤Eq[−log⁡p(xT)−∑t≥1log⁡pθ(xt−1∣xt)q(xt∣xt−1)]=:L\mathbb{E}[-\log p_\theta(x_0)] \le \mathbb{E}_q \left[ -\log p(x_T) - \sum_{t \ge 1} \log \frac{p_\theta(x_{t-1}|x_t)}{q(x_t|x_{t-1})} \right] =: LE[−logpθ(x0)]≤Eq[−logp(xT)−∑t≥1logq(xt∣xt−1)pθ(xt−1∣xt)]=:L

这样就把复杂的积分问题，转化成了优化期望值的问题。

剖析扩散过程

单步加噪

论文在公式 (2) 中定义了单步的加噪过程：

q(xt∣xt−1):=N(xt;1−βtxt−1,βtI)q(x_t|x_{t-1}) := \mathcal{N}(x_t; \sqrt{1-\beta_t}x_{t-1}, \beta_t I)q(xt∣xt−1):=N(xt;1−βtxt−1,βtI)

公式解读：

q(xt∣xt−1)q(x_t|x_{t-1})q(xt∣xt−1)：代表条件概率密度函数。该表达式描述了：在给定前一个状态 xt−1x_{t-1}xt−1 完全已知的条件下，当前状态 xtx_txt 的概率分布情况。因为 xtx_txt 只依赖于紧邻的前一步 xt−1x_{t-1}xt−1，这体现了严格的马尔可夫性质。

在深度学习中，我们通常用 qqq 来表示前向的、用来近似或人为设定的概率分布，而用 ppp 来表示模型真正要去学习和生成的概率分布。所以在这里， qqq 专门用来指代“前向加噪过程”的分布。

q(xT∣xt−1)q(x_T|x_{t-1})q(xT∣xt−1) 与 q(xT)q(x_T)q(xT) 的关系(全概率公式)：

q(xT)=∫q(xT∣xt−1)q(xt−1)dxt−1q(x_T) = \int q(x_T|x_{t-1}) q(x_{t-1}) dx_{t-1}q(xT)=∫q(xT∣xt−1)q(xt−1)dxt−1

N\mathcal{N}N：作者人为规定每一次加噪都必须加上高斯噪音。之所以这么选，是因为高斯分布的加法法则非常完美独立高斯分布的线性组合。

数学符号解读：

N(xt;1−βtxt−1,βtI)\mathcal{N}(x_t; \sqrt{1-\beta_t}x_{t-1}, \beta_t I)N(xt;1−βtxt−1,βtI)：在多维空间的正式数学表达中，高斯分布通常写成 N(变量;均值,协方差矩阵)\mathcal{N}(\text{变量}; \text{均值}, \text{协方差矩阵})N(变量;均值,协方差矩阵)。

xtx_txt：这是我们要研究的随机变量。分号的意思是“以……为条件”或“参数为……”。即“变量 xtx_txt 是一个服从正态分布的随机变量，它的分布参数如下”。

βt\beta_tβt：方差调度。它决定了在第 ttt 步我们要往图像中注入多少噪声。
- 它的本质：它是一个介于 0 和 1 之间的数值序列。
- 在本文中的设定：在论文的实验中（第 4 节），作者把总步数设为 T=1000T=1000T=1000 ，并且将 βt\beta_tβt 设定为从 β1=10−4\beta_1 = 10^{-4}β1=10−4 线性增加到 βT=0.02\beta_T = 0.02βT=0.02 的常数。
- 为什么慢慢变大： ttt 较小时，原图信息很清晰，我们只加微小的噪声（ 0.00010.00010.0001 ）；越到后面（ ttt 接近 1000），图像已经被破坏得差不多了，我们需要加更大的噪声（ 0.020.020.02 ）来确保最终的图像 xTx_TxT 彻底变成纯高斯噪声。
1−βtxt−1\sqrt{1-\beta_t}x_{t-1}1−βtxt−1 （均值 μ\muμ ）：因为 βt\beta_tβt 很小，所以 1−βt\sqrt{1-\beta_t}1−βt 是一个非常接近 1 但是稍微小于 1 的数。这个设计的巧妙之处在于：我们不是直接在 xt−1x_{t-1}xt−1 上原封不动地加噪声，而是先把 xt−1x_{t-1}xt−1 的像素值稍微衰减一点点，向 0 靠拢。
βtI\beta_t IβtI （方差/协方差矩阵 Σ\SigmaΣ ）：这代表我们要加进去的噪声强度大小。 βt\beta_tβt 就是方差。后面跟着的 III 是单位矩阵。因为我们的图像有很多像素点，这个 III 的数学含义是保证图像上的每一个像素点都在独立地加噪声，互相不干扰。

重参数化

为了简化表达，论文在公式(4)之前定义了一个新变量： αt:=1−βt\alpha_t := 1 - \beta_tαt:=1−βt

根据单步加噪公式和新变量 αt\alpha_tαt，我们可以把采样的过程写成一个确定的等式。假设 ϵt−1∼N(0,I)\epsilon_{t-1} \sim \mathcal{N}(0, I)ϵt−1∼N(0,I) 是我们采样的标准高斯噪声：DDPM

xt=αtxt−1+1−αtϵt−1x_t = \sqrt{\alpha_t} x_{t-1} + \sqrt{1 - \alpha_t} \epsilon_{t-1}xt=αtxt−1+1−αtϵt−1

公式推导

同理，上一步的图像 xt−1x_{t-1}xt−1 也是由 xt−2x_{t-2}xt−2 加噪得来的： xt−1=αt−1xt−2+1−αt−1ϵt−2x_{t-1} = \sqrt{\alpha_{t-1}} x_{t-2} + \sqrt{1 - \alpha_{t-1}} \epsilon_{t-2}xt−1=αt−1xt−2+1−αt−1ϵt−2

现在把这个 xt−1x_{t-1}xt−1 代入前一步的 xtx_{t}xt 等式中：

xt=αt(αt−1xt−2+1−αt−1ϵt−2)+1−αtϵt−1x_t = \sqrt{\alpha_t} (\sqrt{\alpha_{t-1}} x_{t-2} + \sqrt{1 - \alpha_{t-1}} \epsilon_{t-2}) + \sqrt{1 - \alpha_t} \epsilon_{t-1}xt=αt(αt−1xt−2+1−αt−1ϵt−2)+1−αtϵt−1

展开括号：

xt=αtαt−1xt−2+(αt(1−αt−1)ϵt−2+1−αtϵt−1)x_t = \sqrt{\alpha_t \alpha_{t-1}} x_{t-2} + (\sqrt{\alpha_t (1 - \alpha_{t-1})} \epsilon_{t-2} + \sqrt{1 - \alpha_t} \epsilon_{t-1})xt=αtαt−1xt−2+(αt(1−αt−1)ϵt−2+1−αtϵt−1)

再利用独立高斯分布的线性组合合并噪声：

在这里， ϵt−2\epsilon_{t-2}ϵt−2 和 ϵt−1\epsilon_{t-1}ϵt−1 的方差都是 111，所以，这两个噪声合并成一个新的标准高斯噪声（我们叫它 ϵˉ\bar{\epsilon}ϵˉ ），它的系数（也就是新方差的平方根）：

(αt(1−αt−1))2+(1−αt)2(\sqrt{\alpha_t (1 - \alpha_{t-1})})^2 + (\sqrt{1 - \alpha_t})^2(αt(1−αt−1))2+(1−αt)2

=αt(1−αt−1)+1−αt= \alpha_t(1 - \alpha_{t-1}) + 1 - \alpha_t=αt(1−αt−1)+1−αt

=αt−αtαt−1+1−αt= \alpha_t - \alpha_t\alpha_{t-1} + 1 - \alpha_t=αt−αtαt−1+1−αt

=1−αtαt−1= 1 - \alpha_t\alpha_{t-1}=1−αtαt−1

噪声合并后，等式变为了： xt=αtαt−1xt−2+1−αtαt−1ϵˉx_t = \sqrt{\alpha_t \alpha_{t-1}} x_{t-2} + \sqrt{1 - \alpha_t \alpha_{t-1}} \bar{\epsilon}xt=αtαt−1xt−2+1−αtαt−1ϵˉ

顺着这个规律一直推下去，直到最开始的 x0x_0x0，最终 xtx_txt 的表达式为： xt=αˉtx0+1−αˉtϵx_t = \sqrt{\bar{\alpha}_t}x_0 + \sqrt{1-\bar{\alpha}_t}\epsilonxt=αˉtx0+1−αˉtϵ

这里 αˉt:=∏s=1tαs\bar{\alpha}_t := \prod_{s=1}^t \alpha_sαˉt:=∏s=1tαs

最终分布

通过上一步的推导，我们便得到了论文里的公式(4)：

q(xt∣x0)=N(xt;αˉtx0,(1−αˉt)I)q(x_t|x_0) = \mathcal{N}(x_t; \sqrt{\bar{\alpha}_t}x_0, (1 - \bar{\alpha}_t)I)q(xt∣x0)=N(xt;αˉtx0,(1−αˉt)I)

它使得模型可以在任何时间步 ttt 直接采样出 xtx_txt，而不需要一步步遍历。

随着时间步 ttt 不断变大，因为 αt\alpha_tαt 都是小于 1 的数，所以他们的连乘积 αˉt\bar{\alpha}_tαˉt 会越来越小，最终趋近于 0。

均值 αˉtx0\sqrt{\bar{\alpha}_t}x_0αˉtx0 会慢慢趋近于 0。这意味着原图 x0x_0x0 的特征被逐渐抹除了。
方差 (1−αˉt)I(1 - \bar{\alpha}_t)I(1−αˉt)I 会趋近于 1⋅I1 \cdot I1⋅I。这意味着随机噪声的权重越来越大。

当 t=Tt=Tt=T （即 1000 步）时， αˉT≈0\bar{\alpha}_T \approx 0αˉT≈0。此时 xTx_TxT 的分布就变成了 N(0,I)\mathcal{N}(0, I)N(0,I) 。也就是说，到了最后一步，所有的原始图像信息都灰飞烟灭，剩下的只有完美的、纯粹的标准高斯噪声。

拆解反向过程

模型定义

在反向过程中，我们要训练一个神经网络，去一步步地消除图像中的噪声。数学上，这个过程被定义为一个由参数 θ\thetaθ 控制的马尔可夫链：

pθ(xt−1∣xt):=N(xt−1;μθ(xt,t),Σθ(xt,t))p_\theta(x_{t-1}|x_t) := \mathcal{N}(x_{t-1}; \mu_\theta(x_t, t), \Sigma_\theta(x_t, t))pθ(xt−1∣xt):=N(xt−1;μθ(xt,t),Σθ(xt,t))

我们的目标是让这个网络输出均值 μθ\mu_{\theta}μθ 和协方差 Σθ\Sigma_\thetaΣθ

工程简化：固定方差

作者在消融实验中尝试了让神经网络同时去预测对角协方差矩阵，结果发现，学习方差会导致训练极其不稳定，并且生成的图像质量更差。因为均值决定了图像“是什么样”，而方差只决定了分布的“宽窄”，在 DDPM 的设定下，固定方差不仅能简化模型，还能带来更好的生成效果。

于是，作者直接把方差 Σθ(xt,t)\Sigma_\theta(x_t, t)Σθ(xt,t) 设定为一个未经训练的、与时间相关的常数 σt2I\sigma_t^2 Iσt2I。作者给出了两个数学上合理的极端边界选择：

直接让 σt2=βt\sigma_t^2 = \beta_tσt2=βt。这个选择在假设原始数据 x0x_0x0 也是标准高斯分布时是最佳的。
让 σt2=β~t=1−αˉt−11−αˉtβt\sigma_t^2 = \tilde{\beta}_t = \frac{1-\bar{\alpha}_{t-1}}{1-\bar{\alpha}_t}\beta_tσt2=β~t=1−αˉt1−αˉt−1βt。这个选择在假设原始数据 x0x_0x0 只有一个确定点时是最佳的。

论文中提到，实验表明这两种常数设定的结果差不多，都非常好。

推导标准答案

利用变分推断，得到我们要最小化的变分上界：

为了让这个界限 LLL 在代码里跑起来，作者进一步利用马尔可夫链和贝叶斯定理，将上式重写为:

Eq[DKL(q(xT∣x0)∥p(xT))⏟LT+∑t>1DKL(q(xt−1∣xt,x0)∥pθ(xt−1∣xt))⏟Lt−1−log⁡pθ(x0∣x1)⏟L0]\mathbb{E}_q \left[ \underbrace{D_{\text{KL}}(q(\mathbf{x}_T | \mathbf{x}_0) \parallel p(\mathbf{x}_T))}_{L_T} + \sum_{t>1} \underbrace{D_{\text{KL}}(q(\mathbf{x}_{t-1} | \mathbf{x}_t, \mathbf{x}_0) \parallel p_\theta(\mathbf{x}_{t-1} | \mathbf{x}_t))}_{L_{t-1}} \underbrace{- \log p_\theta(\mathbf{x}_0 | \mathbf{x}_1)}_{L_0} \right]EqLTDKL(q(xT∣x0)∥p(xT))+∑t>1Lt−1DKL(q(xt−1∣xt,x0)∥pθ(xt−1∣xt))L0−logpθ(x0∣x1)

这个重写把整个模型拆分成了三个部分的KL 散度：

LTL_TLT：前向最终状态与纯噪声的散度（常数，不参与训练）
Lt−1L_{t-1}Lt−1：真实的去噪步骤 q(xt−1∣xt,x0)q(x_{t-1}|x_t, x_0)q(xt−1∣xt,x0) 与神经网络预测的去噪步骤 pθ(xt−1∣xt)p_\theta(x_{t-1}|x_t)pθ(xt−1∣xt) 之间的 KL 散度。
L0L_0L0 ：最后一步生成图像的重建损失。

这样，我们便将 q(xt−1∣xt,x0)q(x_{t-1}|x_t, x_0)q(xt−1∣xt,x0) 作为我们预测网络的标准答案，它也是一个高斯分布： q(xt−1∣xt,x0)=N(xt−1;μ~t(xt,x0),β~tI)q(x_{t-1}|x_t, x_0) = \mathcal{N}(x_{t-1}; \tilde{\mu}_t(x_t, x_0), \tilde{\beta}_t I)q(xt−1∣xt,x0)=N(xt−1;μ~t(xt,x0),β~tI)

其中，真正的均值 μ~t\tilde{\mu}_tμ~t 是由 xtx_txt 和 x0x_0x0 计算出来的： μ~t(xt,x0):=αˉt−1βt1−αˉtx0+αt(1−αˉt−1)1−αˉtxt\tilde{\mu}_t(x_t, x_0) := \frac{\sqrt{\bar{\alpha}_{t-1}}\beta_t}{1-\bar{\alpha}_t}x_0 + \frac{\sqrt{\alpha_t}(1-\bar{\alpha}_{t-1})}{1-\bar{\alpha}_t}x_tμ~t(xt,x0):=1−αˉtαˉt−1βtx0+1−αˉtαt(1−αˉt−1)xt

方差 β~t=1−αˉt−11−αˉtβt\tilde{\beta}_t = \frac{1-\bar{\alpha}_{t-1}}{1-\bar{\alpha}_t}\beta_tβ~t=1−αˉt1−αˉt−1βt

公式推导：

根据贝叶斯定理： q(xt−1∣xt,x0)=q(xt∣xt−1,x0)q(xt−1∣x0)q(xt∣x0)q(x_{t-1}|x_t, x_0) = \frac{q(x_t|x_{t-1}, x_0) q(x_{t-1}|x_0)}{q(x_t|x_0)}q(xt−1∣xt,x0)=q(xt∣x0)q(xt∣xt−1,x0)q(xt−1∣x0)

q(xt∣xt−1,x0)q(x_t|x_{t-1}, x_0)q(xt∣xt−1,x0)：因为马尔可夫链的无记忆性，它其实就等于单步加噪 q(xt∣xt−1)=N(xt;αtxt−1,βtI)q(x_t|x_{t-1}) = \mathcal{N}(x_t; \sqrt{\alpha_t}x_{t-1}, \beta_t I)q(xt∣xt−1)=N(xt;αtxt−1,βtI)。

q(xt−1∣x0)q(x_{t-1}|x_0)q(xt−1∣x0)：利用最终分布，它是 N(xt−1;αˉt−1x0,(1−αˉt−1)I)\mathcal{N}(x_{t-1}; \sqrt{\bar{\alpha}_{t-1}}x_0, (1-\bar{\alpha}_{t-1})I)N(xt−1;αˉt−1x0,(1−αˉt−1)I)。

q(xt∣x0)q(x_t|x_0)q(xt∣x0)：同理，它是 N(xt;αˉtx0,(1−αˉt)I)\mathcal{N}(x_t; \sqrt{\bar{\alpha}_t}x_0, (1-\bar{\alpha}_t)I)N(xt;αˉtx0,(1−αˉt)I) 。

这三个部件全都是标准的高斯分布。把它们各自的概率密度函数（包含指数函数 eee 的一长串公式）代入到贝叶斯公式中相乘和相除，经过一番非常繁琐的代数展开和合并同类项，最终就能精简出论文公式 (6) 和 (7) 里的 μ~t\tilde{\mu}_tμ~t 和 β~t\tilde{\beta}_tβ~t 。

推导简化目标函数

从KL散度到均方误差

我们希望网络预测的均值 μθ\mu_\thetaμθ 尽可能接近真正的均值 μ~t\tilde{\mu}_tμ~t。因为这两个分布都是高斯分布，它们之间的 KL 散度（也就是前一步的 Lt−1L_{t-1}Lt−1 项）可以直接用闭式解KL散度算出来，结果就是一个均分误差（MSE）公式：

Lt−1=Eq[12σt2∣∣μ~t(xt,x0)−μθ(xt,t)∣∣2]+CL_{t-1} = \mathbb{E}_q \left[ \frac{1}{2\sigma_t^2} ||\tilde{\mu}_t(x_t, x_0) - \mu_\theta(x_t, t)||^2 \right] + CLt−1=Eq[2σt21∣∣μ~t(xt,x0)−μθ(xt,t)∣∣2]+C

这里的 CCC 是一个跟我们要训练的参数 θ\thetaθ 无关的常数，可以直接忽略。

消灭 x0x_0x0

在实际生成图片的时候，我们手里只有纯噪声 xTx_TxT，我们是没有上帝视角 x0x_0x0 的。既然如此，我们便需要把 μ~t\tilde{\mu}_tμ~t 公式里的 x0x_0x0 给替换掉。

由公式推导最后的公式可知：

xt=αˉtx0+1−αˉtϵx_t = \sqrt{\bar{\alpha}_t}x_0 + \sqrt{1 - \bar{\alpha}_t}\epsilonxt=αˉtx0+1−αˉtϵ

稍微变形，便可用 xtx_txt 和 ϵ\epsilonϵ 把 x0x_0x0 反向表达出来：

x0=1αˉt(xt−1−αˉtϵ)x_0 = \frac{1}{\sqrt{\bar{\alpha}_t}} (x_t - \sqrt{1 - \bar{\alpha}_t}\epsilon)x0=αˉt1(xt−1−αˉtϵ)

现在，把这个 x0x_0x0 代入 μ~t\tilde{\mu}_tμ~t 的公式中去，化简可得：

μ~t=1αt(xt−βt1−αˉtϵ)\tilde{\mu}_t = \frac{1}{\sqrt{\alpha_t}} \left( x_t - \frac{\beta_t}{\sqrt{1-\bar{\alpha}_t}}\epsilon \right)μ~t=αt1(xt−1−αˉtβtϵ)

范式转化

在化简之后的 μ~t\tilde{\mu}_tμ~t 公式里， xtx_txt 是当前这步模糊的图像，是作为输入喂给神经网络的已知量； αt\alpha_tαt 和 βt\beta_tβt 都是我们提前设定好的常数（已知量）。则在这个公式里，唯一未知的变量，就是那个纯高斯噪音 ϵ\epsilonϵ 。

既然如此，我们便可以定义神经网络的输出形式为：

μθ(xt,t)=1αt(xt−βt1−αˉtϵθ(xt,t))\mu_\theta(x_t, t) = \frac{1}{\sqrt{\alpha_t}} \left( x_t - \frac{\beta_t}{\sqrt{1-\bar{\alpha}_t}}\epsilon_\theta(x_t, t) \right)μθ(xt,t)=αt1(xt−1−αˉtβtϵθ(xt,t))

即，我们让神经网络扮演一个“噪声预测器” ϵθ\epsilon_{\theta}ϵθ 。

最终损失函数

最后，再把这个重新定义的 μθ\mu_{\theta}μθ 和消去 x0x_0x0 的 μ~t\tilde{\mu}_tμ~t 代回到损失函数 Lt−1L_{t-1}Lt−1 中，我们得到下式：

Ex0,ϵ[βt22σt2αt(1−αˉt)∥ϵ−ϵθ(αˉtx0+1−αˉtϵ,t)∥2]\mathbb{E}_{\mathbf{x}_0, \boldsymbol{\epsilon}} \left[ \frac{\beta_t^2}{2\sigma_t^2 \alpha_t (1 - \bar{\alpha}_t)} \left\| \boldsymbol{\epsilon} - \boldsymbol{\epsilon}_\theta(\sqrt{\bar{\alpha}_t}\mathbf{x}_0 + \sqrt{1 - \bar{\alpha}_t}\boldsymbol{\epsilon}, t) \right\|^2 \right]Ex0,ϵ[2σt2αt(1−αˉt)βt2ϵ−ϵθ(αˉtx0+1−αˉtϵ,t)2]

再把前边的权重系数去掉（作者发现去掉系数、用简化的无权重版本效果反而更好），便得到了最终的损失函数：

Lsimple(θ):=Et,x0,ϵ[∣∣ϵ−ϵθ(αˉtx0+1−αˉtϵ,t)∣∣2]L_{simple}(\theta) := \mathbb{E}_{t, x_0, \epsilon} \left[ ||\epsilon - \epsilon_\theta(\sqrt{\bar{\alpha}_t}x_0 + \sqrt{1-\bar{\alpha}_t}\epsilon, t)||^2 \right]Lsimple(θ):=Et,x0,ϵ[∣∣ϵ−ϵθ(αˉtx0+1−αˉtϵ,t)∣∣2]

总结 LsimpleL_{simple}Lsimple 的执行过程：

从训练集随便抽出一张真图 x0x_0x0 。
随便生成一个高斯噪声 ϵ\epsilonϵ 。
随便抽一个时间步 ttt 。
把 x0x_0x0 和 ϵ\epsilonϵ 混合，算出加噪后的图像 xtx_txt 。
把 xtx_txt 喂给神经网络，让它预测出一个噪声 ϵθ\epsilon_\thetaϵθ 。
计算真实的 ϵ\epsilonϵ 和网络预测的 ϵθ\epsilon_\thetaϵθ 之间的均方误差，然后反向传播更新参数。

探究架构细节

核心骨架：基于 Wide ResNet 的 U-Net

为了表示反向过程，作者使用了一个 U-Net 骨架。

U-Net

任务：输入一张图片，输出一张空间分辨率（宽和高）完全一样的图片。在 DDPM 中，输入是 3×32×323 \times 32 \times 323×32×32 的带噪图像 xtx_txt ，输出是 3×32×323 \times 32 \times 323×32×32 的预测噪声 ϵθ\epsilon_\thetaϵθ 。
编码器/下采样：负责压缩。图像经过一层层的卷积和池化（或步长卷积），特征图的长宽越来越小，但通道数越来越深。这个过程网络在提取高级语义信息。
瓶颈层：特征图被压缩到最下，这里浓缩了整张图片的全局信息。
解码器/上采样：负责放大。用最近邻插值+标准卷积，将特征图一步步放大回原来的分辨率。

最近邻插值：最无脑的放大。如果要把4×44 \times 44×4 放大到8×88 \times 88×8 ，就把原来的每个像素直接复制成 2×22 \times 22×2 的四个一模一样的像素，这个操作没有任何可学习的参数。

标准卷积：插值放大后，图像会全是马赛克。紧接着立刻上一个 3×33 \times 33×3 的标准卷积层。这个卷积层包含可学习的参数，它的任务就是把输入的马赛克变得平滑，提取出合理的特征。

跳跃连接：如果只靠解码器放大，图像的边缘和细节早就丢失了。U-Net 会把编码器里相同分辨率的特征图，直接拼接到解码器的特征图上。

这里的拼接是在通道维度进行拼接。

假设在 U-Net 的编码器，某一层输出的特征图形状是 (B,C,H,W)(B,C,H,W)(B,C,H,W) ，当这个特征图通过跳跃连接传到解码器对应的层时，解码器也有一个经过上采样得到的特征图，形状也是 (B,C,H,W)(B,C,H,W)(B,C,H,W) 。U-Net 会把这两个张量沿着通道维度拼接起来，形状变为 (B,2C,H,W)(B,2C,H,W)(B,2C,H,W) 。随后，U-Net 会紧接着跟上一个标准的卷积层，这个卷积层的任务就是把这个 2C2C2C 个通道的信息进行融合，然后再把通道数压回CCC ，继续往上层传递。

时间条件注入

核心目的：我们的网络要在不同的时间步 ttt 执行不同强度的去噪任务，但在所有的时间步里，网络参数是完全共享的。所以必须让网络在每次前向传播时知道当前处于去噪过程的哪一步 ttt 。
编码方式：作者借鉴了transformer 模型中的正弦位置编码公式，利用不同频率的正弦和余弦函数，为每一个时间步 ttt 生成一个绝对唯一，且包含相对位置信息的向量。

正弦位置编码公式：

假设我们要把时间 ttt 编码成一个长度为 ddd 的向量（比如 d=256d=256d=256），向量中的每一个位置（索引标记为 iii）的值是这样计算的：

对于向量里的偶数位置（0,2,4…0, 2, 4 \dots0,2,4…）：PE(t,2i)=sin⁡(t100002i/d)PE_{(t, 2i)} = \sin\left(\frac{t}{10000^{2i/d}}\right)PE(t,2i)=sin(100002i/dt)

对于向量里的奇数位置（1,3,5…1, 3, 5 \dots1,3,5…）：PE(t,2i+1)=cos⁡(t100002i/d)PE_{(t, 2i+1)} = \cos\left(\frac{t}{10000^{2i/d}}\right)PE(t,2i+1)=cos(100002i/dt)

注入机制：将上一步生成的位置向量经过线性层，映射到与当前U-Net 残差块通道数相同的维度（比如当前特征图是 C×H×WC \times H \times WC×H×W，时间向量就被映射成长度为 CCC 的向量）。随后，利用广播机制，这个一维的时间向量会在空间维度（高和宽）上被复制拉伸，变成 (C,H,W)(C, H, W)(C,H,W)。然后直接与特征图相加，让图像的每个像素都带上时间戳。

全局视野：自注意力机制

为了让网络在预测局部噪声时能参考整张图片的全局上下文，作者在 16×1616 \times 1616×16 的特征图分辨率层之间，加入了自注意力块。这大大提升了模型处理复杂长距离结构的能力。

在 DDPM 中，加入自注意力机制的方式简单粗暴，采取了串联的方式：

特征重塑：假设卷积层输出的特征图是 C×H×WC \times H \times WC×H×W。为了送进自注意力层，我们需要把它展平。我们会把空间维度合并，变成一个序列：形状变为 C×NC \times NC×N（其中 N=H×WN = H \times WN=H×W 就是序列长度，也就是 Token 的数量）。
注意力交互：此时，每一个像素点（共 NNN 个）就相当于 NLP 里的一个 Token，它的特征维度是 CCC。自注意力机制会计算这 NNN 个像素点彼此之间的相似度权重，然后更新每个像素的特征。DDPM 特意选择在特征图被压缩到 16×1616 \times 1616×16 时计算自注意力。因为此时 N=256N = 256N=256，计算量不大，又能完美捕捉全局结构。
还原形状：注意力计算完成后，序列会被重新“折叠”回 C×H×WC \times H \times WC×H×W 的形状，然后继续送入下一个普通的卷积层中。

组归一化

生成模型参数量大，Batch Size 通常很小，传统的 Batch Normalization 算出的均值和方差会剧烈抖动，导致训练不稳定。

作者明确指出，他们在整个网络中统一使用了组归一化（Group Normalization）。

这是一个针对单张图片内部的通道的归一化。假设当前特征图有 256 个通道。GN 会把这 256 个通道分成若干个“组”（Groups，比如分成 32 组，每组 8 个通道）。然后，在单张图片的每一组内部，跨越这 8 个通道和空间维度去求均值和方差，并进行归一化。

实验与模型评估

图像生成领域的实验指标

FID

FID 是目前图像生成领域最具权威性的图像质量评估指标。论文中特别提到，他们的无条件模型在 CIFAR10 上达到了 SOTA 的 3.17 FID 分数。

它提取真实图像和生成图片在一个预训练好的图像分类网络（通常是 Inception-V3）中的特征向量，计算真实图片特征分布和生成图片特征分布之间的距离。

FID 越低，说明生成的图片不仅清晰真实，且整体特征分布越接近真实的训练集数据。

计算公式

首先，把真实图片和生成图片分别喂进图像分类网络（通常是 Inception-V3），然后分布提取 Inception 网络倒数第二层的特征向量，得到两组庞大的特征向量集合。

我们假设这两组特征在隐空间里都服从多元高斯分布。FID 计算的就是真实特征分布 N(μr,Σr)\mathcal{N}(\mu_r,\Sigma_r)N(μr,Σr) 和生成特征分布 N(μg,Σg)\mathcal{N}(\mu_g, \Sigma_g)N(μg,Σg) 之间的 Wasserstein-2 距离：

FID=∣∣μr−μg∣∣2+Tr(Σr+Σg−2(ΣrΣg)1/2)\text{FID} = ||\mu_r - \mu_g||^2 + \text{Tr}(\Sigma_r + \Sigma_g - 2(\Sigma_r \Sigma_g)^{1/2})FID=∣∣μr−μg∣∣2+Tr(Σr+Σg−2(ΣrΣg)1/2)

μr,μg\mu_r, \mu_gμr,μg：分别是真实图片特征和生成图片特征的均值向量。
Σr,Σg\Sigma_r, \Sigma_gΣr,Σg：分别是两者的协方差矩阵。
Tr\text{Tr}Tr：矩阵的迹（主对角线元素之和）。

第一项算的是两个特征分布中心的距离，第二项算的是两个分布形状的重合度。两者越接近，FID 越小，说明生成的图像在高级语义特征上越接近真实世界。

实验中计算

大规模采样：模型训练完成之后，在推理阶段，模型随机采样生成一大批图片。在论文中，他们生成了50000 张样本。
提取特征：把这 50000 张生成的假图，以及 50000 张训练集里的真图，全部喂给一个预训练好的 Inception 网络，然后提取网络深层的特征向量。
计算分布距离：利用 FID 的计算公式，得到 FID 分数。
得出结论：如果生成的 50000 张图在宏观上涵盖了各种猫、狗、飞机的特征，且特征的统计规律和真实的 50000 张图几乎重合，FID 就会非常低。我们根本不需要关心某一张生成的猫对应真实世界里的哪只猫。

为什么无条件生成的图片，可以与训练集作比较计算 FID？

因为模型学到的是训练集的数据分布 p(x)p(x)p(x)。当 DDPM 的 U-Net 拿着纯噪声开始反向去噪时，因为这个网络 pθ(xt−1∣xt)p_\theta(x_{t-1}|x_t)pθ(xt−1∣xt) 是在 CIFAR10 上日日夜夜训练出来的，它会本能地把那些杂乱无章的噪点，往它最熟悉的那 10 个类别的特征上“雕刻” 。这就是生成模型最奇妙的地方：它的自由是有限度的自由，它的潜意识完全由它的训练集决定。

IS

IS 是早期 GAN 时代非常流行的指标，同样使用预训练的 Inception 网络。论文中他们在 CIFAR10 上的 IS 达到了 9.46。

它重点看两点：一是清晰度（分类模型能确信图片属于某个特定类别），二是多样性（生成模型生成的图片包含各种不同的类别，而不是陷入模式崩溃，只生成同一种图）。

IS 越高越好。但因为 IS 并不和真实图片的实际数据分布直接对比，现在它的核心参考地位略逊于 FID。

计算公式

IS 的公式基于 KL 散度KL散度 :

IS=exp⁡(Ex∼pg[DKL(p(y∣x)∣∣p(y))])\text{IS} = \exp \left( \mathbb{E}_{x \sim p_g} [D_{KL}(p(y|x) || p(y))] \right)IS=exp(Ex∼pg[DKL(p(y∣x)∣∣p(y))])

x∼pgx \sim p_gx∼pg：表示从你生成的图像分布中采样出一张图片 xxx。
p(y∣x)p(y|x)p(y∣x)：把生成的图片 xxx 喂给 Inception 网络，网络输出的分类概率分布（清晰度）。如果图片很清晰，比如是一只狗，那它在“狗”这个类别的概率会极高，其他类别极低，这个分布会很“尖锐”。
p(y)p(y)p(y)：所有生成图片经过分类器后的边缘概率分布（多样性）。如果你的模型生成的图片什么都有（猫、狗、车），那总的类别分布就会很平缓（接近均匀分布）。

我们希望单张图片特征明确（p(y∣x)p(y|x)p(y∣x) 尖锐），而整体生成的类别丰富（p(y)p(y)p(y) 平缓）。这两个分布差异越大，KL 散度越大，IS 分数就越高。

实验中计算

与 FID 相同，也是利用训练好的模型生成大批样本，然后喂给分类模型，计算 IS。

NLL / Bits/dim

NLL 主要用来衡量基于似然函数的模型（比如 VA、Flow、扩散模型）对数据分布拟合的好坏。在论文中，单位是 bits/dim。

NLL 越低越好。它类似于计算数据的无损压缩编码长度。虽然 DDPM 生成的图片 FID 表现极佳，但论文也非常坦诚地指出，他们在 NLL 指标上并没有优于其他的似然模型。

论文的精妙之处在于，他们发现虽然 DDPM 算出来的无损编码长度（NLL）比不上一些其他模型，但它的生成质量极高。这是因为模型把大把的 Bit 都消耗在了去描述那些肉眼根本察觉不到的微小失真细节上了。

计算公式

似然 (Likelihood) pθ(x0)p_\theta(x_0)pθ(x0)：模型认为产生某张真实图片 x0x_0x0 的概率。
负对数似然 (NLL) −log⁡pθ(x0)-\log p_\theta(x_0)−logpθ(x0)：根据香农的理论，这恰恰是用模型的逻辑去压缩这张真实图片，所需要花费的二进制比特数（Bits）。
计算整个数据集的期望 E[−log⁡pθ(x0)]\mathbb{E}[-\log p_\theta(x_0)]E[−logpθ(x0)]，即：用这个模型来做无损压缩，平均每张图需要多少个 Bit。
计算 bits/dim：为了让不同分辨率的图片可以相互比较，研究者会把算出来的总 Bit 数，除以图片的维度总数（Dim）。

实验中计算

NLL 虽然与损失函数相关，但是并不是训练过程的额外产物。在这篇论文中，NLL的计算是需要额外花时间单独去跑的。

原因：

训练时使用的是简化的目标函数LsimpleL_{simple}Lsimple推导简化目标函数
算 NLL 必须用真正的原版公式：既然训练时用的是为了提升图像质量而简化过的LsimpleL_{simple}Lsimple ，那训练日志里打印出来的 Loss 值，就已经不能代表严格的 bit 了。

因此，为了算出严谨的 NLL 指标，作者必须在训练结束后，用完整的真实变分下界公式重新计算得分。不仅如此，正规的 NLL 通常要在测试集上计算。在论文表 1 中，作者明确列出了在训练集和测试集上不同的 NLL 分数，测试集和训练集的差距最多只有 0.03 bits/dim，以此来证明模型并没有过拟合。

计算流程：

核心公式：真实变分下界（公式 5）：

L=Eq[DKL(q(xT∣x0)∣∣p(xT))⏟LT+∑t>1DKL(q(xt−1∣xt,x0)∣∣pθ(xt−1∣xt))⏟Lt−1−log⁡pθ(x0∣x1)⏟L0]L = \mathbb{E}_q \left[ \underbrace{D_{KL}(q(x_T|x_0) || p(x_T))}_{L_T} + \sum_{t>1} \underbrace{D_{KL}(q(x_{t-1}|x_t, x_0) || p_\theta(x_{t-1}|x_t))}_{L_{t-1}} - \underbrace{\log p_\theta(x_0|x_1)}_{L_0} \right]L=EqLTDKL(q(xT∣x0)∣∣p(xT))+∑t>1Lt−1DKL(q(xt−1∣xt,x0)∣∣pθ(xt−1∣xt))−L0logpθ(x0∣x1)

在计算 NLL 时，我们实际上就是在计算并累加这三大项。
逐项计算细节与物理意义：

先验匹配项：LTL_TLT：
- 公式：DKL(q(xT∣x0)∣∣p(xT))D_{KL}(q(x_T|x_0) || p(x_T))DKL(q(xT∣x0)∣∣p(xT))
- 含义：它比较的是经过 TTT 步彻底加噪后的真实图片分布 q(xT∣x0)q(x_T|x_0)q(xT∣x0)，和我们设定的纯标准正态分布 p(xT)=N(0,I)p(x_T) = \mathcal{N}(0,I)p(xT)=N(0,I) 之间有多大差距。
- 计算细节：因为 DDPM 的前向加噪过程的方差 βt\beta_tβt 是固定不变的常数，这就导致前向过程 qqq 没有任何可学习的参数。所以，LTL_TLT 其实是一个固定的常数。在论文的实验中，这个值非常小，大约只有 10−510^{-5}10−5 bits/dim ，计算时直接代入高斯分布的 KL 散度闭式解即可。
核心去噪匹配项：Lt−1L_{t-1}Lt−1 （对于 t>1t > 1t>1 ）：
- 公式：DKL(q(xt−1∣xt,x0)∣∣pθ(xt−1∣xt))D_{KL}(q(x_{t-1}|x_t, x_0) || p_\theta(x_{t-1}|x_t))DKL(q(xt−1∣xt,x0)∣∣pθ(xt−1∣xt))
- 含义：它对比的是“真实去噪路径”与“神经网络预测的去噪路径”。在论文 4.3 节的信息论视角下，这 T−1T-1T−1 个项的加和构成了数据压缩中的“率” (Rate)。
- 计算细节：由于条件分布 q(xt−1∣xt,x0)q(x_{t-1}|x_t, x_0)q(xt−1∣xt,x0) 和神经网络的预测 pθ(xt−1∣xt)p_\theta(x_{t-1}|x_t)pθ(xt−1∣xt) 都是高斯分布。两个高斯分布算 KL 散度是有现成数学公式的（Rao-Blackwellized 闭式表达式），完全不需要采样近似。算法会遍历时间步 ttt，算出所有的 Lt−1L_{t-1}Lt−1 并求和。
重构/解码项：L0L_0L0：
- 公式：−log⁡pθ(x0∣x1)-\log p_\theta(x_0|x_1)−logpθ(x0∣x1)
- 含义：在最后一步，我们要从连续的高斯分布 x1x_1x1 生成离散的真实像素 x0x_0x0（像素值是 0 到 255 的整数，论文中线性缩放到了 [-1, 1] 区间）。这一项评估的是最终生成的图像和真实图像有多像。在信息论视角下，它代表了压缩过程中的“失真” (Distortion)。
- 计算细节：为了得到严谨的离散对数似然，作者使用了一个基于高斯分布推导出的独立离散解码器（公式 13）。它通过计算高斯概率密度函数在像素区间内的积分，来得到精确的概率值。这样就能确保算出来的变分下界，是一个真实离散数据的无损编码长度，不需要给数据人为添加噪声。
NLL 的最终汇总与单位换算：

当上述 LTL_TLT、∑Lt−1\sum L_{t-1}∑Lt−1 以及 L0L_0L0 计算完毕后，我们就得到了变分下界 LLL 的总数值。但由于计算机在算对数时默认用的是自然对数（底数为 eee），算出来的单位叫 Nats。将总 Nats 值除以 ln⁡(2)\ln(2)ln(2)，转换为以 2 为底的比特数 (Bits)。再将得到的总 Bits 除以图像的维度总数 DDD （对于 CIFAR10，D=32×32×3=3072D = 32 \times 32 \times 3 = 3072D=32×32×3=3072）。得到的值就是论文表 1 中报告的 NLL 值，例如 3.17 bits/dim 。

实验与超参数设置

数据集与预处理

为了公平对比，研究者都会在公开数据集上测试。这篇论文中主要用到了：

CIFAR10：32x32 的低分辨率小图，包含 10 个类别。虽然图小，但极度考验模型的基础生成能力。标准划分是 50,000 张训练集图片和 10,000 张测试集图片。
LSUN & CelebA-HQ：分辨率达到了 256x256 。LSUN 包含各种特定场景（如教堂、卧室），CelebA-HQ 则是高清人脸数据集。能够在这些数据集上生成清晰的高清图，说明模型具备很强的实用价值。

预处理：真实的图像数据（像素值原本是 0 到 255 的整数）会被线性缩放到 [−1,1][-1, 1][−1,1] 的区间。这样做是为了保证神经网络在处理初始的标准正态先验分布 p(xT)p(x_T)p(xT) 时，输入数据的尺度是一致的。

前向过程参数调度

时间步长 TTT ：作者将总的扩散时间步设为了 T=1000T = 1000T=1000 。
方差调度表：前向过程的方差 βt\beta_tβt 是固定常数，并没有让网络去学习。作者采用了一种线性递增的策略，βt\beta_tβt 从 β1=10−4\beta_1 = 10^{-4}β1=10−4 线性增加到 βT=0.02\beta_T = 0.02βT=0.02 。

为什么这么设？

保持这些常数相对较小，可以确保前向加噪和反向去噪过程具有近似相同的函数形式。同时，经过 1000 步加噪后，到了 xTx_TxT 时，图像的信噪比已经极小，原本的信号被彻底破坏，几乎等同于纯粹的高斯噪声。

训练与优化技巧

优化器与 EMA：使用了 Adam 优化器。在保存模型参数时，作者使用了指数移动平均（EMA），衰减率设为 0.9999。
Dropout：在训练 CIFAR10 数据集时，作者将 Dropout 率设为 0.1。如果不加 Dropout，生成的样本质量会变差，出现过拟合伪影。

EMA：

EMA 是一种在深度学习训练时非常常用的参数平滑技巧。

工作逻辑：

在训练神经网络时，模型有一组真正参与梯度反向传播和更新的“当前参数”（记作 θcurrent\theta_{\text{current}}θcurrent）。当开启 EMA 时，程序会在后台悄悄维护另一组“影子参数”（记作 θEMA\theta_{\text{EMA}}θEMA）。每次当前参数更新后，影子参数会按照下面的公式进行微调：θEMA=β⋅θEMA+(1−β)⋅θcurrent\theta_{\text{EMA}} = \beta \cdot \theta_{\text{EMA}} + (1 - \beta) \cdot \theta_{\text{current}}θEMA=β⋅θEMA+(1−β)⋅θcurrent

β\betaβ 就是衰减因子，DDPM 里设置得非常接近 1（β=0.9999\beta = 0.9999β=0.9999）

这意味着，影子参数每次只吸收当前参数极小一部分（0.01%0.01\%0.01%）的新变化，保留了绝大部分（99.99%99.99\%99.99%）的自身历史记忆。

EMA 的核心作用：

稳定训练过程：在训练后期，或者面对像生成模型这样极其复杂的损失函数空间时，每个 Batch 计算出来的梯度可能会非常嘈杂，导致模型的参数在最优解附近剧烈震荡。EMA就像一个减震器，它记录了参数历史移动的平滑轨迹，过滤掉了短期的剧烈抖动。

提高生成质量：可以把 EMA 理解为在时间维度做了一次模型集成。它融合了模型在过去成千上万次迭代里的状态。在图像生成领域，经验表明，这种平滑融合后的权重往往能生成质量更高、更锐利的图像。

训练与推理分离：EMA 参数是不参与训练时的反向传播的。在训练时不断更新 θcurrent\theta_{\text{current}}θcurrent，而当训练结束，准备去算 FID 分数或者展示生成的图片时，我们会丢弃 θcurrent\theta_{\text{current}}θcurrent，加载平滑且稳定的 θEMA\theta_{\text{EMA}}θEMA 来进行推理采样。

消融实验

均值 μ~\tilde{\mu}μ~ vs 噪声 ϵ\epsilonϵ

配方 A：预测真实的后验均值 μ~\tilde{\mu}μ~ (Baseline)：

作者发现，预测均值只有在配合极其严格的“真实变分下界 (LLL)”目标函数时才勉强有效（FID 约为 23.69）。一旦换成简单的均方误差目标函数，训练就不稳定了，生成的图片惨不忍睹。
配方 B：预测加入的噪声 ϵ\epsilonϵ (Ours / DDPM 的最终选择)：

表现极佳！尤其是在配合简化版目标函数时，FID 瞬间飙升到了 3.17 的 SOTA 级别。

深层原因：作者在 3.2 节用数学证明了，预测噪声 ϵ\epsilonϵ 在数学形式上不仅等价于朗之万动力学 (Langevin dynamics)，而且让目标函数看起来非常像“去噪得分匹配 (denoising score matching)” 。这赋予了模型极好的物理和概率学意义。

真实变分下界 LLL vs 简化均方误差 LsimpleL_{simple}Lsimple

配方 A：使用真实的变分下界 (LLL)
- 这是严谨推导出来的公式（也就是我们在前面算 NLL 用的那个）。它对每一个时间步 ttt 的 Loss 都分配了一个极其复杂的权重系数。
- 缺点：在真实的 LLL 中，时间步 ttt 很小（也就是快要生成最终清晰图像、噪声极小）的时候，权重特别大。这就导致网络把大部分精力都花在了去抠那些极其微小的噪点上。
配方 B：使用简化版目标函数 (LsimpleL_{simple}Lsimple)
- 作者大笔一挥，直接把前面那一坨复杂的权重系数全扔了，变成了最纯粹的非加权均方误差。Lsimple=Et,x0,ϵ[∥ϵ−ϵθ(αˉtx0+1−αˉtϵ,t)∥2]L_{simple} = \mathbb{E}_{t, x_0, \epsilon} [ \| \epsilon - \epsilon_\theta(\sqrt{\bar{\alpha}_t}x_0 + \sqrt{1-\bar{\alpha}_t}\epsilon, t) \|^2 ]Lsimple=Et,x0,ϵ[∥ϵ−ϵθ(αˉtx0+1−αˉtϵ,t)∥2]
- 作者发现，丢掉权重相当于降低了小时间步（ttt 很小）的损失权重。这样一来，网络就不会在最后那些鸡毛蒜皮的微小噪点上死磕，而是强迫自己把更多的精力放在 ttt 较大时（也就是满屏雪花点时）的高难度去噪任务上。
- 结果：虽然这样算出来的 NLL变差了，但生成的图像质量（FID）实现了质的飞跃！这就是典型的“为了好看，牺牲了理论上的严谨压缩率”。

方差 Σθ\Sigma_\thetaΣθ 的设定

配方 A：让网络去学习方差
- 结果：作者在表 2 中报告，如果把方差也放进网络里去学习，会导致训练极其不稳定，并且生成的图片质量很差。
配方 B：人工固定方差为常数 (Fixed isotropic Σ\SigmaΣ)
- 作者直接把方差固定为和前向加噪时有关的常数（比如 βt\beta_tβt）。
- 结果：在预测噪声 ϵ\epsilonϵ 的前提下，固定方差不仅让网络更容易训练，而且配合 LsimpleL_{simple}Lsimple 拿到了全场最高的生成质量。

最终配置

经过一系列消融实验，作者敲定了最终的模型设定：

使用 U-Net 预测噪声 ϵ\epsilonϵ + 使用不带权重的简化的均方误差 LsimpleL_{simple}Lsimple 作为 Loss + 人工固定方差。

这套组合拳奠定了后续几乎所有主流扩散模型（包括 Stable Diffusion 的底层逻辑）的基础。

DDPM 的高阶特性

渐进式生成与有损压缩

在传统的 GAN（生成对抗网络）中，图像通常是“一瞬间”生成的，我们要么得到一张好图，要么得到一张崩坏的图。但扩散模型是一个 T=1000T=1000T=1000 步的漫长过程，这就带来了一个极其迷人的特性：渐进式生成。

观察论文中的图 6 ，会发现在反向去噪的早期（ttt 比较大的时候，比如从 1000 到 500），模型主要在确定图像的大尺度特征，比如天空的位置、鸟的轮廓。而到了晚期（ttt 接近 0 的时候），模型才开始填充毛发、纹理等极其微小的细节。

作者绘制了失真率-比特率曲线（图 5）。他们发现，在这个 1000 步的降噪旅程中，刚开始消耗极少的比特（Bits）就能让图像的均方误差（失真）大幅下降。这说明大部分的“信息编码量”其实都被模型用在了最后那些人类肉眼几乎无法察觉的微小像素波动上了。这也呼应了我们之前讨论的，为什么 DDPM 的 NLL 分数一般，但看起来极度逼真。

作者甚至提出，高斯扩散模型可以被解释为一种具有广义比特排序的自回归模型，这种排序方式是普通的重排像素坐标无法表达的。

重排像素坐标：

传统的生成顺序：自回归模型生成图片，就像我们平时写字或者打印机工作一样，是逐个像素（Pixel-by-Pixel）生成的。它通常遵循一个固定的空间坐标顺序：从左上角第一个像素开始，然后第二个，一直到右下角最后一个。

重排像素坐标：有些研究者发现，从左上角按顺序生成未必是最好的。于是他们尝试“重排”这个顺序，比如：先生成所有偶数坐标的像素，再生成奇数坐标的像素；或者从图像正中心开始，像螺旋一样往外生成。

无论怎么“重排像素坐标”，它本质上依然是在物理空间上决定“先画哪一个点，再画哪一个点”。

广义比特排序的自回归模型：

DDPM 在生成图片时，根本不是逐个像素生成的，它是对着整张图片的所有像素同时开工。那为什么作者还说它是一种“自回归模型”呢？

作者在 4.3 节提出了一个极其精妙的思想实验：假设一张图片有 3072 个像素（维度），如果我们把扩散步数 TTT 也设为 3072，并且规定每一步的“加噪”不是加高斯噪声，而是精确地抹掉（Mask out）一个像素。那么，反向去噪的过程，就变成了每次精确地预测并填补一个被抹掉的像素。在这个特定的极端设定下，扩散模型就完美等价于一个传统的自回归模型了！

但是，真实的 DDPM 并没有使用这种“每次抹掉一个像素”的做法：

广义的比特（信息）排序： DDPM 使用的是连续的高斯噪声，在 1000 步里对着所有像素同时加噪或去噪。

这就导致 DDPM 的生成顺序不再是物理空间上的“先画左边，再画右边”，而是信息维度（频率）上的“先画大轮廓，再画小细节”。

在信息论里，一张图片所包含的信息是由一段段二进制比特（Bits）组成的。DDPM 等于是在解码时，先解码描述全局结构的比特，再解码描述微小失真的比特。

结论：作者说这是一种“广义比特排序（Generalized bit ordering）” ，是因为这种从“模糊到清晰”、“从低频到高频”的信息逐步释放过程，是在物理空间上无论怎么“重排像素坐标”都绝对无法模拟出来的。作者认为，给图像全局加上高斯噪声，可能比单独抹掉某些像素显得更自然，这也就是为什么 DDPM 能生成如此逼真图像的一个重要潜在原因（归纳偏置 Inductive bias）。

隐空间平滑插值

在图像生成中，我们经常想把两张图片混合在一起（比如把一张男性的脸平滑过渡到一张女性的脸）。如果你直接在像素层面把两张图按比例相加，只会得到一张带有重影的“幽灵图”。DDPM 提供了一种优雅的隐空间插值方案（见图 8 和图 9）。

插值流程：
1. 随机编码（加噪）：拿到两张真实的源图像 x0x_0x0 和 x0′x_0'x0′，利用前向过程把它们加噪到同一个中间时间步 ttt，得到隐变量 xtx_txt 和 xt′x_t'xt′ 。
2. 线性混合：在这个全是噪点的隐空间里，把两个特征按比例 λ\lambdaλ 混合：xˉt=(1−λ)xt+λxt′\bar{x}_t = (1-\lambda)x_t + \lambda x_t'xˉt=(1−λ)xt+λxt′ 。
3. 反向解码（去噪）：把混合后的 xˉt\bar{x}_txˉt 喂给训练好的 U-Net，让它一路去噪回到 xˉ0\bar{x}_0xˉ0 。
为什么这样做效果好？：

混合后的噪点图本来是不符合真实自然图像规律的（它脱离了图像流形）。但是，DDPM 的反向去噪过程本质上是一个“去除伪影”的过滤器。它能硬生生地把这个不自然的混合态，强行拉回到真实图像的数据分布中，从而生成出极其合理、平滑的高质量重构图像。
时间步 ttt 的控制魔力：
- 如果 ttt 比较小，模型只会保留大体框架，插值时只改变微小的细节。
- 如果在 t=500t=500t=500 左右插值，生成的图像能够平滑地改变姿态、肤色、发型、表情和背景等高级属性。
- 如果在最极端的 t=1000t=1000t=1000 步进行混合，原本两张图的信息已经全部丢失了，这时的插值实际上就是在两个纯噪声之间过渡，最终会生成完全新颖的随机样本。

总结与广泛影响

核心贡献总结

理论上的大一统：DDPM 将变分推断、马尔可夫链、去噪得分匹配、退火朗之万动力学、自回归模型以及渐进式有损压缩等多个看似不相关的领域联系在一起。
工程上的突破：其在无条件图像生成上取得了非常好的效果，证明了扩散模型在图像数据上拥有极佳的归一化偏置。

深度生成模型的广泛社会影响

潜在风险：可以被恶意用来生成虚假的政治人物图像和视频。此外，生成模型会吸收并放大训练数据集里潜藏的偏见。
未来发展潜力：扩散模型不仅在艺术创作上有潜力，在数据压缩和无监督表示学习上也大有可为。

Cyber-Ledger 发布：一款本地记账 App

小yo — Sat, 21 Feb 2026 12:03:03 GMT

历时几天的折腾，终于把我一直心心念念的记账 App —— Cyber-Ledger (赛博账本) 给敲出来了。没有花哨的云同步强制绑定，也没有各种冗杂的社区和广告，这只是一款单纯查账、记账的本地应用。

缘起

其实一开始也没想搞个这么个东西，只是这学期经历的事情比较多，各种杂项开销也变得琐碎起来。加上我经常因为搞人工智能要租用 AutoDL 的算力显卡，或者去调用一些大模型的 API，这就导致我的花销里总有一笔很难用传统记账软件（比如某记、某手记）去精确归类的“赛博账单”。

每到月底核算的时候，看着那些死板的分类和永远对不上的余额，我就开始后悔为什么没有早点用一种更符合极客直觉的方式把钱管起来。尤其是当你发现有一些开支明明是“待报销”的，但在那些传统的 App 里，它们也会无情地吃掉你当月的正常预算限额，这就让人很焦虑。

思来想去，干脆自己手搓一个吧。

它能做什么？

这并没有什么革命性的技术，用的也都是很常规的 React + Vite + Tailwind 栈，最后通过 Capacitor 套了个安卓的壳子。但我把所有让我觉得“痛”的地方都修补了：

绝对掌控的本地数据：我太反感现在的软件动不动就要把账本传到他们的服务器上了。这个 App 所有的账单数据都只存在本地手机里。如果实在想备份或者多端同步，我也做了一个基于 WebDAV 的私有云连接选项。没有乱七八糟的账号体系，只有开屏的一个 4 位 PIN 码锁防偷窥。
开发者视角的精算器：我专门在里面插了个功能，可以根据目前的汇率去模拟算力显卡（比如 4090 或 H800 的价格）和 LLM Token 的具体租用消耗。那些烧钱买算力的日子，现在终于能以精确的数字直观地显示在账本上了。
防吃灰的“周期订阅”与结转：我老是会忘了给某些小众服务器节点或者 Netflix 续订而导致服务停摆。现在内置了周期订阅监视器；不仅如此，这个月没吃完的餐饮费或者娱乐预算，下个月它会自动累加滚存过去（Rollover），不用再为了“清空预算”而刻意消费。

结语与体验

整个折腾的过程虽然遇到了不少排版上的麻烦，比如在小屏幕上由于字太多老是溢出，最后也被我硬生生把文案全砍成了两个字（比如“编辑”、“删除”）给治好了。

看着最终在终端跑完 assembleDebug 生成出 APK 安装包的那一刻，手机桌面上出现那个带有炫光紫背景的 SYS.LEDGER 图标，还是有一些成就感的。虽然比不上大佬们做的那些大工程，但这好歹是一笔一划解决掉自己真实痛点的东西。

目前这还是 v1.0.0，里面可能还有暗坑，但也算圆了自己一个造轮子的念想。如果你也和我一样，苦于找不到一个安静的、算力和传统开销能两手抓的本地账本，可以下载下来试试。代码是开源在我的 GitHub 上的，随缘做做更新吧。

👇🏻 下方是我放出来的第一版安卓原生包，可以直接在手机浏览器里点击下载安装：

下载 Cyber-Ledger 安卓包(v1.0.0)

最后，夹带点私货： 如果你觉得这个小工具的想法还不错，或者正好也解决了你的痛点，非常欢迎去我的 GitHub 仓库里逛逛。毕竟自己折腾了这么久，如果能骗到一个 Star ⭐️ 那绝对是莫大的鼓励。当然，也欢迎大佬指点代码或者提个 PR 交流。

🔗 GitHub 传送门： https://github.com/zjs3490581068/Cyber-Ledger

寒假学习计划（日更）

小yo — Sun, 15 Feb 2026 00:02:54 GMT

大纲

概率统计基础
《计算机教育中缺失的一课》十讲
安装Linux 双系统并熟悉操作
练习 Deep Learning 代码
学习 HTML、CSS
阅读图像生成领域的最新文献

每日计划

2.13

安装 ubuntu22.04 系统
《计算机教育中缺失的一课》第一讲 Shell
一高数《概率论》第一章
FCC《Basic HTML》前 60 步

2.14

《计算机教育中缺失的一课》第二讲 Shell、第三讲 Vim
一高数《概率论》第二章+第三章部分
FCC《Basic HTML》完成 （121/128）

老是静不下心来学习，尤其是学概率论的时候，感觉看网课终究不如看书本来得快。到底要不要整理笔记也是一个值得思考的点。

2.15

《计算机教育中缺失的一课》第四讲数据整理、第五讲命令行环境
一高数《概率论》第三章+第四章+第五章
FCC《Basic HTML》+《Semantic HTML》

明天除夕了，帮家里干了些家务

2.16&2.17&2.18&2.19

过年了就不卷了，回老家没事干的时候从手机上看会儿公众号或者论文得了。

2.20&2.21

这两个搞了个 app，也就是 2.21 发的那篇博客，以及整了下 obsidian，感觉还是用不习惯。

2.22

《计算机教育中缺失的一课》第六讲Git、第七讲调试及性能分析、第八讲元编程
《Denoising Diffusion Probabilistic Models》阅读及代码学习
《Semantic HTML》
科目四两套题

要正式开始读论文学代码了，也是犯愁，好难。

数学推导还是太难了，推了一天还没把 DDPM 搞清楚，明天继续叭

2.23

《计算机教育中缺失的一课》第九、十讲
《Denoising Diffusion Probabilistic Models》阅读、笔记整理
科目四三套题

机械工程基础概念背诵总结

小yo — Thu, 05 Feb 2026 20:07:59 GMT

标题1

机械工程基础概念背诵

数据库概念背诵笔记

小yo — Thu, 05 Feb 2026 20:00:33 GMT

标题1

数据库背诵

大学计算机-算法编程作业80题

小yo — Thu, 05 Feb 2026 19:49:32 GMT

预览

80道作业题

线性代数习题及解析

小yo — Thu, 05 Feb 2026 19:40:45 GMT

预览

线代习题册线代解析册

高等数学习题及解析

小yo — Thu, 05 Feb 2026 19:35:28 GMT

预览

高数习题册高数解析册

数学建模方法总结

小yo — Thu, 05 Feb 2026 19:13:18 GMT

评价决策类

层次分析法（AHP）

输入输出

输入：判断矩阵：准则层的分析因素、判断矩阵的元素aija_{ij}aij表示的是第 i 个因素相对于第 j 个因素的重要性比较结果
输出：各因素的指标权重、一致性检验结果、各方案的量化得分

作用

解决多目标的复杂问题的定性与定量相结合的决策分析方法，用决策者的经验判断各衡量目标之间能否实现的标准之间的相对重要程度。

步骤

建立多级递阶的结构模型：
1. 目标层：系统想要达到的目标或结果，是系统评价的首要准则
2. 准则层：是为实现目标层所设立的准则、自准则等
3. 方案层：是为实现目标所采取的各种方案、措施等
构造两两比较判断矩阵：对同一级的因素/准则，以上一级要素为准则进行逐对比较，建立判断矩阵。
权重计算
一致性检验：为保证求得的权重的正确性及合理性。当随机一致性比率C.R.<0.1C.R.<0.1C.R.<0.1时认为计算所得的层次排序权重是正确的、合理的，否则，需要重新调整判断矩阵，直到一致性检验合格为止
综合重要性的计算：权重最大的方案即为实现目标的最优选择

优点

系统性强：将复杂问题结构化、层次化，逻辑清晰
定性与定量结合：能有效处理那些难以完全用数据量化的指标，将其转化为数值权重
简洁实用：原理简单，所需的定量数据少，便于操作

缺点：

主观性强：核心输入依赖于人的主观打分，如果专家判断不准，结果就会有偏差
指标数量限制：每一次指标数不宜过多，否则两两比较工作量大，且难以通过一致性检验
粗略性：比较标度 1-9 相对粗糙，对于精度要求高的问题可能不够精细

适用场景

优选决策：从多个候选方案中选出最优解（例如：最佳旅游景点选择、最佳供应商选择）
评价体系构建：确定评价体系中各指标的权重（例如：员工绩效考核权重、城市宜居度评价指标权重）
资源分配：根据各因素的重要性比例分配资源

熵权法

输入输出

输入：至少两项或以上的定量变量（可以是效应性变量/成本性变量）
输出：输入定量变量对应的权重值

作用

用信息熵来判断某个指标的离散程度，最终反映出该指标对综合评价的影响（权重），为多指标综合评价提供依据

步骤

数据归一化处理：对于效应性变量：
zij=Xij−XminXmax−Xminz_{ij} = \frac{X_{ij}-X_{min}}{X_{max}-X_{min}}zij=Xmax−XminXij−Xmin
对于成本性变量：
zij=Xmax−XijXmax−Xminz_{ij} = \frac{X_{max}-X_{ij}}{X_{max}-X_{min}}zij=Xmax−XminXmax−Xij
计算比重pijp_{ij}pij
计算信息熵eje_{j}ej
计算信息效用值djd_{j}dj
计算权重wjw_{j}wj
计算综合得分

优点

客观性强：结果完全依赖数据本身，没有人为干扰
挖掘信息：能敏锐捕捉到数据中的变化差异，利用数据差异进行评价

缺点

忽略实际意义：只看数据差异，不看指标含义。如果某个关键指标在所有样本中数值很接近，但从业务逻辑上它又至关重要，此时绝不能单独使用熵权法。
对异常值敏感：数据中的噪音或极端值会显著拉偏权重

适用场景

有大量客观数据支持的评价问题
需要 AHP 之外提供另一种视角进行验证

组合赋权：AHP+熵权法

作用

将 AHP 与熵权法结合，即尊重专家的经验判断，又尊重数据的客观规律

方法

线性加权：

W综合=αWAHP+(1−α)W熵权W_{综合} = \alpha W_{AHP} + (1-\alpha)W_{熵权}W综合=αWAHP+(1−α)W熵权

α\alphaα：
- 如果没有特殊偏好，取α=0.5\alpha =0.5α=0.5
- 如果题目数据质量不好，可以偏向 AHP，反之亦然。

模糊综合评价

作用

对实际的综合评价问题提供评价。将一些边界不清、不易定量的因素定量化，进而进行综合性评价的一种方法。最终得到一个整体的评价结果。

输入输出

输入：评价指标、评语、模糊矩阵
输出：反应考核指标在量化评价中的综合得分

步骤

确定评价指标与评语的等级，确定模糊矩阵
计算权重
计算评语等级的隶属度
计算综合得分

优点

更符合客观世界：解决了“一刀切”评价的生硬问题
定性转定量：适合处理那些语言化、难以量化的指标
信息保留完整：相比于直接给一个分，它保留了对象在各个等级上的分布信息

缺点

隶属度函数难定：如何确定“隶属度”（即构建矩阵 R）是最大的难点，往往需要依赖专家打分或统计分布，带有主观性
计算复杂度：如果指标层级过多，计算量会变大
分辨力可能失效：当指标极多且权重非常分散时，计算出来的结果向量可能各项数值都很接近，导致无法区分优劣。

适用场景

满意度调查
坏境评估：空气质量等级（一级、二级、三级……往往界限是渐变的）
风险评估：项目风险等级
HR 绩效考核：员工综合素质评价

TOPSIS法

作用

充分利用原始数据的信息，其结果能精确地反映各评价方案之间的差距。

输入输出

输入：评价矩阵（评价指标和数值）
输出：反应考核指标在量化评价中的综合得分

步骤

数据预处理：正向化与归一化
确定指标权重：熵权法/AHP/其他
计算最优解与最劣解
计算与最优解和最劣解的距离
计算综合得分与排序

优点

充分利用原始数据：基于原始数据计算距离，信息损失少，能精确反映各方案之间的细微差异
对样本无严格限制：不需要大样本，不需要样本服从正态分布
结果直观

缺点

依赖外部权重：自身无法确定指标权重，需结合 AHP 或熵权法
逆序问题：是一个理论上的缺陷。有时候引入一个新的（表现一般的）方案，可能会导致原本排第一和第二的方案顺序互换
对异常值敏感：如果某个方案在某项指标上表现得好得离谱（极端值），会拉大理想解的距离，导致评价结果失真

适用场景

多指标决策分析
绩效评估
医疗/工程方案优选

灰色关联分析

作用

对一个系统发展变化态势的定量描述和比较方法，反映两个因素变化的趋势的关联性。可以进行因素分析、综合评价

输入输出

输入：母序列、比较序列
输出：反映考核指标与母序列的关联程度

步骤

确定母序列和比较序列
无量纲化处理：初值化方法适用于稳定递增或递减的数据，而均值化适合没有明显升降趋势现象的数据
计算关联系数
计算关联度：关联度为关联系数的加权平均
关联度排序

优点

小样本：只要有四个以上的数据点就能算，不需要海量数据
不假设分布：不需要数据服从正态分布，也不要求线性关系，适用性广
计算简单：公式简单，结果稳定，不会因为增加几个数据就导致结论反转

缺点

分辨力系数ρ\rhoρ的主观性：ρ\rhoρ的取值主要靠经验，取值不同可能会影响最终排序
相对粗糙：主要分析趋势，对具体的数值大小不如回归分析那么敏感
标准化敏感：采用不同的无量纲化方法，可能会算出不同的结果

适用场景

小样本因素分析
动态过程评价
多指标评价
与 TOPSIS 法结合：“为了保证评价结果的稳健性，本文分别采用了 TOPSIS 法和灰度关联分析法对方案进行排序。结果显示，两种方法得到的排名高度一致，证明了模型的可靠性”

秩和比综合评价法

作用

对评价对象的优劣直接排序或分档排序，从而对评价对象做出综合评价，特别适合将对象分档次。

输入输出

输入：原始数据矩阵
输出：反映考核指标在量化评价中的综合得分与分档

步骤

数据处理：同趋势处理和归一化处理
非整秩编秩计算
Rij=1+(n−1)zijR_{ij} = 1 + (n-1)z_{ij}Rij=1+(n−1)zij
计算权重：熵权法/AHP/默认平均权重
计算加权秩和比（WRSR）
Probit 分档与回归分析
最终分档结果

优点

鲁棒性极强：能够有效消除异常值的干扰。
分类功能：结合统计学原理给出分档
兼容性好：既可以单独使用，也可以加入权重

缺点

信息损失：把数值变成排名，丢失了具体的数量差异信息
区分度较弱：当样本较少或者指标较少时，容易出现 RSR 值相同的情况，难以精确区分前几名

适用场景

医疗质量评价
产品分级
数据波动大
与 TOPSIS 结合：用 TOPSIS 计算出精确的得分，再用 RSR 对这些得分进行回归分析和分档

数理统计类

时间序列模型

ARIMA模型

作用

是统计模型中最常见的一种用来进行时间序列预测的模型

输入输出

输入：特征序列为 1 个时间序列数据定量变量
输出：未来 N 天的预测值

步骤

时间序列的平稳性检验：通常采用 ADF 或 PP 检验方法，对原始序列进行单位根检验，如果时间序列不满足平稳性条件，可以通过差分变换或者对数差分变换，将非平稳时间序列转化为平稳时间序列，然后对平稳时间序列构建 ARIMA 模型
确定模型的阶数
参数估计与诊断检验：包括检验模型参数的显著性，模型本身的有效性以及检验残差序列是否为白噪声序列，如果模型通过检验，则模型设定基本正确，否则，必须重新确定模型的形式，并诊断检验，直到得到设定正确的模型形式
用建立的 ARIMA 模型进行预测

优点

解释性极强：数学原理清晰，通过 ACF/PACF 图直观解释数据特征
小数据：对小样本数据表现往往优于深度学习模型
速度快：训练速度快
短期预测精度高

缺点

无法捕捉非线性关系
无法处理海量数据或多变量耦合
长期预测能力差

适用场景

短期趋势预测
数据量较少时
作为对比基准
数据相对平稳或有简单趋势

灰度预测模型

作用

针对含有不确定因素、不完全信息或者少量数据样本的系统进行预测的有效方法。基于处理后的数据序列建立一阶单变量微分方程模型，从而实现对事物未来发展趋势的预测

输入输出

输入： 1 个时间序列数据定量变量
输出：拟合预测结果、模型精度

步骤

数据准备（平移变换）
级比检验
累加序列生成
紧邻均值序列
构建矩阵 B 和向量 Y
最小二乘估计参数 a 和 b
预测模型建立
还原预测值
模型检验

优点

对数据量要求极低
不需要数据服从任何统计分布

确定

只适合中短期预测
对数据波动敏感
仅适用于指数增长或者衰减趋势

适用场景

数据极度匮乏时
呈指数增长趋势的数据：细菌繁殖、早期传染病传播、GDP 快速增长期、硬盘容量增长等
作为辅助验证模型

LSTM模型

作用

捕捉长距离依赖，处理非线性曲线，预测

输入输出

输入：时间序列
输出：预测值

步骤

数据预处理：归一化
滑动窗口构建
模型搭建
训练与验证
反归一化

优点

拟合能力强
多变量支持：支持多变量输入，可以融合多个特征
能够保留较长期特征
鲁棒性好：对噪声数据有更好的抗干扰能力

缺点

黑盒模型
训练慢，对算力要求高
对于超长序列，效果不如 transformer
容易过拟合

适用场景

大数据量的时间序列（1000+）
多变量耦合预测
高度非线性的复杂系统
作为对比组

计量统计

线性回归

作用

利用数理统计中的回归分析，来确定两种或两种以上变量间相互依赖的定量关系

输入输出

输入：自变量 X：至少包含一项或以上的定量变量，如果自变量包含二分类定类变量，需要将这些变量转化为哑变量。因变量 Y：定量变量，如果因变量是定类变量，则应考虑逻辑回归或者其他适当的分类模型
输出：模型检验优度的结果，自变量对因变量的线性关系

步骤

矩阵构造
计算XTXX^{T}XXTX和XTYX^{T}YXTY
求逆矩阵(XTX)−1(X^{T}X)^{-1}(XTX)−1
计算自回归系数
计算标准误差
模型评估统计量
最终模型公式

优点

形式简单，可解释性强
建模速度快
数学理论完善

缺点

线性假设限制
对异常值敏感
多重共线性问题：如果自变量之间高度相关，会导致模型参数估计极其不稳定

适用场景

趋势外推/短期预测
影响因素分析
基准模型

岭回归

作用

专用于共线性（即自变量之间高度相关）数据分析的有偏估计回归方法，用于研究变量之间的关系以及估计因变量基于自变量的变化情况。

输入输出

输入：自变量 X：至少包含一项或以上的定量变量，如果自变量包含二分类定类变量，需要将这些变量转化为哑变量。因变量 Y：定量变量，如果因变量是定类变量，则应考虑逻辑回归或者其他适当的分类模型
输出：模型检验优度的结果，自变量对因变量的线性关系

步骤

数据标准化
构建岭迹图
确定最佳λ\lambdaλ值
模型求解与评估

优点

稳定性强：在处理多重共线性时，比普通线性回归更稳健
防止过拟合：通过压缩系数，使模型泛化能力更强
计算成本低

缺点

有偏估计：拟合优度 R2R^2R2通常会比普通线性回归略低
无法做变量筛选

适用场景

特征之间高度相关（多重共线性）
样本量少于特征数
模型系数出现反常

逻辑回归

作用

研究多分类因变量与一些影响因素之间关系的一种多变量分析方法

输入输出

输入：因变量 Y 为分类变量，自变量 X 为至少一项定量变量或定类变量
输出：逻辑回归系数估计以及分类预测的效果评价

步骤

参数设置：类别设置
用近似法求w1,w2,bw_1,w_2,bw1,w2,b
确定模型
预测样本

优点

结果可解释性强
计算代价低
无需假设数据分布

缺点

容易过拟合：分类边界只能是线性的，对于非线性可分的数据效果很差
对多重共线性敏感
数据不平衡问题：如果正负样本比例极度失衡，模型会倾向于把所有样本都判为多数类

适用场景

二分类问题
需要概率值的场景
寻找危险因素

K-Means聚类

作用

通过迭代，将样本分组成 k 个簇，使得每个样本与其所属类的中心或均值的距离之和最小。

输入输出

输入： 1 个或 1 个以上的定类变量或定量变量，预先设定类别个数
输出：根据预先设定的类别个数，划分为其设定的类别

步骤

数据预处理
初始化质心
分配样本到最近质心
更新质心
迭代至收敛

优点

原理简单、直观
速度快
可调节性：只需要调整 K 值就能观察到不同粒度的分类结果

缺点

k 值难定：解决方法：手肘法
对初值敏感：随机选取的初始质心不同，最终结果可能完全不同。解决方法：K-Means++
对异常值敏感：一个离群点可能会把中心点拉的很远
形状限制：假设簇是球状的（凸集）

适用场景

客户细分
选址问题
图像压缩
异常检测

分层聚类

作用

对给定数据对象的集合进行层次分解。

输入输出

输入：一个以上的定量变量和可选的索引项
输出：个体或者变量被划分的类别和树状图

步骤

初始化：把每个样本各自归为一类，计算每两个类之间的距离
寻找各个类之间最近的两个类，把他们归为一类
重新计算新生成的类与各个旧类之间的距离
重复 2、3 步，直到所有的样本都归为一类

优点

无需预设 k 值
结果信息丰富：不仅知道谁和谁一类，还能知道他们的亲缘关系的远近
适合小样本

缺点

计算复杂度极高
对异常值敏感

适用场景

样本量较小
分类数量不确定
生物/分类学研究
寻找层次关系

主成分分析（PCA）

作用

将多个有一定相关性的指标进行线性组合，以最少的维度解释原数据中尽可能多的信息为目标进行降维，消除多重共线性。

输入输出

输入： 2个或2个以上的定量变量
输出：若干个变量

步骤

数据标准化
计算相关系数矩阵
计算特征值与特征向量
计算主成分得分
计算综合得分

优点

消除相关性
无参数限制：不需要调参

缺点

解释性差
线性假设

适用场景

指标太多，需要降维
构建综合评价体系
图像压缩/去噪

双重差分DID

作用

评估某些政策或时间产生的净效应。

输入输出

输入：
- 面板数据
- 分组变量
- 时间变量
- 控制变量
输出：
- 交叉项系数
- 显著性

步骤

标准的 DID 回归方程如下：

Yit=β0+β1Treati+β2Postt+β3(Treati×Postt)+μXit+ϵitY_{it} = \beta_0 + \beta_1 Treat_i + \beta_2 Post_t + \mathbf{\beta_3 (Treat_i \times Post_t)} + \mu X_{it} + \epsilon_{it}Yit=β0+β1Treati+β2Postt+β3(Treati×Postt)+μXit+ϵit

YitY_{it}Yit: 结果变量。
TreatiTreat_iTreati: 组别效应（处理组为1）。
PosttPost_tPostt: 时间效应（政策后为1）。
Treati×PosttTreat_i \times Post_tTreati×Postt: 交互项，这是模型的灵魂！
β3\beta_3β3: 这就是 DID 估计量 (Treatment Effect)。如果 β3>0\beta_3 > 0β3>0 且显著，说明政策起到了正向作用。

优点

解决内生性问题
逻辑清晰，公信力强
操作简便

缺点

平行趋势假设
数据要求高
外溢效应

适用场景

政策评估
自然灾害/突发事件影响

PSM-DID

作用

结合 PSM(倾向得分匹配)和 DID（双重差分）的优势，主要用于解决非随机分组带来的选择偏差

输入输出

输入：
- 面板数据
- 匹配变量
- DID 变量
输出：
- 匹配后的样本
- 净效应
- 平衡性检验结果

步骤

计算倾向得分 (Propensity Score Estimation):

使用 Logit 或 Probit 回归，以“是否受到政策干预 (TreatTreatTreat)”为因变量，各种特征变量 (XXX) 为自变量，计算每个样本进入处理组的概率（即倾向得分）。

匹配 (Matching):

根据得分进行配对。最常用的是 k-近邻匹配 (k-Nearest Neighbor)（比如 1
或 1
匹配）或 核匹配 (Kernel Matching)。
直观理解： 给每个“处理组城市”找一个得分最接近的“对照组城市”。

平衡性检验 (Balance Test): (关键步骤！)

检查匹配后，处理组和对照组在各个特征上是否还有显著差异。理想情况是：匹配后，两组在统计上没有区别（标准偏差Bias < 10%）。

运行 DID:

只保留匹配成功的样本，在这些样本上运行标准的 DID 回归模型。

优点

双重保险
缓解平行趋势假设

缺点

数据浪费
无法解决“时变”的不可观测因素

适用场景

基准 DID 效果不好时
个体差异巨大的自然实验
自选性很强的政策

断点回归

作用

RDD 利用了一个规则：个体的处理状态（是否受到干预）完全取决于某个驱动变量 (Running Variable) 是否超过了特定的阈值 (Cutoff)。

输入输出

输入：
- 驱动变量 X
- 断点/阈值
- 处理变量
- 结果变量
输出：
- 断点效应

步骤

一个简单的线性 RDD 模型如下：

Yi=α+β1(Xi−c)+τDi+β2(Xi−c)Di+ϵiY_i = \alpha + \beta_1 (X_i - c) + \tau D_i + \beta_2 (X_i - c)D_i + \epsilon_iYi=α+β1(Xi−c)+τDi+β2(Xi−c)Di+ϵi

Xi−cX_i - cXi−c: 这里的去中心化是为了让截距更有意义。
τ\tauτ: 这就是我们要求的局部平均处理效应 (LATE)。
β2\beta_2β2: 允许断点左右两侧的斜率不同。

优点

内部有效性极高
假设较弱
直观

缺点

局部有效性
样本量要求大
操纵检验

适用场景

教育领域
社会保障
环境政策

机器学习

BP神经网络

作用

非线性映射。用于拟合/回归、分类、降维/特征提取

输入输出

输入：一系列数据
输出：回归问题：输出连续值分类问题：输出概率或者类别

步骤

数据预处理：缺失值填补、异常值剔除、归一化、划分训练集、验证集、测试集
网络结构确定
模型训练
模型评价与验证：适用 R2R^2R2、MSE、MAE 或准确率、混淆矩阵评价

优点

强大的非线性映射能力
自学习与自适应

缺点

黑箱模型
容易陷入局部最优
过拟合

随机森林

作用

强鲁棒性的预测/分类，特征重要性评估

输入输出

输入： X（特征矩阵）
输出：分类：类别回归：预测附加输出：特征重要性排序

步骤

Bootstrap 重采样
决策树构建
结果聚合
模型分析

优点

自带特征选择/解释性：能够解释特征的重要性
抗过拟合能力强
数据预处理简单：对异常值不敏感，不需要归一化

缺点

回归预测不连续：在回归问题中不能输出超出训练集范围的值（无法外推），且输出是阶梯状的
黑箱：看不出具体的函数关系式

适用场景

“因素分析”类问题：哪些因素对结果影响最大？筛选出关键指标
高维小样本数据：特征很多，但样本很少
处理混合数据

决策树

作用

通过一种树形结构来进行决策。可以用于直观的决策支持和规则提取

输入输出

输入：特征矩阵
输出：分类树：叶子节点代表类别回归树：叶子节点代表该区域内样本的均值路径：从根节点到叶子节点的完整判断逻辑

步骤

特征选择：决定用哪个特征、在哪个值进行切分
树的生成：递归地分割数据，直到满足停止条件
剪枝：为了防止过拟合，需要剪枝预剪枝：限制最大深度或者叶子节点最小样本数后剪枝：先长成大树，再根据验证集精度剪掉多余枝叶

优点

极致的可解释性
非线性且无需预处理

缺点

容易过拟合
不稳定性：数据变动一点点，生成的树可能完全不同。
正交边界：决策边界只能是平行于坐标轴的直线，处理倾斜边界效果不好

适用场景

题目要求制定“具体规则”或策略
画出漂亮的流程图来填充版面
作为复杂模型的“代理解释器”：用决策树来解释神经网络的逻辑

支持向量机

作用

分类、回归

输入输出

输入：特征矩阵
输出：分类：类别标签回归：连续预测值

步骤

数据标准化
核函数选择：
- Linear（线性核）：特征多，样本少时用
- RBF（高斯核）：适用于非线性关系
- Ploy（多项式核）：较少用，参数难调
参数寻优
模型训练与求解

优点

小样本表现极佳
数学理论严备
泛化能力强

缺点

对缺失值/噪声敏感
大规模数据太慢
多分类稍显笨重

适用场景

小样本的高维分类、回归
非线性小数据
二分类问题

朴素贝叶斯

作用

是基于贝叶斯定理和特征条件独立假设的分类算法

计算后验概率
文本分类/情感分析
多分类基准

输入输出

输入：X 离散型数据：效果最好连续性数据：需要假设其服从高斯分布
输出：概率值：样本属于各个类别的概率类别：概率最大的那个类

步骤

假设提出：核心假设：各个特征之间相互独立
计算先验概率
计算条件概率
贝叶斯公式求解

优点

数学逻辑极其清晰
极速与高维适应
小样本表现好

缺点

特征独立性假设太强
对输入形式敏感：尽量将连续数据离散化后再用

适用场景

自然语言处理（NLP）
垃圾邮件/欺诈检测
多分类问题的 baseline

XGBoost

作用

极致的回归与分类

输入输出

输入：特征矩阵
输出：
- 原理值
- 特征重要性

步骤

目标函数构建
二阶泰勒展开
树的生成
结果累加

优点

精度天花板
内置正则化
自动处理缺失值

缺点

参数极其复杂
黑箱模型
容易过拟合噪声

适用场景

追求极致精度的预测
数据存在大量缺失值
特征筛选

LightGBM

作用

极速回归/分类
处理海量数据

输入输出

输入：特征矩阵
输出：预测值

步骤

基于直方图的算法
带有深度限制的 leaf-wise 生长策略
单边梯度采样

优点

训练速度快
内存占用低
极度高

缺点

过拟合风险高
参数条件敏感：必须要调 num_leaves 参数

适用场景

大数据量的回归/分类
高维稀疏特征
多分类问题

差异分析

作用

验证区别：判断观察到的差异是由于随机误差造成，还是本质上就不同
模型对比：证明新模型在准确率或者运行时间上显著由于基准模型
政策评估：比较政策实施前后的数据变化

输入输出

输入：分组变量（自变量 X）：通常是分类变量数值变量（因变量 Y）：具体的观测数值
输出：统计量：如 t 值，F 值，卡方 P 值：核心指标效应量

步骤

正态性检验
方差齐性检验
选择检验指标：
可视化

适用场景

模型性能对比
社会科学/政策影响
多方案优选

运筹优化类

线性规划

作用

在有限的资源约束下，寻找最优解。在满足一系列线性约束条件的前提下，求一个线性目标函数的极值

输入输出

输入：
- 决策变量：需要控制的量
- 目标函数系数
- 约束条件参数
- 变量边界
输出：
- 最优决策方案
- 最优目标值
- 灵敏度分析

步骤

定义决策变量：明确哪些量是可以控制的？用数学符号表示
确立目标函数
列出约束条件：把限制写出线性等式或不等式
规定非负约束

优点

全局最优性：只要有解，必定是全局最优
求解速度快
理论成熟
灵敏度分析：可以量化“资源价值”，便于后续的深入讨论

缺点

线性假设强
变量连续性
确定性假设

适用场景

生产计划问题
配料/混合问题
运费/指派问题
网络流问题
多阶段投资问题

整数规划

作用

在满足线性约束的前提下，求整数解的最优方法。

输入输出

输入：
- 同线性规划
- 整数限制
- 二值限制：指定某些变量只能取 0/1
输出：
- 整数解
- 最优目标值

步骤

定义决策变量：
- 特别是引入yi=0/1y_i =0/1yi=0/1
确立目标函数
列出约束条件：
- 互斥约束：两个项目只能选一个：x1+x2<=1x_1 + x_2 <= 1x1+x2<=1
- 依赖约束：只有选了 A 才能选 B：xB<=xAx_B<=x_AxB<=xA
- 固定成本：如果生产产品 x，必须支付开机费 K：Cost=c⋅x+K⋅yCost =c·x + K·yCost=c⋅x+K⋅y（y 是 0-1 变量）
规定非负约束
规定整数/0-1 约束

优点

真实性强
逻辑表达能力强
适用面广

缺点

求解困难
灵敏度分析困难
对求解器要求高

适用场景

指派问题：N 个人做 N 件事
背包问题：物品体积价值不同，背包容量有限
选址问题：在 10 个备选点中选 3 个建物流中心
排班/调度问题
路径规划问题

非线性规划

作用

处理目标函数或者约束条件中包含非线性项的优化问题。

输入输出

输入：
- 决策变量
- 非线性目标函数
- 非线性约束
- 初始值
输出：
- 局部最优解
- 全局最优解：很难保证找到，除非模型是凸的
- 梯度/Hessian 矩阵：描述在最优解附近曲面的弯曲程度，用于分析稳定性

步骤

定义决策变量
确立目标函数
列出约束条件
判断凸性
选择求解算法

优点

高度逼真
灵活性强

缺点

局部最优陷阱
求解难度大
数值稳定性差

适用场景

投资组合优化
曲线拟合：最小二乘法
工程设计
选址问题

图论

最短路径法

作用

在一个加权图中，寻找两个节点之间累计权重最小的路径

输入输出

输入：
- 节点集合
- 边集合
- 权重矩阵
输出：
- 最短路径值
- 路径序列

步骤

抽象节点与边
定义权重
选择算法
求解与还原路径

优点

全局最优
算法成熟高效
易于扩展

缺点

负权回路失效
内存消耗
静态假设：标准算法假设路况（权重）不变。

适用场景

交通/物流导航
网络路由协议
设备更新/生产计划
管道铺设/布线
社交网络分析

最小生成树

作用

在一个连通加权图中，找到最小生成树

输入输出

输入：
- 节点集合
- 边集合
- 权重
输出：
- 选定的边集合
- 最小总权重
- 树的结构

步骤

识别需求
构建图
选择算法

优点

全局最优且高效
结果简单

缺点

鲁棒性差
单点路径不优：从 A 到 B 可能要绕很远的路，远不如直接 A-B。

适用场景

基础设施建设：电力网、通信网、供水管道、燃气管道
聚类分析：基于 MST 的聚类
近似 TSP
图像分割

启发式算法

模拟退火算法

作用

在庞大的搜索空间中寻找全局最优解

输入输出

输入：
- 目标函数
- 解空间
- 初始解
- 控制参数：初始温度、终止温度、降温系数、马尔可夫链长度
输出：
- 近似全局最优解
- 最优目标函数值

步骤

初始化 (Initialization):

随机生成初始解 xcurrentx_{current}xcurrent，计算其目标函数值 Ecurrent=f(xcurrent)E_{current} = f(x_{current})Ecurrent=f(xcurrent)。
设定初始温度 T=TmaxT = T_{max}T=Tmax。

外层循环 (降温过程):*当 T>TminT > T_{min}T>Tmin 时，执行以下步骤：
内层循环 (等温过程/Metropolis抽样): 重复 LLL 次：
- 产生新解: 在当前解 xcurrentx_{current}xcurrent 附近进行扰动（例如：交换两个城市的顺序、微调参数值），产生新解 xnewx_{new}xnew。
- 计算增量: 计算能量差（目标函数差值） ΔE=f(xnew)−f(xcurrent)\Delta E = f(x_{new}) - f(x_{current})ΔE=f(xnew)−f(xcurrent)。
- 接受判断 (Metropolis准则):
  - 情况 A (ΔE<0\Delta E < 0ΔE<0): 新解更优（能量更低），直接接受。令 xcurrent=xnewx_{current} = x_{new}xcurrent=xnew。
  - 情况 B (ΔE>0\Delta E > 0ΔE>0): 新解更差，但以概率 PPP 接受。
    
    P=exp⁡(−ΔET)P = \exp\left(-\frac{\Delta E}{T}\right)P=exp(−TΔE)
    
    (注意：温度 TTT 越高，接受差解的概率 PPP 越大；随着 TTT 降低，PPP 迅速减小，算法趋于贪心)。
降温 (Cooling):
- 更新温度：T=T×αT = T \times \alphaT=T×α。
终止 (Termination):

输出搜索过程中记录到的历史最优解 xbestx_{best}xbest。

优点

全局搜索能力强
通用性强
鲁棒性好：对初值不敏感

缺点

收敛速度慢
参数敏感

适用场景

NP-Hard组合优化问题

TSP 问题
排班/调度问题
选址问题
布局优化
连续函数优化

遗传算法

作用

全局搜索与优化

输入输出

输入：
- 适应度函数：即目标函数
- 编码方式
- 控制参数：种群规模、交叉概率、变异概率、最大迭代次数
输出：
- 进化结束后的最优个体
- 最优适应度值

步骤

编码
初始化种群
循环迭代
终止

优点

并行搜索能力强
可拓展性强
适合于多目标优化

缺点

效率较低
编码困难
参数敏感

适用场景

复杂的组合问题
多目标规划

粒子群算法

作用

全局优化

输入输出

输入：
- 目标函数
- 解空间维度
- 控制参数：种群规模、惯性权重、学习因子、最大速度
输出：
- 全局最优位置
- 最优适应度值

步骤

1. 初始化 (Initialization):

随机生成 NNN 个粒子的初始位置 XXX 和初始速度 VVV。
初始化每个粒子的个体最优解 Pbest=XPbest = XPbest=X。
找到初始群体中的全局最优解 GbestGbestGbest。

2. 循环迭代 (Iteration Loop):

对于每个粒子 iii：

更新速度 (Velocity Update):

这是 PSO 的灵魂公式：

vit+1=w⋅vit⏟惯性+c1⋅r1⋅(Pbesti−xit)⏟自我认知+c2⋅r2⋅(Gbest−xit)⏟社会认知v_{i}^{t+1} = \underbrace{w \cdot v_{i}^{t}}_{\text{惯性}} + \underbrace{c_1 \cdot r_1 \cdot (Pbest_i - x_{i}^{t})}_{\text{自我认知}} + \underbrace{c_2 \cdot r_2 \cdot (Gbest - x_{i}^{t})}_{\text{社会认知}}vit+1=惯性w⋅vit+自我认知c1⋅r1⋅(Pbesti−xit)+社会认知c2⋅r2⋅(Gbest−xit)

(其中 r1,r2r_1, r_2r1,r2 是 0 到 1 之间的随机数)
更新位置 (Position Update):

xit+1=xit+vit+1x_{i}^{t+1} = x_{i}^{t} + v_{i}^{t+1}xit+1=xit+vit+1
边界处理: 如果粒子飞出了定义域，将其拉回边界或做特殊处理。

3. 评估与更新:

计算新位置的适应度 f(xit+1)f(x_{i}^{t+1})f(xit+1)。
更新 Pbest: 如果现在的适应度比自己的历史最好还好，就更新 PbestPbestPbest。
更新 Gbest: 如果现在的适应度比整个群体的历史最好还好，就更新 GbestGbestGbest。

终止: 达到最大迭代次数或满足精度要求，输出 GbestGbestGbest。

优点

收敛速度快
参数少，实现简单
适合连续优化

缺点

容易早熟，困死在局部
离散问题处理较弱

适用场景

连续函数优化
电力系统优化

第三学期总结

小yo — Thu, 05 Feb 2026 18:55:01 GMT

让我想想我该怎么总结这一学期，从开学忙于新文科大赛，到美赛结束回家，中间找导师也好，实验室选拔也好，总像个无头苍蝇一样到处奔波，不知道自己究竟想做什么，只知道埋头向前。。。

故事应该是开始于 AI 学组的那次讲座，学长分享了他的保研和科研经验，彼时的我正忙于新文科大赛改 PPT 中。那场讲座之后，茅塞顿开，我终于清楚，如果想要保研到上交甚至清北，我要做的只有卷绩点、科研，比赛是毫无性价比的。我选择了退出已经进入国赛的新文科团队，开始去寻找我心里认为真正该做的事情，贯彻于我一整个学期的焦虑，也就此开始了。

我开始联系本科生导师，经过第一次谈话之后，我才意识到，我一直引以为傲的各种成绩、奖项都算不了什么，想要进组科研，可彼时的我甚至连 python 都不会，老师让我回去自学，或许也算是一种变相的拒绝吧。

后来看到了北京大学一个课题组招本科生实习，抱着试一试的心态，我投去了简历，对方老师看了我的简历之后，说我年级还太低，然后给我发了他们要求低年级学生的学习清单，清单上净是我没有见过的东西，这时我才彻底意识到差距。

我开始了日复一日的后悔，我后悔我选择了平转而从未考虑过降转，我太过于相信自己的能力；我后悔大一的自己视线只局限在转专业的笔试面试，而从未考虑过转完之后我该做什么；我后悔自己一直沉迷在高数线代的种种题型，却没有学习计算机各种常用的内容。

后来又看到本校一个本科生实验室招生，我再次报名，七十多人进四人，这是一个硬仗。随着一轮轮考核的推进，我实实在在地学习了很多知识，从图像分类到大语言模型，都有个一知半解。只可惜最后一轮面试，面试前的一周每每开始读论文我便静不下心，囫囵吞枣，面试时果然被抓出原型，倒在了最后一轮考核。焦虑和后悔继续蔓延。

期间还参加了数学竞赛，从开学前就规划着要怎么怎么复习，然后冲击决赛。但显然我是一个精于规划而疏于执行的人，直到赛前一天，我才终于决心开始复习。那一天从早上开始，写了几套往年题，发现好多已经忘记。晚上正好朋辅答疑值班，在自习室看速通视频看到凌晨三点。第二天八点考试，七点多才着急爬起来。或许是转专业时沉迷于高数线代积累的数理基础，让我意外幸运地闯进了决赛。不过这并没有带来任何成就感，虽然开学前就各种规划，但实际上我只付出了一天的时间，目标也成了拿个省奖混德育分。所以这次进入决赛带给我的更多是幸运感而非成就感，远不如大一时拿到省一令人振奋。

实验室考核失败之后迎面而来的就是期末，由于一整个学期都在四处碰壁，我在课内学习上花的时间远没有大一时多，十天七门的期末周更是雪上加霜。期末周过得很痛苦，每天早七到晚十二，三个室友期末周都只有英语和毛概两门课，导致宿舍是完全没法呆的，每天来往于自习室和食堂，午休也只好趴在座位上眯一会。

期末结束随之而来的就是美赛的备赛，其实最初是完全没有参加美赛的想法的，正如前文所提，比赛对于保研是最没有性价比的东西。但是工创赛中给予我莫大帮助的侯老师找到我，说可以为我推荐指导老师。或许所谓“士为知己者死”就是如此吧，我没在犹豫，选择了报名参赛。虽然在备赛期间我曾无数次迷茫后悔，想一走了之，但终于还是坚持到了美赛前夕。四天美赛更是生不如死，由于自身一直在搞人工智能相关的内容，对 C 题额外感兴趣，所以前期的备赛几乎是一直围绕 C 题展开的。结果今年 C 题不再是时序预测，这就使得我这个建模手彻底没招了，其他题不会，C 题也没看明白，无可奈何只能硬着头皮选 C 题。好在最后是做出来了个结果，至于对错，随它去吧。

美赛结束第二天就坐上了回家的火车，15 小时的火车，耳机的一只不知道掉哪去了，不见了，使得这次旅途格外漫长，便有感而发，选择来写这样一个总结。

总的来看，这学期远没有大一振奋人心，经历了很多，但大多是失败的经历，虽说失败是成功之母，但是时间不等人啊，这份焦虑还会持续到什么时候。。。

小yo2025年年度报告

小yo — Wed, 31 Dec 2025 20:25:00 GMT

📂 目录

一、2025年时间线

01.01：结识小Q，非常非常好的朋友

01.10：高数出成绩，收获大学第一个满分

01.17：再次站上蒙阴一中大礼堂的讲台，讲述我与西交的故事

02.16：陕西历史博物馆秦汉馆，“一个博物馆就是一所大学校”
03.26：工创大赛校赛决赛，斩获第五名，晋级省赛

04.27：工创大赛陕西省省赛决赛，第十二名，压线晋级国赛

05.24：“青焰未央”毕业晚会

07.25：转专业成功，大数据管理与应用→计算机科学与技术

08.07：西安飞往大连，人生第一次坐飞机

08.08：工创大赛国赛初赛，第十一名，止步国二

08.10：大连之旅结束

08.25：潍坊面基

09.07：作为朋辈辅导员第一次组织班会

09.12：举办转专业讲座

09.26：“闪亮的青春”2024-2025学年优秀本科生标兵评选展示大会

09.28：十九岁生日

10.08：国家奖学金答辩

10.15：仲英书院第十四次学生代表大会

10.19：小yo博客问世

11.08：全国大学生数学竞赛初赛，全校第9，92分晋级国赛

12.20：小yo博客第一次大更新，风格趋于个性化

12.30：国家奖学金奖品，感谢西交，感谢国家

12.30：岱宗学室第一次团建，感谢友友们的陪伴，祝岱宗学室做大做强！

12.31：本田梦想基金答辩 “从排名第一转专业，到工创赛国赛的队长，再到实验室考核的挫折，我从未停止过奔跑。今天的我，比任何时候都更清楚自己想要什么。”

12.31：来西安见到的第一场雪。一下雪，西安就变成了长安。

12.31：《小yo2025年年度报告》发布。 2025年的最后一天，那些遗憾和纠结，爽快翻篇；复盘一年来的经验和教训，默默蓄力。 2026，继续全力以赴，勇敢追逐梦想，大胆地表达爱意；2026，也要学会接纳自己，允许自己不完美，允许一切慢慢来……

二、2025年阅读/观影/游玩清单

书籍：

《西游记》
《地心游记》
《论语》

影视：

《南京照相馆》
《志愿军：浴血奋战》
《黑铁的鱼影》
《血战湘江》
《长津湖》
《志愿军：雄兵出击》
《古田军号》
《大决战之辽沈战役》
《大决战之淮海战役》
《大决战之平津战役》

游戏

《黑神话悟空》
《多乐够级》
《导师模拟器》
《恋爱泡馍！青春老陕》
《星露谷》
《植物大战僵尸2》
《无悔华夏》

景点

陕西历史博物馆秦汉馆
陕西历史博物馆本馆
西安曲江池
西安兴庆宫
西安城墙
西安钟楼
大连星海广场
大连黑石礁
大连威尼斯水城
大连东港
大连森林动物园

三、2025年10件最有成就感的事

转专业成功
智育综测双专业第一
收获国家奖学金
工创大赛挺进国赛
高数线代双满分
结识了很多志同道合的朋友
小yo博客成功问世
作为朋辈辅导员，帮助了很多新生
大学生数学竞赛入围全国决赛
身体健康没有生大病

四、心中的遗憾

纵观整个2025年，最大的遗憾或许就是工创大赛没能闯进国决了。其实这部分反复写了删，删了写，但总是写不出刚完赛时的遗憾，就只好把当初写的内容放在下边了，虽然是十月多上传到博客的，但原文确是小yo在完赛回学校的飞机上写的，字里行间或充满了不舍与遗憾。

纪念2025年工创大赛

五、2026年三个关键词

成长
忠于自己
关关难过关关过

六、2026年十个目标

学习前端，继续升级小yo博客，实现完全个性化
发表第一篇论文
减肥减到130斤
攒钱买一台mac
养成早睡的习惯
再冲一次国奖
读至少6本书
去一趟延安
坚持锻炼
坚持梦想

七、给2026年的自己的一封信

亲爱的2026年的小yo：

见字如面。

写下这行字的时候，2025年的日历只剩下最后几页了。窗外是十二月的寒冬，夜很深，但我心里还很暖。我正坐在这个转折点上，隔着一整年的时光试图拥抱你。不知道当你再次读到这些文字时，是在某个赶完DDL后如释重负的深夜，还是在某个阳光洒满书桌的午后？

2025年对我们来说，真的太特殊了。这一年，我们用力地撕掉了旧的标签，从管理学院跨进了计算机的大门；我们拿到了国奖，证明了自己在学业上的努力；我们也第一次坐上飞机，去看了大海，却也把遗憾留在了大连的云层之上。我现在闭上眼，还能想起那天在工创赛场上的不甘心，以及回程路上那份沉甸甸的沉默。但我想告诉你的是，那一刻的失落，恰恰是我现在最珍视的行囊——它比奖杯更沉，也更压得住脚下的路。

亲爱的，2026年的你，应该已经是大三或即将大三的老登了吧。我猜，这一年的路并不会比2025年好走。计算机专业的课业压力，还有科研的迷茫、竞赛的内卷，各种事情也许会像潮水一样常常让你喘不过气。当你面对那些晦涩的算法推导，或者在深夜里对着报错的终端发呆，甚至在第一篇论文被拒稿时感到自我怀疑，请一定不要苛责自己。要知道，即使是那些看似游刃有余的时刻，背后也都是无数次的咬牙坚持。你并不孤独，因为曾经那个从零开始转专业的我都挺过来了，现在的你，更加强大。

在这深耕计算机的一年里，我不求你写出惊天动地的代码，但我希望当你敲击键盘时，内心是充盈而快乐的。也许你正在为了论文的数据焦头烂额，也许你正在一行行重构小yo博客的前端代码，无论进度快慢，都请享受那个创造的过程。那是属于你的世界，是你一点点搭建起来的城堡。我更希望，那个博客里记录的不仅是技术，还有你的日常、你的经历、你的感悟，是你在这个纷繁世界里留下的真实回响。

在学业和忙碌之外，我更想嘱咐你的是：请务必忠于自己，也请务必善待自己。你也别忘了那些陪在你身边的人。2025年我们很幸运遇到了很多志同道合的朋友。到了2026年，哪怕再忙，也请记得和朋友们保持联系，去吐吐槽，去分享彼此的快乐与脆弱。人不是一座孤岛，爱与被爱，也是成长的必修课。

过去的一年，我们好像总是在赶路，总是在证明什么。“你太专注于未来，却没有意识到今天正是你多年前祈求的模样，因为你眺望远方视而不见”——我们曾因为这样一句话而思考整夜，到了2026年，我希望你能把这句话真正融进骨子里。我希望你能慢一点，再去感受生活的颗粒感。

早睡不再是一句空洞的口号，而是你对身体最温柔的承诺；吃饭不再是为了对付饥饿，而是为了品尝滋味。如果不开心了，或者觉得压力大到扛不住了，就去运动吧，看着体重秤上的数字一点点减小，感受汗水流过脸颊的温度，那种掌控身体的感觉，会是你对抗失控生活最好的武器。

还有，别忘了给心灵留一个出口。如果城市的喧嚣让你迷失，记得去翻翻书桌上那几本厚厚的书，或者，真的背上包去一趟延安吧。去看看那片黄土地，去吹吹那里的风，去感受那种纯粹与厚重，去看看革命前辈们在那里留下的痕迹。有时候，我们需要适当走出来，才能看清要去的地方。

2026年的小yo，生活也许依然是“关关难过”，但我相信你一定能“关关过”。我不祝你从此一帆风顺，因为那不现实；我祝你在被否定时依然相信自己的价值，在想要放弃时能想起此刻我写下的期许。再冲一次国奖也好，发表论文也罢，结果固然重要，但更重要的是，在追逐这些光芒的路上，你始终没有弄丢那个赤诚的自己。

我祝你依然有少年的莽撞，也有成年的稳重。去爱这一年吧，爱它的不完美，爱它的挑战，也爱那个在跌跌撞撞中始终坚持初心的自己。

我就在这里，在2025年的尽头，为你这一年的每一次勇敢，哪怕是微不足道的尝试，用尽全力地鼓掌。

愿你足够尽力、尽情、尽心。选择你所爱，爱你所选择，然后认真走下去，成为那个你最想成为的、真正可以发光的人。

加油，去奔赴那个属于你的未来吧。

——爱你的，2025年的小yo

周记Week10

小yo — Sun, 21 Dec 2025 20:14:16 GMT

这周潦潦草草过了几篇论文，以前从来没读过英文论文，再加上英语太差，读起来实在困难，只能依靠B站的讲解视频和gemini的deep research，可以给大家分享一个我自己感觉还挺好用的提示词：“我正在精读***的这篇论文，请你全面深刻地解读一下这篇文献，让我能达到彻底看懂这篇论文的效果，注意我的理论基础很低！一定要帮我讲明白，同时也要让我理解他的底层原理。我对英语一窍不通，我只会中文！一定要面面俱到，达到精读的效果”。

这周不知道为什么，整个人特别没有动力，干什么事都不提不起精神，或许是感到对时间失去了掌握。。。

下周第16周了，得开始复习期末了，也该换换心了，科研真不养人。。。

视觉指令微调的艺术：LLaVA 及其进化版本的深度剖析报告

小yo — Sun, 21 Dec 2025 19:45:25 GMT

视觉指令微调的艺术：LLaVA 及其进化版本的深度剖析报告

1. 引言：打破模态的壁垒

在人工智能的发展历程中，视觉（Computer Vision, CV）与语言（Natural Language Processing, NLP）长期以来被视为两个独立的研究领域。视觉模型擅长“看”，识别图像中的像素排列并将其分类；语言模型擅长“读”与“写”，处理符号系统的逻辑与生成。然而，人类智能的本质在于多模态的融合——我们不仅看到图像，还能用语言描述它，不仅听到指令，还能在视觉场景中执行它。这种跨越感知与认知的桥梁，正是多模态大模型（Large Multimodal Models, LMMs）试图构建的圣杯。

本报告将对 LLaVA（Large Language-and-Vision Assistant）及其后续迭代版本 LLaVA-1.5 进行百科全书式的深度解读。LLaVA 不仅是一个特定的模型架构，更代表了一种通用的、低成本的、高效的视觉-语言对齐范式。对于初学者而言，理解 LLaVA 是打开多模态大模型黑盒的最佳钥匙。本报告将剥离晦涩的数学公式，从底层原理出发，通过详尽的机制拆解、数据流分析与实验论证，带领读者彻底通晓这一里程碑式的工作。

LLaVA 的核心贡献在于它证明了一个极其优雅的假设：如果我们将视觉世界“翻译”成大语言模型（LLM）能够理解的“词汇”，那么大模型本身强大的推理能力就能无缝迁移到视觉任务上。这一过程被称为“视觉指令微调”（Visual Instruction Tuning）1。不同于以往需要从头训练庞大模型的方法，LLaVA 展示了如何站在巨人（CLIP 与 Vicuna）的肩膀上，仅通过轻量级的连接层与高质量的数据，就能实现令人惊叹的多模态交互能力。

在接下来的篇幅中，我们将首先夯实理解 LLaVA 所需的理论地基，随后深入剖析 LLaVA 1.0 的架构创新，继而重点解读 LLaVA-1.5 如何通过三个简单的改进实现性能的飞跃，最后探讨该领域面临的幻觉、高分辨率适配等开放性问题。

2. 理论基石：多模态大模型的组件与原理

在深入 LLaVA 的具体设计之前，必须先理解它所依赖的三大核心组件：视觉编码器、大语言模型以及将二者连接起来的对齐机制。对于理论基础薄弱的读者，我们将采用形象的比喻来解释这些概念。

2.1 视觉编码器：让机器拥有“眼睛” (CLIP)

LLaVA 并没有自己重新发明“眼睛”，而是直接借用了 OpenAI 发布的 CLIP（Contrastive Language-Image Pre-training）模型的视觉部分。理解 CLIP 是理解 LLaVA 的第一步。

2.1.1 传统视觉模型 vs. CLIP

在 CLIP 出现之前，计算机视觉模型（如 ResNet）大多是在 ImageNet 数据集上训练的。这类模型的训练目标是“分类”——给它一张图，它输出一个标签（如“猫”、“狗”、“汽车”）。这种模型虽然能识别物体，但它不仅识别的类别有限（通常只有 1000 类），而且无法理解图像中丰富的语义关系，比如“一只猫躺在阳光下的沙发上”。

CLIP 采用了完全不同的训练逻辑，即对比学习（Contrastive Learning）。它使用了 4 亿对“图像-文本”数据（从互联网上抓取）。

训练机制：CLIP 同时训练一个图像编码器和一个文本编码器。它的目标是：给定一张图片，从一堆文本描述中找出最匹配的那一句。
结果：CLIP 的视觉编码器不再输出单纯的类别标签，而是输出一个特征向量（Feature Vector）。

2.1.2 特征向量：机器的视觉语言

什么是特征向量？我们可以将其想象为一串长长的数字列表（例如 1024 个数字）。这串数字是图像在机器眼中的“压缩摘要”。

语义空间：在 CLIP 的向量空间中，意思相近的图像和文本，其对应的向量距离非常近。例如，“宇航员”的照片向量和单词 “Astronaut” 的文本向量，在数学空间上几乎重合。
LLaVA 的选择：LLaVA-1.5 选择了 CLIP-ViT-L-336px 作为视觉编码器 1。
- ViT (Vision Transformer)：表示它使用 Transformer 架构处理图像，将图像切成小方块（Patches）进行处理，这比传统的卷积神经网络（CNN）更擅长捕捉全局关系。
- L (Large)：表示模型规模较大，参数更多，理解力更强。
- 336px：表示输入图像的分辨率为 336x336 像素。相比于标准的 224px，这能让模型看清更多细节。

底层洞察：LLaVA 之所以选择 CLIP，是因为 CLIP 已经将视觉信息“翻译”成了一种包含了丰富语义的向量。LLaVA 的任务不再是教模型“看图”，而是教模型如何把这些视觉向量“读”出来。

2.2 大语言模型：机器的“大脑” (Vicuna)

LLaVA 的“大脑”是 Vicuna，一个基于 LLaMA 微调而来的开源大语言模型。

2.2.1 自回归生成与 Token

大语言模型本质上是一个**自回归（Auto-regressive）**预测器。它的工作原理像是一个极高明的“接龙游戏玩家”：给定前面的一段话，它预测下一个最可能出现的字（Token）。

Token（词元）：LLM 处理的最小单位不是单词，而是 Token（可以是单词的一部分）。
Embedding（嵌入）：每个 Token 在进入 LLM 之前，都会被转换成一个向量（Word Embedding）。例如，单词 “Apple” 对应向量 [0.1, -0.5,...]。

2.2.2 指令微调 (Instruction Tuning)

原始的基座模型（Base Model）像 LLaMA，虽然读过很多书，但不懂得如何对话。它可能会在用户提问时继续续写问题，而不是回答问题。

指令微调通过“指令-回复”的数据对，教会模型遵循人类的指令。Vicuna 就是经过高质量对话数据微调后的 LLaMA，因此它具备了极强的对话和逻辑推理能力 3。

LLaVA 的创新点：LLaVA 思考的是，既然 LLM 能理解“文本向量”，那如果我们把“图像向量”伪装成“文本向量”喂给它，它是不是就能理解图像了？

2.3 跨模态对齐：连接视觉与语言的“视神经” (Projection)

这是 LLaVA 架构中最关键的“魔法”所在。

虽然 CLIP 输出的视觉向量蕴含了语义，但它和 LLM 理解的文本向量属于不同的“语言体系”（数学上称为不同的特征空间）。直接把 CLIP 的向量喂给 Vicuna，Vicuna 会看到一堆乱码。

我们需要一个翻译器，这就是 Projector（投影层）。

线性投影 (Linear Projection)：在 LLaVA 1.0 中，这个翻译器是一个简单的矩阵乘法。它试图寻找一个线性的变换规则，把视觉向量空间“旋转”一下，使其与文本向量空间对齐。
多层感知机 (MLP)：在 LLaVA-1.5 中，这个翻译器升级为两层 MLP。相比于线性投影，MLP 引入了非线性激活函数，能够处理更复杂的特征映射关系 1。

深度比喻：

CLIP 是眼睛，看到了世界的景象，并将其转化为电信号（视觉特征）。
Vicuna 是大脑，拥有逻辑和语言中心，但它看不见外部世界。
Projector 是视神经。它负责把眼睛传来的电信号，转换成大脑皮层能够接收和理解的生物电信号。LLaVA 的训练过程，很大程度上就是在“接通”这根视神经，并校准信号的传输。

3. LLaVA (v1) 的方法论：极简架构与数据生成

在深入 LLaVA-1.5 的改进之前，我们必须先理解 LLaVA 原版（v1）建立的范式。LLaVA 的成功并不依赖于极其复杂的网络结构设计，而是在于其独创的数据生成策略和高效的训练流水线。

3.1 核心创新：GPT-4 辅助的数据生成 (Data Generation)

在 LLaVA 诞生之前，多模态领域面临的最大瓶颈是高质量数据的匮乏。已有的数据集（如 COCO）通常只包含简单的图像描述（Caption），例如“一只狗在草地上”。这种数据无法训练出能进行多轮对话、复杂推理的助手。

如果让人工去标注“图像-多轮对话”数据，成本将是天文数字。LLaVA 团队提出了一个极具创造性的解决方案：利用纯文本的 GPT-4 来“伪造”多模态数据。

3.1.1 纯文本如何生成多模态数据？

GPT-4（当时还没开放视觉功能）看不见图，但它能看懂代码和标注。COCO 数据集中不仅有图片，还有极其详尽的标注信息：

Captions：简短的描述（如“一个穿红衣服的人”）。
Bounding Boxes：物体的坐标框（如 : Person）。
Categories：物体类别列表。

LLaVA 团队设计了精妙的 Prompt（提示词），将这些文本化的视觉信息喂给 GPT-4，让 GPT-4 “脑补”出这张图的场景，并生成三种类型的数据 1：

多轮对话 (Conversation)：
- Prompt：“设计一段两人之间的对话，讨论这张照片。照片里有[物体列表]…位置在…”。
- 产出：模仿人类用户向助手提问，助手根据坐标信息回答。例如“左上角那个人在干什么？” GPT-4 会推理出：“根据坐标，他和另一个物体（滑板）重叠，他可能在滑滑板。”
详细描述 (Detailed Description)：
- Prompt：“请极其详尽地描述这张图片，包括物体的颜色、位置、动作背景等。”
- 产出：一段数百字的丰富描述，弥补了原始 Caption 信息量不足的问题。
复杂推理 (Complex Reasoning)：
- Prompt：“基于图片内容设计一些需要逻辑推理的问题。”
- 产出：例如“为什么这辆车停下来了？”（GPT-4 根据标注中的‘红灯’或‘斑马线’推理出答案）。

底层原理分析：这种方法本质上是一种知识蒸馏 (Knowledge Distillation)。它将 GPT-4 强大的世界知识和逻辑推理能力，通过文本这一中介，转移到了多模态数据中。虽然 GPT-4 没看图，但它生成的对话在逻辑上与图片内容高度一致（因为基于 Ground Truth 标注）。这为 LLaVA 提供了 158K 条高质量的指令微调数据（LLaVA-Instruct-150K）。

3.2 训练策略：两阶段训练法

LLaVA 采用了两阶段的训练策略，这在后来的 LLaVA-1.5 中也得到了沿用。理解这两个阶段的区别对于掌握模型原理至关重要。

阶段一：特征对齐预训练 (Feature Alignment Pre-training)

目标：打通“视神经”。让 LLM 能够理解视觉特征的基本含义，而不是看到一堆乱码。
数据：CC3M 数据集过滤出的约 600K 个“图像-文本”对。这是简单的描述任务。
模型状态：
- 视觉编码器 (CLIP)：冻结 (Frozen)。不更新参数，保持其预训练好的视觉能力。
- LLM (Vicuna)：冻结 (Frozen)。不更新参数，保持其语言能力。
- 投影层 (Projector)：可训练 (Trainable)。
过程：输入图片，经过 CLIP 得到特征 ZvZ_vZv，再经过投影层得到 HvH_vHv。LLM 接收 HvH_vHv，被要求输出图片的描述文本。
结果：经过这一阶段，投影层学会了将“视觉语言”翻译成“LLM 词向量”。

阶段二：视觉指令微调 (Visual Instruction Tuning)

目标：赋予模型多模态交互能力。让模型不仅能看懂图，还能根据图进行对话、推理、创作。
数据：GPT-4 生成的 LLaVA-Instruct-150K 数据。
模型状态：
- 视觉编码器 (CLIP)：冻结。
- 投影层 (Projector)：可训练。
- LLM (Vicuna)：可训练。
过程：这是真正的 Fine-tuning。LLM 的参数开始更新，以适应多模态任务的逻辑。模型学会了处理复杂的 Prompt，如“如果图里有危险，请指出来”。
结果：一个能够像 ChatGPT 一样聊天，同时又能看懂图片的 LLaVA 模型诞生了。

4. LLaVA-1.5：通过简单的改进实现 SOTA

LLaVA 1.0 虽然开创了先河，但在学术界的标准测试集（Benchmark）上，它的表现并不完美。主要问题在于它容易产生“幻觉”，且在需要简短回答的任务（如 VQA）上表现不佳，容易“话痨”。

论文《Improved Baselines with Visual Instruction Tuning》的核心贡献在于，它证明了不需要复杂的架构魔改，只需要三个极其简单的调整，就能让 LLaVA 的性能产生质的飞跃，甚至超越那些使用了十亿级训练数据的竞品（如 Qwen-VL, InstructBLIP）1。

本节将详细拆解这三大改进。

4.1 改进一：MLP 投影层 (MLP Projection)

在 LLaVA 1.0 中，连接视觉与语言的是一个简单的线性层（Linear Layer）。LLaVA-1.5 将其替换为两层多层感知机（MLP）。

4.1.1 线性 vs. 非线性：数学视角的解读

线性层：数学表达为 y=Wx+by = Wx + by=Wx+b。这相当于对特征空间进行旋转、缩放或平移。如果视觉特征空间和语言特征空间的对应关系比较简单，线性层是够用的。但实际上，视觉语义（如纹理、形状）到语言语义（如抽象概念）的映射往往是极其复杂的、非线性的。
MLP：数学表达为 y=W2⋅σ(W1x+b)y = W_2 \cdot \sigma(W_1 x + b)y=W2⋅σ(W1x+b)，其中 σ\sigmaσ 是激活函数（如 GELU）。
- 激活函数的作用：激活函数引入了非线性。它允许模型“弯曲”特征空间，去拟合更复杂的映射关系。

4.1.2 为什么 MLP 更好？

通过引入 MLP，投影层不仅仅是简单的“翻译字典”，它变成了一个具有一定推理能力的“特征处理器”。它能够提取视觉特征中更深层次的组合关系，从而更精准地对齐到 LLM 的词嵌入空间。

实验数据显示，仅此一项改动，就能显著提升模型在多模态理解上的准确率。这告诉我们，在跨模态对齐中，连接器的表达能力（Capacity）至关重要。

4.2 改进二：高分辨率视觉输入 (Scaling to Higher Resolution)

LLaVA 1.0 使用的 CLIP 模型输入分辨率为 224x224。LLaVA-1.5 升级为 CLIP-ViT-L-336px，输入分辨率提升至 336x336 1。

4.2.1 分辨率与“视力”

224x224 的分辨率对于大模型来说相当于“高度近视”。在这个分辨率下，一张复杂的照片被压缩成非常模糊的信息，许多细节（如书上的文字、远处的小物体）会丢失。

幻觉的根源：当模型看不清时，它并不会闭嘴，而是会根据语言模型的概率习惯去“猜”。比如看到模糊的一团黑色，LLM 可能会根据上下文瞎编说“这是一只猫”。这就是**幻觉（Hallucination）**的主要来源之一。
336px 的改变：像素数量增加了 2.25 倍（3362/2242336^2 / 224^23362/2242）。这让模型能“看清”更多细节。

4.2.2 为什么不直接用超高分辨率？

既然分辨率越高越好，为什么不用 1024px？

这受限于预训练的 CLIP 模型。OpenAI 发布的 CLIP 模型最高分辨率版本就是 336px。如果强行输入更大的图片，需要对位置编码（Positional Embeddings）进行插值，这会导致性能下降，除非进行大规模的重新预训练。LLaVA-1.5 选择 336px 是在性能与训练成本之间的一个最优平衡点。

4.3 改进三：学术任务导向的数据与“格式提示” (Response Format Prompting)

这是 LLaVA-1.5 最具智慧的数据策略改进。

4.3.1 痛点：多任务平衡的困境

之前的模型（如 InstructBLIP）存在一个严重问题：过拟合。

场景：InstructBLIP 为了刷榜，使用了大量的 VQA（视觉问答）数据。VQA 数据的特点是问题很短，答案也很短（通常是一个单词，如 “Red”, “Yes”, “2”）。
后果：模型学傻了。当你像聊天一样问它“请描述这张图”时，它也只回几个词。它丧失了进行长文本生成和自然对话的能力。

4.3.2 LLaVA-1.5 的解决方案：Response Format Prompting

LLaVA-1.5 引入了大量的 VQA 数据（如 VQAv2, GQA, OKVQA）以提升学术能力，但为了防止模型变傻，它设计了特殊的格式提示。

机制：在训练 VQA 数据时，不仅仅给模型看问题，还在问题后面追加一段明确的指令后缀。
- 原始问题：“What color is the car?”
- LLaVA-1.5 输入：“What color is the car? Answer the question using a single word or phrase.”
原理：这本质上是在做条件控制（Conditional Generation）。
- 模型学会了：当看到后缀“用单词回答”时 -> 输出短答案（VQA 模式）。
- 模型学会了：当没有后缀时 -> 输出长答案（聊天模式）。

这一简单的策略，成功地让 LLaVA-1.5 既保留了 LLaVA 1.0 强大的闲聊能力，又在 VQA 等学术榜单上拿到了 SOTA 分数，完美解决了多任务冲突。

4.3.3 数据混合的艺术 (Data Mixture)

LLaVA-1.5 最终使用的微调数据量约为 665K，其构成经过了精心设计 1：

数据类型	来源数据集	数量	作用与洞察
多模态对话	LLaVA-Instruct	158K	基石。保持模型的对话交互能力和逻辑推理能力。
学术 VQA	VQAv2, GQA, OKVQA	~220K	事实性增强。提升模型对细节事实的精确回答能力，减少“废话”。
OCR (文本识别)	OCRVQA, TextCaps	~100K	文字阅读能力。让模型能读懂图片里的文字，这是很多实际应用的关键。
视觉定位	Visual Genome, RefCOCO	~130K	细粒度感知。训练模型理解“哪里有什么”，提升空间感知。
纯文本对话	ShareGPT	40K	逻辑增强。这是一项反直觉的发现：加入纯文本数据能提升多模态能力。因为多模态推理的瓶颈往往在大脑（LLM）的逻辑能力，ShareGPT 强化了大脑。

小结：LLaVA-1.5 的成功并非源于单一的黑科技，而是 MLP + 高分辨率 + 精细化数据策略的组合拳。它证明了在深度学习中，Data Quality（数据质量） 和 Architecture Design（架构设计） 的匹配度远比单纯堆砌数据量重要。

5. 实验分析与核心发现

为了达到“精读”的效果，我们不能只看结论，必须深入分析实验结果背后的含义。LLaVA-1.5 在 11 个基准测试上取得了 SOTA，这不仅仅是分数的胜利，更是方法论的胜利。

5.1 核心基准测试解读

下表总结了 LLaVA-1.5 与主要竞品（如 InstructBLIP, Qwen-VL）的对比情况：

Benchmark	描述	LLaVA-1.5 表现	深度解读
MMBench	综合能力测试（包含感知、推理、逻辑）	SOTA	证明了模型是一个“全能选手”，没有明显的短板。这得益于多样化的数据混合策略。
MME	感知与识别能力测试	大幅提升	相比 LLaVA 1.0，MME 分数几乎翻倍。这主要归功于引入了 VQA 和 OCR 数据，增强了事实性细节的捕捉。
POPE	幻觉测试（Object Hallucination）	低幻觉率	这是一个关键指标。LLaVA-1.5 极少无中生有。实验表明，高分辨率 (336px) 是降低幻觉的核心因素。
ScienceQA	科学问答（图表、公式、常识）	SOTA	证明了模型不仅能“看”，还能结合科学常识进行深度推理。ShareGPT 数据对此贡献巨大。

5.2 幻觉 (Hallucination) 的本质探讨

论文中关于幻觉的实验非常引人深思。

现象：早期的多模态模型经常会“瞎编”。比如给它一张空桌子的图，问“桌上的苹果是什么颜色？”，它可能会回答“红色”。
LLaVA 的发现：
- 很多人认为幻觉是因为训练数据里有噪音。但 LLaVA 发现，分辨率不足是更大的罪魁祸首。
- 当图像被压缩到 224px 时，很多细节模糊不清。LLM 在看不清的情况下，倾向于利用**语言先验（Language Priors）**来回答。因为它在纯文本训练中见过太多“桌子上有苹果”的句子，所以它猜测有苹果。
- 结论：治好“近视”，就能治好“幻觉”。 提升到 336px 后，模型看清了桌子是空的，自然就不瞎编了。

5.3 数据效率 (Data Efficiency) 的启示

LLaVA-1.5 只用了 1.2M 的数据进行训练。相比之下：

InstructBLIP 用了 1.29 亿 数据。
Qwen-VL 用了 14 亿 数据。
Sparkles 用了数千万数据。

LLaVA-1.5 用不到 1% 的数据量击败了对手。这一现象被称为 “Less is More”（少即是多）。

原理：大多数爬取的互联网图文对（如 LAION-5B）噪声极大，文本往往无法准确描述图片。大量低质数据反而会“污染”模型，让模型学到错误的对齐关系。
LLaVA 的策略：使用 GPT-4 生成的合成数据，虽然数量少，但信息密度极高，逻辑链条完整。这启示我们，未来的 AI 竞争可能不再是数据的比拼，而是数据合成与清洗能力的比拼。

5.4 消融实验 (Ablation Studies)

为了证明每个改进都是有效的，论文进行了消融实验（控制变量法）：

去掉 MLP，换回 Linear：性能下降明显。证明非线性映射是必要的。
降低分辨率：幻觉率飙升，细粒度识别能力下降。证明高分辨率是感知的基石。
去掉学术数据 (VQA)：MME 等感知榜单分数暴跌。证明学术数据对于纠正模型的“事实性”至关重要。

6. 前沿探索：LLaVA-HD 与高分辨率的未来

在论文的探讨部分（Discussion）及附录中，作者并未止步于 336px，而是提出了一个开放性问题：如何处理更高分辨率（如 1024x1024 或任意比例）的图像？这引出了 LLaVA-HD (High Definition) 的探索。

6.1 传统方法的局限

如果直接把一张 1000x1000 的图缩放到 336x336，会产生严重的变形和细节丢失。如果强行调整 CLIP 的参数来适应大图，需要极高的训练成本。

6.2 LLaVA-HD 的切片策略 (Grid Splitting)

LLaVA 提出了一种不需要重新预训练 CLIP 就能处理大图的机制。

机制：切片 + 全局 (Local + Global)
1. 切片 (Grid Splitting)：将一张大图切分成多个 336x336 的小图块（Patches）。例如，一张长图可以切成 2x2 或 1x3 的网格。
2. 独立编码：每个小图块被视为一张独立的图片，通过 CLIP 编码得到特征向量。
3. 全局概览 (Global Context)：除了切片，还将原图缩放成一张 336x336 的缩略图，并进行编码。
4. 拼接：将“缩略图特征”和所有“切片特征”拼接在一起，喂给 LLM。
隐喻：这就像人类看地图。
- Global：先看一眼全图，知道大概的轮廓和区域分布（缩略图）。
- Local：再拿着放大镜，一块一块地看细节（切片图）。
- 这种机制让 LLaVA 能够兼顾宏观布局和微观细节，极大地增强了对文档、图表等密集信息图像的理解能力。

7. 局限性与未来展望

即使是强大的 LLaVA-1.5，也存在其局限性，理解这些局限对于客观评估模型至关重要。

图像分辨率的计算开销：

虽然 LLaVA-HD 解决了分辨率问题，但图片切得越多，生成的 Visual Tokens 就越多。LLM 的上下文窗口是有限的，处理过长的视觉序列会显著增加推理时间和显存占用。未来的方向是如何压缩视觉 Token（如 Token Merging）。
多图理解能力 (Multi-image Understanding)：

目前的 LLaVA 主要针对单图对话。对于“比较两张图的区别”或“视频理解（多帧图像）”，LLaVA 的训练数据较少，能力相对较弱。后续的 LLaVA-NeXT 等工作正在着手解决这一问题。
特定领域的短板：

虽然 LLaVA 是通用助手，但在极度专业的领域（如复杂的医疗影像诊断、极小语种识别），其表现仍不如专用模型。这受限于预训练数据（CLIP）和微调数据的覆盖范围。

8. 总结

LLaVA 及其进化版 LLaVA-1.5 的故事，是人工智能领域化繁为简的经典案例。

它没有：重新训练昂贵的视觉编码器，也没有设计复杂的注意力机制模块（如 Q-Former）。
它做了：
1. 数据创新：利用 GPT-4 的文本推理能力，无中生有地创造了高质量的多模态指令数据，解决了“教什么”的问题。
2. 架构极简：用最简单的 MLP 将视觉与语言连接，利用高分辨率输入解决幻觉，解决了“怎么学”的问题。
3. 策略精细：通过 Response Format Prompting 解决了多任务冲突，实现了学术能力与对话能力的统一。

对于希望彻底看懂这篇论文的读者，请记住以下核心底层原理：

跨模态本质是翻译：视觉特征只是另一种语言，Projector 是翻译器。
模型能力源于数据：LLaVA 的智能很大程度上来自于 GPT-4 生成的那 158K 条高质量对话链。
感知决定认知：看不清（分辨率低）就会导致瞎想（幻觉）。

LLaVA 不仅是一个模型，它定义了开源多模态大模型的基准线（Baseline）。如今，无数的后续工作（如 BakLLaVA, LLaVA-Med, Yi-VL）都建立在 LLaVA 的代码库和方法论之上。读懂了 LLaVA，你就读懂了现代多模态大模型的半壁江山。

9. 附录：核心术语对照表

为了辅助您的学习，以下整理了文中的核心概念对照表：

英文术语	中文翻译	通俗解释
Visual Instruction Tuning	视觉指令微调	教模型“看图听话”的过程。
Vision Encoder	视觉编码器	模型的眼睛 (CLIP)，负责把图片变成数字向量。
Projector / Connector	投影层 / 连接器	视神经，负责把视觉向量翻译成语言向量。
MLP (Multilayer Perceptron)	多层感知机	一种非线性的神经网络层，比线性层更聪明。
Hallucination	幻觉	模型一本正经地胡说八道（通常因为看错或不知道）。
SOTA (State of the Art)	业界最强	当前技术水平下的最高分或最好表现。
Zero-shot	零样本	没专门学过某道题，但凭通识能力直接做出来的能力。
Ablation Study	消融实验	拆掉某个零件看看车还能不能跑，用来证明该零件的重要性。

LLaMA-1 深度技术剖析：开源大语言模型的范式转变与工程实践

小yo — Sun, 21 Dec 2025 19:44:59 GMT

LLaMA-1 深度技术剖析：开源大语言模型的范式转变与工程实践

1. 绪论：从参数竞赛到计算效率的范式重构

在人工智能的发展历程中，特别是自然语言处理（NLP）领域，2023 年 2 月发布的 LLaMA（Large Language Model Meta AI）标志着一个分水岭时刻。此前，OpenAI 的 GPT-3（1750 亿参数）、Google 的 PaLM（5400 亿参数）以及 DeepMind 的 Gopher（2800 亿参数）等模型确立了“规模法则”（Scaling Laws）的早期信条：更大的参数量意味着更强的智能涌现 1。然而，这种对参数规模的无尽追逐导致了算力门槛的极度攀升，使得大语言模型（LLM）的研究成为了少数科技巨头的“围墙花园”。

本报告将对 LLaMA-1 技术论文进行彻底的解构与重组。考虑到读者的需求，我们将不仅复述论文结论，更将深入每一个技术决策背后的理论根源、数学原理及工程权衡。我们将从 Scaling Laws 的演变讲起，剖析 LLaMA 如何通过“过度训练”（Overtraining）打破了原有的效率平衡，进而深入其模型架构的每一个微小但关键的改动（如 RMSNorm、SwiGLU、RoPE），解析数据工程的细节，最后探讨其优化器设计与社会伦理考量。

1.1 大语言模型的发展脉络与瓶颈

在 Transformer 架构（Vaswani et al., 2017）提出之前，NLP 主要依赖循环神经网络（RNN）和长短期记忆网络（LSTM）。这些模型虽然能够处理序列数据，但存在严重的串行计算瓶颈，且难以捕捉长距离依赖 1。Transformer 的出现引入了自注意力机制（Self-Attention），使得并行计算成为可能，从而开启了大规模预训练时代。

随后，BERT（双向编码器）和 GPT（自回归解码器）确立了两种主流路线。GPT-3 的出现展示了少样本学习（Few-shot Learning）的惊人能力，即模型无需微调权重，仅通过提示（Prompt）中的几个例子即可完成任务。这导致了业界对参数量的迷信：为了追求更强的 Few-shot 能力，模型被设计得越来越大。

然而，巨大的模型带来了两个核心问题：

训练成本高昂：训练一个 540B 的模型需要数千张 TPU/GPU 运行数月。
推理（Inference）难以部署：175B 的 GPT-3 需要约 350GB 的显存（FP16 精度），这意味着推理服务必须依赖昂贵的多卡服务器集群，且响应延迟（Latency）极高。

1.2 LLaMA 的核心哲学：推理预算主导论

LLaMA 的论文《LLaMA: Open and Efficient Foundation Language Models》的核心论点是对现有 Scaling Laws 的反思与修正。Meta AI 的研究团队指出，DeepMind 提出的 Chinchilla Scaling Laws 虽然指导了如何在给定训练计算预算下获得最优模型，但却忽略了推理计算预算 1。

在实际的工业与学术应用中，一个模型被训练一次，但会被调用推理数亿次。因此，对于给定的性能目标（Performance Target），最优的模型并不是那个训练最快的模型（参数量大、数据量适中），而是那个推理最快的模型（参数量小、数据量极大）。

核心洞察：LLaMA 的设计哲学是“小模型，海量数据”。相比于 Chinchilla 推荐的训练数据量，LLaMA-7B 被训练了 1 万亿（1T）Token，远远超过了理论上的“训练最优”点。虽然这增加了训练阶段的成本，但却换来了一个极其精简、高效且性能强大的模型，能够在单张 GPU 上运行，从而真正实现了 LLM 的“民主化” 。

2. 理论基础：扩展法则（Scaling Laws）的数学重构

为了读懂 LLaMA，我们必须首先理解指导模型设计的数学法则——Scaling Laws。这是决定模型“身高体重”（参数量与数据量）的基因蓝图。

2.1 第一代法则：Kaplan Scaling Laws

2020 年，OpenAI 的 Kaplan 等人提出了著名的 Scaling Laws。他们通过实验得出结论：模型性能（Loss）与参数量 NNN、数据量 DDD 和计算量 CCC 之间存在幂律关系（Power Law）。

L(N)∝N−αL(N) \propto N^{-\alpha}L(N)∝N−α

Kaplan 的研究表明，参数量 NNN 的增加比数据量 DDD 的增加对性能提升的贡献更大。这直接导致了 GPT-3 等模型的设计思路：极度追求参数规模，而相对忽视了数据量的同步增长。在 Kaplan 的指导下，模型变得越来越“宽”和“深”，但“吃”的数据却相对不足。

2.2 第二代法则：Chinchilla Scaling Laws

2022 年，DeepMind 的 Hoffmann 等人发表了颠覆性的 Chinchilla 论文。他们指出 Kaplan 的结论存在偏差，原因是 Kaplan 固定了学习率调度，且未在足够宽的数据范围内进行探索。

Chinchilla Scaling Laws 提出了一个新的观点：为了在给定的计算预算 CCC 下实现 Loss 最小化，模型参数量 NNN 和训练数据量 DDD 应该等比例增加。

具体来说，两者都应该随着计算量的增加而按 C\sqrt{C}C 的比例扩展。

Chinchilla 最优比：

Chinchilla 推导出的黄金比例大约是 20 Tokens / Parameter。

即：每拥有 1 个参数，模型应该阅读 20 个 Token 的数据。
例如：Chinchilla-70B 模型（700 亿参数）的最佳训练数据量应为 70×109×20=1.4×101270 \times 10^9 \times 20 = 1.4 \times 10^{12}70×109×20=1.4×1012（1.4 万亿 Token）。

2.3 LLaMA 的策略：超越 Chinchilla

LLaMA 的作者并未盲从 Chinchilla 法则，而是从工程实用性的角度对其进行了批判性继承。虽然 Chinchilla 法则指出了训练阶段的计算最优（Compute-Optimal），但在推理阶段，模型的大小直接决定了推理成本（Latency 和 Throughput）。

为了优化推理预算（Inference Budget），LLaMA 选择了过度训练（Overtraining）策略：

模型	参数量 (N)	Chinchilla 推荐数据量	LLaMA 实际训练数据量	数据/参数比 (Ratio)
LLaMA-7B	6.7 Billion	~134 Billion	1 Trillion	~150 : 1
LLaMA-13B	13.0 Billion	~260 Billion	1 Trillion	~77 : 1
LLaMA-33B	32.5 Billion	~650 Billion	1.4 Trillion	~43 : 1
LLaMA-65B	65.2 Billion	~1.3 Trillion	1.4 Trillion	~21 : 1

深度解析：

LLaMA-7B 的训练数据量是 Chinchilla 推荐值的 7 倍以上。
根据 Chinchilla 法则，训练 7B 模型使用 1T Token 是“浪费”算力的，因为同样的算力如果分配给一个更大的模型（如 15B）并在较少的数据上训练，可以更快地达到相同的 Training Loss。
但是，LLaMA 论文图 1（Training Loss）显示，即使在远超 Chinchilla 推荐的数据量后，7B 和 13B 模型的 Loss 仍在持续下降，并未饱和 1。这意味着小模型的潜力远未被挖掘殆尽。
战略意义：通过在训练阶段投入更多的“沉没成本”（Sunk Cost），LLaMA 换取了一个在推理阶段极其轻量且高性能的模型。对于一个需要服务数亿用户的模型来说，推理成本是主要矛盾，因此这种策略在经济上是更优的 1。

3. 数据工程：构建高质量知识库的底层逻辑

在深度学习领域，常有一句话：“Garbage in, Garbage out”（垃圾进，垃圾出）。对于致力于在有限参数内压缩极致知识的 LLaMA 而言，数据质量至关重要。LLaMA 证明了仅使用公开数据集（Publicly Available Data）就能达到 SOTA 水平，打破了私有数据霸权 1。

3.1 数据混合（Data Mixture）策略

LLaMA 的训练数据不仅仅是量的堆砌，更是质的筛选。总计 1.4T Token 的数据由七个部分组成，每个部分都有其特定的功能定位。

数据源	比例	Epochs	磁盘大小	预处理与功能定位
English Common Crawl	67.0%	1.10	3.3 TB	基石数据。代表了互联网的广泛文本。经过了 CCNet 管道的严苛清洗。
C4	15.0%	1.06	783 GB	多样性补充。T5 模型使用的数据集，经过不同的启发式规则清洗，增加了数据的多样性。
Github	4.5%	0.64	328 GB	逻辑推理。代码数据具有极强的逻辑结构，有助于提升模型的逻辑推理（Chain-of-Thought）能力。
Wikipedia	4.5%	2.45	83 GB	事实知识库。包含 20 种语言的高密度知识。2.45 个 Epoch 意味着这些核心知识被模型“复习”了两遍半。
Books (Gutenberg & Books3)	4.5%	2.23	85 GB	长程依赖与叙事。书籍文本提供了长上下文和复杂的叙事结构，有助于提升模型的语言连贯性。
ArXiv	2.5%	1.06	92 GB	科学推理。包含大量 LaTeX 公式和科学论证，赋予模型 STEM 领域的专业能力。
Stack Exchange	2.0%	1.03	78 GB	问答与解题。包含人类解决问题的思维过程，按分数排序确保了高质量的“思维链”样本。

3.2 深度数据清洗：CCNet Pipeline

占据 67% 权重的 Common Crawl 数据的质量直接决定了模型的底色。LLaMA 复用了 CCNet 的处理流程 1，这是一个工业级的数据清洗管道，其底层原理包含三个关键步骤：

去重（Deduplication）：
- 行级去重：删除重复的行。互联网文本中包含大量的导航栏、版权声明等重复且无意义的文本。
- 段落级/文件级去重：防止模型“背诵”特定文本。研究表明，重复数据会导致模型过拟合，降低零样本泛化能力。
语言识别（Language Identification）：
- 使用 fastText 线性分类器移除非英语网页。虽然这主要是一个英语模型，但 Wikipedia 部分保留了 20 种语言，保证了基本的跨语言能力。
质量过滤（Quality Filtering）：
- N-gram 语言模型：使用一个在高质量文本（如 Wikipedia）上训练的语言模型来评估网页内容的“困惑度”（Perplexity）。如果一个网页的文本对于该模型来说极其“意外”（困惑度过高），通常意味着乱码或低质量文本；如果困惑度过低，则可能是重复的垃圾文本。
- 引用分类器（Reference Classifier）：这是一个非常巧妙的设计。作者训练了一个线性模型，用来区分“Wikipedia 引用页”和“随机网页”。如果在 Wikipedia 中被引用的网页被视为高质量，那么模型会保留那些与这些引用页特征相似的网页，丢弃特征差异大的。这意味着 Wikipedia 充当了“质量锚点” 。

3.3 Tokenizer（分词器）的底层原理与数字处理

LLaMA 使用了基于 Byte-Pair Encoding (BPE) 算法的 SentencePiece 实现。

BPE 算法原理：

BPE 是一种介于字符级（Character-level）和词级（Word-level）之间的子词（Subword）分词方法。

初始化：从字符开始。
统计：统计语料库中所有相邻字符对的出现频率。
合并：将频率最高的字符对合并成一个新的符号（Token）。
迭代：重复上述过程，直到词表大小达到预设值（LLaMA 为 32k）。

LLaMA 的特殊设计：数字分割（Digit Splitting）

LLaMA 的分词器有一个关键的细节设计：将所有数字拆分为独立的数字 Token。

传统分词：2023 可能被作为一个整体 Token 2023，或者 20 和 23。这导致模型在面对未见过的数字时，难以理解其数值含义。
LLaMA 分词：2023 -> 2, 0, 2, 3。
底层原理：这种处理方式使得模型能够学习到数学运算中的位值原理（Place Value System）。例如，在加法运算中，模型可以学习到“个位加个位，进位到十位”的通用规则，而不是记忆特定数字的加法表。这显著解释了为什么 LLaMA 在数学推理任务（如 GSM8k）上表现优异 1。

UTF-8 字节回退（Byte Fallback）：

对于词表中不存在的罕见字符（如生僻字或特殊符号），SentencePiece 会将其分解为 UTF-8 字节。这确保了模型永远不会遇到（未知词）标记，理论上可以处理任何 Unicode 字符串，增强了模型的鲁棒性。

4. 架构解析：Transformer 的现代化改进

LLaMA 的模型架构基于 Transformer（Vaswani et al., 2017），但它并非简单的复制。它集成了自 2017 年以来 NLP 社区探索出的多种架构优化，主要包括 Pre-normalization (RMSNorm)、SwiGLU 激活函数 和 Rotary Embeddings (RoPE)。这些改进共同提升了模型的训练稳定性、收敛速度和长文本处理能力。

4.1 Pre-normalization 与 RMSNorm：稳定性的基石

4.1.1 Pre-normalization（前置归一化）

原始 Transformer 使用的是 Post-normalization，即在残差连接（Residual Connection）之后进行 LayerNorm：

xl+1=LayerNorm(xl+Sublayer(xl))x_{l+1} = \text{LayerNorm}(x_l + \text{Sublayer}(x_l))xl+1=LayerNorm(xl+Sublayer(xl))

这种设计在深层网络中容易导致梯度消失或爆炸，因为梯度必须经过非线性的 LayerNorm 才能传播到前面的层，使得模型训练初期的 Warmup 阶段极其脆弱。

LLaMA 采用了 GPT-3 验证过的 Pre-normalization：

xl+1=xl+Sublayer(RMSNorm(xl))x_{l+1} = x_l + \text{Sublayer}(\text{RMSNorm}(x_l))xl+1=xl+Sublayer(RMSNorm(xl))

原理：在进入子层（Attention 或 FFN）之前先进行归一化。这使得残差连接路径（xlx_lxl）保持了一条干净的“高速公路”，梯度可以直接无损地反向传播到最底层。这极大地提升了深层网络的训练稳定性，允许使用更大的学习率。

4.1.2 RMSNorm（均方根归一化）

LLaMA 用 RMSNorm 替换了标准的 LayerNorm。这是对计算效率的极致追求 6。

标准 LayerNorm 的计算：

需要计算均值 μ\muμ 和方差 σ2\sigma^2σ2，然后进行中心化（Centering）和缩放（Scaling）：

xˉi=xi−μσ⋅γ+β\bar{x}_i = \frac{x_i - \mu}{\sigma} \cdot \gamma + \betaxˉi=σxi−μ⋅γ+β

这意味着需要对每个 Token 的向量进行两次遍历（一次求和算均值，一次求平方和算方差）。
RMSNorm 的数学原理：

RMSNorm（Zhang & Sennrich, 2019）基于一个观察：LayerNorm 的主要贡献来自于缩放不变性（Rescaling Invariance），而平移不变性（由减去均值 μ\muμ 提供）并不重要。因此，RMSNorm 省去了计算均值和减均值的步骤，仅利用均方根（RMS）进行缩放：

RMS(x)=1d∑i=1dxi2+ϵ\text{RMS}(x) = \sqrt{\frac{1}{d} \sum_{i=1}^d x_i^2 + \epsilon}RMS(x)=d1∑i=1dxi2+ϵ

xˉi=xiRMS(x)⋅γi\bar{x}_i = \frac{x_i}{\text{RMS}(x)} \cdot \gamma_ixˉi=RMS(x)xi⋅γi

注意，这里没有偏置项 β\betaβ。
优势：
1. 计算节省：减少了计算量，尤其是在 GPU 上，减少了 synchronization overhead（同步开销）。
2. 梯度性质：理论分析表明，RMSNorm 在某些情况下能提供更稳定的梯度，防止激活值过大。

4.2 SwiGLU 激活函数：非线性的升维打击

在 Transformer 的前馈网络（FFN）中，LLaMA 使用了 SwiGLU（Shazeer, 2020），取代了标准的 ReLU 1。

4.2.1 从 ReLU 到 SwiGLU 的演进

ReLU (max⁡(0,x)\max(0, x)max(0,x))：简单，但在 x<0x<0x<0 时梯度为 0（Dying ReLU），导致神经元“死亡”。
GELU (xΦ(x)x \Phi(x)xΦ(x))：GPT-3 使用，引入了概率平滑，解决了负区间梯度问题。
Swish (x⋅sigmoid(βx)x \cdot \text{sigmoid}(\beta x)x⋅sigmoid(βx))：Google 提出，具有非单调性，效果优于 ReLU。
GLU (Gated Linear Unit)：引入门控机制，控制信息流。

4.2.2 SwiGLU 的数学形式

SwiGLU 是 Swish 激活函数与 GLU 门控机制的结合。

标准 Transformer FFN：

FFN(x)=ReLU(xW1+b1)W2+b2\text{FFN}(x) = \text{ReLU}(xW_1 + b_1)W_2 + b_2FFN(x)=ReLU(xW1+b1)W2+b2

LLaMA 的 SwiGLU FFN：

FFNSwiGLU(x)=(Swish(xWG)⊙(xWin))Wout\text{FFN}_{\text{SwiGLU}}(x) = (\text{Swish}(xW_G) \odot (xW_{in})) W_{out}FFNSwiGLU(x)=(Swish(xWG)⊙(xWin))Wout

这里 ⊙\odot⊙ 代表逐元素乘法（Element-wise product）。

xWinxW_{in}xWin：是一条线性变换路径（Linear Path）。
xWGxW_GxWG：是一条门控路径（Gating Path），经过 Swish 激活函数后，变成一个“软门”（Soft Gate），控制线性路径的信息通过量。

4.2.3 为什么 SwiGLU 更强？

可学习的门控：SwiGLU 允许网络根据上下文动态调整信息的通过率。这类似于 LSTM 中的门控机制，增强了模型的表达能力。
梯度的丰富性：Swish 函数的导数是非单调的，且在负区间非零。这意味着即使输入是负的，梯度也能反向传播，且不同的输入值会有不同强度的梯度响应，丰富了学习信号 12。
参数调整：由于 GLU 引入了两个权重矩阵（WGW_GWG 和 WinW_{in}Win），为了保持参数总量与标准 Transformer 一致，LLaMA 将隐藏层维度（Hidden Dimension）从 4d4d4d 减少到了 234d\frac{2}{3} 4d324d。实验证明，即便参数量相同，SwiGLU 的效果依然显著优于 ReLU 和 GELU。

4.3 Rotary Positional Embeddings (RoPE)：优雅的相对位置编码

位置编码是 Transformer 架构中最令人头疼的部分，因为 Self-Attention 本身无法感知位置。LLaMA 采用了 RoPE（Su et al., 2021），这是一种基于复数旋转的数学技巧，被公认为是目前最佳的位置编码方案。

4.3.1 绝对位置编码的局限

GPT-3 使用的可学习绝对位置编码（Learned Absolute PE）直接将位置向量加到词向量上：xi=xi+pix_i = x_i + p_ixi=xi+pi。

缺陷：模型在训练时见过最长 2048 的位置，推理时就无法处理第 2049 个 Token，因为 p2049p_{2049}p2049 从未被训练过。外推性（Extrapolation）极差。

4.3.2 RoPE 的数学直觉

RoPE 的核心思想是：通过旋转词向量的角度来注入位置信息。

假设我们将词向量的每两个维度 (x1,x2)(x_1, x_2)(x1,x2) 视为复平面上的一个复数 z=x1+ix2z = x_1 + i x_2z=x1+ix2。

对于位置 mmm，RoPE 将这个复数乘以一个旋转因子 eimθe^{im\theta}eimθ：

z′=z⋅eimθz' = z \cdot e^{im\theta}z′=z⋅eimθ根据欧拉公式 eiθ=cos⁡θ+isin⁡θe^{i\theta} = \cos \theta + i \sin \thetaeiθ=cosθ+isinθ，这等价于在二维平面上应用旋转矩阵：(x1′x2′)=(cos⁡mθ−sin⁡mθsin⁡mθcos⁡mθ)(x1x2)\begin{pmatrix} x'_1 \\ x'_2 \end{pmatrix} = \begin{pmatrix} \cos m\theta & -\sin m\theta \\ \sin m\theta & \cos m\theta \end{pmatrix} \begin{pmatrix} x_1 \\ x_2 \end{pmatrix}(x1′x2′)=(cosmθsinmθ−sinmθcosmθ)(x1x2)

4.3.3 相对位置的自然涌现

为什么旋转能编码相对位置？

当我们计算两个 Token（位置 mmm 的 Query qqq 和位置 nnn 的 Key kkk）的注意力分数（内积）时：

Score(qm,kn)=(Rmq)T(Rnk)=qTRmTRnk\text{Score}(q_m, k_n) = (R_m q)^T (R_n k) = q^T R_m^T R_n kScore(qm,kn)=(Rmq)T(Rnk)=qTRmTRnk

根据旋转矩阵的性质，旋转 mmm 度再反向旋转 mmm 度等于不旋转；而 RmTR_m^TRmT 正是 RmR_mRm 的逆矩阵。

RmTRn=R−mRn=Rn−mR_m^T R_n = R_{-m} R_n = R_{n-m}RmTRn=R−mRn=Rn−m因此：Score(qm,kn)=qTRn−mk\text{Score}(q_m, k_n) = q^T R_{n-m} kScore(qm,kn)=qTRn−mk

结论：注意力分数只取决于 n−mn-mn−m（即两个 Token 的相对距离），而与绝对位置 mmm 和 nnn 无关！

4.3.4 RoPE 的优势

完美的外推性：理论上，只要旋转规则确定，模型可以处理任意长度的序列（尽管实际效果受限于注意力机制的注意力窗口）。
长程衰减：RoPE 具有自然的长程衰减特性，即随着相对距离 ∣n−m∣|n-m|∣n−m∣ 的增加，注意力分数会自然减小（对于高频分量），这符合语言模型的直觉（离得越远的词关系越弱）15。
乘性耦合：位置信息通过旋转“乘”入向量，与 Attention 的点积操作深度融合，比加性位置编码更平滑。

5. 优化器与高效训练：工程实现的艺术

训练一个 65B 参数、1.4T Token 的模型是一项浩大的系统工程。LLaMA 在优化器选择和系统实现上做出了精细的权衡。

5.1 AdamW 优化器与权重衰减解耦

LLaMA 使用 AdamW 优化器，超参数设置为 β1=0.9,β2=0.95\beta_1=0.9, \beta_2=0.95β1=0.9,β2=0.95 1。

为什么是 AdamW 而不是 Adam？

这是一个关于 L2 正则化（L2 Regularization）与权重衰减（Weight Decay）的微妙区别。

Adam 的问题：在 Adam 中，标准的 L2 正则化是直接加到梯度上的：gt=∇f(x)+λxg_t = \nabla f(x) + \lambda xgt=∇f(x)+λx。然而，Adam 会根据梯度的历史平方和 vtv_tvt 来调整学习率。这意味着，L2 正则化的项 λx\lambda xλx 也会被这个自适应学习率缩放。结果是，对于梯度变化大的参数，正则化力度变小了；对于梯度变化小的参数，正则化力度变大了。这并非我们想要的。
AdamW 的解决方案：AdamW 将权重衰减从梯度更新中解耦（Decoupled）。它在执行完 Adam 的自适应梯度更新后，独立地对权重进行衰减：

θt+1=θt−η(AdamUpdate)−ηλθt\theta_{t+1} = \theta_t - \eta (\text{AdamUpdate}) - \eta \lambda \theta_tθt+1=θt−η(AdamUpdate)−ηλθt

这种解耦确保了权重衰减以恒定的速率作用于所有参数，提升了模型的泛化能力，尤其是在长周期训练中。

5.2 学习率调度：Cosine Annealing

LLaMA 采用了余弦退火（Cosine Annealing）策略：

Warmup：前 2000 步线性增加学习率。这有助于在训练初期稳定模型，防止梯度爆炸。
Cosine Decay：随后学习率按余弦曲线下降，直到最终衰减为最大学习率的 10%。
- 优势：相比于阶梯式衰减（Step Decay），余弦曲线更加平滑。它在训练中期保持较高的学习率，允许模型在参数空间中进行广泛的探索（Exploration）；在后期缓慢下降，进行精细的开发（Exploitation），通常能收敛到更优的局部极小值 19。

5.3 高效训练的“魔法”：xformers 与 Gradient Checkpointing

为了在 2048 张 A100 GPU 上在 21 天内完成训练，LLaMA 必须解决显存墙（Memory Wall）和计算墙的问题。

内存高效注意力（Memory-efficient Attention）

LLaMA 使用了 Meta 的 xformers 库。

标准 Attention 瓶颈：计算 QKTQ K^TQKT 会生成一个 N×NN \times NN×N 的注意力矩阵（NNN 为序列长度）。对于 N=2048N=2048N=2048，这个矩阵非常大，且显存占用随 NNN 平方增长 O(N2)O(N^2)O(N2)。
xformers 优化：基于 FlashAttention (Dao et al., 2022) 的原理，它不显式存储这个巨大的注意力矩阵。通过分块（Tiling）技术，它在 GPU 的 SRAM（高速缓存）中计算局部的 Attention Score，更新输出后立即丢弃中间结果。这不仅将显存复杂度降为 O(N)O(N)O(N)，还通过减少对 HBM（高带宽内存）的读写次数，显著提升了计算速度 1。
梯度检查点（Gradient/Activation Checkpointing）

为了训练 65B 这样的大模型，单卡 80GB 显存依然捉襟见肘。LLaMA 使用了梯度检查点技术。

原理：在标准反向传播中，必须保存所有层的激活值（Activations）以计算梯度。Checkpointing 策略是：只保存部分关键层（如 Transformer Layer 的边界）的激活值，丢弃中间层的激活值。当反向传播需要用到丢弃的激活值时，重新计算前向传播。
代价与收益：这是一种“时间换空间”的策略。虽然计算量增加了（约 20-30%），但显存占用大幅下降（可达 L\sqrt{L}L），使得可以使用更大的 Batch Size（LLaMA 使用了 4M Token 的超大 Batch），从而提升了整体的训练吞吐量和稳定性。

6. 实验结果深度分析：小模型的逆袭

LLaMA 的实验结果是其设计哲学的直接验证。论文在 Zero-shot 和 Few-shot 设置下对比了 GPT-3、Gopher、Chinchilla 和 PaLM。

6.1 常识推理与问答：GPT-3 的落败

在 BoolQ, PIQA, SIQA 等 8 个常识推理基准测试中：

LLaMA-13B vs GPT-3：LLaMA-13B（130 亿参数）在大多数任务上超越了 GPT-3（1750 亿参数）。
- 深度解读：这是一个里程碑式的结果。它证明了 GPT-3 存在严重的“训练不足”。GPT-3 仅训练了 300B Token，而 LLaMA-13B 训练了 1T Token。这表明，知识密度（每参数包含的信息量）比单纯的参数数量更重要。LLaMA-13B 就像一个虽然脑容量较小，但阅读量极其丰富且消化吸收极好的学生，战胜了一个脑容量巨大但读书不多的学生。

6.2 数学与代码能力：数据工程的胜利

在 MATH 和 GSM8k（数学应用题）基准上，LLaMA 表现优异。

GSM8k：LLaMA-65B 的得分甚至超过了专门针对数学微调过的 Minerva-62B 模型。
归因：这主要归功于两点设计：
1. 分词器改进：如前所述，数字分割让模型理解了算术原理。
2. 代码数据：Github 代码数据的引入。代码具有严密的逻辑和控制流，学习代码能显著增强模型的逻辑推理（Reasoning）能力，这种能力迁移到了数学解题上。

6.3 训练过程的非单调性（Non-monotonicity）

论文图 2 展示了一个有趣的现象：在训练过程中，虽然 Training Loss 是一直下降的，但在某些下游任务（如 SIQA, WinoGrande）上，性能并没有稳步提升，甚至出现了剧烈的波动。

启示：这表明预训练的困惑度（Perplexity）与特定下游任务的性能之间并非总是强相关的。模型可能在学习语言模式的同时，暂时“遗忘”或是“混淆”了某些特定的推理模式。这提醒我们在评估 LLM 时，不能仅依赖 Loss 曲线，必须进行周期性的全面 Benchmark 评估。

7. 安全性、偏见与伦理：硬币的背面

LLaMA 论文并没有回避大模型的负面影响。作者使用了多个基准来评估模型的毒性（Toxicity）和偏见（Bias）。

7.1 毒性评估：RealToxicityPrompts

该测试使用 Perspective API 来评分模型生成的续写内容的毒性。

结果：LLaMA-65B 的毒性分数高于 LLaMA-7B。
深度解读（能力诅咒）：这是一个反直觉但普遍存在的现象。模型越大，拟合能力越强，就越能“完美”地学到训练数据中的脏话、仇恨言论和攻击性模式。大模型更“懂”得如何进行攻击，因此在诱导下会生成更具毒性的内容。这表明单纯扩大模型规模无法解决安全问题，必须引入 RLHF（基于人类反馈的强化学习）等对齐技术。

7.2 偏见评估：CrowS-Pairs

CrowS-Pairs 数据集通过对比模型对“刻板印象句”和“反刻板印象句”的困惑度（Perplexity）来衡量偏见。

原理：如果模型认为“女人拒绝了男人的求婚”比“男人拒绝了女人的求婚”更“令人惊讶”（困惑度更高），则说明模型存在性别刻板印象。
结果：LLaMA 在宗教类别的偏见得分较高（+10% 相比 OPT-175B），这可能源于 CommonCrawl 数据中包含大量带有宗教偏见的网络讨论。

8. 总结与未来展望

LLaMA-1 的发布是开源 LLM 历史上的一个转折点。它不仅提供了一组高性能的 Base Model，更重要的是它验证了一套新的最佳实践（Best Practices）：

数据为王：在推理预算受限时，大幅增加训练数据量（Overtraining）是提升性能的最佳路径。
架构微调：Pre-RMSNorm、SwiGLU 和 RoPE 的组合成为了后续模型（如 LLaMA 2/3, Mistral, Qwen）的事实标准。
开放科学：通过证明仅用公开数据即可达到 SOTA，LLaMA 打破了私有数据的壁垒，激励了全球开源社区的爆发式创新。

对于精读这篇论文的读者来说，理解 LLaMA 不仅仅是理解一个模型，更是理解**工程权衡（Trade-offs）**的艺术——如何在训练成本、推理效率、模型性能和显存限制之间找到那个完美的平衡点。LLaMA 正是这个平衡点的杰作。

周记Week9

小yo — Sun, 14 Dec 2025 22:28:47 GMT

这周终于是把minimind模型的相关实验做完了，下周准备线下汇报了，好好准备，争取通过考核。

这周看了《古田军号》、《大决战之辽沈战役》，对革命故事情有独钟，实在佩服前辈们的意志。

周日还去KTV待了三个小时，忙了一个学期了，也该出去嗨一下放松一下，接下来就得投入期末的复习中啦。

加油加油！

周记Week8

小yo — Sun, 07 Dec 2025 17:52:22 GMT

这周一直在忙于实验室的考核，从读代码到上手实践，最大的感触就是一定要主动接触新技术，不要被已有技术故步自封，不然真的要付出很多时间空间代价，得不偿失。

由于任务繁多，自然是疏于锻炼了，接下来马上进入期末周了，时间更加紧张，希望能平衡好吧。

不多说了，小yo最近在规划一次特别的跨年活动，嘿嘿，31号见！

Python数据分析-数据可视化

小yo — Sun, 30 Nov 2025 21:45:54 GMT

matplotlib

折线图

import matplotlib.pyplot as plt
from matplotlib import rcParams # 字体
rcParams['font.family'] = 'SimHei'

# 创建图表，设置大小
plt.figure(figsize=(10,5))

# 要绘图的数据
month=["1月","2月","3月","4月"]
sales=[100,150,80,130]
# 绘制折线图
plt.plot(month,sales,
        label='产品A',color='orange',
        linewidth=2,
        linestyle='--',
        marker='o') # （x,y）
# 添加标题
plt.title("2025年销售趋势",color='red',fontsize=20)
# 添加坐标轴标签
plt.xlabel('月份',fontsize=10)
plt.ylabel('销售额（万元）',fontsize=10)
# 添加图例
plt.legend(loc='upper left')
# 添加网格线
plt.grid(True,alpha=0.1,color='blue',linestyle='--') # True使得两个方向的格子都有;alpha控制透明度
# plt.grid(axis='y') 只有横向的格子
# 设置刻度字体大小
plt.xticks(rotation=20,fontsize=15) # rotation控制字体旋转角度
# 设置y轴范围
plt.ylim(0,160)
# 在每个数据点上显示数值
for x,y in zip(month,sales):
    plt.text(x,y+1,str(y),ha='center',va='bottom',fontsize=10)
    # plt.text(x位置,y位置,显式内容,水平排列方式,垂直排列方式，字体大小)
# 


# 显式图表
plt.show()

柱状图

# 创建图表，设置大小
plt.figure(figsize=(10,5))

# 要绘图的数据
subjects=['语文','数学','英语','科学']
scores=[85,92,78,88]
# 绘制柱状图
plt.bar(subjects,scores,
       label='小红',
       color='orange',
       width=0.6)
# 添加标题
plt.title("小红2025年成绩分布",color='red',fontsize=20)
# 添加坐标轴标签
plt.xlabel('科目',fontsize=10)
plt.ylabel('分数',fontsize=10)
# 添加图例
plt.legend(loc='upper right')
# 添加网格线
plt.grid(axis='y',alpha=0.1,color='blue',linestyle='--') 

# 设置刻度字体大小
plt.xticks(rotation=20,fontsize=15) # rotation控制字体旋转角度
# 设置y轴范围
plt.ylim(0,100)
# 在每个数据点上显示数值
for x,y in zip(subjects,scores):
    plt.text(x,y+1,str(y),ha='center',va='bottom',fontsize=10)
    # plt.text(x位置,y位置,显式内容,水平排列方式,垂直排列方式，字体大小)
# 自动优化排版
plt.tight_layout()


# 显式图表
plt.show()

条形图

# 创建图表，设置大小
plt.figure(figsize=(10,5))

# 要绘图的数据
countries=['United States','China','Japan','Germany','India']
gdp=[95,92,48,30,4]
# 绘制条形图
plt.barh(countries,gdp)
# 添加标题
plt.title("2025年GDP排名",color='red',fontsize=20)
# 添加坐标轴标签
plt.xlabel('GDP',fontsize=10)
plt.ylabel('国家',fontsize=10)


# 显式图表
plt.show()

饼图

# 创建图表，设置大小
plt.figure(figsize=(10,5))

# 要绘图的数据
things = ['学习','娱乐','运动','睡觉','其他']
times=[6,4,1,8,5]
colors=['#66b3ff','#99ff99','#ffcc99','#ff9999','#ff4499'] # 配色方案
# 绘制饼图
plt.pie(times,labels=things,
       autopct='%.1f%%', # 显式百分比
       startangle=90, # 调整初始画图的角度
       colors = colors 
       )
# 添加标题
plt.title("一天的时间分布",color='red',fontsize=20)
# 自动优化排版
plt.tight_layout()


# 显式图表
plt.show()

环形图

# 创建图表，设置大小
plt.figure(figsize=(10,5))

# 要绘图的数据
things = ['学习','娱乐','运动','睡觉','其他']
times=[6,4,1,8,5]
colors=['#66b3ff','#99ff99','#ffcc99','#ff9999','#ff4499'] # 配色方案
# 绘制环形图
plt.pie(times,labels=things,
       autopct='%.1f%%', # 显式百分比
       startangle=90, # 调整初始画图的角度
       colors = colors, # 设置配色
       wedgeprops={'width':0.5}, # 设置圆环的宽度
       pctdistance=0.8 # 设置百分数显示的位置
       )
# 添加标题
plt.title("一天的时间分布",color='red',fontsize=20)
# 在圆环中心添加内容
plt.text(0,0,'总计：100%',ha='center')
# 自动优化排版
plt.tight_layout()


# 显式图表
plt.show()

爆炸式饼图

# 创建图表，设置大小
plt.figure(figsize=(10,5))

# 要绘图的数据
things = ['学习','娱乐','运动','睡觉','其他']
times=[6,4,1,8,5]
colors=['#66b3ff','#99ff99','#ffcc99','#ff9999','#ff4499'] # 配色方案
explode=[0.1,0,0,0,0] # 设置突出块位置
# 绘制
plt.pie(times,labels=things,
       autopct='%.1f%%', # 显式百分比
       startangle=0, # 调整初始画图的角度
       colors = colors, # 设置配色
       explode=explode, # 设置突出块
       shadow =True, # 设置阴影
       )
# 添加标题
plt.title("一天的时间分布",color='red',fontsize=20)

# 自动优化排版
plt.tight_layout()


# 显式图表
plt.show()

散点图

import random
# 创建图表，设置大小
plt.figure(figsize=(10,5))

# 要绘图的数据
x=[]
y=[]
for i in range(100):
    tmp = random.uniform(0,10)
    x.append(tmp)
    tmp2 = 2*tmp + random.gauss(-1,1)
    y.append(tmp2)
# 绘制散点图
plt.scatter(x,y,
           color='blue',
           alpha=0.5,
           s=20, # 设置圆点大小
           label='数据' 
           )
# 添加标题
plt.title("x与y的关系",color='red',fontsize=20)
# 添加坐标轴标签
plt.xlabel('x',fontsize=10)
plt.ylabel('y',fontsize=10)
# 添加图例
plt.legend(loc='upper left')
# 添加网格线
plt.grid(True,alpha=0.1,color='blue',linestyle='--') # True使得两个方向的格子都有;alpha控制透明度
# plt.grid(axis='y') 只有横向的格子
# 设置刻度字体大小
plt.xticks(rotation=20,fontsize=15) # rotation控制字体旋转角度
# 设置y轴范围
plt.ylim(-2,25)

# 添加一条直线
plt.plot([0,10],[0,20],color='red')

# 显式图表
plt.show()

箱线图

# 模拟 3 门课的成绩
data = {
    '语文': [82, 85, 88, 70, 90, 76, 84, 83, 95],
    '数学': [75, 80, 79, 93, 88, 82, 87, 89, 92],
    '英语': [70, 72, 68, 65, 78, 80, 85, 90, 95]
}

plt.figure(figsize=(8,6))
plt.boxplot(data.values(),labels=data.keys())

plt.title('各科成绩分布（箱线图）')
plt.ylabel("分数")
plt.grid(True,axis='y',linestyle='--',alpha=0.5)
plt.show()

# 多个图的绘制方法
# 要绘图的数据
month = ['1','2','3','4']
sales = [100,150,80,130]

# 动态图表的生成
# f1 = plt.subplot(2,2,1) #生成一个子图 行 列 索引
f1 = plt.subplot(221) #生成一个子图 行 列 索引
f1.plot(month,sales)
f2 = plt.subplot(2,2,2)
f2.bar(month,sales)
f3 = plt.subplot(2,2,3)
f3.scatter(month,sales)
f4 = plt.subplot(224)
f4.barh(month,sales)

<BarContainer object of 4 artists>

seaborn

import seaborn as sns
import pandas as pd

penguins = pd.read_csv('penguins.csv')

penguins.dropna(inplace=True)
penguins.head()

vertical-align: top; } .dataframe thead th { text-align: right; }

	species	island	bill_length_mm	bill_depth_mm	flipper_length_mm	body_mass_g	sex
0	Adelie	Torgersen	39.1	18.7	181.0	3750.0	Male
1	Adelie	Torgersen	39.5	17.4	186.0	3800.0	Female
2	Adelie	Torgersen	40.3	18.0	195.0	3250.0	Female
4	Adelie	Torgersen	36.7	19.3	193.0	3450.0	Female
5	Adelie	Torgersen	39.3	20.6	190.0	3650.0	Male

# 直方图
sns.histplot(data=penguins,x='species')

<Axes: xlabel='species', ylabel='Count'>

# 核密度估计图
sns.kdeplot(data=penguins,x='bill_length_mm')

<Axes: xlabel='bill_length_mm', ylabel='Density'>

sns.histplot(data=penguins,x='bill_length_mm',kde=True)

<Axes: xlabel='bill_length_mm', ylabel='Count'>

# 计数图
sns.countplot(data=penguins,x='island')

<Axes: xlabel='island', ylabel='count'>

# 散点图
sns.scatterplot(data=penguins,x='body_mass_g',
               y='flipper_length_mm',
               hue='sex', # 按sex来分类
               )

<Axes: xlabel='body_mass_g', ylabel='flipper_length_mm'>

# 蜂窝图
sns.jointplot(data=penguins,x='body_mass_g',
             y='flipper_length_mm',kind='hex')

<seaborn.axisgrid.JointGrid at 0x1e6d16bc8b0>

#二维核密度估计图
#通过kdeplot()函数，同时设置x参数和y参数来绘制二维核密度估计图。
sns.kdeplot(data=penguins, x="body_mass_g", y="flipper_length_mm")

<Axes: xlabel='body_mass_g', ylabel='flipper_length_mm'>

#通过fill=True设置为填充，通过cbar=True设置显示颜色示意条。
sns.kdeplot(data=penguins, x="body_mass_g", y="flipper_length_mm", fill=True, cbar=True)

<Axes: xlabel='body_mass_g', ylabel='flipper_length_mm'>

#条形图
sns.barplot(data=penguins, x="species", y="bill_length_mm", estimator="mean", errorbar=None)

<Axes: xlabel='species', ylabel='bill_length_mm'>

#箱线图
sns.boxplot(data=penguins, x="species", y="bill_length_mm")

<Axes: xlabel='species', ylabel='bill_length_mm'>

#小提琴图
'''小提琴图（Violin Plot） 是一种结合了箱线图和核密度估计图（KDE）的可视化图表，用于展示数据的分布情况、集中趋势、散布情况以及异常值。小提琴图不仅可以显示数据的基本统计量（如中位数和四分位数），还可以展示数据的概率密度，提供比箱线图更丰富的信息。'''
sns.violinplot(data=penguins, x="species", y="bill_length_mm")

<Axes: xlabel='species', ylabel='bill_length_mm'>

#成对关系图
'''成对关系图是一种用于显示多个变量之间关系的可视化工具。它可以展示各个变量之间的成对关系，并且通过不同的图表形式帮助我们理解数据中各个变量之间的相互作用。
对角线上的图通常显示每个变量的分布（如直方图或核密度估计图），帮助观察每个变量的单变量特性。其他位置展示所有变量的两两关系，用散点图表示。'''
sns.pairplot(data=penguins, hue="species")

<seaborn.axisgrid.PairGrid at 0x1e6d2d6b400>

Python数据分析-数据分析方法

小yo — Sun, 30 Nov 2025 21:45:48 GMT

数据导入与导出

import numpy as np
import pandas as pd

# 数据导入
df = pd.read_csv("data.csv")

print(df.head())
print(type(df))

   Unnamed: 0  Epoch  Train_Loss  Train_Acc  Val_Loss  Val_Acc
0           0      1    1.378301   0.496378  1.138243   0.5956
1           1      2    0.913497   0.673756  0.876917   0.7026
2           2      3    0.714228   0.748956  0.672718   0.7590
3           3      4    0.598144   0.792978  0.625913   0.7864
4           4      5    0.527811   0.817778  0.536250   0.8182
<class 'pandas.core.frame.DataFrame'>

print(df.Train_Acc.mean())

0.8865800000000001

# 数据的导出
df1= df.tail()
df.to_csv("new.csv")

# json文件
df2 = pd.read_json("E:\\mytheme\\package.json")
print(df2.head())

            name    type version                   scripts dependencies  \
dev      vhastro  module   0.0.1                 astro dev          NaN   
build    vhastro  module   0.0.1               astro build          NaN   
preview  vhastro  module   0.0.1             astro preview          NaN   
astro    vhastro  module   0.0.1                     astro     ^5.13.10   
newpost  vhastro  module   0.0.1  node ./script/newpost.js          NaN   

        devDependencies pnpm  
dev                 NaN  NaN  
build               NaN  NaN  
preview             NaN  NaN  
astro               NaN  NaN  
newpost             NaN  NaN

数据清洗

# 缺失值的处理
s = pd.Series([1,2,np.nan,None,pd.NA])
print(s)

0       1
1       2
2     NaN
3    None
4    <NA>
dtype: object

# 查看是否是缺失值
print(s.isna())

0    False
1    False
2     True
3     True
4     True
dtype: bool

print(s.isnull())

0    False
1    False
2     True
3     True
4     True
dtype: bool

print(df.isna())

    Unnamed: 0  Epoch  Train_Loss  Train_Acc  Val_Loss  Val_Acc
0        False  False       False      False     False    False
1        False  False       False      False     False    False
2        False  False       False      False     False    False
3        False  False       False      False     False    False
4        False  False       False      False     False    False
5        False  False       False      False     False    False
6        False  False       False      False     False    False
7        False  False       False      False     False    False
8        False  False       False      False     False    False
9        False  False       False      False     False    False
10       False  False       False      False     False    False
11       False  False       False      False     False    False
12       False  False       False      False     False    False
13       False  False       False      False     False    False
14       False  False       False      False     False    False
15       False  False       False      False     False    False
16       False  False       False      False     False    False
17       False  False       False      False     False    False
18       False  False       False      False     False    False
19       False  False       False      False     False    False
20       False  False       False      False     False    False
21       False  False       False      False     False    False
22       False  False       False      False     False     True
23       False  False       False      False     False    False
24       False  False       False      False     False    False
25       False  False       False      False     False    False
26       False  False       False      False     False    False
27       False  False        True      False     False    False
28       False  False       False      False      True    False
29       False  False       False      False     False    False

print(df.isna().sum()) # 查看缺失值的个数

Unnamed: 0    0
Epoch         0
Train_Loss    1
Train_Acc     0
Val_Loss      1
Val_Acc       1
dtype: int64

# 剔除缺失值
print(s.dropna())
print(df.dropna()) # 删掉一整条记录

0    1
1    2
dtype: object
    Unnamed: 0  Epoch  Train_Loss  Train_Acc  Val_Loss  Val_Acc
0            0      1    1.378301   0.496378  1.138243   0.5956
1            1      2    0.913497   0.673756  0.876917   0.7026
2            2      3    0.714228   0.748956  0.672718   0.7590
3            3      4    0.598144   0.792978  0.625913   0.7864
4            4      5    0.527811   0.817778  0.536250   0.8182
5            5      6    0.473939   0.835600  0.582652   0.8072
6            6      7    0.432094   0.848644  0.468109   0.8388
7            7      8    0.393686   0.864111  0.429461   0.8552
8            8      9    0.356874   0.876356  0.500846   0.8360
9            9     10    0.333076   0.883822  0.446606   0.8488
10          10     11    0.310424   0.891867  0.395992   0.8662
11          11     12    0.284330   0.900867  0.395248   0.8714
12          12     13    0.267211   0.904689  0.466472   0.8512
13          13     14    0.252369   0.912067  0.357027   0.8788
14          14     15    0.225934   0.920222  0.326612   0.8886
15          15     16    0.215926   0.924067  0.329903   0.8930
16          16     17    0.200772   0.930667  0.407676   0.8770
17          17     18    0.191555   0.932378  0.344014   0.8890
18          18     19    0.177961   0.936844  0.362166   0.8850
19          19     20    0.170277   0.940867  0.306026   0.8990
20          20     21    0.158309   0.944289  0.448888   0.8664
21          21     22    0.145230   0.948644  0.330578   0.9014
23          23     24    0.133425   0.952511  0.363670   0.8928
24          24     25    0.123354   0.956467  0.411105   0.8836
25          25     26    0.120446   0.957178  0.335317   0.9038
26          26     27    0.111692   0.960667  0.400440   0.8964
29          29     30    0.094147   0.965889  0.331762   0.9028

print(df.dropna(how = "all")) # 如果全都是缺失值才删除这一行
print(df.dropna(thresh=2)) # 如果至少有n个不是缺失值。就保留

    Unnamed: 0  Epoch  Train_Loss  Train_Acc  Val_Loss  Val_Acc
0            0      1    1.378301   0.496378  1.138243   0.5956
1            1      2    0.913497   0.673756  0.876917   0.7026
2            2      3    0.714228   0.748956  0.672718   0.7590
3            3      4    0.598144   0.792978  0.625913   0.7864
4            4      5    0.527811   0.817778  0.536250   0.8182
5            5      6    0.473939   0.835600  0.582652   0.8072
6            6      7    0.432094   0.848644  0.468109   0.8388
7            7      8    0.393686   0.864111  0.429461   0.8552
8            8      9    0.356874   0.876356  0.500846   0.8360
9            9     10    0.333076   0.883822  0.446606   0.8488
10          10     11    0.310424   0.891867  0.395992   0.8662
11          11     12    0.284330   0.900867  0.395248   0.8714
12          12     13    0.267211   0.904689  0.466472   0.8512
13          13     14    0.252369   0.912067  0.357027   0.8788
14          14     15    0.225934   0.920222  0.326612   0.8886
15          15     16    0.215926   0.924067  0.329903   0.8930
16          16     17    0.200772   0.930667  0.407676   0.8770
17          17     18    0.191555   0.932378  0.344014   0.8890
18          18     19    0.177961   0.936844  0.362166   0.8850
19          19     20    0.170277   0.940867  0.306026   0.8990
20          20     21    0.158309   0.944289  0.448888   0.8664
21          21     22    0.145230   0.948644  0.330578   0.9014
22          22     23    0.137505   0.951489  0.321336      NaN
23          23     24    0.133425   0.952511  0.363670   0.8928
24          24     25    0.123354   0.956467  0.411105   0.8836
25          25     26    0.120446   0.957178  0.335317   0.9038
26          26     27    0.111692   0.960667  0.400440   0.8964
27          27     28         NaN   0.963289  0.381005   0.8998
28          28     29    0.101621   0.964067       NaN   0.8988
29          29     30    0.094147   0.965889  0.331762   0.9028
    Unnamed: 0  Epoch  Train_Loss  Train_Acc  Val_Loss  Val_Acc
0            0      1    1.378301   0.496378  1.138243   0.5956
1            1      2    0.913497   0.673756  0.876917   0.7026
2            2      3    0.714228   0.748956  0.672718   0.7590
3            3      4    0.598144   0.792978  0.625913   0.7864
4            4      5    0.527811   0.817778  0.536250   0.8182
5            5      6    0.473939   0.835600  0.582652   0.8072
6            6      7    0.432094   0.848644  0.468109   0.8388
7            7      8    0.393686   0.864111  0.429461   0.8552
8            8      9    0.356874   0.876356  0.500846   0.8360
9            9     10    0.333076   0.883822  0.446606   0.8488
10          10     11    0.310424   0.891867  0.395992   0.8662
11          11     12    0.284330   0.900867  0.395248   0.8714
12          12     13    0.267211   0.904689  0.466472   0.8512
13          13     14    0.252369   0.912067  0.357027   0.8788
14          14     15    0.225934   0.920222  0.326612   0.8886
15          15     16    0.215926   0.924067  0.329903   0.8930
16          16     17    0.200772   0.930667  0.407676   0.8770
17          17     18    0.191555   0.932378  0.344014   0.8890
18          18     19    0.177961   0.936844  0.362166   0.8850
19          19     20    0.170277   0.940867  0.306026   0.8990
20          20     21    0.158309   0.944289  0.448888   0.8664
21          21     22    0.145230   0.948644  0.330578   0.9014
22          22     23    0.137505   0.951489  0.321336      NaN
23          23     24    0.133425   0.952511  0.363670   0.8928
24          24     25    0.123354   0.956467  0.411105   0.8836
25          25     26    0.120446   0.957178  0.335317   0.9038
26          26     27    0.111692   0.960667  0.400440   0.8964
27          27     28         NaN   0.963289  0.381005   0.8998
28          28     29    0.101621   0.964067       NaN   0.8988
29          29     30    0.094147   0.965889  0.331762   0.9028

print(df.dropna(subset=["Train_Loss"])) # 如果某列有缺失值，则剔除这一行

    Unnamed: 0  Epoch  Train_Loss  Train_Acc  Val_Loss  Val_Acc
0            0      1    1.378301   0.496378  1.138243   0.5956
1            1      2    0.913497   0.673756  0.876917   0.7026
2            2      3    0.714228   0.748956  0.672718   0.7590
3            3      4    0.598144   0.792978  0.625913   0.7864
4            4      5    0.527811   0.817778  0.536250   0.8182
5            5      6    0.473939   0.835600  0.582652   0.8072
6            6      7    0.432094   0.848644  0.468109   0.8388
7            7      8    0.393686   0.864111  0.429461   0.8552
8            8      9    0.356874   0.876356  0.500846   0.8360
9            9     10    0.333076   0.883822  0.446606   0.8488
10          10     11    0.310424   0.891867  0.395992   0.8662
11          11     12    0.284330   0.900867  0.395248   0.8714
12          12     13    0.267211   0.904689  0.466472   0.8512
13          13     14    0.252369   0.912067  0.357027   0.8788
14          14     15    0.225934   0.920222  0.326612   0.8886
15          15     16    0.215926   0.924067  0.329903   0.8930
16          16     17    0.200772   0.930667  0.407676   0.8770
17          17     18    0.191555   0.932378  0.344014   0.8890
18          18     19    0.177961   0.936844  0.362166   0.8850
19          19     20    0.170277   0.940867  0.306026   0.8990
20          20     21    0.158309   0.944289  0.448888   0.8664
21          21     22    0.145230   0.948644  0.330578   0.9014
22          22     23    0.137505   0.951489  0.321336      NaN
23          23     24    0.133425   0.952511  0.363670   0.8928
24          24     25    0.123354   0.956467  0.411105   0.8836
25          25     26    0.120446   0.957178  0.335317   0.9038
26          26     27    0.111692   0.960667  0.400440   0.8964
28          28     29    0.101621   0.964067       NaN   0.8988
29          29     30    0.094147   0.965889  0.331762   0.9028

# 填错缺失值
print(df.fillna({"Train_Loss":0.1}).tail()) # 自定义填充

    Unnamed: 0  Epoch  Train_Loss  Train_Acc  Val_Loss  Val_Acc
25          25     26    0.120446   0.957178  0.335317   0.9038
26          26     27    0.111692   0.960667  0.400440   0.8964
27          27     28    0.100000   0.963289  0.381005   0.8998
28          28     29    0.101621   0.964067       NaN   0.8988
29          29     30    0.094147   0.965889  0.331762   0.9028

print(df.fillna(df[["Train_Loss","Val_Loss"]].mean()).tail()) # 使用统计值来填充

    Unnamed: 0  Epoch  Train_Loss  Train_Acc  Val_Loss  Val_Acc
25          25     26    0.120446   0.957178  0.335317   0.9038
26          26     27    0.111692   0.960667  0.400440   0.8964
27          27     28    0.329108   0.963289  0.381005   0.8998
28          28     29    0.101621   0.964067  0.458378   0.8988
29          29     30    0.094147   0.965889  0.331762   0.9028

print(df.ffill().tail()) # 用前边的数据进行填充front

    Unnamed: 0  Epoch  Train_Loss  Train_Acc  Val_Loss  Val_Acc
25          25     26    0.120446   0.957178  0.335317   0.9038
26          26     27    0.111692   0.960667  0.400440   0.8964
27          27     28    0.111692   0.963289  0.381005   0.8998
28          28     29    0.101621   0.964067  0.381005   0.8988
29          29     30    0.094147   0.965889  0.331762   0.9028

print(df.bfill().tail()) # 用后边的数据进行填充behind

    Unnamed: 0  Epoch  Train_Loss  Train_Acc  Val_Loss  Val_Acc
25          25     26    0.120446   0.957178  0.335317   0.9038
26          26     27    0.111692   0.960667  0.400440   0.8964
27          27     28    0.101621   0.963289  0.381005   0.8998
28          28     29    0.101621   0.964067  0.331762   0.8988
29          29     30    0.094147   0.965889  0.331762   0.9028

# 重复数据的处理
print(df.duplicated()) # 一整条记录都是一样的，则标记为重复，返回true

0     False
1     False
2     False
3     False
4     False
5     False
6     False
7     False
8     False
9     False
10    False
11    False
12    False
13    False
14    False
15    False
16    False
17    False
18    False
19    False
20    False
21    False
22    False
23    False
24    False
25    False
26    False
27    False
28    False
29    False
dtype: bool

print(df.drop_duplicates()) # 把全部重复的一行删除

    Unnamed: 0  Epoch  Train_Loss  Train_Acc  Val_Loss  Val_Acc
0            0      1    1.378301   0.496378  1.138243   0.5956
1            1      2    0.913497   0.673756  0.876917   0.7026
2            2      3    0.714228   0.748956  0.672718   0.7590
3            3      4    0.598144   0.792978  0.625913   0.7864
4            4      5    0.527811   0.817778  0.536250   0.8182
5            5      6    0.473939   0.835600  0.582652   0.8072
6            6      7    0.432094   0.848644  0.468109   0.8388
7            7      8    0.393686   0.864111  0.429461   0.8552
8            8      9    0.356874   0.876356  0.500846   0.8360
9            9     10    0.333076   0.883822  0.446606   0.8488
10          10     11    0.310424   0.891867  0.395992   0.8662
11          11     12    0.284330   0.900867  0.395248   0.8714
12          12     13    0.267211   0.904689  0.466472   0.8512
13          13     14    0.252369   0.912067  0.357027   0.8788
14          14     15    0.225934   0.920222  0.326612   0.8886
15          15     16    0.215926   0.924067  0.329903   0.8930
16          16     17    0.200772   0.930667  0.407676   0.8770
17          17     18    0.191555   0.932378  0.344014   0.8890
18          18     19    0.177961   0.936844  0.362166   0.8850
19          19     20    0.170277   0.940867  0.306026   0.8990
20          20     21    0.158309   0.944289  0.448888   0.8664
21          21     22    0.145230   0.948644  0.330578   0.9014
22          22     23    0.137505   0.951489  0.321336      NaN
23          23     24    0.133425   0.952511  0.363670   0.8928
24          24     25    0.123354   0.956467  0.411105   0.8836
25          25     26    0.120446   0.957178  0.335317   0.9038
26          26     27    0.111692   0.960667  0.400440   0.8964
27          27     28         NaN   0.963289  0.381005   0.8998
28          28     29    0.101621   0.964067       NaN   0.8988
29          29     30    0.094147   0.965889  0.331762   0.9028

print(df.drop_duplicates(subset=["Epoch"],keep="last")) # 根据指定列去重，并保留最后一次出现的记录

    Unnamed: 0  Epoch  Train_Loss  Train_Acc  Val_Loss  Val_Acc
0            0      1    1.378301   0.496378  1.138243   0.5956
1            1      2    0.913497   0.673756  0.876917   0.7026
2            2      3    0.714228   0.748956  0.672718   0.7590
3            3      4    0.598144   0.792978  0.625913   0.7864
4            4      5    0.527811   0.817778  0.536250   0.8182
5            5      6    0.473939   0.835600  0.582652   0.8072
6            6      7    0.432094   0.848644  0.468109   0.8388
7            7      8    0.393686   0.864111  0.429461   0.8552
8            8      9    0.356874   0.876356  0.500846   0.8360
9            9     10    0.333076   0.883822  0.446606   0.8488
10          10     11    0.310424   0.891867  0.395992   0.8662
11          11     12    0.284330   0.900867  0.395248   0.8714
12          12     13    0.267211   0.904689  0.466472   0.8512
13          13     14    0.252369   0.912067  0.357027   0.8788
14          14     15    0.225934   0.920222  0.326612   0.8886
15          15     16    0.215926   0.924067  0.329903   0.8930
16          16     17    0.200772   0.930667  0.407676   0.8770
17          17     18    0.191555   0.932378  0.344014   0.8890
18          18     19    0.177961   0.936844  0.362166   0.8850
19          19     20    0.170277   0.940867  0.306026   0.8990
20          20     21    0.158309   0.944289  0.448888   0.8664
21          21     22    0.145230   0.948644  0.330578   0.9014
22          22     23    0.137505   0.951489  0.321336      NaN
23          23     24    0.133425   0.952511  0.363670   0.8928
24          24     25    0.123354   0.956467  0.411105   0.8836
25          25     26    0.120446   0.957178  0.335317   0.9038
26          26     27    0.111692   0.960667  0.400440   0.8964
27          27     28         NaN   0.963289  0.381005   0.8998
28          28     29    0.101621   0.964067       NaN   0.8988
29          29     30    0.094147   0.965889  0.331762   0.9028

# 数据类型的转化
print(df.dtypes)
df["Epoch"] = df["Epoch"].astype("int16")
print(df.dtypes)

Unnamed: 0      int64
Epoch           int64
Train_Loss    float64
Train_Acc     float64
Val_Loss      float64
Val_Acc       float64
dtype: object
Unnamed: 0      int64
Epoch           int16
Train_Loss    float64
Train_Acc     float64
Val_Loss      float64
Val_Acc       float64
dtype: object

# 数据重塑
df3= pd.melt(df,id_vars=["Unnamed: 0","Epoch"],var_name="指标",value_name="分数")
print(df3.sort_values("Epoch")) # 宽表转化为长表

     Unnamed: 0  Epoch          指标        分数
0             0      1  Train_Loss  1.378301
90            0      1     Val_Acc  0.595600
60            0      1    Val_Loss  1.138243
30            0      1   Train_Acc  0.496378
91            1      2     Val_Acc  0.702600
..          ...    ...         ...       ...
28           28     29  Train_Loss  0.101621
59           29     30   Train_Acc  0.965889
29           29     30  Train_Loss  0.094147
89           29     30    Val_Loss  0.331762
119          29     30     Val_Acc  0.902800

[120 rows x 4 columns]

# 长表转宽表
print(pd.pivot(df3,index=["Unnamed: 0","Epoch"],columns="指标",values="分数"))

指标                Train_Acc  Train_Loss  Val_Acc  Val_Loss
Unnamed: 0 Epoch                                          
0          1       0.496378    1.378301   0.5956  1.138243
1          2       0.673756    0.913497   0.7026  0.876917
2          3       0.748956    0.714228   0.7590  0.672718
3          4       0.792978    0.598144   0.7864  0.625913
4          5       0.817778    0.527811   0.8182  0.536250
5          6       0.835600    0.473939   0.8072  0.582652
6          7       0.848644    0.432094   0.8388  0.468109
7          8       0.864111    0.393686   0.8552  0.429461
8          9       0.876356    0.356874   0.8360  0.500846
9          10      0.883822    0.333076   0.8488  0.446606
10         11      0.891867    0.310424   0.8662  0.395992
11         12      0.900867    0.284330   0.8714  0.395248
12         13      0.904689    0.267211   0.8512  0.466472
13         14      0.912067    0.252369   0.8788  0.357027
14         15      0.920222    0.225934   0.8886  0.326612
15         16      0.924067    0.215926   0.8930  0.329903
16         17      0.930667    0.200772   0.8770  0.407676
17         18      0.932378    0.191555   0.8890  0.344014
18         19      0.936844    0.177961   0.8850  0.362166
19         20      0.940867    0.170277   0.8990  0.306026
20         21      0.944289    0.158309   0.8664  0.448888
21         22      0.948644    0.145230   0.9014  0.330578
22         23      0.951489    0.137505      NaN  0.321336
23         24      0.952511    0.133425   0.8928  0.363670
24         25      0.956467    0.123354   0.8836  0.411105
25         26      0.957178    0.120446   0.9038  0.335317
26         27      0.960667    0.111692   0.8964  0.400440
27         28      0.963289         NaN   0.8998  0.381005
28         29      0.964067    0.101621   0.8988       NaN
29         30      0.965889    0.094147   0.9028  0.331762

# 数据分箱 pd.cut(x,bins,labels)
df1 = df.head(10)[["Epoch","Train_Loss"]]
print(df1)

   Epoch  Train_Loss
0      1    1.378301
1      2    0.913497
2      3    0.714228
3      4    0.598144
4      5    0.527811
5      6    0.473939
6      7    0.432094
7      8    0.393686
8      9    0.356874
9     10    0.333076

pd.cut(df1["Train_Loss"],bins = 2) # bins=n，分成n段区间，起始值和结束值取的数据的最小值和最大值

0    (0.856, 1.378]
1    (0.856, 1.378]
2    (0.332, 0.856]
3    (0.332, 0.856]
4    (0.332, 0.856]
5    (0.332, 0.856]
6    (0.332, 0.856]
7    (0.332, 0.856]
8    (0.332, 0.856]
9    (0.332, 0.856]
Name: Train_Loss, dtype: category
Categories (2, interval[float64, right]): [(0.332, 0.856] < (0.856, 1.378]]

pd.cut(df1["Train_Loss"],bins = 3).value_counts()

Train_Loss
(0.332, 0.681]    7
(0.681, 1.03]     2
(1.03, 1.378]     1
Name: count, dtype: int64

 pd.cut(df1["Train_Loss"],bins = [0,0.4,0.8,1.5]) # bins = list，分成n段

0    (0.8, 1.5]
1    (0.8, 1.5]
2    (0.4, 0.8]
3    (0.4, 0.8]
4    (0.4, 0.8]
5    (0.4, 0.8]
6    (0.4, 0.8]
7    (0.0, 0.4]
8    (0.0, 0.4]
9    (0.0, 0.4]
Name: Train_Loss, dtype: category
Categories (3, interval[float64, right]): [(0.0, 0.4] < (0.4, 0.8] < (0.8, 1.5]]

pd.cut(df1["Train_Loss"],bins = [0,0.4,0.8,1.5],labels=["低","中","高"])

0    高
1    高
2    中
3    中
4    中
5    中
6    中
7    低
8    低
9    低
Name: Train_Loss, dtype: category
Categories (3, object): ['低' < '中' < '高']

df1["损失函数"]=pd.cut(df1["Train_Loss"],bins = [0,0.4,0.8,1.5],labels=["低","中","高"])
df1

vertical-align: top; } .dataframe thead th { text-align: right; }

	Epoch	Train_Loss	损失函数
0	1	1.378301	高
1	2	0.913497	高
2	3	0.714228	中
3	4	0.598144	中
4	5	0.527811	中
5	6	0.473939	中
6	7	0.432094	中
7	8	0.393686	低
8	9	0.356874	低
9	10	0.333076	低

pd.qcut(df1["Train_Loss"],3).value_counts() # 等频率划分

Train_Loss
(0.598, 1.378]    4
(0.332, 0.432]    3
(0.432, 0.598]    3
Name: count, dtype: int64

#df.rename(),df.set_index(),df.reset_index()
df1.set_index("Epoch",inplace=True)
print(df1) # 直接设置epoch为索引
df1.reset_index(inplace=True)
print(df1) # 重置

       Train_Loss 损失函数
Epoch                 
1        1.378301    高
2        0.913497    高
3        0.714228    中
4        0.598144    中
5        0.527811    中
6        0.473939    中
7        0.432094    中
8        0.393686    低
9        0.356874    低
10       0.333076    低
   Epoch  Train_Loss 损失函数
0      1    1.378301    高
1      2    0.913497    高
2      3    0.714228    中
3      4    0.598144    中
4      5    0.527811    中
5      6    0.473939    中
6      7    0.432094    中
7      8    0.393686    低
8      9    0.356874    低
9     10    0.333076    低

df1.rename(columns={"Train_Loss":"准确率"})

vertical-align: top; } .dataframe thead th { text-align: right; }

	Epoch	准确率	损失函数
0	1	1.378301	高
1	2	0.913497	高
2	3	0.714228	中
3	4	0.598144	中
4	5	0.527811	中
5	6	0.473939	中
6	7	0.432094	中
7	8	0.393686	低
8	9	0.356874	低
9	10	0.333076	低

# 时间数据处理
d = pd.Timestamp('2015-05-02 10:22')
print(d)
print("年",d.year)
print("季度",d.quarter)

2015-05-02 10:22:00
年 2015
季度 2

print("是否是月底",d.is_month_end)

是否是月底 False

# 方法
print("星期几",d.day_name())

星期几 Saturday

print("转化为天",d.to_period("D"))
print("转化为季度",d.to_period("Q"))

转化为天 2015-05-02
转化为季度 2015Q2

# 字符串转换为日期类型
a = pd.to_datetime('20150225')
print(a)

2015-02-25 00:00:00

# 时间间隔
d1 = pd.Timestamp('2013-01-15')
d2 = pd.Timestamp('2023-02-18')
d3 = d2-d1
print(d3)

3686 days 00:00:00

# 创建时间序列
days = pd.date_range("2025-07-03",'2026-02-09',freq='W')
print(days)

DatetimeIndex(['2025-07-06', '2025-07-13', '2025-07-20', '2025-07-27',
               '2025-08-03', '2025-08-10', '2025-08-17', '2025-08-24',
               '2025-08-31', '2025-09-07', '2025-09-14', '2025-09-21',
               '2025-09-28', '2025-10-05', '2025-10-12', '2025-10-19',
               '2025-10-26', '2025-11-02', '2025-11-09', '2025-11-16',
               '2025-11-23', '2025-11-30', '2025-12-07', '2025-12-14',
               '2025-12-21', '2025-12-28', '2026-01-04', '2026-01-11',
               '2026-01-18', '2026-01-25', '2026-02-01', '2026-02-08'],
              dtype='datetime64[ns]', freq='W-SUN')

days = pd.date_range("2025-07-03",periods=10,freq='W')
print(days)

DatetimeIndex(['2025-07-06', '2025-07-13', '2025-07-20', '2025-07-27',
               '2025-08-03', '2025-08-10', '2025-08-17', '2025-08-24',
               '2025-08-31', '2025-09-07'],
              dtype='datetime64[ns]', freq='W-SUN')

# 分组聚合
# df.groupby('分组的字段')['聚合的字段'].聚合函数()

Python数据分析-dataframe

小yo — Sun, 30 Nov 2025 21:45:38 GMT

dataframe的创建

import pandas as pd
import numpy as np

# 通过series创建
s1 = pd.Series([1,2,3,4,5])
s2 = pd.Series([6,7,8,9,10])
df1 = pd.DataFrame({"第一列":s1,"第二列":s2})
print(df1)

   第一列  第二列
0    1    6
1    2    7
2    3    8
3    4    9
4    5   10

# 通过字典来创建
df2 = pd.DataFrame(
    {
        "id":[1,2,3,4,5],
        "name":["tom","bob","jack","alice","mark"],
        "age":[18,19,20,17,18]
    },
    index = [1,2,3,4,5],columns = ["name","age","id"]
)
print(df2)

    name  age  id
1    tom   18   1
2    bob   19   2
3   jack   20   3
4  alice   17   4
5   mark   18   5

属性

# 行索引
print(df2.index)
# 列索引
print(df2.columns)
# 值
print(df2.values)

Index([1, 2, 3, 4, 5], dtype='int64')
Index(['name', 'age', 'id'], dtype='object')
[['tom' 18 1]
 ['bob' 19 2]
 ['jack' 20 3]
 ['alice' 17 4]
 ['mark' 18 5]]

# 维度
print(df2.ndim)
# 数据类型
print(df2.dtypes)
# 形状
print(df2.shape)
# 元素个数
print(df2.size)

2
name    object
age      int64
id       int64
dtype: object
(5, 3)
15

# 行列转置
print(df2.T)

        1    2     3      4     5
name  tom  bob  jack  alice  mark
age    18   19    20     17    18
id      1    2     3      4     5

# 获取元素 loc iloc at iat
# 获取某行数据
print(df2)
print(df2.loc[4]) # 显式索引
print(df2.iloc[3]) #隐式索引

    name  age  id
1    tom   18   1
2    bob   19   2
3   jack   20   3
4  alice   17   4
5   mark   18   5
name    alice
age        17
id          4
Name: 4, dtype: object
name    alice
age        17
id          4
Name: 4, dtype: object

# 获取某列
print(df2.loc[:,"name"])
print(df2.iloc[:,0])

1      tom
2      bob
3     jack
4    alice
5     mark
Name: name, dtype: object
1      tom
2      bob
3     jack
4    alice
5     mark
Name: name, dtype: object

# 单个元素
print(df2.at[3,"age"])
print(df2.iat[2,1])

20
20

# 其他获取单列
print(df2["name"])
print(df2.name)
print(df2[["name","age"]]) # 获取多列

1      tom
2      bob
3     jack
4    alice
5     mark
Name: name, dtype: object
1      tom
2      bob
3     jack
4    alice
5     mark
Name: name, dtype: object
    name  age
1    tom   18
2    bob   19
3   jack   20
4  alice   17
5   mark   18

# 查看部分数据
print(df2.head(2))
print(df2.tail(3))

  name  age  id
1  tom   18   1
2  bob   19   2
    name  age  id
3   jack   20   3
4  alice   17   4
5   mark   18   5

print(df2.age>18)

1    False
2     True
3     True
4    False
5    False
Name: age, dtype: bool

# 使用布尔索引筛选数据
print(df2[df2.age>18])
print(df2[(df2.age>18)&(df2.id<3)])

   name  age  id
2   bob   19   2
3  jack   20   3
  name  age  id
2  bob   19   2

# 随机抽样
df2.sample(3)

vertical-align: top; } .dataframe thead th { text-align: right; }

	name	age	id
5	mark	18	5
2	bob	19	2
4	alice	17	4

常用方法

print(df2.head())
print(df2.tail())

    name  age  id
1    tom   18   1
2    bob   19   2
3   jack   20   3
4  alice   17   4
5   mark   18   5
    name  age  id
1    tom   18   1
2    bob   19   2
3   jack   20   3
4  alice   17   4
5   mark   18   5

#  是否在集合中
print(df2.isin(["bob",20]))

    name    age     id
1  False  False  False
2   True  False  False
3  False   True  False
4  False  False  False
5  False  False  False

print(df2.isna()) # 是否是缺失值

    name    age     id
1  False  False  False
2  False  False  False
3  False  False  False
4  False  False  False
5  False  False  False

# 统计方法
print(df2.age.sum())

print(df2.age.max())

print(df2.age.mean())

18.4

print(df2.age.median())

18.0

print(df2.age.mode()) # 众数

0    18
Name: age, dtype: int64

print(df2.age.std())
print(df2.age.var())

1.140175425099138
1.3

print(df2.age.quantile(0.25)) # 分位数

18.0

print(df2.describe()) # 描述信息

             age        id
count   5.000000  5.000000
mean   18.400000  3.000000
std     1.140175  1.581139
min    17.000000  1.000000
25%    18.000000  2.000000
50%    18.000000  3.000000
75%    19.000000  4.000000
max    20.000000  5.000000

print(df2.count()) # 每列非缺失值元素个数

name    5
age     5
id      5
dtype: int64

print(df2.value_counts())

name   age  id
alice  17   4     1
bob    19   2     1
jack   20   3     1
mark   18   5     1
tom    18   1     1
Name: count, dtype: int64

print(df2.drop_duplicates()) # 去重

    name  age  id
1    tom   18   1
2    bob   19   2
3   jack   20   3
4  alice   17   4
5   mark   18   5

print(df2.duplicated(subset=["age"])) # 检查是否重复

1    False
2    False
3    False
4    False
5     True
dtype: bool

# 随机采样
df2.sample(2)

vertical-align: top; } .dataframe thead th { text-align: right; }

	name	age	id
3	jack	20	3
1	tom	18	1

print(df2.replace(18,30)) # 18改为30

    name  age  id
1    tom   30   1
2    bob   19   2
3   jack   20   3
4  alice   17   4
5   mark   30   5

# 累计和
df2.cumsum()

vertical-align: top; } .dataframe thead th { text-align: right; }

	name	age	id
1	tom	18	1
2	tombob	37	3
3	tombobjack	57	6
4	tombobjackalice	74	10
5	tombobjackalicemark	92	15

# 累计最小
df2.cummin()

vertical-align: top; } .dataframe thead th { text-align: right; }

	name	age	id
1	tom	18	1
2	bob	18	1
3	bob	18	1
4	alice	17	1
5	alice	17	1

# 按索引排序
print(df2.sort_index(ascending=False)) # 降序

    name  age  id
5   mark   18   5
4  alice   17   4
3   jack   20   3
2    bob   19   2
1    tom   18   1

print(df2.sort_values(by=["age","id"],ascending=[True,False]))

    name  age  id
4  alice   17   4
5   mark   18   5
1    tom   18   1
2    bob   19   2
3   jack   20   3

df2.nlargest(2,columns=['age','id'])

vertical-align: top; } .dataframe thead th { text-align: right; }

	name	age	id
3	jack	20	3
2	bob	19	2

df2.nsmallest(2,columns=['age','id'])

vertical-align: top; } .dataframe thead th { text-align: right; }

	name	age	id
4	alice	17	4
1	tom	18	1

Python数据分析-series

小yo — Sun, 30 Nov 2025 21:45:30 GMT

创建方法

import pandas as pd
import numpy as np

s = pd.Series([1,2,7,4,5])
print(s)

0    1
1    2
2    7
3    4
4    5
dtype: int64

# 自定义索引
s = pd.Series([1,2,7,4,5],index=['A','B','C','D','E'])
print(s)

A    1
B    2
C    7
D    4
E    5
dtype: int64

# 定义name
s = pd.Series([1,2,7,4,5],index=['A','B','C','D','E'],name='月')
print(s)

A    1
B    2
C    7
D    4
E    5
Name: 月, dtype: int64

# 通过字典创建
s = pd.Series({"a":1,"b":2,"c":3})
print(s)
s1 = pd.Series(s,index=["a","c"])
print(s1)

a    1
b    2
c    3
dtype: int64
a    1
c    3
dtype: int64

属性

print(s.index)

Index(['a', 'b', 'c'], dtype='object')

print(s.values)

[1 2 3]

print(s.shape,s.ndim,s.size)

(3,) 1 3

print(s.dtype)

int64

s.name = 'test'
print(s.name)

test

print(s.loc["a"])  # 显式索引

print(s.iloc[2]) # 隐式索引

print(s.loc["a":"c"])

a    1
b    2
c    3
Name: test, dtype: int64

print(s.at['a']) # at不支持切片
print(s.iat[2])

1
3

访问数据

# 直接访问
print(s['a'])

print(s[s>1]) # 布尔索引

b    2
c    3
Name: test, dtype: int64

print(s.head()) # 默认返回前五行

a    1
b    2
c    3
Name: test, dtype: int64

print(s.tail()) # 默认后五行
print(s.head(2))

a    1
b    2
c    3
Name: test, dtype: int64
a    1
b    2
Name: test, dtype: int64

常用方法

s1 = pd.Series([10,2,np.nan,None,3,4,5],index=['A','B','C','D','E','F','G'],name='date')
print(s1)

A    10.0
B     2.0
C     NaN
D     NaN
E     3.0
F     4.0
G     5.0
Name: date, dtype: float64

s1.head()

A    10.0
B     2.0
C     NaN
D     NaN
E     3.0
Name: date, dtype: float64

s1.tail(2)

F    4.0
G    5.0
Name: date, dtype: float64

s1.describe()

count     5.000000
mean      4.800000
std       3.114482
min       2.000000
25%       3.000000
50%       4.000000
75%       5.000000
max      10.000000
Name: date, dtype: float64

# 获取非缺失值的元素个数
print(s1.count())

# 获取索引
print(s1.keys()) # 方法
print(s1.index)  # 属性

Index(['A', 'B', 'C', 'D', 'E', 'F', 'G'], dtype='object')
Index(['A', 'B', 'C', 'D', 'E', 'F', 'G'], dtype='object')

# 判断
print(s1.isna()) # 检查每个元素是否为缺失值
print(s1.isin([4,5,6])) # 检查每个元素是否在参数集合中

A    False
B    False
C     True
D     True
E    False
F    False
G    False
Name: date, dtype: bool
A    False
B    False
C    False
D    False
E    False
F     True
G     True
Name: date, dtype: bool

print(s1.mean())
print(s1.std())
print(s1.var())
print(s1.sum())
print(s1.max())
print(s1.min())
print(s1.median()) # 缺失值都不参与运算

4.8
3.1144823004794877
9.700000000000001
24.0
10.0
2.0
4.0

s1.sort_values()

B     2.0
E     3.0
F     4.0
G     5.0
A    10.0
C     NaN
D     NaN
Name: date, dtype: float64

print(s1.quantile(0.25))

3.0

# 众数
print(s1.mode())

0     2.0
1     3.0
2     4.0
3     5.0
4    10.0
Name: date, dtype: float64

print(s1.value_counts()) # 每个元素的计数

date
10.0    1
2.0     1
3.0     1
4.0     1
5.0     1
Name: count, dtype: int64

# 去重
s1.drop_duplicates() # 缺失值也会被去重

A    10.0
B     2.0
C     NaN
E     3.0
F     4.0
G     5.0
Name: date, dtype: float64

s1.sort_index() # 按索引排序

A    10.0
B     2.0
C     NaN
D     NaN
E     3.0
F     4.0
G     5.0
Name: date, dtype: float64

s1.sort_values() # 按值排序

B     2.0
E     3.0
F     4.0
G     5.0
A    10.0
C     NaN
D     NaN
Name: date, dtype: float64

s1.diff() # 计算前后两个之间的差值

A    NaN
B   -8.0
C    NaN
D    NaN
E    NaN
F    1.0
G    1.0
Name: date, dtype: float64

Python数据分析-numpy_function

小yo — Sun, 30 Nov 2025 21:45:22 GMT

1.基本数学函数

import numpy as np

# 计算平方根
print(np.sqrt(9))
print(np.sqrt([1,4,9])) # 默认返回浮点数
arr = [1,25,64]
print(np.sqrt(arr))

3.0
[1. 2. 3.]
[1. 5. 8.]

# 计算指数
print(np.exp(1)) # e的1次方

2.718281828459045

# 计算自然对数
print(np.log(2.71)) # ln(e)

0.9969486348916096

# 计算正弦值、余弦值
print(np.sin(1))
print(np.cos(np.pi))

0.8414709848078965
-1.0

# 计算绝对值
arr = np.array([-1,1,-2,-3])
print(np.abs(arr))

[1 1 2 3]

# 计算a的b次幂
print(np.power(arr,3))

[ -1   1  -8 -27]

# 四舍五入
print(np.round([3.5,2.2,4.5])) # 四舍五入，但是0.5向偶数凑

[4. 2. 4.]

# 向上取整，向下取整
arr = np.array([1.5,2.1,4.5,])
print(np.ceil(arr))
print(np.floor(arr))

[2. 3. 5.]
[1. 2. 4.]

# 检测缺失值NaN
np.isnan([1,2,np.nan,3])

array([False, False,  True, False])

2.统计函数

arr = np.random.randint(1,20,8)
print(arr)

[10  4  9  9  6  4 17  5]

# 求和
print(np.sum(arr))

# 计算平均值
print(np.mean(arr))

8.0

# 计算中位数
print(np.median(arr))

7.5

# 计算标准差和方差
print(np.var(arr)) # 方差
print(np.std(arr)) # 标准差

16.5
4.06201920231798

# 计算最大值和最小值
print(np.max(arr),np.argmax(arr)) # agrmax用于把最大值的索引找出来
print(np.min(arr))

17 6
4

# 分位数
print(np.percentile(arr,25))

4.75

# 累计和、累计积
print(np.cumsum(arr))
print(np.cumprod(arr))

[10 14 23 32 38 42 59 64]
[     10      40     360    3240   19440   77760 1321920 6609600]

3.比较函数

# 是否大于
print(np.greater([3,4,5,6,7],4)) # 数组元素依次和4进行比较判断是否大于
# 是否小于
print(np.less([3,4,5,6,7],4))
# 是否等于
print(np.equal([3,4,5,6,7],4))
print(np.equal([3,4,5],[3,4,6]))

[False False  True  True  True]
[ True False False False False]
[False  True False False False]
[ True  True False]

# 逻辑运算
print(np.logical_and([0,1],[1,1]))
print(np.logical_or([0,1],[1,1]))
print(np.logical_not([1,0]))

[False  True]
[ True  True]
[False  True]

# 检查元素是否至少一个元素为True
print(np.any([0,0,1,0]))
# 检查元素是否全部为True
print(np.all([0,0,1,0]))

True
False

# 自定义条件
# print(np.where(条件，符合条件，不符合条件))
a = np.array([1,2,3,4,5])
print(np.where(a>3,a,0))
print(np.where(a<5,a,0))
# 用于分类
score = np.random.randint(0,100,20)
print(score)
print(np.where(score<60,'不及格',np.where(
    score<80,'良好','优秀'
)
              ))

# 替代
print(np.select([score>=80,(score>=60)&(score<80),score<60],['优秀','良好','不及格'],default='未知'))

[0 0 0 4 5]
[1 2 3 4 0]
[30 21 27 73 94 15 33 13 44 83 59 20  5 97 73 28 81 28 43 49]
['不及格' '不及格' '不及格' '良好' '优秀' '不及格' '不及格' '不及格' '不及格' '优秀' '不及格' '不及格'
 '不及格' '优秀' '良好' '不及格' '优秀' '不及格' '不及格' '不及格']
['不及格' '不及格' '不及格' '良好' '优秀' '不及格' '不及格' '不及格' '不及格' '优秀' '不及格' '不及格'
 '不及格' '优秀' '良好' '不及格' '优秀' '不及格' '不及格' '不及格']

4.排序函数

# 排序
np.random.seed(0)
arr1 = np.random.randint(1,100,20)
print(arr1)
arr1.sort() # 直接排序并改变arr
print(arr1)
np.random.seed(0)
arr2 = np.random.randint(1,100,20)
print(arr2)
print(np.sort(arr2)) # 不改变arr
print(np.argsort(arr2)) # 排序后的索引

[45 48 65 68 68 10 84 22 37 88 71 89 89 13 59 66 40 88 47 89]
[10 13 22 37 40 45 47 48 59 65 66 68 68 71 84 88 88 89 89 89]
[45 48 65 68 68 10 84 22 37 88 71 89 89 13 59 66 40 88 47 89]
[10 13 22 37 40 45 47 48 59 65 66 68 68 71 84 88 88 89 89 89]
[ 5 13  7  8 16  0 18  1 14  2 15  3  4 10  6 17  9 11 12 19]

# 去重函数
print(np.unique(arr2)) # 删除重复值的同时进行排序

[10 13 22 37 40 45 47 48 59 65 66 68 71 84 88 89]

5.其他函数

# 数组的拼接
arr1 = np.array([1,2,3])
arr2 = np.array([4,5,6])
print(np.concatenate((arr1,arr2))) # 注意要将需要拼接的数组放到一个括号里

[1 2 3 4 5 6]

# 数组的分割
print(np.split(arr,5)) #分成5份
print(np.split(arr,[6,12,18]))

[array([10, 13, 22, 37]), array([40, 45, 47, 48]), array([59, 65, 66, 68]), array([68, 71, 84, 88]), array([88, 89, 89, 89])]
[array([10, 13, 22, 37, 40, 45]), array([47, 48, 59, 65, 66, 68]), array([68, 71, 84, 88, 88, 89]), array([89, 89])]

# 调整数组的形状
print(np.reshape(arr,[4,5]))

[[10 13 22 37 40]
 [45 47 48 59 65]
 [66 68 68 71 84]
 [88 88 89 89 89]]

Python数据分析-ndarray

小yo — Sun, 30 Nov 2025 21:44:51 GMT

1.ndarray的特性

多维性

import numpy as np

arr = np.array(5)
print(arr)
print("array的维度",arr.ndim)

5
array的维度 0

arr2 = np.array([1,2,3])
print(arr2)
print("arrar的维度",arr2.ndim)

[1 2 3]
arrar的维度 1

arr2 = np.array([[1,2,3],[4,5,6]])
print(arr2)
print("arrar的维度",arr2.ndim)

[[1 2 3]
 [4 5 6]]
arrar的维度 2

同质性

arr3 = np.array([1,"hello"])
print(arr3)

['1' 'hello']

不同的数据类型会被转化成相同的数据类型

arr4 = np.array([1,2.5])
print(arr4)

[1.  2.5]

2.ndarray的属性

arr4 = np.array(1)
print(arr4)
print("数组的形状:",arr4.shape)
print("数组的维度:",arr4.ndim)
print("元素的个数:",arr4.size)
print("元素的数据类型:",arr4.dtype)
print("元素的转置:",arr4.T)

1
数组的形状: ()
数组的维度: 0
元素的个数: 1
元素的数据类型: int32
元素的转置: 1

arr5 = np.array([1,2,3])
print(arr5)
print("数组的形状:",arr5.shape)
print("数组的维度:",arr5.ndim)
print("元素的个数:",arr5.size)
print("元素的数据类型:",arr5.dtype)
print("元素的转置:",arr5.T)

[1 2 3]
数组的形状: (3,)
数组的维度: 1
元素的个数: 3
元素的数据类型: int32
元素的转置: [1 2 3]

arr6 = np.array([[1,2,3],[4,5.0,6]])
print(arr6)
print("数组的形状:",arr6.shape)
print("数组的维度:",arr6.ndim)
print("元素的个数:",arr6.size)
print("元素的数据类型:",arr6.dtype)
print("元素的转置:",arr6.T)

[[1. 2. 3.]
 [4. 5. 6.]]
数组的形状: (2, 3)
数组的维度: 2
元素的个数: 6
元素的数据类型: float64
元素的转置: [[1. 4.]
 [2. 5.]
 [3. 6.]]

3.ndarray的创建

基础的创建方法

arr7 = np.array([1,2,3],dtype=np.float32)
print(arr7)
arr7

[1. 2. 3.]





array([1., 2., 3.], dtype=float32)

copy

arr8 = np.copy(arr7) # 元素跟原始的数组相同，但是不是一个数组了
arr8

array([1., 2., 3.], dtype=float32)

预定义形状

# 全0
arr9 = np.zeros((2,3)) 
print(arr9)
print(arr9.dtype) # 默认float64

[[0. 0. 0.]
 [0. 0. 0.]]
float64

# 全1
arr10 = np.ones((3,4))
print(arr10)

[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]

# 未初始化
arr11 = np.empty((3,5)) # 内容是随机的
print(arr11)

[[0.00000000e+000 0.00000000e+000 0.00000000e+000 0.00000000e+000
  0.00000000e+000]
 [0.00000000e+000 0.00000000e+000 0.00000000e+000 0.00000000e+000
  0.00000000e+000]
 [0.00000000e+000 0.00000000e+000 0.00000000e+000 0.00000000e+000
  2.59305626e-306]]

# 任意数填充
arr12 = np.full((3,4),78)
arr12

array([[78, 78, 78, 78],
       [78, 78, 78, 78],
       [78, 78, 78, 78]])

arr13 = np.zeros_like(arr12)
print(arr13)
arr14 = np.empty_like(arr10)
print(arr14)

[[0 0 0 0]
 [0 0 0 0]
 [0 0 0 0]]
[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]

特殊数列

# 等差数列
arr15 = np.arange(2,11,2) # start,end,step
print(arr15)

[ 2  4  6  8 10]

# 等间隔数列
arr16 = np.linspace(1,10,5) # start end number
print(arr16)

[ 1.    3.25  5.5   7.75 10.  ]

# 对数间隔数列
arr17 = np.logspace(0,4,3,base=3)
print(arr17)

[ 1.  9. 81.]

特殊矩阵

# 单位矩阵:
arr18 = np.eye(3,dtype=int)
print(arr18)

[[1 0 0]
 [0 1 0]
 [0 0 1]]

# 对角矩阵
arr19 = np.diag([1,2,5,3])
print(arr19)

[[1 0 0 0]
 [0 2 0 0]
 [0 0 5 0]
 [0 0 0 3]]

# 随机矩阵
# 生成0到1之间的随机浮点数（均匀分布）
arr20 = np.random.rand(2,3)
print(arr20)

[[0.71912505 0.4289779  0.28617504]
 [0.15021712 0.21373923 0.11392345]]

# 生成指定范围区间的随机浮点数
arr21 = np.random.uniform(3,6,(2,3))
print(arr21)

[[3.80064859 3.98720526 3.46284681]
 [3.45723353 3.67728475 4.88173559]]

# 生成指定范围区间的随机整数
arr22 = np.random.randint(3,6,(2,3))
print(arr22)

[[3 4 4]
 [5 4 4]]

# 生成随机数列（正态分布）
arr23 = np.random.randn(2,3)
print(arr23)

[[-0.15306313  1.19935259  0.84587337]
 [ 0.54632939 -0.15679205 -1.3430744 ]]

# 设置随机种子
np.random.seed(200)
arr24 = np.random.randint(1,10,(2,5))
print(arr24)

[[1 5 8 7 9]
 [2 8 4 2 8]]

4.ndarray的数据类型

# 布尔类型
arr25 = np.array([0,1,3,0],dtype='bool')
print(arr25)

[False  True  True False]

# 整数类型
arr26 = np.array([0,1,2,0],dtype=np.int8)
print(arr26)

[0 1 2 0]

# 浮点数类型float
# 复数类型complex

5.索引与切片

# 一维数组的索引与切片
arr27 = np.random.randint(1,100,10)
print(arr27)
print(arr27[7])
print(arr27[:]) # 获取全部数据
print(arr27[2:5]) # 左包右不包
print(arr27[(arr27>10) & (arr27<70)]) # 取出大于10小于70的元素
print(arr27[slice(2,8,2)]) # start end step

[85 34 22 13 43 46 16 56 51 97]
56
[85 34 22 13 43 46 16 56 51 97]
[22 13 43]
[34 22 13 43 46 16 56 51]
[22 43 16]

# 二维数组的索引与切片
arr28 = np.random.randint(1,100,(4,8))
print(arr28)
print(arr28[1,3])
print(arr28[:,:])
print(arr28[1,2:5])
print(arr28[arr28>50]) # 返回1维数组
print(arr28[1,:][arr28[1,:]>50]) # 取第二行大于50的元素

[[17 48 13 49 86 19 59 68]
 [20 97 51 27 92 18 38 50]
 [77 19 37 50 49 18 17 96]
 [83 45 65 74 62 39 32 80]]
27
[[17 48 13 49 86 19 59 68]
 [20 97 51 27 92 18 38 50]
 [77 19 37 50 49 18 17 96]
 [83 45 65 74 62 39 32 80]]
[51 27 92]
[86 59 68 97 51 92 77 96 83 65 74 62 80]
[97 51 92]

6.ndarray的运算

# 算数运算
a = np.array([[1,2,3],[7,8,9]])
b = np.array([[4,5,6],[3,6,7]])
print(a+b)
print(a-b)
print(a*b)  # 对应位置元素相乘
print(a/b)  # 对应位置元素相除
print(a**2)

[[ 5  7  9]
 [10 14 16]]
[[-3 -3 -3]
 [ 4  2  2]]
[[ 4 10 18]
 [21 48 63]]
[[0.25       0.4        0.5       ]
 [2.33333333 1.33333333 1.28571429]]
[[ 1  4  9]
 [49 64 81]]

# 广播机制
print(a+3)
c = np.array([1,2,3])
print(a+c)

[[ 4  5  6]
 [10 11 12]]
[[ 2  4  6]
 [ 8 10 12]]

# 矩阵运算
d = np.array([2,3,4])
e = np.diag([1,2,4])
print(d)
print(e)
print(d@e) # ‘@’表示矩阵乘法

[2 3 4]
[[1 0 0]
 [0 2 0]
 [0 0 4]]
[ 2  6 16]

周记Week7

小yo — Sun, 30 Nov 2025 21:24:15 GMT

这周感觉总是很忙，但是现在回头一看好像也没做出什么东西来……

先庆幸一下通过了实验室的第一阶段考核，很幸运，不过随之而来的第二阶段就很麻烦了，前边耽误太多时间了，感觉很可能会被淘汰掉，尽力吧。

转眼间教学周第十三周了，期末周又要到了，又要开始疯狂的复习了，累呦。

这周睡眠质量整体还好，不过有时候睡的还是太晚了。

还有好多任务要做，不多写了，继续加油。

周记Week6

小yo — Sun, 23 Nov 2025 21:22:16 GMT

“用力挥一鞭继续和死亡比赛再跑快点别再发呆犹豫和徘徊”

上周一直在忙实验的事情，忘记了更新周记，这周无论如何也得抽出时间总结一下了。

这段时间LUDlab第一阶段开始验收了，实验内容是做一个cifar10的图像分类。前边自己看李沐学了很多，但是从来没有动手做过，这次真的开始做项目了才感到手忙脚乱。一开始跑了很多实验，但是没有写保存数据点的代码，后边写报告的时候发现没法画图，没有办法只能重新跑了一遍。结果重新跑一遍发现之前的结论是具有偶然性的，反复实验最后证明了Adam优化器对lr的确不敏感。虽然证明了这个结论，但这应该是我在平时学习的时候就意识到的点，结果却没有掌握，导致在实验里多走了很多弯路。

不过也好，实战项目确实学到了很多书本上学不到的东西，总的来说虽然很忙但也充实。

这两周总是感到茫然，很多时间都在思考各种问题。往前看，看不到出路。课内太卷太累，科研也没找到路子，竞赛也是不知道该怎么准备。虽然cmc取得了全校第9，有望进入决赛，得知消息的当晚是很开心的。可是真正夜深人静的时候，又总会思考这样真的就满足了吗。最近在水群的时候看到有人发了这么一句话，很有感触，希望送给自己：

“你太专注于未来，却没有意识到今天正是你多年前祈求的模样，因为你眺望远方视而不见”

小时候写作文，写到自己未来的梦想，是想成为一名“电脑科学家”。年少的自己还没学到“计算机”这个名词，梦想却已埋下种子。如今进入大学成功转到计算机专业，实实在在感到离梦想越来越近，却又总是患得患失，希望自己能早日和现实和解吧。这两周晚上睡觉总是很晚，一方面老在思考，另一方面习惯确实有问题。剩下不到半个学期，还是得坚持锻炼，该休息的时候好好休息。

就先写到这吧，还有很多事情要做，继续加油！

周记Week4

小yo — Sun, 09 Nov 2025 22:22:44 GMT

前言

这周学了很多内容，但是周六上午考完cmc之后明显松懈了很多，一整个周末都在放松了。

学习

这周写了很多DL的知识，各种算法还挺有意思的，在数模中也有用。

快考六级了，得开始复习一下了。

生活

睡觉真好

总结

多学习多睡觉。

感觉cmc考的很好，开心放松一阵，不多写了。

周记Week3

小yo — Sun, 02 Nov 2025 22:00:43 GMT

前言

这周感冒发烧外加两门考试，导致精力严重不足，没怎么额外学习东西，甚至课内也没怎么学好。

学习

因为这周周六要考大物期中和工程经济学期末，整个周的时间都用在了复习上，周日考完了也得抓紧时间补作业，完全没时间学习DL和数模相关的……

数模美赛开始报名了，还有两个月的时间，得从头开始打基础了，回头制定出一个合理的学习清单。

LUDLab的招新也开始了，要求两周内学完DL/ML的基础，时间压力还是有点大的，得多抽出时间来才行。

下周六还有cmc，说实话去年拿到省一已经很极限了，今年真的就是随缘参赛了，周五晚上复习一晚上，周六看运气吧，希望能拿省一吧。

生活

换季了又不小心感冒了，再加上体育课运动量大，上完也没注意保暖，直接发烧了😣，要注意保暖哇。

下周感冒好了要开始跑步了，现在不下雨了，再不锻炼真不行了。

今天看到有人分享了个游戏，《导师模拟器》，感觉还蛮有意思的，抽空玩一下试试。

总结

下周得把大量时间投入到DL/ML和数模的学习中，同时得加强锻炼，笑死了，好累，但也很满足。

下周有一些需要额外做的事情，给自己列一下吧：

重装vscode
安装linux双系统
MATLAB换回2024b版

大学计算机-算法编程作业80题[上]

小yo — Tue, 28 Oct 2025 22:45:13 GMT

预览

7-10周作业（原附件暂缺）

大学计算机-算法编程作业80题[下]

小yo — Tue, 28 Oct 2025 22:45:13 GMT

预览

11-14周作业（原附件暂缺）

周记Week2

小yo — Sun, 26 Oct 2025 19:37:25 GMT

前言

这周做了好多事，经历了好多，非常充实的一周

学习

首先这周给自己制定的计划超额完成了，这周在时间分配上做的不错，每天几乎都能高效学习七八个小时。

这周申请了外校某个课题组的线上实习，但是由于太弱被拒绝了😭不过也是意料之中，我到现在连Python都还没完全掌握，ML和DL更是一窍不通，被拒也是理所应当，只能说未来还有很长的一段路要走。

值得一提的是对方老师特别好，虽然拒了我，但给我一些学习清单和相应资料，也让我对接下来怎么继续提升自己有了更清醒的认识。

下周六要考大物期中和工程经济学期末，为什么要把两场考试放在同一天，要累死我吗😣

生活

首先就是经过近半个月的反复修改，国奖申请终于通过了哈，一大喜事。

今天西安天终于晴了，下午去兴庆宫转了一圈，沐浴在阳光下的感觉真好。

总结

这周整体效率是相当高的了，但是还有一些时间可以优化，有时候经常沉迷在内耗中浪费了时间，这些时间拿来用在学习上多好。

这周不太好的一点是每天睡觉太晚了，也是得益于半夜打游戏的舍友，希望下周的睡眠质量能高一些吧，四节早八得不到好的休息太折磨人了。

下周的两场考试的复习必然要占据大量时间了，但还是希望可以多抽出一些时间学习更重要的知识吧。

继续加油

周记Week1

数据结构--二叉树[更新中]

小yo — Fri, 24 Oct 2025 23:46:43 GMT

二叉树的代码实现

二叉树构造算法

递归算法

以二叉链表，且输入序列为先序序列为例（其中输入-1表示该处为空指针）

typedef struct Node{
    int data;
    Node* left;
    Node* right;
}BTree; // 二叉链表的结点定义

BTree* CreateBTree(){
    int x;
    scanf("%d",&x);
    if (x == -1) return NULL; // 输入-1表示该处为指针
    BTree* BT;
    BT = (BTree*)malloc(sizeof(BTree));
    BT->data = x; // 先序序列，则优先存储根结点
    BT->left = CreateBTree(BT->left); // 递归创建左子树
    BT->right = CreateBTree(BT->right); // 递归创建右子树
    return BT;
}

前序+中序遍历序列构造算法

后续+中序遍历序列构造算法

前序遍历算法

递归算法

int PreOrderBTree(BTree* BT){
    if (BT == NULL) return 0; // 节点为空则结束递归
    visit(BT);  // 先序遍历，先访问根节点
    PreOrderBTree(BT->left); // 节点不为空，开始递归
    PreOrderBTree(BT->right);
    return 0;
}

非递归算法1

int PreOrderBTree(BTree* BT,S*S){ // 借助堆栈来记录路径
    if (BT == NULL) return 0; // 空二叉树直接返回0
    BTree* p = BT;
    S->top = 0; // 初始化
    while (p != NULL || S->top != 0){ 
        while (p != NULL){ // 一直沿左子树遍历直至空
            visit(p); // 先序遍历。先访问根节点
            push(p); // 记录该结点
            p = p->left; // 沿左子树遍历
        }
        if (S->top != 0){ 
            p = pop(S); // 栈顶元素出栈
            p = p->right; // 访问右子树
        }
    }
    return 0;
}

非递归算法2

int PreOrderBTree(BTree* BT,S*S){ // 借助堆栈来记录路径
    if (BT == NULL) return 0; // 空二叉树直接返回0
    BTree* p = BT;
    S->top = 0; // 堆栈置空
    push(p); // 根结点先入栈
    while(S->top >0){ //循环结束条件：堆栈为空
        p = pop(S); //出栈
        visit(p); //先序遍历，所以先访问根节点
        if (p->right != NULL){
            push(p->right); // 右结点入栈
        }
        if (p->left != NULL){
            push(p->left); // 左结点入栈，入栈顺序：右结点->左结点，保证能够先访问左结点
        }
    }
    return 0;
}

时间/空间复杂度分析

时间复杂度：由非递归算法2可知，每个结点都只被访问一次，则时间复杂度 T=O(n)T=O(n)T=O(n)
空间复杂度：由非递归算法2可知，堆栈一次性最多存储h+1h+1h+1个元素(hhh表示二叉树的深度)，而hhh最大为nnn，所以空间复杂度 S=O(n)S=O(n)S=O(n)

中序遍历算法

递归算法

int InOrderBTree(BTree* BT){
    if (BT == NULL) return 0; // 节点为空直接结束递归
    InOrderBTree(BT->left); //中序遍历先访问左子树
    visit(BT); // 其次访问根节点
    InOrderBTree(BT->right); //最后访问右子树
    return 0;
}

非递归算法1

int InOrderBTree(BTree* BT , S*S){ // 借助堆栈来记录路径
    if (BT == NULL) return 0; // 空二叉树直接返回0
    BTree* p = BT;
    S->top = 0; // 堆栈置空
    while (p != NULL || S->top != 0){ 
        while (p != NULL) { // 一直沿左子树遍历直至为空
            push(p); //中序遍历，所以先不需要访问根结点
            p = p->left;
        }
        if (S->top != 0){
            p = pop(S); 
            visit(p); // 左子树都遍历完了，访问根节点
            p = p->rigth; // 开始右子树
        }
    }
    return 0;
}

非递归算法2

需要改造堆栈，使每个元素加上一个tag（1,2）来标识第几次访问

int InOrderBTree(BTree* BT, S*S){
    if (BT == NULL) return 0;
    BTree* p = BT;
    S->top = NULL; // 把栈置空
    push(p,1); // p入栈的同时tag记为1
    while (S->top != NULL){ // 循环条件：堆栈不空
        if (S->top.tag == 1){ // tag=1 标识第一次访问
            p = pop(S); // 出栈
            if (p->right != NULL) push(p->right,1); // 右子树入栈，tag记为1
            push(p,2); // 二次入栈，tag记为2
            if (p->left != NULL) push(p->left,1); // 左子树入栈，tag记为1
        }
        else if (S->top.tag == 2){ // tag=2 标识第二次访问
            p = pop(S); // 出栈
            visit(p); // 访问
        }
    }
    return 0;
}

时间/空间复杂度分析

时间复杂度：由非递归算法2可知，每个结点被访问两次，所以时间复杂度 T=O(n)T=O(n)T=O(n)
空间复杂度：由非递归算法2可知，堆栈一次性最多存储h+1h+1h+1个元素(hhh表示二叉树的深度)，而hhh最大为nnn，所以空间复杂度 S=O(n)S=O(n)S=O(n)

后序遍历算法

非递归算法需借用堆栈

递归算法

int PostOrderBTree(BTree* BT){
    if (BT == NULL) return 0; // 空二叉树直接返回0
    PostOrderBTree(BT->left);  // 后序遍历先访问左子树
    PostOrderBTree(BT->right); // 然后访问右子树
    visit(BT); // 后序遍历最后访问根节点
    return 0;
}

非递归算法1

int PostOrderBtree(BTree* BT,S*S){ // 借助堆栈来记录路径，同时需要引入tag来标识状态
    BTree* p = BT;
    S->top =0; // 初始化
    while (p != NULL || top != 0){
        while (p != NULL){ // 先一直遍历左子树直至空
            push(p,1); //p入栈并将tag记为1
            p = p->left;
        }
        p = pop(S); // 出栈
        if (p->tag == 1){ //tag=1标识第一次访问
            push(p,2); //二次入栈，tag记为2
            p = p->right; // 开始遍历右子树
        }
        else {
            visit(p); // 第二次访问，说明左右子树都遍历完了，可以访问p了
            p = NULL; // 非常重要的一步！将p置为空，才能开启下次循环，否则又开始遍历p的左子树了
        }
    }
    return 0;
}

非递归算法2

需要改造堆栈，使每个元素加上一个tag（1,2,3）来标识第几次访问

int PostOrder(BTree* BT,S*S){
    if (BT == NULL) return 0;
    BTree* p = BT;
    S->top = NULL; // 堆栈置空
    push(p,1); // p入栈，同时tag记为1
    while (S->top != NULL){ // 循环结束条件：堆栈为空
        if (S->top.tag == 1){ //tag=1，标识第一次访问
            p = pop(S); // 出栈
            push(p,2); // 二次入栈，同时tag记为2
            if (p->left != NULL) push(p->left,1); //左子树入栈
        }
        else if (S->top.tag == 2){ // tag=2，标识第二次访问
            p = pop(S); // 出栈
            push(p,3); // 三次入栈，同时tag记为3
            if (p->right != NULL) push(p->right,1); // 右子树入栈
        }
        else if (S->top.tag == 3){ // tag=3，标识第三次访问
            p = pop(S); // 出栈
            visit(p); // 访问p
        }
    }
    return 0;
}

时间/空间复杂度分析

时间复杂度：由非递归算法2可知，每个结点被访问两次，所以时间复杂度 T=O(n)T=O(n)T=O(n)
空间复杂度：由非递归算法2可知，堆栈一次性最多存储h+1h+1h+1个元素(hhh表示二叉树的深度)，而hhh最大为nnn，所以空间复杂度 S=O(n)S=O(n)S=O(n)

逐层遍历二叉树

需借助队列

算法

int Q(BTree* BT, Quene*Q){ // 逐层遍历二叉树
    BTree p = BT;
    Empty(Q); // 将队列置空
    if (p != NULL){ // 根节点入队
        InsQ(p);
    }
    while(!Empty(Q)){ // 当队列为空时遍历结束
        p = outQ(Q); //出队并访问
        visit(p);
        if (p->left != NULL){ // 左节点入队
            InsQ(p->left);
        }
        if (p->right != NULL){ // 右节点入队
            InsQ(p->right);
        }
    }
}

时间/空间复杂度分析

时间复杂度：每个结点访问一次，则时间复杂度 T=O(n)T=O(n)T=O(n)
空间复杂度：显然空间复杂度 S=O(n)S=O(n)S=O(n)

TBT(Thread BT)遍历算法

任何包含n个结点的二叉树，采用二叉链表表示，有2n个指针域……（实现基础）
需要修改存储结构，在节点上加入左右标识
空的左指针指向“前驱”
空的右指针指向“后继”

代码实现

typedef struct Node{
    int data;
    Node* left;
    Node* right;
    bit Ltag; // 取0标识指针指向儿子结点，取1标识指针指向前驱或后继
    bit Rtag; // 
}; //更改存储结构

时间/空间复杂度分析

三叉链表存储遍历

需在节点上加入一个标识符，用来标注遍历情况（访问左、根、右节点）

代码实现

typedef struct Node{
    int data;
    Node* left;
    Node* right;
    char tag; // 使用char类型占用空间最小
};

int oderBTree(BTree* BT){
    BTree* p = BT;
    while( p != NULL){ 
        if(p->tag == 1){ // tag=1标识第一次访问该结点
            visit(p); // 这里以前序遍历为例
            p->tag = 2; // 访问完即改变tag
            if (p->left != NULL) p = p->left; // 访问左子树
        }
        if (p->tag == 2){ // tag=2标识第二次访问该结点
            p->tag = 3; // 若中序遍历，需在此句前visit(p)
            if (p->right != NULL) p = p->right; // 访问右子树
        }
        if (p->tag == 3){ // tag=3标识第三次访问该结点
            p->tag = 1; // 重置结点
            p = p->parent; // 返回父子树
        }
    }
    return 0;
}

时间/空间复杂度分析

时间复杂度：每个结点都访问了三次，则时间复杂度 T=O(n)T=O(n)T=O(n)
空间复杂度：没有借助任何附加空间，则空间复杂度 S=O(0)S=O(0)S=O(0)

递归算法

递归算法的书写过程
递归算法的执行过程 -> 非递归过程
T/S分析

二叉树的应用

1. 哈夫曼树

性质

WPL是最小的
权值越大的离根节点越近
不唯一

2. BST/AVL

3. T / BT转化

4. Heap(堆)

“数据结构实验”

数据结构实验题目及代码实现[更新中]

小yo — Fri, 24 Oct 2025 12:48:09 GMT

数据结构实验

1. 背包问题的求解

问题描述:

假设有一个能装入总体积为T的背包和n件体积分别为w1,w2,…wn的物品，能否从n件物品中挑选若干件恰好装满背包，即使w1+w2+…+wm=T，要求找出所有满足上述条件的解.

例如：当T=10，各件物品的体积{1,8,4,3,5,2}时，可找到下列4组解:(1,4,3,2)、(1,4,5) 、(8,2) 、(3,5,2)。

2. 农夫过河问题的求解

问题描述:

一个农夫带着一只狼、一只羊和一棵白菜，身处河的南岸。他要把这些东西全部运到北岸。他面前只有一条小船，船只能容下他和一件物品，另外只有农夫才能撑船。如果农夫在场，则狼不能吃羊，羊不能吃白菜，否则狼会吃羊，羊会吃白菜，所以农夫不能留下羊和白菜自己离开，也不能留下狼和羊自己离开，而狼不吃白菜。请求出农夫将所有的东西运过河的方案。

3. 简易电子表格的设计

问题描述:

设计一个支持基本计算统计功能和其它一些表格管理/处理功能的软件，使用户可在该软件的支持下，用交互方式进行表格建立、数据输入、数据编辑及其它一些表格操作。即类似于简易Excel表格处理软件。

4. 八皇后问题

问题描述:

设在初始状态下在国际象棋的棋盘上没有任何棋子（这里的棋子指皇后棋子）。然后顺序在第1行，第2行……第8行上布放棋子。在每一行中共有8个可选择的位置，但在任一时刻棋盘的合法布局都必须满足3个限制条件（1）任意两个棋子不得放在同一行（2）任意两个棋子不得放在同一列上（3）任意棋子不得放在同一正斜线和反斜线上。

5. 约瑟夫环问题仿真

问题描述:

设编号为1，2，…，n(n>0)个人按顺时针方向围坐一圈，每人持有一个正整数密码。开始时任意给出一个报数上限m，从第一个人开始顺时针方向自1起顺序报数，报到m时停止报数，报m的人出列，将他的密码作为新的m值，从他在顺时针方向上的下一个人起重新自1报数；如此下去直到所有人全部出列为止。

基本要求

设计一个程序模拟此过程，给出出列人的编号序列。

测试数据： N=7，七个人的密码依次为3，1，7，2，4，8，4. 初始报数上限值m=20。

算法思路

已知：N，各自密码。

数据结构选择：循环双链表

步骤：

S1：创建大小为N的循环链表，并读入各自的密码，p = head，count = 1;

S2：当p!= NULL时：{

S21：当count != m：{

p = p->next;

count ++;

}

S22：else{

print(p->number);

m = p->value;

p = destroy(p);

count = 1;

}

代码实现

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    int num;
    int data;
    struct Node* next;
    struct Node* prev;
} Node;

Node* CreateList(int n) {
    Node* head = (Node*)malloc(sizeof(Node));
    int x;
    scanf("%d", &x);
    head->data = x;
    head->num = 1;
    Node* p = head;
    for (int i = 1; i < n; i++) {
        Node* newNode = (Node*)malloc(sizeof(Node));
        scanf("%d", &x);
        newNode->data = x;
        newNode->num = i + 1;
        newNode->prev = p;
        p->next = newNode;
        p = newNode;
    }
    p->next = head; //形成环
    head->prev = p;
    return head;
}

int Josephus(Node* head, int m) {
    Node* p = head;
    int count = 1;
    while (p->next != p) {
        if (count != m) {
            p = p->next;
            count++;
        }
        else {
            printf("%d ", p->num);
            m = p->data;
            Node* temp = p;//删除节点
            p->prev->next = temp->next;
            temp->next->prev = p->prev;
            p = temp->next;
            free(temp);
            count = 1;
        }
    }
    printf("%d\n", p->num);
}

int main() {
    int n, m;
    printf("请输入人数和初始报数值：");
    scanf("%d %d", &n, &m);
    printf("请输入每个人的密码：");
    Node* head = CreateList(n);
    printf("出列顺序为：");
    Josephus(head, m);
    return 0;
}

6. 教学计划编制问题

问题描述:

大学的每个专业都要制定教学计划。假设任何专业都有固定的学习年限，每学年含两学期，每学期的时间长度和学分上限值均相等。每个专业开设的课程都是固定的，而且课程在开设时间的安排必须满足先修关系。每门课程有哪些先修课程是确定的，可以有任意多门，也可以没有。每门课恰好占一个学期。试在这样的前提下设计一个教学计划编制程序。

7. 二叉排序树与平衡二叉树的实现

问题描述:

分别采用二叉链表和顺序表作存储结构，实现对二叉排序树与平衡二叉树的操作。

8. 停车场模拟管理程序的设计与实现

问题描述:

设停车场只有一个可停放几辆汽车的狭长通道，且只有一个大门可供汽车进出。汽车在停车场内按车辆到达的先后顺序依次排列，若车场内已停满几辆汽车，则后来的汽车只能在门外的便道上等候，一旦停车场内有车开走，则排在便道上的第一辆车即可进入；当停车场内某辆车要离开时，由于停车场是狭长的通道，在它之后开入的车辆必须先退出车场为它让路，待该车辆开出大门，为它让路的车辆再按原次序进入车场。在这里假设汽车不能从便道上开走，试设计这样一个停车场模拟管理程序。

9. 学生成绩分析

问题描述:

录入、保存一个班级学生多门课程的成绩，并对成绩进行分析。

10. 一元稀疏多项式计算器

问题描述:

设计一个一元稀疏多项式简单计算器。

11. 哈夫曼压缩/解压缩算法（编译码器）

问题描述：

利用哈夫曼编码进行信息通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，要求在发送端通过一个编码系统对传输数据预先编码（压缩）；在接收端将传来的数据进行译码（解压缩复原）。试为这样的通信站编写一个哈夫曼编译码系统---哈夫曼压缩/解压缩算法。

12. 全国交通咨询模拟系统

问题描述：

处于不同目的的旅客对交通工具有不同的要求。例如，因公出差的旅客希望在旅途中的时间尽可能地短，出门旅游的游客则期望旅费尽可能省，而老年旅客则要求中转次数最少。编制一个全国城市间的交通咨询程序，为旅客提供两种或三种最优决策的交通咨询。

13. 迷宫问题

问题描述：

迷宫实验是取自心理学的一个古典实验。在该实验中，把一只老鼠从一个无顶大盒子的门放入，在盒中设置了许多墙，对行进方向形成了多处阻挡。盒子仅有一个出口，在出口处放置一块奶酪，吸引老鼠在迷宫中寻找道路以到达出口。对同一只老鼠重复进行上述实验，一直到老鼠从入口到出口，而不走错一步。老鼠经多次试验终于得到它学习走迷宫的路线。

周记Week1

小yo — Sun, 19 Oct 2025 17:54:24 GMT

前言

创建博客的目的之一，就是想记录自己的生活。写周记是个不错的形式，可以对自己过去一周的成果和日常进行总结。

学习

这周其实没太进行过多的学习，写了写离散的作业，大物写完了波动光学一，电路与电子学跟着老师进度，也没多学……数值计算方法作业截至目前甚至还没做。

唯一值得一提的估计就是在周末完成了该网站的搭建，虽然借鉴了很多很多的前人智慧，但还是有一些成就感的。

这周各种事物繁杂，搞得一直没专心投入到自己学业上的提升，下周还是应该好好安排时间，提升自己毕竟是最重要的。

生活

想来这周很多时间都用在了学习之外。

最重要的的当然是国家奖学金的评定了，材料来回修改，虽然占用了大量时间，但这份荣誉是值得这些时间的。

这周也参加了学生代表大会和党组织生活会。在党组织生活会就“和平发展”的主题展开了领学，做PPT的确花费了些时间，在台上讲的时候尝试脱稿，有点紧张了，出现了不少卡顿，但总体还是不错的。

这周西安还是在持续下雨，阴雨绵绵，也没法跑步，已经好长时间没有锻炼了，还是挺担心第十周的体侧的。

总结

这周的时间安排很大程度上有问题，下周要着重调整一下，更多地专注学业是对的。

给下周立几个flag吧：

把数据结构中线性表和二叉树的代码实现写一篇blog，正好也巩固一下数据结构知识。
大物的波动光学学完，写一篇期中考试范围的知识点总结，来应对第八周周末的大物期中。
数值计算方法的作业也得写一下，顺便写个blog来记录一下相关的代码实现吧。

差不多就这样吧，第一次写周记，形式还在摸索。期待下周的更新吧。

纪念2025年工创大赛

小yo — Sun, 19 Oct 2025 01:43:59 GMT

写在开头

这是笔者的第一篇博客，思来想去，还是决定写给工创赛。

说起来，小yo 这个网名，就是工创赛中认识的好友给笔者起的，这样想来，这第一篇博客送给工创赛，应是最好的选择。

认识笔者的读者应该知道，笔者在工创赛结束之时已经写个一个长篇来纪念，并发在了朋友圈和qq空间，这篇博客或许会有大量文字与之相同，请读者见谅。

初识工创

2024年12月5日，笔者第一次在学校官网看到了这个比赛，出于好奇心理选择了报名参加了eovs赛道。寒假，从B站学习了eovs基本玩法之后，便开始了日复一日的训练。记得那个时候主要是在饭盟训练，那时就认识了好多朋友，有色花、明月、恰逢、泽……寒假报名了岁寒杯，选拔赛就遇到了岁寒杯最终的冠军zhu和亚军花花，最终止步初赛，喜提三等奖，这是笔者在eovs中取得的第一个奖项，也正式开启了笔者的工创之旅。

险进国赛

3月份连续进行了三轮校赛，分别以小组第二，第三，第五的成绩晋级了每一轮比赛，并以第五名压线进入省赛，校一等奖，这是笔者在eovs中取得的第二个奖项。四月份为了省赛又开始了日复一日的训练。3.30找到了恩师汉谟，开始了系统性的培训。省赛是在4.26，初赛很顺利，小天选，小组第一晋级决赛。决赛就没有那么幸运了，20人局10人空北，令人窒息的天谴，2季度没卡上150更是雪上加霜，最终遗憾取得小组第十二，万幸，晋级国赛，省特等奖，这是第三个奖项。

止步国初

时间过得很快，转眼间进入暑假，笔者在转完专业之后便开始全身心投入国赛的备赛中。刚开始康复的时候总是难以触及初赛晋级线，后来在一众朋友的帮助下，成绩才一步步好起来，目标也从晋级决赛指向了全国特等奖。8.6抵达大连，一天的休整后便来到了8.7的初赛阶段。6号晚上思考了很多可能的情景，多方考虑后最终选择了风险最大的打法：一季度贪研发。初赛开始，筹建期翻季，一季度权益150整，贪到的同时也意识到，又是天谴。4274的市场，前9晋级，要翻过2个均衡天选，我看不到希望。笔者只能嘴里默念自己能行，但心里又很清楚，一切可能都结束了。八个季度4.5小时的努力，尽可能做到了每个季度都贴，第八季度放手一搏定高价，但命运或许从一开始筹建期就已经注定了，小组第11，全组空南无一晋级，天选最低都比天谴最高高了100w权益，真的是无力回天。最终，笔者无缘晋级决赛，止步全国二等奖，这是最后一个奖项。一切都结束了。

自我怀疑

半年以来，笔者的自我怀疑从未停止。校赛之前的寒假，无数次怀疑训练的意义，不知道自己能否走出校赛。省赛前更是无休无止的自我怀疑，看不到前路。感谢 桉桉姐 在那段时间一直开导笔者，帮助笔者挺过了省赛。国赛前不停地担心焦虑，让笔者选择了风险最大的打法，虽然最终无济于事。一路上充满了自我怀疑，好在，坚持下来了。

感谢恩师

感谢恩师汉谟，选择拜师汉谟是笔者这段旅程中做过最正确的选择。一次次教学复盘是一次次的进步，一步步走到国赛赛场，离不开汉谟哥的帮助。国赛初赛过后才知道，笔者和汉谟哥的队伍是一个小组的并且撞在了空南，但是正如前边所说，全组空南无一晋级，二人都无缘决赛。不过想来，两个人在互不知道的情况下同台竞技并全力以赴，这还是第一次，虽然最后因为这令人绝望的市场两人都被淘汰，但这场师徒“偶遇”也让这段故事的结尾有了更多的意义。汉谟哥 徒弟众多，笔者在其中并不出彩，笔者不知道 汉谟哥 对笔者的期望是什么，希望没能对笔者失望。

感谢队友

也要感谢一路陪笔者走过来的两位队友，没有他们，笔者不可能走到国赛。笔者不是一个会做旅游攻略的人，初赛淘汰后也始终解不开心结，多亏了二位，才让这次大连之旅不只有遗憾，也有了一路的欢声笑语。这一路辛苦了，很抱歉没能带着这个队伍挺进决赛。

关于热爱

笔者曾多次和其他不了解eovs的人提起这个比赛，他们不理解笔者为什么这么执迷于这个东西，意义是什么，笔者想引用 汉谟哥 发过的话：

你们坚持下来的每个天谴、改了n次的三四季度营销、争到面红耳赤的均价，早就刻成了比奖状更硬的底气。企业运营的魅力从来不止于结果，那些同市场没打过时的懊恼、三市场全贴时的雀跃，作为主力正式进入赛场时直面的那种未知和压力，才是你们人生中最宝贵的经历。

关于未来

这一届比赛笔者作为少有的进入国赛的大一选手，真的见证了诸神黄昏，国冠 zhu ，警长，沐沐，抱抱姐 ，顺遂哥 ，花花，长惜 …25年一代传奇，或许都将无缘27年的新一届比赛。笔者曾多次开玩笑说笔者要称霸27年eovs，但当真的面对即将来临的新版eovs和两年后的各种不确定性，是否会选择报名27年的工创赛，笔者无法给出一个肯定的回复。

最后

面向未来，笔者无数次感到迷茫，但笔者将不再犹豫不前。这篇是笔者博客的开始，笔者将持续更新自己所学和生活日常，记录这一往无前的旅程。

小yo 博客

周记 6.1-6.7

fuckZHS

马原“我来讲”校赛

随想

崇实之光

难抢的服务器

仓颉五子棋

写在最后

五月记

转专业经验分享帖

转专业经验分享帖

写在开头

个人背景

转专业前

关于政策

关于均分

纪念第十七届大学生数学竞赛

纪念第十七届大学生数学竞赛

启程

考场之上

熊猫基地的放松

出分

深夜的电话

聚光灯下

终点？

关于梦想

《LagerNVS》论文精读

领域背景与前置概念

新视角合成（NVS）任务定义

两种3D 表征路线

显式 3D 表征

潜空间几何

相机模型

外参

内参

场景尺度

w1w_1w1​：基于最大平移

w2w_2w2​：基于平均深度点

普吕克坐标系与射线

为什么需要射线

为什么传统的直线方程行不通

普吕克坐标系

参考视角

宏观架构设计

研究动机

核心 pipeline

架构对比

编码器剖析

Patchify

可选相机参数

11 维向量

输入网络

可选

VGGT

图像嵌入器 (Embedder)

聚合器 (Aggregator)

LagerNVS 中使用

解码器剖析

射线 token 化

目标视角的来源

训练阶段

推理阶段

目标视角计算为射线

目标视角 token 化

双向交叉注意力机制

全注意力 (Full Attention)

双向交叉注意力 (Bidirectional Cross-Attention)

渲染输出

训练、优化与扩散模型扩展

确定性回归训练

损失函数

端到端微调

www 的处理

确定性模型的问题

扩散模型扩展

模型改造

去噪训练

局限性

伪影与视频闪烁

w1w_1w1：基于最大平移

w2w_2w2：基于平均深度点