Posts on Ganko Space

SAM 3D:3Dfy anything in Images

Tue, 28 Jul 2026 00:00:00 +0000

原本看这篇论文以为是一个比之前更接近真实世界的3d生成新任务，还想着水他一篇，但是看了之后发现数据集不公开，做的话也没那么多资源，但是meta的工作，所以主要从这里边学习大厂大规模研究的工程和技术细节:数据pipline怎么做，训练策略以及实验评测设计。

这是看完之后的Ganko，纯大厂风格的力大砖飞工作，鉴定完毕，又浪费一天，tmd。（没有看不起的意思，我觉得我的小作坊编故事风格的工作还不如这种，这种至少有用）

论文想解决的问题

这篇论文要解决的是三个层层递进的问题，一个是旧3d重建任务针对单个物体，但是真实世界中的物体通常有遮挡，远距离等各种影响。这篇论文要解决的是一整个真实场景的3d重建，在重建场景中每个物体的同时预测物体的具体位姿以重建整个场景。因此就会引出第二个问题，3d模型数据不像自然2d图像和语言数据，自然界存在很多，合成数据有sim2real的问题要解决。然后就是标注问题，分类任务普通人就能标注，极低成本获得大量数据，但是3d建模需要专业技术。

解决思路

三个问题是递进的，解决了标注和数据问题，设计迭代模型反而简单。所以先从标注成本入手，普通人不能进行3d建模，但是能区分3d建模质量的高低（Human in loop - HIL），设计了MITL pipline，让普通人从几个候选中挑选并且对齐位姿（怎么获得候选个问题，就是冷启动问题，核心方法会写）。用这个pipline收集大规模的数据，然后针对真实世界的复杂性设计了方法和仿LLM的训练策略，（合成预训练-半合成中期训练-真实数据后训练）。

核心方法

网络结构

每个部分的具体实现：

Encoder：Encoder全都使用DINOv2，得到4组条件token，一组是裁剪物体：通过掩码M以及对应的裁剪二值Mask对裁剪的图像I进行编码，提供聚焦的高分辨率的物体视图。另一组是全图I以及全图二值掩码，提供全局上下文线索。点云Encoder可选可不选，可以选用硬件采集也可以用其他深度估计方法来得到。
Geometry Model：论文的问题定义中把这个任务定义成了一个条件分布估计 $q(S, T, R, t, s|I, M )$，在具体的实现中又把整个任务拆成了两个条件分布，几何模型负责 $p(O,R,t,s∣I,M)$,回答物体在什么地方，大概长什么样子。（O是粗形状，R是6d pose，t是物体在相机系中的3维位置，s是在三个轴上的缩放）。输入图像和掩码经过编码后，送入一个 12 亿参数的流匹配 Transformer（flow transformer），采用 Mixture-of-Transformers (MoT) 架构——一种多模态 Transformer 变体，通过精心设计的 attention mask（Fig. 2 右图所示）让不同模态（图像、掩码、形状、位姿）之间既共享信息又保持各自的处理流（two-stream approach）。MoT 的特点是稀疏高效：不同模态有各自的 Transformer 层，只在多模态自注意力层做信息交互。（本质双流加交叉注意力）
Texture & Refinement Model：这部分负责 $p(S,T∣I,M,O)$,从粗形状 O 中只保留"被占据"的体素（active voxels），跳过空区域，一个 6 亿参数的稀疏潜流 Transformer（sparse latent flow transformer）在这些活跃体素上做两件事——把粗糙的几何细节补全（比如把 643643 的粗体素细化成更高分辨率的形状 S），同时合成物体的纹理 T。
3D Decoders：得到Texture & Refinement Model的隐空间的特征表示之后，使用两个独立的解码器解码，一个mesh解码器用于传统建模行业，另一个Gaussian解码器用于实时渲染和新视角合成，两个解码器共享一个隐编码空间。

训练

TODO

Thu, 02 Jul 2026 00:00:00 +0000

一个索引+TODO

TODO

CodeByMySelf-VAE（TODO）
CodeByMySelf-RL（TODO）
并行训练实践（未完成）

关于爱情的一些思考

Tue, 30 Jun 2026 00:00:00 +0000

什么是回避型依恋

回避型依恋的核心特征：

恐惧亲密——不是不需要，是怕被伤害
推开即测试——冷落你不是不爱你，是在看你走不走
自我消化情绪——有事自己扛，不习惯求助
忽冷忽热——靠近了怕失去自我，远了又怕失去你

最核心的一件事：用她感受爱的方式去爱她

这不是一条技巧，是下面所有技巧背后的那句话：

爱一个人，要用她感受爱的方式去爱她，而不是用我自己能感受爱的方式去爱。

我们默认用自己的方式去爱：我收到礼物会感动，所以送你礼物；我说「我爱你」会被安慰，所以反复说；我需要陪伴，所以以为多陪你就是爱你。但这其实是在爱自己——在用「如果我被这样对待，我会感到被爱」来推测她。她接收爱的方式可能完全不同：

她可能不看你说了什么，只看你有没有在
她可能不要惊喜，要的是稳定、是说话算数
你花了一整天准备的浪漫，她的需求可能只是你按时回她消息

检验的标准不是「我表达了没有」，而是「她收到了没有」。 以她的感受为准，不以你的付出为准。

怎么知道她怎么感受爱：

看她怎么对人好——人通常给出自己最想收到的那种爱
看她抱怨什么——抱怨里藏着需求：「你总是不记得小事」→ 细节是她爱的语言
直接问：「怎样会让你觉得被爱？」——这个问题本身，就是一种爱的表达

这个原则对所有关系都成立，不只是回避型。 只是对回避型尤其致命：她接收爱的方式和你表达爱的方式，差异往往最大。你用热烈的爱去追一个需要安静的爱的人——她收不到，你觉得委屈；你觉得付出很多，她觉得窒息。两个人都受伤。

下面所有的应对原则，都是这句话的具体化。

应对原则

1. 不追，但在

追太紧她会跑，退太远她会觉得「果然如此」。最好的距离：让她看见你一直在，但不逼她过来。

2. 用行动，不用承诺

回避型不相信「永远」「以后」这种词。她信你做了的事：你等了她、你记得她说过的话、你在她冷的时候没走。

3. 吵架时语气 > 内容

你赢了逻辑，她输了安全感。一旦安全感没了，她会缩回去很久。

4. 别问她「你怎么了」

她想说的时候会说。问就是压力。换成「我在，你什么时候想说都行。」

5. 接受撤退不是拒绝

她冷淡 = 系统过载，自动关机。不是讨厌你。给她时间重启。

6. 表达情绪时收着点

回避型对强烈情绪过敏。平静的、稳定的表达，比激烈的告白更让她安心。

7. 她逃之前，你先退半步

当她开始退缩，不要等她冷到零度再反应。在她缩的初期，主动拉开一点距离——但不是冷漠，是控制节奏。

话术示例：「最近有点忙，周末再找你。」

「忙」→ 不是她的错，不是她在被惩罚
「周末」→ 给了时间锚点，她知道你不是消失
你主动走半步 → 她不用愧疚地逃

分析： 回避型的退缩本质上是对「被吞没」的恐惧——她感觉关系在升温，本能想拉开距离保护自我边界。如果你等她先冷，她会觉得自己伤害了你，然后更不敢回来。如果你在她感受到压力之前主动松一松，她不需要逃，因为绳子没勒紧。

建议：

在她态度开始变淡的第一天就主动减频，不要在第三天崩溃追问
减频时带一个「客观理由」（课题、开会、赶 due），让她不用猜
约定的回头时间一定要兑现——这是建立信任的关键测试

关键信号

信号	含义
主动联系你	对你信任度很高
跟你说脆弱的事	已经把你放进内圈
之后突然冷淡	不是后悔，是后怕——这是最关键的判断节点
在你面前任性	安全感足够高，开始摘面具

给自己的提醒

不能把全部安全感寄托在她身上。

[论文阅读] Vision Transformers Need More Than Registers

Sun, 21 Jun 2026 00:00:00 +0000

一句话总结

ViT使用语义无关的背景块作为表示全局语义的捷径，在全局注意力和粗粒度语义监督的驱动下。这篇论文选择性地将补丁特征集成到CLS token中，减少了背景主导的快捷方式的影响，并在标签、文本和自监督的情况下，在12个基准测试中提高性能。

论文信息

标题：Vision Transformers Need More Than Registers
作者：Cheng Shi, Yizhou Yu, Sibei Yang (University of Hong Kong & Sun Yat-sen University)
会议/期刊：arXiv preprint (2602.22394)
链接：https://arxiv.org/abs/2602.22394
代码：https://github.com/ChengShiest/LAST-ViT
前置工作：Vision Transformers Need Registers (Darcet et al., ICLR 2024)

研究背景与动机

原始 ViT 中的 CLS token 用于聚合全局图像表示
Darcet et al. (ICLR 2024) 发现 ViT 的特征图中会出现异常的 high-norm artifact patches，提出添加额外的 register tokens 来吸收这些 artifacts
但这篇论文认为问题不仅仅是 artifact patches —— ViT 存在更根本的 lazy aggregation 行为，Lazy Aggregation：在图像级粗粒度监督下，ViT倾向于将前景语义"扩散"到大量背景patch中，利用背景token作为编码全局语义的捷径。

lazy aggregation是这篇论文贡献中提出的一个关键假设，但是我不认为应该这么局限于vit，我认为这是对于目前整个学习范式的问题，数据不可能做到面面俱到，模型在寻找最优解的时候可能会偏向于利用背景分析，比如dataset中所有bird类图片的background都是类似的，模型就会把背景作为一个主要判断依据，但是从另一个角度来看，又不能完全不考虑背景信息，例如一个像狗又像狼的生物，在野外会判断成狼，但是在农村院子里就是狗，虽然通过主体自身信息能做到百分之八十到九十的准确性，但是背景并非完全无用，就像我在我的论文中描述的一样。

CS336 Lecture 5-6: GPUs & Kernels, Triton

Mon, 08 Jun 2026 00:00:00 +0000

为什么这两讲至关重要

在已经学过的课程中，L1-L4 讲的是"模型长什么样"，L7-L8 讲的是"多卡怎么协作"。L5-L6 卡在两者之间——单卡内部到底在发生什么。

如果你不理解 GPU 的硬件结构，你就无法理解：

为什么 Flash Attention 是过去五年 LLM 领域最重要的系统优化
为什么大矩阵乘法是"compute-bound"而 Attention 是"memory-bound"
为什么你写的 PyTorch 代码有时 GPU 利用率只有 30%
ZeRO-3 的通信开销到底卡在哪里（看懂 L7-8 那块没懂的）

Percy 在 L6 的原话很直白：“You cannot optimize what you don’t measure, and you cannot measure what you don’t understand.”

Lecture 5：GPU 架构解剖（Tatsu）

5.1 从一张 H100 说起

H100 的基本参数：

HBM（显存）：80GB，带宽 ~3.35 TB/s
SRAM（片上共享内存）：每 SM 约 256KB，总带宽 ~几十 TB/s（比 HBM 快一个数量级）
计算能力：BF16 下 ~990 TFLOPS

关键不在于这些数字有多大，而在于数字之间的比例。

CV领域的多任务统一模型

Fri, 05 Jun 2026 00:00:00 +0000

改论文intro的时候突然想到，看到过有人问为什么CV领域没一个Scaling law，很明显的原因是CV领域不同的任务太多了，先不说图片的信息密度问题，单是把所有任务统一到一个模型里，都很费时间。但是又想到，大部分cv任务本质上可以通过完美的理解图片来解决，比如：模型知道每一块每一个像素具体是哪个类别的（或者有一些任务是某种属性）。这样就有一个想法: 假设有一个模型，在给定一个框（可以是像素，也可以是规则/不规则的块）和完整图片，模型需要知道这个框是什么类别的，这样的话分类任务可以通过最高占比来决定（一张蜜蜂的图片，大部分是空白蓝天会分类错误，但是这并不能证明这个方法的缺陷，只能说明预先定义了空白蓝天是无意义的类别（从平常摄影的角度来说，也可能是对焦问题））；分割和定位任务可以通过对每一个像素点（或者说大patch，像素太小了）循环问是什么类别来得到，不过这个时候就会有一个问题，效率问题，很自然就想到一个办法，采样。想到这里突然就联系起来了，SAM用的就是用的采样，但是依然很慢其实（）。想法就到这里了，虽然没什么结果，但是让我知道了这个领域，这篇就用来记一下试图去统一CV任务的论文阅读了（可能论文本身没写，但是确是有这种趋势或者可能的也会在这里放） 2026/6/5

写完上边那些突然想到，超分、去雾、生成这些任务怎么统一啊，诶，看来还是论文看少了。最后感慨一下，如果放在以前，脑子里有这么一个奇怪的idea，我需要花费数周的时间查询阅读相关论文，但是现在只需要一个小时就能大概了解这个方向大家在做什么。 2026/6/5

GPT4RoI[ECCV WORKSHOPS 2024]

GPT最推荐我读的论文。它用户 instruction 里的 RoI / box 替换成 RoI features，再送进 LLM，做 region-level image understanding。它还强调 region-text pairs 对细粒度理解的重要性。

NanoVLM-AnyRes

Sun, 31 May 2026 00:00:00 +0000

AnyRes（动态高分辨率）是 LLaVA-NeXT 1.6 的核心创新，解决了固定分辨率下细节丢失的问题：将图像按纵横比自适应切分为多个 tile，每个 tile 独立编码后和全局缩略图一起送入 LLM。NanoVLM 在保留原始单图模式的基础上新增了 AnyRes 能力，两个模式通过一个布尔值切换。

问题：固定分辨率的瓶颈

NanoVLM 的基础版本将每张图 resize 到 384×384，经 SigLIP 编码为 729 个 visual token。这对大多数自然图像够用——但遇到高分辨率图像（文档、OCR、大场景）时，细节会被压缩到不可辨认。

一个具体的例子：

原始图像: 1920×1080 的截图（包含文字）
 ↓ resize 到 384×384
丢失了 (1920×1080) / (384×384) = 14× 的像素信息
 ↓
文字模糊到 LLM 无法识别

AnyRes 的思路很直接——不要压缩整张图，而是把大图切成多个小图，每个小图保持清晰。

核心算法

处理流程

原图 (如 1200×800, AR=1.5)
 │
 ├─ Step 1: 选 grid → 2×2（4 tiles）
 │
 ├─ Step 2: 生成缩略图
 │ resize → 384×384 → 729 tokens（全局上下文）
 │
 └─ Step 3: 切分 + 编码 tiles
 原图 → resize_to_fit(768×768) → 切成 4 个 384×384 tile
 tile[0,0] → SigLIP → 729 tokens
 tile[0,1] → SigLIP → 729 tokens
 tile[1,0] → SigLIP → 729 tokens
 tile[1,1] → SigLIP → 729 tokens
 ─────────
 总计: 5 × 729 = 3645 tokens

关键细节：缩略图保留全局上下文，tiles 保留局部细节。两者互补——缩略图告诉 LLM"这是一张包含文字和图表的信息图"，tiles 告诉 LLM 文字具体写了什么。

NanoVLM-LLaVA

Wed, 06 May 2026 00:00:00 +0000

总结了NanoVLM（LLaVA格式）的背景、原理、核心代码、实现细节。最开始只是LLaVA思想的初步实现，即使用一个线性层（或MLP）将视觉特征转换为文本特征，或者说是将视觉特征和文本特征对齐，后边会慢慢加入LLaVA-1.5、LLaVA-NeXT、LLaVA-OneVision的思想。

LLaVA

LLaVA 最初的结构如下:

其中， Xv为输入图像，而Xq为输入文本指令。 Xv经过冻结的预训练视觉编码器（例如CLIP的视觉编码器）转换为视觉特征, 又进一步经过一个简单的线性层W转换为文本特征,便可和文本指令特征Hq一起送入LLM进行处理。

LLaVA的训练目标为LM:

$$ p(\mathbf{X}_{\mathrm{a}} \mid \mathbf{X}_{\mathrm{v}}, \mathbf{X}_{\mathrm{instruct}}) = \prod_{i=1}^{L} p_{\boldsymbol{\theta}}(x_i \mid \mathbf{X}_{\mathrm{v}}, \mathbf{X}_{\mathrm{instruct}}, \mathbf{X}_{\mathrm{a}, < i}) $$

即基于当前图像、历史指令、历史答复预测新一轮的答复。整个训练过程包含两步：

步骤1: 固定Vision Encoder和LLM，预训练Projection 以实现图像和文本模态对齐；

步骤2: 放开LLM，进行端到端的训练。

原始 LLaVA 1.0 的具体配置

组件	配置	参数量
Vision Encoder	CLIP ViT-L/14@224²	~300M
Projector	单层 Linear (1024→4096)	~4.2M
LLM	Vicuna-7B/13B	7B/13B

Vision Encoder：使用 OpenAI 预训练的 CLIP ViT-L/14，输入分辨率为 224×224。patch_size=14，因此每张图产生 $(224/14)^2 = 256$ 个 patch token + 1 个 CLS token，每个 token 维度为 1024。视觉编码器在整个训练过程中完全冻结。

多卡并行训练和微调技术

Mon, 27 Apr 2026 00:00:00 +0000

这是使用 Google DeepResearch 生成的偏理论分析报告，内容基于2026/4/27之前的公开资料和技术文献，主要是方便自己学习，准确性和时效性可能无法完全保证。

第一章深度学习分布式训练的底层基石：显存与通信的博弈

随着大语言模型（LLM）参数规模从十亿级别飙升至万亿级别，深度学习的训练与微调已经彻底演变为一项复杂的系统工程。在这一演进过程中，单张图形处理器（GPU）的显存容量与计算能力已无法满足动辄数千吉字节（GB）的内存需求，多卡并行架构成为必然选择。

在多卡分布式训练中，架构设计的核心挑战始终围绕着**“显存墙（Memory Wall）”与“通信墙（Communication Wall）”**的博弈展开。

[1].1 显存消耗模型解构

要深刻理解分布式训练的演进，必须首先解构模型在训练过程中的显存消耗。在采用混合精度训练（Mixed Precision Training）及 Adam 优化器的情况下，每个模型参数通常需要消耗约 20 字节的显存：

模型状态（Model States）：
- 权重与梯度： 半精度（16-bit）各占用 [2] 字节（共 [4] 字节）。
- 权重与梯度副本： 全精度（32-bit）各占用 [4] 字节（共 [8] 字节）。
- 优化器状态： Adam 优化器的一阶与二阶矩估计状态各占用 [4] 字节（共 [8] 字节）。
剩余消耗： 前向传播过程中产生的**残差状态（Residual States，即激活值 Activations）**和各类临时缓冲区，会随着批次大小（Batch Size）和序列长度呈线性甚至二次方增长。

示例： 一个 [75] 亿参数的模型，仅静态模型状态就需要消耗约 150GB 显存，远超单张 H100（80GB）的物理极限。

[1].2 通信原语与同步机制

在多 GPU 协同计算时，节点间必须通过特定的**集体通信原语（Collective Communications）**进行数据交互：

基础原语： 包括广播（Broadcast）、收集（Gather）、分散（Scatter）以及规约（Reduce）。
核心同步机制： 全规约（All-Reduce）。它确保了所有 GPU 在反向传播后能够获得一致的梯度总和。

从底层实现来看，最优的 All-Reduce 操作通常被分解为两个连续步骤：Reduce-Scatter（规约-分散） 与 All-Gather（全收集）。理解这种分解机制是掌握高级状态切分策略（如 ZeRO 和 FSDP）的技术基石。

[Paper] Causal

Thu, 23 Apr 2026 00:00:00 +0000

所有之前

这篇文章是我在阅读因果理论在视觉方面应用相关论文时的笔记总结,通过这篇文章，我希望能够系统地梳理相关论文的核心方法和我的理解和思考。后边到了写作的时候，增加了一些写作的参考。写作思路部分会按照普遍论文的结构进行-摘要、引言、相关工作、方法、实验、结论来总结写作思路，当然也会根据不同论文的特点进行调整。

[TPAMI] A Causal Adjustment Module for Debiasing Scene Graph Generation

这篇论文想解决什么问题？

这篇论文想解决场景图生成中对于长尾关系对的偏见问题，通过基于全局的统计量设计的一个后处理模块来调整模型的预测结果，从而提升模型在长尾关系对上的性能。

传统的去偏方法（重采样、重加权、调整方法）只关注关系分布 R 的长尾问题，但它们忽略了一个更深层的因果链条：

物体分布 O → 物体对分布 P → 关系分布 R :

物体分布 O ：不同物体类别的频率（如"人"很常见，“大象"很罕见）

物体对分布 P ：两个物体共同出现的频率（如<人, 椅子>很常见，<人, 大象>很罕见）

关系分布 R ：具体关系的频率

仅仅建模 O→P 是不够的,直观上，如果"人"和"树"都是高频物体，按 O→P 的逻辑，<人, 树>应该是最常见的物体对。但现实中，<人, 衬衫>比<人, 树>更常见，因为人和衬衫的共现（Co-occurrence）概率更高。

论文提出了 Mediator-based Causal Chain Model (MCCM)，将因果链修正为：

$$ O→中介：共现分布 C→P→R $$

核心方法

原理:从因果推断中引入 Average Treatment Effect (ATE) 概念，用于指导调整因子的学习。

反事实问题：如果能把物体对分布 P 从"高频状态”（p ）改为"低频状态"（p0 ），模型的预测会如何变化？

公式 20 展示了 CAModule 如何估计这种反事实效应：

CS336 Lecture 7-8：Parallelism

Thu, 09 Apr 2026 00:00:00 +0000

本篇主题

这两节Lecture都是关于并行训练的，主要内容包括：

理解训练超大模型时系统层面的复杂性
掌握不同的 parallelization paradigms，以及为什么人们通常会同时使用多种并行方式
了解大规模训练任务通常是如何进行的

Lecture 7 - Parallelism 1

单块GPU无法满足SCALING的需求，必须使用多块GPU进行训练,所以我们需要Multi-GPU、Multi-Machine的并行训练方法，如下图所示：

首先讲了一些Basic Concepts：

All Reduce：通信操作，所有参与的进程都将输入数据进行规约（如求和、最大值等）后，将结果分发给所有进程。常用于分布式训练中的梯度同步。
Broadcast：通信操作，数据从一个进程发送到所有其他进程。常用于分布式训练中的分发模型参数或者初始化数据。
All Gather：通信操作，所有参与的进程将各自的数据发送给所有其他进程，最终每个进程都获得所有数据的集合。常用于分布式训练中的收集模型输出或者中间结果。和All Reduce的区别在于，All Reduce会对数据进行规约操作（如求和），而All Gather只是简单地收集数据，不进行任何计算。
Reduce Scatter：通信操作，所有参与的进程将各自的数据发送给所有其他进程，并对数据进行规约操作（如求和），最终每个进程都获得规约后的结果的一部分。常用于分布式训练中的分布式梯度更新。

了解了初始知识之后，可以正式进入核心部分，不同的并行方式：

Data Parallelism：最早的并行方式，模型复制到每个GPU上，每个GPU处理不同的数据batch，计算梯度后进行同步更新。优点是实现简单；缺点是通信开销大，尤其是模型参数较大时。假设计算一个 SGD：我们会把 B 大小下的 batch 分给 M 个不同的机器，然后交换梯度去同步计算。这种情况对于 Compute scaling，每个 GPU 计算 B/M 个数据（不错！）；对于 Communication overhead，每个 batch 需要转移两次梯度（发送和接受）；对于 Memory scaling，完全没有，每个 GPU 都需要复制一次模型参数。早期的data parallelism问题是只缓解了计算压力，内存压力没有缓解，需要每个GPU都复制一份模型参数，通信压力也很大。 Zero[HTTPS://arxiv.org/pdf/1910.02054]可以解决这个问题，核心的思想是将模型的state（参数和优化器状态）分布在不同的GPU上，每个GPU只存储模型的一部分，这样可以显著减少每个GPU的内存占用，同时通过通信操作来同步更新模型参数。 ZeRO分三个阶段：

ZeRO-1：主要聚焦于 optimizer state sharding。把 optimizer state（first + second moments）分给每个 GPU，每个 GPU 都有 parameters + gradients，负责更新一部分 params。每个 GPU 根据分配到的 batch 子集计算完整的梯度，此时只拥有局部梯度利用 Reduce-Scatter 将所有 GPU 的局部梯度汇总并分散到每个设备上，现在每个 GPU 只持有全局梯度的一部分每个 GPU 利用局部梯度和 optimizer state 更新该部分参数利用 AllGather 将所有 GPU 的部分参数收集并分发给所有设备，确保每个 GPU 拥有完整的参数。这种方法的通信开销并没有增加，而且 memory 减少了接近四倍（优化器状态是fp32，参数是fp16）。

Pytorch-Tricks

Tue, 07 Apr 2026 00:00:00 +0000

写在前面：Pytorch 内容繁杂，实验中用到的技巧与机制若不及时记录，容易遗忘并导致重复造轮子。本文档用于记录 Pytorch 的相关技巧与机制，将持续更新，方便后续查阅。

动态计算图

缘起

在一次实验日志中，发现一个固定的 CNN 模块推理时间存在较大波动。排查后发现是数据流水线卡顿或 GPU 内存管理抖动所致，但也因此注意到了 Pytorch 的动态计算图机制。

Pytorch 在每次前向传播时都会重新构建计算图，这意味着每次前向传播都会产生额外开销，尤其在模型结构复杂或输入数据变化较大时，可能导致推理时间波动。

具体而言：

每次前向传播，即便模型结构未变，Pytorch 仍会依据当前输入数据和模型结构重建计算图。
若输入数据形状或模型结构发生变化，计算图会重新构建，进而引发性能波动。

可能导致性能波动的情况

1. 条件分支结构

模型中包含数据依赖的条件分支（如 if 语句）时，不同前向传播可能执行不同计算路径，导致计算图结构变化。

class BadEncoder(nn.Module):
 def forward(self, x):
 if x.sum() > 0: # 数据依赖的条件
 x = self.heavy_conv(x)
 else:
 x = self.light_conv(x)
 return x

2. 变长序列

处理变长序列（如 RNN 或 Transformer）时，每次输入长度可能不同，导致计算图结构变化。

class BadRNN(nn.Module):
 def forward(self, x):
 for i in range(x.size(1)): # 依赖输入序列长度
 x = self.rnn_cell(x[:, i, :], x)
 return x

3. 其他情况

动态形状
随机性操作
稀疏操作

解决方案

使用静态计算图：若模型结构固定，可借助 TorchScript 或 ONNX 转换为静态计算图，避免每次前向传播都重新构建。
Padding + Mask：对于变长序列，采用填充至统一长度，并利用 mask 标识有效部分，保持计算图结构一致。

模型训练/推理速度分析与优化

背景

修改模型与训练代码后发现速度明显下降。排查发现数据加载耗时过长，遂将 DataLoader 的在线预处理改为离线处理。但模型推理速度仍慢于基线，后续需进一步优化。

CS336 Lecture 2: Resource Accounting

Mon, 06 Apr 2026 00:00:00 +0000

本讲主线

这节课围绕一个核心问题展开：如何精确估算训练成本。主要分为三块：

内存占用
FLOPs 估算
模型与训练配置

这和 Lecture 1 提到的“效率优先”直接相关。

例题：70B 模型训练时长

问题：使用 1024 张 H100，在 15T tokens 上训练一个 70B 模型，需要多久？

根据 Transformer 常用训练量估算公式（$6 \times$ 参数量 $\times$ token 数）：

$$ \text{总 FLOPs} = 6 \times 70 \times 10^9 \times 15 \times 10^{12} = 6.3 \times 10^{24}\,\text{FLOPs} $$

单卡 H100（BF16）理论性能约为 $2 \times 10^{15}$ FLOPs/s。若考虑大模型训练实际效率约为 30%，则单卡有效 FLOPs/s 为：

$$ 0.3 \times 2 \times 10^{15} = 6 \times 10^{14}\,\text{FLOPs/s} $$

总时长：

$$ \text{总时间} = \frac{\text{总 FLOPs}}{\text{每秒有效 FLOPs} \times \text{GPU 数量}} = \frac{6.3 \times 10^{24}}{6 \times 10^{14} \times 1024} $$

约等于 119 天。

CS336 Lecture 3-4: Architectures, Hyperparameters, and MoE

Mon, 06 Apr 2026 00:00:00 +0000

本讲主线

老师推荐了 The Illustrated Transformer 作为辅助材料。

这节课基于 Tatsu H 对 2017-2025 年经典模型的统计，讨论两个问题：

不同模型在架构与超参数上有哪些共性与分歧？
这些演化背后的工程动机是什么？

架构与超参数观察

Pre-Norm vs Post-Norm 几乎所有现代 LLM（BERT 这类早期模型除外）都采用 Pre-Norm。核心原因是训练更稳定，梯度路径更顺畅。近年还出现了 double norm 等变体（如 Grok、Gemma 2），但尚未完全普及。
LayerNorm vs RMSNorm RMSNorm 不计算均值，只做均方根归一化，计算更简单。表面上看节省 FLOPs 不多，但在真实系统中，norm 的时间开销往往受 data movement 影响明显，因此 RMSNorm 的工程收益更像是在缓解内存墙，而不仅是减少算术量。
激活函数演化 从早期 ReLU，到 GPT 系列常见的 GeLU，再到近年广泛采用的 SwiGLU（门控激活变体）。门控结构通过逐元素调制，提升了表达能力与训练效率的折中表现。
串行层与并行层 传统 Transformer block 以串行堆叠为主。并行 block（如部分 GPT-J 设计）存在，但总体采用度不高。
位置编码路线 Sine/Absolute/Relative 都在不同阶段被主流模型采用。近年 RoPE（rotary position embeddings）几乎成为事实标准之一。
FFN 维度比（ffn dim : model dim） 传统经验常用 4 倍宽度；在 GLU 系列激活流行后，很多模型会选在 2.5-3.5 区间（常见约 8/3），以平衡参数规模与表达能力。

CS336-写在所有之前

Mon, 06 Apr 2026 00:00:00 +0000

CS336 是一门很好的课，但是很多内容都比较基础，或者在网上已经有很多资源了。

2026/04/06:我学到了Lecture4，目前来看，CS336的精华内容还是在Lab上面，如果想要系统学习LLM的训练细节，建议直接看Lab的内容，Lecture部分可以作为辅助材料来理解一些概念和背景知识。

2026/04/09：Lecture4之后因为对并行训练的兴趣，直接跳到了Lecture7-8，感觉内容非常有价值，值得细看一下lecture视频或者讲义，精华在于不同并行方式的介绍和分析，在Lecture8里有一些简单的通信操作代码示例，帮助理解。

CS336 Lecture 1: Overview and Tokenization

Fri, 03 Apr 2026 00:00:00 +0000

课程导读

这门课的讲义基于 notebook 组织，不同章节通过函数模块化展开。

开场老师提出了一个很尖锐的问题：研究者正在与底层技术逐步脱节。他给了一个时间线：

八年前，研究者会自己补充数据并训练模型；
六年前，研究者还会下载模型后进行 fine-tune；
现在，很多人直接向闭源模型（GPT-4/Claude/Gemini）提问。

这虽然有些夸张，但确实反映了趋势：模型能力提升后，很多基础环节被“封装”了。老师强调：

“Full understanding of this technology is necessary for fundamental research”

随着模型规模持续增大，训练中的计算压力正在从 Attention 逐步转向 FFN。

课程收获

Mechanics：系统如何工作（如 Transformer 结构、GPU 并行方式）
Mindset：如何最大化利用硬件与内存，如何看待 scaling laws
Intuition：哪些数据和建模决策更可能带来更好结果

老师也指出一个常见误解：只要堆算力，模型就会自动变好。他给出的观点是：准确率 = 效率 × 资源。

在数据和资源固定时，效率决定了上限。

老师将近年的 LLM 工作大致分成两类：

闭源路线：以 GPT 系列为代表，最早系统性拥抱 Scale，但细节封闭。
开放权重路线：以 Qwen 等 open-weight 模型为代表，拥抱 Scale 的同时提升开放度，但常见情况是只公开部分训练细节，数据与失败案例仍不完整。

Tokenization

为什么需要 tokenization？因为 LLM 在 token 序列上建模概率分布，我们需要把原始字符串编码为 token，并保证可逆解码。

🔗 Tokenization 可视化工具: tiktokenizer.vercel.app

常见 tokenization 方法：

博客网站优化日志

Fri, 03 Apr 2026 00:00:00 +0000

📅 2026-04-03

✅ 已完成工作

环境搭建：Hugo+PaperMod 部署。
域名申请：ganko.asia 申请。

🚧 进行中（等待审核）

域名备案/审核：域名实名审核/备案状态，不能通过自定义域名访问。

📅 2026-04-04

头像发光效果，文章卡片悬浮效果。

📅 2026-04-07

域名审核通过，绑定成功，使用Nginx+Certbot配置HTTPS。
增加阅读的目录，直接跳转到文章不同部分。

胡思乱想

Fri, 27 Mar 2026 00:00:00 +0000

这里用来记录一些无论是产品角度的想法，还是算法角度的想法，或者是一些其他的想法。总之就是一些胡思乱想，这里不会引用任何论文，我也不会去查找任何资料，完全是凭空想象的。也就是说，这里记录的内容可能完全是错误的，甚至是荒谬的，但我觉得有趣，所以就记录下来.

神奇的特征空间 2026-4-1

在这个神奇的特征空间中，同一物体的特征不再是无规律的，而是可以通过运算得到的，例如：

一个朝向我可乐瓶的特征可以通过旋转得到一个背向我的可乐瓶的特征。
一半可乐瓶的特征应该是contact另一半可乐瓶的特征得到完整可乐瓶的特征。

具体来说，就是一个可旋转，拼接，以及不同角度拼接的特征空间，如果可以的话，这个特征空间应该是三维的（不过很明显这里的特征不包括-一瓶水甜还是苦这种单从图片无法推测的属性）

VIT和CNN都有的惰性问题：依赖背景对主体进行识别 2026-4-18

在一些数据集中，模型可能会过度依赖背景信息来识别主体。例如，在一个包含大量猫的图片数据集中，模型可能会学会通过识别草地或室内环境来判断图片中是否有猫，而不是通过识别猫的特征。这种依赖背景的现象可能会导致模型在面对新的环境或背景时表现不佳，因为它没有真正学会识别主体的特征。

找到哪些受上下文影响较大的特征，让模型仅通过这些特征识别，让总体的识别减去这些敏感特征的识别，效果会不会变好。因为从最近研究的因果角度来说，背景信息某种程度上也会影响主体的识别，所以完全去除背景信息可能也不是最好的选择，而是找到一个平衡点，让模型减去完全使用背景信息盲猜的结果，在因果图上相当于切断了背景信息对主体识别的直接影响，但保留了背景信息通过主体再影响识别的间接影响。

补充:四月刷到了一篇关于解决VIT这个问题的论文，不过没看，不知道他用的什么方法（还是抽空看一下吧）;现在是5月26，这篇论文看了，笔记在vit_lazy_aggregation但是还是有点不一样，和我想的有一点不一样，他还是在针对前景和背景这两个具体的块做，本质还是针对不同信息密度的区域做不同处理，有点像是任务导致的区别，分类任务本质就是要找到主体，而类分割任务要的是主要根据自身区域并一定程度上参考其他区域能给予的辅助信息来预测。（讲的好像不是很好，不过我暂时没心思做这么大的任务，说笼统一点就是，不分主体背景，模型就是根据那片区域本身和上下文区域的辅助信息来做预测，无论是分类任务还是类分割任务，这是一个完全符合人类逻辑的因果链条）

VLM对一个图像中不同区域的识别问题

论文的方案想用VLM做标注，因为用原有数据集的位姿轨迹自监督效果并不好，主要是想让VLM去评估一个off-road场景下不同区域的Risk，方案开始是超像素分割->合并并区域标号->VLM评估每个区域的Risk。在用的时候发现，区域数目20-30（测的22）的时候，VLM会有自己编造的区域，会自己编造到30个区域。原因可能感觉有很多：

一个是图像的分辨率低，为了省钱，图像分辨率我用的是960*640，可能VLM觉得这个分辨率太低了，无法识别出足够的细节。
第二个是超像素分割的问题，没有仔细调超像素的参，分割出很多长条状，形状极不规则的区域，增大了VLM的识别难度。
第三个就是老生常谈的VLM根本没办法真正理解图片。最终没采用VLM标注的方案，因为试了每个区域一个一个送，发现标完所有近两万张图的花费太高了，不知道老师会不会报销。

相对数据会比绝对数据更有用吗 2026-5-7

这个idea已经总结成了一个确切的方案了，对比了一些现有的工作感觉值得做，打算做完现在这个和老师提一下，现在先自己做一些小范围的验证，反正有了ai之后做的快了很多。

突然想起来毕设的任务里有一个小的深度估计器，还有当时对输入输出的分析，当时对比好的结果和坏的结果，发现好的定位结果的文本描述中相对位置的描述特别多，例如“在左边”、“在右边”、“在上面”、“在下面”等等，而坏的定位结果的文本描述中相对位置的描述特别少，更多的是绝对位置的描述，例如“在某个车右边0.5米处”，好像答辩的时候也提过这个问题，觉得相对位置的描述可能更有用。这辈子还有机会做这个问题吗？感觉这个问题挺有意思的，可能也挺有用的，如果能证明相对位置的描述更有用的话，可能会对定位任务优化有用，或许已经有人做了呢？一个本科毕设能分析出啥好东西来。

嘴型特征作为分布中心，猜测文本和真实文本以他为中心 2026-5-15

这只是个猜测，这个点从一些up主一个人说话不出声，另一个人猜什么并和第三个人打电话沟通来的，我感觉，猜的文本很明显不是瞎猜的，是根据嘴型（主要），对方的性格，当时的情景等（不过要是一个人纯瞎说肯定没法猜了）。这个肯定可以用在从嘴型猜文本这个任务上，但是这个任务不知道有啥用（偷拍别人视频然后恢复人家说话来偷听？），我想的是之前做过语音驱动数字人（嘴型），在刚刚的猜测链条上加一个语音并且反过来，文本增强（如果能搞到这个分布的话增强更好）语音驱动数字人。还有一个，直接从嘴型猜文本很难，加上语音（语音本身直接就可以）相当于把之前以嘴型为中心的分布进行约束得到最终的文本，那如果用不同的语音约束呢。

这个想法真怪，但是这个以嘴型特征分布为中心，我确信应该是对的，只是不知道怎么用。

LLM+生成模型来增强数据集来达到提升很多不同任务模型的因果推断能力 2026-5-24

以图像分类任务为例，假设我们现在有一个模型，想提升它的因果推断能力.首先我们需要知道，原本的错误的因果链是什么，例如在图像分类任务中，模型可能过度依赖背景信息来识别主体，那么这个错误的因果链就是背景信息→主体识别。我们想要提升模型的因果推断能力，就需要打破这个错误的因果链，让模型学会真正识别主体的特征，而不是依赖背景信息。我们不通过理论的方法来打破这个因果链，依然通过数据的方式。动机是，对于人类来说，其实我们也有很多错误的因果认知，不过人类可以在经由他人指出错误的因果认知之后，直接修改这个因果链，直接把错误的因果链改成正确的因果链，而不需要通过大量的数据来重新学习这个因果链。但是对于模型来说，没有直接修改因果链这个说法，除非模型本身显示构建了，所以我们只能通过数据来间接修改这个因果链。

大概的方案可能是，首先对输入数据进行全方位的结构化描述，然后根据预测结果进行分类，分为正确的预测结果和错误的预测结果两类，因为之前的描述很结构化，可以使用自动化工具来构建出模型的认知因果链，例如如果观测到，模型对一个猫的预测正确的描述中，大量的背景描述相似，并且错误预测中背景描述和正确预测的背景描述差异较大，那么我们就可以推断出模型可能过度依赖背景信息来识别主体。

接下来我们就可以针对这个错误的因果链，构建一个新的数据集，这个数据集中的图像会有更多的背景变化，例如同一只猫在不同的背景下出现，这样模型就需要学会真正识别猫的特征，而不是依赖背景信息来识别猫了。通过这样的方式，我们就可以提升模型的因果推断能力，让模型学会真正识别主体的特征，而不是依赖背景信息来识别主体了。

这个方案不会提出任何具体的模型结构和针对任何任务，而是一个通用的方案，可以应用于很多不同的任务，例如图像分类、目标检测、语义分割等等。通过这个方案，我们可以提升很多不同任务模型的因果推断能力。但是有个前提是，我们需要能够生成新的输入数据和确切的标签数据，对于分类任务来说很简单，例如我们可以生成同一只猫在不同背景下的图像，并且标签仍然是猫。对于其他任务来说可能会更复杂一些，例如目标检测，我们需要生成同一只猫在不同背景下的图像，并且标签需要包含猫的位置和大小等信息，这可能需要一些更复杂的生成策略实现。

人类直觉和AI的联系 2026-6-5

很明显，上面idea很多都很直觉，我发现很多现有的领域/任务/方法都和人类有一些联系。这也让我重新审视一些之前习以为常的做法，例如特征金字塔实际上做的是，人看整体、看局部（他是同时看的，那如果是看了整体之后再看局部会更好还是更差）

放大图片但不增加分辨率

在我看不清一个图片的时候，我会放大，但是实际上图片的分辨率并没有提高，这实际上是人类视觉系统与计算机视觉在处理有限信息时的区别。已经有很多工作有这种思想了，主要在于怎么“放大”，“放大”的本质是：用固定的感知资源去“扫描”一个更小的空间范围，从而提高该区域的信息采样密度。

空间注意力机制：模型学出一个“关注度热图”（如Transformer中的注意力权重），然后让后续层只对高权重区域进行精细计算，其他区域粗略处理，模拟人类聚焦的思想。
多尺度推理 + 空间插值: 模拟放大并重新看的思想，将图像（或特征图）的一个局部区域通过双线性插值等操作“物理放大”到原来尺寸，再送入模型进行二次判断。虽然插值不增加信息，但它让后续的卷积核能够在该区域上用更多的参数去扫描，相当于人类眼球在局部区域做更多扫视。
递归/循环放大 (Recursive Zoom)：模型反复对自己生成的“放大预测”进行再分析，逐轮修正。例如，先用低分辨率图像得到一个粗糙的语义图，然后将其作为先验，引导对原始低分辨率图像的第二次“注意力扫描”。
特征金字塔 (Feature Pyramid Networks)：模型从原始图像中提取多尺度的特征图（例如原图的 1/4, 1/8, 1/16 大小）。高层特征感受野大，负责看整体；低层特征分辨率高，负责看细节。在进行推理时，融合高低层信息，相当于同时对全图（宏观）和局部（微观）进行“放大观察”。

NanoGPT

Mon, 24 Nov 2025 00:00:00 +0000

所有之前:这篇是关于NanoGPT项目的核心代码的总结和理解，我会持续把主流技术加入到这个项目中，并对核心代码进行解释。完整项目代码需要查询NanoGPT.

模型架构

Base

最基础的模型架构是一个Decoder-only的Transformer模型，代码实现参考CodeByMyself,在CodeByMyself的基础上，使用了更现代化的Rope位置编码和SwiGLU激活函数，并且加入了Moe用于和FFN对比，可在配置文件中选择是否使用Moe。部分代码如下:

# swiglu
class ffn_swiglu(nn.Module):

 def __init__(self, d_model, d_hidden, dropout=0.1):
 super().__init__()
 #第一个 Linear 输出 2 * d_hidden
 self.w_gate_up = nn.Linear(d_model, 2 * d_hidden) #同时生成 gate 和 up
 self.w_down = nn.Linear(d_hidden, d_model)
 self.dropout = nn.Dropout(dropout)


 def forward(self, x):
 # x: [B, L, d_model]
 gate_up = self.w_gate_up(x) # [B, L, 2 * d_hidden]
 gate, up = gate_up.chunk(2, dim=-1) # each: [B, L, d_hidden]
 swiglu_out = F.silu(gate) * up # [B, L, d_hidden]
 out = self.w_down(self.dropout(swiglu_out)) # [B, L, d_model]
 return out
# moe

class moe(nn.Module):
 def __init__(self,n_expert,d_model,top_k=2,dropout=0.1):
 super().__init__()
 self.d_model = d_model
 self.n_expert = n_expert
 self.top_k = top_k
 self.dropout = dropout

 self.gate = nn.Linear(d_model,n_expert,bias=False)
 self.softmax = nn.Softmax(dim=-1)
 # self.experts = nn.ModuleList([ffn(self.d_model,self.d_model*4,dropout) for _ in range(n_expert)]) relu激活的expert
 self.experts = nn.ModuleList([ffn_swiglu(self.d_model,self.d_model*2,dropout) for _ in range(n_expert)])

 def forward(self,x):
 b,t,d = x.shape
 assert d == self.d_model,f"输入维度和moe设置维度不匹配"

 x_flat = x.view(-1,d)
 N = x_flat.shape[0]

 gate_logits = self.gate(x_flat)
 topk_weights,topk_indices = torch.topk(gate_logits,self.top_k,dim=-1)
 topk_weights= self.softmax(topk_weights)

 out = torch.zeros_like(x_flat)

 for i,expert in enumerate(self.experts):
 mask = (topk_indices == i)
 if not mask.any():
 continue
 token_indices,expert_pos = torch.where(mask)
 select_x = x_flat[token_indices]
 expert_out = expert(select_x)
 weights = topk_weights[token_indices, expert_pos]
 out.index_add_(0, token_indices, expert_out * weights.unsqueeze(1))
 return out.view(b,t,d)

def precompute_freqs_cis(dim: int, end: int, theta: float = 10000.0):
 """
 预计算旋转角度的复数表示（cos + i*sin）
 """
 freqs = 1.0 / (theta ** (torch.arange(0, dim, 2)[: (dim // 2)].float() / dim))
 t = torch.arange(end, device=freqs.device)
 freqs = torch.outer(t, freqs).float() # [end, dim//2]
 freqs_cos = freqs.cos()
 freqs_sin = freqs.sin()
 return freqs_cos, freqs_sin # 分开存储更便于后续操作，不使用torch.complex类型，因为部分系统不支持

SwiGLU激活函数的实现是通过将线性层的输出分成两部分，一部分作为gate，另一部分作为up，然后使用SILU函数对gate进行激活，并与up相乘得到最终的输出。

CodeByMySelf-Diffusion

Wed, 24 Sep 2025 00:00:00 +0000

所有之前：CodeByMySelf 系列之 Diffusion Models 的实现记录，变体不会在这篇里更新。

Diffusion Models

原理

具体的一些公式推导请看李宏毅老师的视频：李宏毅Diffusion

基本概念

（以图像生成为例）首先Diffusion的基本运作过程是，首先Sample出一个全是噪声的图片，然后经过一步一步的Denoise最终得到图片，Denoise的步数是事先确定好的。

在Diffusion中，深度学习模型的唯一作用就是预测噪声，其他过程均由数学公式推理得到

进一步说，不同情况的噪声需要的处理肯定是不一样的，一个Denoise模型肯定无法做到处理不同的情况的噪声，因此Denoise模型需要一个“噪声严重程度”作为输入，在Diffusion中称为时间步。

Denoise内部的工作是，接受带Noise的图片，对噪声进行预测，然后使用带Noise的图片减去预测噪声那么就可以得到。

我们清楚Noise predictor模型的输入输出之后，该怎么训练这个模型呢？已知模型的输入-输出对是Noise图片加上“噪声程度”-Noise数据对，我们需要人为创造这个数据对出来，具体来说，从image list中拿一张图片，然后从GasuionN中采样出一张纯噪声的图片，加了一定的步数之后，就得到了很多数据对（Noise图片、时间步–噪声），这个过程称为Diffusion Process。

现在，已经可以从一个纯噪声得到一张图片，但是我们不能根据噪声随机生成图片，所以我们需要把文字考虑进来，让模型考虑进文字之后再预测噪声。

完整算法

首先是Training的过程，从immage list中取出一张干净的图，之后从1-T中随机取一个值作为时间步，然后从Gaussion中取样出一个noise，之后就是一步一步的梯度更新训练模型。这种方法和我们的想法有些不一样，我们想像中noise是一步一步加进去的，但是在实际中是一下子直接加进去的。

具体的加噪公式推导过程如下：

然后是推理过程，也就是Sampling这个过程。首先，采样得到一个纯噪声图片X_T，然后进行T次公式中的循环，$\epsilon_\theta$表示预测噪声的模型。

但是为什么要加这个z噪声：每次都要重新采样出一个噪声，但是只有当t>1的时候.这个z的使用和生成语句中一个问题类似：为什么每次总要SAMPLE而不是直接取Mean（概率最大）？在The curious case of nerual text degeneration论文中有一个分析，当直接取Mean时候，会一直重复相同的回答和出现跳帧现象，并且他们分析得到人在写文章的时候并不会一定会选概率最大的词。

简单代码实现

Diffusion已经有了许多变体，下面是一个简单的实现，变体不会在这篇里更新。

import torch
from torch import nn
import math
import torch.nn.functional as F
import numpy as np
import time

class WeightedLoss(nn.Module):
 def __init__(self):
 super(WeightedLoss,self).__init__()

 def forward(self,pred,target,weighted=1.0):

 loss = self._loss(pred,target)
 weighted_loss = (loss * weighted).mean() # mean by batch
 return weighted_loss

class L1Loss(WeightedLoss):
 def _loss(self,pred,target):
 return torch.abs(pred - target)

class L2Loss(WeightedLoss):
 def _loss(self,pred,target):
 return (pred - target) ** 2

Losses = {
 'l1':L1Loss,
 'l2':L2Loss
}
class SinusoidalPosEmb(nn.Module):
 def __init__(self,dim):
 super(SinusoidalPosEmb,self).__init__()
 self.dim = dim

 def forward(self,t):
 '''
 扩散模型时间步的位置编码公式和Transformer中的位置编码公式是类似的。
 '''
 device = t.device
 half_dim = self.dim // 2
 emb = math.log(10000) / (half_dim - 1)
 emb = torch.exp(torch.arange(half_dim,device=device) * -emb)
 emb = t[:,None] * emb[None,:]
 emb = torch.cat((emb.sin(),emb.cos()),dim=-1)
 return emb


def extract(a,t,x_shape):
 '''
 a: (T,) t: (B,) x_shape: (B,...)
 '''
 batch_size = t.shape[0]
 out = a.gather(-1,t) # (B,)
 return out.view(batch_size, *((1,) * (len(x_shape) - 1))) # (B,1,1,1...)


class MLP(nn.Module):
 '''
 这是一个简单的多层感知机(MLP)模型，结合了时间步的位置编码，用于处理状态和动作的输入（强化学习）
 '''
 def __init__(self,state_dim,action_dim,hidden_dim,device,t_dim):
 super(MLP,self).__init__()
 self.device = device
 self.t_dim = t_dim
 self.a_tim = action_dim

 self.time_mlp = nn.Sequential(
 SinusoidalPosEmb(t_dim),
 nn.Linear(t_dim,t_dim*2),
 nn.Mish(),
 nn.Linear(t_dim*2,t_dim)
 )

 input_dim = state_dim + action_dim + t_dim

 self.mid_layer = nn.Sequential(
 nn.Linear(input_dim,hidden_dim),
 nn.Mish(),
 nn.Linear(hidden_dim,hidden_dim),
 nn.Mish(),
 nn.Linear(hidden_dim,hidden_dim),
 nn.Mish(),
 )
 self.f_layer = nn.Linear(hidden_dim,action_dim)

 def init_weights(self):
 '''
 初始化模型权重,好的权重初始化可以帮助模型更快收敛，提升训练效果。
 '''
 for m in self.modules():
 if isinstance(m,nn.Linear):
 nn.init.xavier_normal_(m.weight)
 if m.bias is not None:
 nn.init.zeros_(m.bias)

 def forward(self,state,action,t):
 t_emb = self.time_mlp(t) # (batch,t_dim)
 x = torch.cat((state,action,t_emb),dim=-1) # (batch,state_dim+action_dim+t_dim)
 x = self.mid_layer(x) # (batch,hidden_dim)
 action_delta = self.f_layer(x) # (batch,action_dim)
 return action_delta

class Diffusion(nn.Module):
 def __init__(self,loss_type,beta_schedule='linear',clip_denoise=True,predict_epsilon=True,**kwargs):
 '''
 loss_type: 损失函数类型
 beta_schedule: beta(时间)的离散方式，常见的有'linear'（线性）和'cosine'（余弦）。
 clip_denoise: 是否在去噪过程中裁剪输出，以防止数值过大。
 '''
 super(Diffusion,self).__init__()
 self.device = kwargs.get('device','cpu')
 self.t_dim = kwargs.get('t_dim',16)
 self.state_dim = kwargs.get('state_dim',10)
 self.action_dim = kwargs.get('action_dim',2)
 self.hidden_dim = kwargs.get('hidden_dim',256)
 self.loss_type = loss_type
 self.beta_schedule = beta_schedule
 self.clip_denoise = clip_denoise
 self.T = kwargs.get('timesteps',1000)
 self.model = MLP(self.state_dim,self.action_dim,self.hidden_dim,self.device,self.t_dim).to(self.device)
 self.kwargs = kwargs
 self.model.init_weights()
 if beta_schedule == 'linear':
 betas = torch.linspace(1e-4,0.02,self.kwargs.get('timesteps', 1000),dtype=torch.float32)


 alphas = 1. - betas
 alphas_cumprod = torch.cumprod(alphas,dim=0) # [1,2,3] -> [1,1*2,1*2*3]
 alphas_cumprod_prev = torch.cat((torch.tensor([1.],dtype=torch.float32),alphas_cumprod[:-1]),dim=0)

 self.register_buffer('betas',betas)
 self.register_buffer('alphas',alphas)
 self.register_buffer('alphas_cumprod',alphas_cumprod)
 self.register_buffer('alphas_cumprod_prev',alphas_cumprod_prev)
 self.register_buffer('sqrt_alphas_cumprod',torch.sqrt(alphas_cumprod))
 # （前向过程）
 self.register_buffer('sqrt_alphas_cumprob',torch.sqrt(alphas_cumprod))
 self.register_buffer('sqrt_one_minus_alphas_cumprod',torch.sqrt(1. - alphas_cumprod))
 # （反向过程）
 posterior_variance = betas * (1. - alphas_cumprod_prev) / (1. - alphas_cumprod)
 self.register_buffer('posterior_variance',posterior_variance)
 # 用于从xt求得x0
 self.register_buffer('sqrt_recip_alphas_cumprod',torch.sqrt(1. / alphas_cumprod))
 self.register_buffer('sqrt_recipm1_alphas_cumprod',torch.sqrt(1. / alphas_cumprod - 1))

 self.register_buffer('posterior_mean_coef1',betas *torch.sqrt(alphas_cumprod_prev) / (1. - alphas_cumprod))
 self.register_buffer('posterior_mean_coef2', (1. - alphas_cumprod_prev) * torch.sqrt(alphas) / (1. - alphas_cumprod))

 self.loss_func = Losses[loss_type]()

 def forward(self,state,*args,**kwargs):
 return self.sample(state,*args,**kwargs)

 def sample(self,state,*args,**kwargs):
 batch_size = state.shape[0]
 shape = [batch_size,self.action_dim]
 action = self.p_sample_loop(state,shape,*args,**kwargs)
 return action.clamp(-1.,1.)

 def q_posterior(self,x0,xt,t):
 '''
 计算后验分布q(x_{t-1}|x_t,x_0)的均值和方差
 '''
 posterior_mean = (extract(self.posterior_mean_coef1,t,x0.shape) * x0 +
 extract(self.posterior_mean_coef2,t,x0.shape) * xt)
 posterior_variance = extract(self.posterior_variance,t,x0.shape)
 posterior_log_variance = torch.log(posterior_variance.clamp(min=1e-20))
 return posterior_mean,posterior_variance,posterior_log_variance

 def p_sample_loop(self,state,shape,*args,**kwargs):
 device = self.kwargs.get('device','cpu')
 batch_size = shape[0]
 x = torch.randn(shape,device=device,requires_grad=False) # 标准DDPM噪声不需要梯度
 for i in reversed(range(0,self.kwargs.get('timesteps',1000))):
 t = torch.full((batch_size,),i,dtype=torch.long,device=device)
 x = self.p_sample(x,t,state)

 return x

 def predict_x0_from_noise(self,x,t,noise):
 '''
 根据公式计算x0
 '''
 return (extract(self.sqrt_recip_alphas_cumprod,t,x.shape) * x -
 extract(self.sqrt_recipm1_alphas_cumprod,t,x.shape) * noise)

 def p_mean_variance(self,x,t,state):
 pred_noise = self.model(state,x,t)
 x_0 = self.predict_x0_from_noise(x,t,pred_noise)
 x_0.clamp_(-1.,1.) if self.clip_denoise else x_0

 model_mean,posterior_variance,posterior_log_variance = self.q_posterior(x_0,x,t)
 return model_mean,posterior_log_variance



 def p_sample(self,x,t,state):
 '''
 x: 当前的噪声状态xt
 t: 当前的时间步t
 state: 状态
 '''
 model_mean,model_log_variance = self.p_mean_variance(x,t,state)
 noise = torch.randn_like(x) if t.sum() > 0 else 0. # 如果t=0,则不添加噪声
 return model_mean + torch.exp(0.5 * model_log_variance) * noise

 def q_sample(self,x0,t,noise):
 sample = (extract(self.sqrt_alphas_cumprod,t,x0.shape) * x0 +
 extract(self.sqrt_one_minus_alphas_cumprod,t,x0.shape) * noise)
 return sample

 def p_losses(self,x0,state,t,weights):
 noise = torch.randn_like(x0)
 x_noisy = self.q_sample(x0,t,noise)
 x_recon = self.model(state,x_noisy,t)

 loss = self.loss_func(x_recon,noise,weights)
 return loss

 def loss(self,x,state,weights=1.0):
 batch_size = x.shape[0]
 t = torch.randint(0,self.T,(batch_size,),device=self.device).long()
 return self.p_losses(x,state,t,weights)


if __name__ == '__main__':
 x = torch.randn(256,2)
 state = torch.randn(256,11)
 model = Diffusion(loss_type='l2',beta_schedule='linear',clip_denoise=True,predict_epsilon=True,
 device='cpu',t_dim=16,state_dim=11,action_dim=2,hidden_dim=256,timesteps=100)

 result = model(state)
 print(result)
 loss = model.loss(x,state)
 print(f"loss: {loss.item()}")

CodeByMySelf-RL

Wed, 24 Sep 2025 00:00:00 +0000

所有之前：CodeByMySelf 系列之 RL（深度强化学习）的实现记录，只有标题没有内容的是TODO。

RL强化学习（深度强化学习）

TODO

CodeByMySelf-Transformer

Wed, 24 Sep 2025 00:00:00 +0000

所有之前：CodeByMySelf 系列之 Transformer 的实现记录，只有标题没有内容的是TODO，针对经典算法的变体和改进算法在其他文章。

Transformer

下面是一个最基本的Transformer实现，主要包含以下几个部分：

基本模块
- 多头注意力模块
- Token和位置嵌入模块
- LayerNorm
- 前馈神经网络FFN
$EncoderLayer -> Encoder$
$DecoderLayer -> Decoder$
$Encoder+Decoder -> Transformer$

多头注意力MHA

多头注意力机制的公式如下：

$$ \text{MultiHead}(Q, K, V) = \text{Concat}(\text{head}_1, \ldots, \text{head}_h)W^O $$

其中，每一个头的计算分别为：

$$ \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^\top}{\sqrt{d_k}}\right)V $$

对于图像数据和序列数据，多头注意力机制的实现是不同，但是核心原理是相同的。对于序列数据，每个位置对应一个token；对于图像数据，每个位置对应一个patch块或者一个像素块，如果是$patch$块，需要展开到一维向量。这里实现的为序列数据的多头注意力机制,初始$shape$为$(batch,time,d_model)$


import torch
from torch import nn
import torch.functional as F
import math

class MultiHeadAttention(nn.Module):
 def __init__(self,d_model,n_head):
 super(MultiHeadAttention, self).__init__()

 assert d_model % n_head == 0
 self.d_model = d_model
 self.n_head = n_head

 self.w_k = nn.Linear(d_model,d_model)
 self.w_q = nn.Linear(d_model,d_model)
 self.w_v = nn.Linear(d_model,d_model)
 self.w_conbine = nn.Linear(d_model,d_model,bias=False) # 对应W^O
 self.softmax = nn.Softmax(dim=-1)

 def forward(self,q,k,v,mask=None):
 batch,time,dimension = q.shape() # q,k,v shape: (batch,time,d_model)
 n_d = self.d_model // self.n_head

 q,k,v = self.w_q(q),self.w_k(k),self.w_v(v)
 print(q.shape, batch, time, self.n_head, n_d)
 q = q.view(batch,time,self.n_head,n_d).transpose(1,2) # self.n_head * n_d = d_model
 k = k.view(batch,time,self.n_head,n_d).transpose(1,2) # shape: (batch,n_head,time,n_d)
 v = v.view(batch,time,self.n_head,n_d).transpose(1,2)

 # compute attention by the formula
 score = q @ k.transpose(-2,-1) / math.sqrt(n_d) # (batch,n_head,time,time)
 if mask is not None:
 score = score.masked_fill(mask==0,float('-inf'))
 attn = self.softmax(score) @ v # (batch,n_head,time,n_d)
 attn = attn.transpose(1,2).contiguous().view(batch,time,dimension) # (batch,time,dimension)
 attn = self.w_conbine(attn) # (batch,time,dimension)
 return attn

d_model = 512
n_head = 8
mha = MultiHeadAttention(d_model,n_head)
x = torch.randn(2,10,d_model)
y = mha(x,x,x) # self-multi-head-attention
print(f"shape: {y.shape}\n输出:{y}") # torch.Size([2, 10, 512])

Token和位置嵌入模块

Token Embedding 是将离散的词（token）转换为连续的向量表示的过程。通常通过查找表（如 nn.Embedding）将每个词的索引映射为一个高维向量，使模型能够处理和学习词之间的语义关系。公式表示：

CodeByMySelf-VAE

Wed, 24 Sep 2025 00:00:00 +0000

所有之前：CodeByMySelf 系列之 VAE（变分自编码器）的实现记录，只有标题没有内容的是TODO。

VAE（变分自编码器）

VAE也是一个非常经典的生成模型，虽然现在主流已经是Diffusion模型，但是它的原理和思想还是非常有启发性的，尤其是对于理解diffusion中的一些概念（如潜在空间、重参数化技巧等）非常有帮助。

TODO

并行训练实践

Thu, 24 Jul 2025 00:00:00 +0000

Accelerate

Accelerate 是 Hugging Face 开发的深度学习多卡并行训练库，构建在 torch_xla 和 torch.distributed 之上。它提供了一个简单的 API，将与多 GPU、TPU、混合精度训练相关的样板代码抽离了出来，让用户可以在不同设备上轻松地进行分布式训练和混合精度训练，而无需重复编写大量样板代码。

另外，Accelerate 还提供了很多性能优化的功能，使得大规模训练和推理变得简单、高效且适应性强。

在学习如何使用 Accelerate 之前，首先回顾一下并行训练的其他方法。

DataParallel (DP)

DP 是最常见的并行训练方式，通过将数据拆分（split）到各个 workers 中（每个 worker 拥有完整模型）进行并行计算，以解决 Batch Size 过大的问题。因为求导以及加和都是线性的，所以数据并行在数学上是等价的。

DataParallel 是 PyTorch 中最容易实现的并行方案，只需要增加一行代码：model = nn.DataParallel(model)。

代码示例

import torch
import torch.nn as nn
from torch.utils.data import DataLoader, Dataset

# 数据集的长度为 100，batch size 为 32
# 模型是一个简单的 fc 层，输入长度是 5，输出是 2
input_size, output_size = 5, 2
batch_size, data_size = 32, 100

model = Model(input_size, output_size)

if torch.cuda.device_count() > 1:
 print(f"Detected {torch.cuda.device_count()} GPUs!")
 model = nn.DataParallel(model)

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model.to(device)

rand_loader = DataLoader(
 dataset=RandomDataset(input_size, data_size),
 batch_size=batch_size,
 shuffle=True
)

for data in rand_loader:
 input = data.to(device)
 output = model(input)

在上述代码中，batch_size=32。由于使用了 DataParallel，在有 2 个 GPU 时，一个 batch 被划分成了 2 份，即 tensor.split(16)，分别送往两个 GPU。

Posts on Ganko Space

SAM 3D:3Dfy anything in Images

论文想解决的问题

解决思路

核心方法

网络结构

训练

TODO

TODO

关于爱情的一些思考

什么是回避型依恋

最核心的一件事：用她感受爱的方式去爱她

应对原则

1. 不追，但在

2. 用行动，不用承诺

3. 吵架时语气 > 内容

4. 别问她「你怎么了」

5. 接受撤退不是拒绝

6. 表达情绪时收着点

7. 她逃之前，你先退半步

关键信号

给自己的提醒

[论文阅读] Vision Transformers Need More Than Registers

一句话总结

论文信息

研究背景与动机

CS336 Lecture 5-6: GPUs & Kernels, Triton

为什么这两讲至关重要

Lecture 5：GPU 架构解剖（Tatsu）

5.1 从一张 H100 说起

CV领域的多任务统一模型

GPT4RoI[ECCV WORKSHOPS 2024]

NanoVLM-AnyRes

问题：固定分辨率的瓶颈

核心算法

处理流程

NanoVLM-LLaVA

LLaVA

原始 LLaVA 1.0 的具体配置

多卡并行训练和微调技术

第一章 深度学习分布式训练的底层基石：显存与通信的博弈

[1].1 显存消耗模型解构

[1].2 通信原语与同步机制

[Paper] Causal

所有之前

[TPAMI] A Causal Adjustment Module for Debiasing Scene Graph Generation

这篇论文想解决什么问题？

核心方法

CS336 Lecture 7-8：Parallelism

本篇主题

Lecture 7 - Parallelism 1

Pytorch-Tricks

动态计算图

缘起

可能导致性能波动的情况

1. 条件分支结构

2. 变长序列

3. 其他情况

解决方案

模型训练/推理速度分析与优化

背景

CS336 Lecture 2: Resource Accounting

本讲主线

例题：70B 模型训练时长

CS336 Lecture 3-4: Architectures, Hyperparameters, and MoE

本讲主线

架构与超参数观察

CS336-写在所有之前

CS336 Lecture 1: Overview and Tokenization

课程导读

课程收获

Tokenization

博客网站优化日志

📅 2026-04-03

📅 2026-04-04

📅 2026-04-07

胡思乱想

神奇的特征空间 2026-4-1

VIT和CNN都有的惰性问题：依赖背景对主体进行识别 2026-4-18

VLM对一个图像中不同区域的识别问题

第一章深度学习分布式训练的底层基石：显存与通信的博弈