Hana's Blog

Paper Reading: CV 1

Fri, 26 Dec 2025 00:00:00 GMT

import { ArxivRating, RatingCriteria } from '@/components/advanced'

import { ManualTOC } from '@/components/advanced'

前言

计算机视觉基础模型关注从图像、视频和点云中学习可迁移的表征与几何结构。相关工作覆盖经典视觉骨干、自监督预训练、开放词表检测、通用分割、点云表征与视觉几何，核心作用是为分类、检测、分割、三维理解、场景重建和机器人感知等任务提供稳定的基础感知能力。

AlexNet

VGG

ResNet

ViT

MAE

DINO

DINOv2

DINOv2 可以看作是 DINO 的规模化与工程化升级版本，目标不再只是验证 self-distillation 在 ViT 上的有效性，而是训练出一组可以直接作为冻结视觉 Backbone 使用的通用特征模型。在数据层面，DINOv2 不再局限于 ImageNet 这类标准数据集，而是从大规模无标签图像中进行去重、过滤、检索和聚类，构建出包含 1.42 亿张图像的 LVD-142M 数据集，从而获得覆盖更广、质量更高的视觉概念分布。在方法层面，DINOv2 仍然沿用教师-学生自蒸馏框架，但将训练目标从 DINO 中偏图像级的表示学习进一步扩展到 patch-level 表示学习：除了使用 DINO loss 对齐全局视图的语义分布，还引入 iBOT 风格的 masked patch prediction，让学生网络在部分 patch 被 mask 的情况下预测教师网络给出的 patch-level 目标。这样模型不仅能学到 image-level 的全局语义，也能学到适合分割、深度估计和视觉对应等任务的 dense features。为了在更大数据和更大模型上稳定训练，DINOv2 还强化了防塌缩机制，包括 Sinkhorn-Knopp centering 和 KoLeo regularization，使特征分布更加均衡、输出空间利用更加充分。总体来看，DINOv2 的核心贡献在于把 DINO 的自监督 ViT 路线扩展为一套可规模化训练、可蒸馏到不同模型尺寸、且能在多种下游任务中直接迁移的通用视觉特征体系。

DINOv3

DINOv3 可以看作是 DINOv2 路线的进一步规模化与 dense feature 强化版本，目标是训练一个可以直接作为冻结视觉 Backbone 使用的通用视觉基础模型。数据层面，DINOv3 使用 LVD-1689M 数据集进行训练，共包含 16.89 亿张无标注图像。这些图像来自约 170 亿张 Instagram 公开帖子图像构成的大规模候选池，随后通过内容过滤、去重、DINOv2 特征聚类、均衡采样和检索式筛选得到最终训练集，从而在保证规模的同时尽量提升视觉概念覆盖和数据质量。模型层面，DINOv3 继续沿用教师-学生自监督蒸馏框架，并将 Teacher 扩展到约 7B 参数规模，同时通过蒸馏得到 ViT 和 ConvNeXt 的多种小模型，方便在不同计算预算下部署。DINOv3 最关键的新方法是 Gram Anchoring：论文发现，在继续放大 DINOv2 并延长训练后，图像级分类能力仍会提升，但 patch-level dense features 可能出现退化，影响分割、深度估计和视觉对应等任务。Gram Anchoring 用早期 dense feature 更干净的模型作为约束对象，通过对齐 patch 特征之间的 Gram 相似性结构，帮助模型在继续学习全局语义的同时保留局部几何关系和空间一致性。总体来看，DINOv3 的核心贡献不在于提出全新的自监督范式，而在于证明 DINOv2 风格的自蒸馏视觉模型可以在更大数据、更大模型和更长训练下继续扩展，并通过 Gram Anchoring 解决 dense feature 质量保持的问题。

Grounding DINO

从 workflow 看，图像先经过 backbone 得到 visual features，文本经过 text encoder 得到 text features，随后在 Feature Enhancer 中做 Fusion。Language-Guided Query Selection 会计算 image tokens 和 text tokens 的相似度，再对文本维度取最大值，得到每个 image token 与整段 prompt 的最高相关分数，最后选出 top-K 个 image tokens 作为 decoder 的初始候选 query。并同时取出 reference boxes，每个 image token 本身来自 feature map 的一个空间位置，检测器也会为每个位置生成或预测一个粗略候选框。Cross-Modal Decoder 再继续 refine 这些 query，若有 L 层 decoder，则有 L 层中间表征。Prediction Head 以每层的中间表征去预测 box refinement，一路计算 query feature 与 text feature 的相似度。

训练时，所有数据都会被整理成 grounding 格式：[image, text, boxes, positive_map]，其中 positive_map 表示每个 box 对应文本中的哪些 token。普通检测数据可以把类别名拼成 prompt，phrase grounding 数据本来就有短语和 box 的对应关系，caption 数据则需要借助已有模型生成 pseudo boxes。由于预测的 query 和真实目标之间没有天然顺序，训练时先用 Hungarian Matching 做一对一匹配，再使用 query-text token matching 上的 focal loss、box L1 loss 和 GIoU loss。

Segment Anything

SAM 对歧义的处理也很关键。如果模型只有一个输出，在单点提示这种天然模糊的场景里容易把多个合理 Mask 平均成一个不干净的结果。因此 SAM 默认对单个提示预测 3 个 Mask，对应 whole、part、subpart 这类常见嵌套层级，并额外预测每个 Mask 的 IoU 置信度用于排序。训练时对多个输出分别计算损失，但只反传最小损失的那一个，相当于允许模型把不同输出槽位分配给不同合理解释。当输入包含多个提示时，歧义通常降低，模型则返回单个更确定的 Mask。损失函数使用 focal loss 与 dice loss 的组合，IoU 预测头使用 MSE 监督。

训练流程模拟交互式分割，而不是只做一次静态预测。每个目标 Mask 先随机选择一个前景点或带噪声的框作为初始提示，模型预测后，再从预测错误区域采样新的前景点或背景点进行修正，并把上一轮未阈值化的 Mask logits 作为 Dense Prompt 输入下一轮。论文默认使用 11 轮：1 个初始提示、8 个从错误区域采样的交互点，以及 2 轮不加入新点的自我细化。这样训练出来的模型不仅能处理单点或框，也能自然接入「用户继续点击修正」的交互流程。

数据层面的贡献同样重要。由于互联网上没有现成的海量分割 Mask，作者构建了一个三阶段 Data Engine。第一阶段是 Assisted-manual：标注员使用 SAM 辅助的浏览器工具点击前景和背景，并可用 brush/eraser 修正，最终在 12 万张图上收集 430 万个 Mask，平均每个 Mask 的标注时间从 34 秒降到 14 秒。第二阶段是 Semi-automatic：先用检测器自动填入高置信 Mask，标注员再补充遗漏物体，累计达到 30 万张图、1020 万个 Mask。第三阶段是 Fully automatic：对每张图使用 32×32 规则点网格提示 SAM，并通过 IoU 置信度、稳定性筛选、NMS 和重叠裁剪过滤结果，最终在 1100 万张授权且隐私处理过的图像上生成 11 亿个高质量 Mask，形成 SA-1B。

实验强调的是 Zero-shot Transfer。单前景点分割中，SAM 在 23 个多域数据集上有 16 个数据集的 mIoU 高于 RITM；如果用 oracle 从 3 个候选 Mask 中选择最接近 GT 的结果，则所有数据集都优于 RITM，说明单点评估会受到 GT 歧义影响。在 BSDS500 边缘检测上，SAM 没有专门训练边缘任务，但 ODS 达到 0.768、R50 达到 0.928，召回很强但会预测更多未标注边缘。在 LVIS 目标提案中，SAM 的 AR@1000 为 59.3，低于 ViTDet-H 的 63.0，但在 medium、common 和 rare objects 上反而超过 ViTDet-H。在实例分割中，SAM 接收 ViTDet 的检测框作为 Prompt，在 COCO 上 AP 为 46.5、LVIS 上 AP 为 44.7，低于全监督 ViTDet，但人工评测认为 SAM 的边界质量更好。

这篇论文最值得学习的是「任务定义、模型接口、数据飞轮」三者绑定在一起。 Promptable Segmentation 给模型提供统一接口，轻量 Mask Decoder 保证交互可用，Data Engine 又利用当前模型降低标注成本、反过来扩大数据规模。因此 SAM 的创新并不只是一个 ViT 分割模型，而是把分割模型做成可组合的视觉基础设施。它的局限也来自这个定位：SAM 追求通用性而不是某个数据集的最高 IoU，细小结构可能漏掉，偶尔会产生小的断裂或幻觉区域；重型 Image Encoder 也让完整端到端推理并非真正实时。另外，论文中的 text-to-mask 只是探索性结果，还不能等价于后续开放词表分割模型。

SAM 2

Memory Bank 是 SAM 2 的核心数据结构。它维护两类空间记忆：一类是最近若干未提示帧的 FIFO 记忆，用来表示短期运动和外观变化；另一类是用户提示过的关键帧记忆，用来长期锚定目标身份。除了空间特征，SAM 2 还保存 object pointers，也就是从 Mask Decoder 输出 token 得到的轻量向量，用来提供高层语义级的目标身份信息。每一帧预测完成后，Memory Encoder 会把当前预测 Mask 下采样，并与该帧未条件化的图像特征相加，再用轻量卷积融合，生成下一步可写入 Memory Bank 的记忆。这形成了一个流式循环：读入一帧 → 查询记忆 → 预测 Mask → 编码新记忆 → 继续处理下一帧。

Prompt Encoder 和 Mask Decoder 大体沿用 SAM。点、框等 sparse prompts 通过位置编码和提示类型 Embedding 表示，Mask 通过卷积编码后加到 frame embedding 上。 Mask Decoder 继续使用 two-way Transformer，在 Prompt Token 和 frame embedding 之间双向交互，并输出 Mask、IoU 分数和目标可见性信息。对于单点这类歧义提示，SAM 2 仍然预测多个候选 Mask；但在视频里，歧义不仅发生在空间上，也可能沿时间传播，因此如果用户没有额外提示消除歧义，模型会根据预测 IoU 选择一个候选继续传播。当某帧目标被遮挡或不可见时，遮挡 / 可见性预测头也会参与判断，避免错误地强行生成目标 Mask。

训练时，SAM 2 同时使用图像和视频数据，并模拟交互式视频标注过程。论文默认采样 8 帧序列，随机选择最多 2 帧作为提示帧，并在训练过程中根据 GT masklet 和模型预测采样纠错点击。初始提示的分布是：50% 使用 GT Mask，25% 使用 GT 内的正点，25% 使用 bounding box。模型需要按时间顺序逐帧预测完整 masklet，并在收到纠错点击后利用新的提示和已有 memory 修正后续结果。损失包括 Mask 的 focal loss 和 dice loss、IoU 预测的 L1/MAE loss，以及目标是否存在的 occlusion / object prediction cross-entropy，权重比例为 20:1:1:1。为增强长视频能力，作者还加入 16 帧序列微调：选择编辑帧最多、最困难的一半 masklets，用较低学习率训练，并冻结图像编码器以适配 A100 80GB 显存。

数据引擎是 SAM 2 的另一条主线。 Phase 1 使用原始 SAM 逐帧辅助标注视频，每帧都要重新分割，质量高但慢，平均 37.8 秒 / 帧，在 1.4K 视频上收集 16K masklets。 Phase 2 引入只能接收 Mask prompt 的 SAM 2 Mask：标注员先用 SAM 标第一帧，再让模型传播到后续帧，错误时仍需要在中间帧重新画 Mask，速度降到 7.4 秒 / 帧，收集 63.5K masklets。 Phase 3 使用完整 SAM 2，标注员可以直接用点或 Mask 在任意帧修正，模型利用 memory 继续传播，速度降到 4.5 秒 / 帧，相比 Phase 1 快 8.4 倍，同时保持可比质量，收集 197K masklets。此外，作者还用规则点网格在首帧自动生成候选 masklets，并经过人工验证筛选，既增加覆盖度，也能把失败样本送回人工修正流程。最终 SA-V 数据集包含 50.9K 视频、642.6K masklets 和 35.5M masks，是已有最大 VOS 数据集 Mask 数量的 53 倍；其中手工部分为 190.9K masklets 和 10.0M masks。

实验上，SAM 2 的重点是 Zero-shot 视频和图像分割。在 promptable video segmentation 中，SAM 2 在 9 个密集标注视频数据集上同时优于 SAM+XMem++ 和 SAM+Cutie，并且达到更好精度所需交互次数少于前者的三分之一。在只给第一帧提示的 semi-supervised VOS 设定中，SAM 2 在 17 个视频数据集平均表现也最好：1-click 为 64.7，3-click 为 75.3，5-click 为 77.6，box 为 74.4，GT mask 为 79.3，均高于 SAM+XMem++ 和 SAM+Cutie。在图像 Segment Anything 任务中，如果只用 SA-1B 训练，SAM 2 的 1-click mIoU 为 58.9，略高于 SAM 的 58.1，但速度从 21.7 FPS 提升到 130.1 FPS；使用作者的视频和图像混合数据后，SA-23 上升到 61.9，14 个新增视频图像化数据集上升到 69.6。在传统 VOS SOTA 对比中，SAM 2 Hiera-L 在 MOSE val、DAVIS 2017 val、LVOS val、SA-V val/test 和 YTVOS 2019 val 上分别达到 77.9、90.7、78.0、77.9、78.4 和 89.3，并且 Hiera-B+ / Hiera-L 都能在 A100 上实时运行，分别约 43.8 / 30.2 FPS。

这篇论文最值得学习的是它把 SAM 的「可提示接口」推广成了一个流式时序系统。 SAM 负责在单帧里根据 Prompt 找到目标，SAM 2 则进一步回答：当目标在视频里移动、遮挡、消失、重现时，模型如何记住它、如何接受用户在任意帧修正、如何把修正继续传播。它的局限也主要来自视频长期建模：跨镜头切换、拥挤场景、长时间遮挡、快速移动的细小结构和多个外观相似目标仍然困难。另外，SAM 2 虽然可以处理多目标，但基本是逐目标独立处理，只共享每帧图像特征，目标之间缺少显式交互。因此 SAM 2 更像是一个通用交互式视频分割基础设施，而不是完全解决所有开放世界视频理解问题的最终模型。

SAM 3

PCS 和 PVS 的本质差异在于「一个提示对应一个实例」变成了「一个概念对应所有实例」。这带来两个新难点。第一是开放词表识别：模型要判断输入中是否存在某个短语对应的概念，尤其要处理大量 hard negatives，例如图中没有该概念、相似概念或细粒度概念。第二是实例穷尽性：只分出一个目标是不够的，模型必须尽量找到所有匹配实例，还要允许用户通过正负 exemplar 交互式补充漏检或移除误检。论文明确限制文本提示为简单名词短语，不直接解决长 referring expression 或需要复杂推理的语言查询；复杂查询可以用 MLLM 拆成多个 noun phrases 后再调用 SAM 3。模型结构由 detector 和 tracker 组成，两者共享一个对齐过的 Perception Encoder 视觉语言 backbone。 Detector 是 DETR 风格的开放词表检测/分割器：图像和文本由 PE 编码，image exemplars 如果存在，则由 exemplar encoder 编码；文本 token 和 exemplar token 合称 prompt tokens。 Fusion Encoder 让图像特征 cross-attend 到 prompt tokens，得到条件化图像特征；随后 DETR-like decoder 用 object queries 在条件化图像特征上定位匹配实例。每层 decoder 都预测 query 是否匹配当前 prompt、box refinement；Mask head 借鉴 MaskFormer 产生实例 Mask，此外还有 semantic segmentation head 逐像素预测是否属于当前概念。

Presence Token 是 SAM 3 中很关键的设计。普通 DETR query 同时承担「识别是什么」和「定位在哪里」两个任务，但开放词表场景下，识别需要看全图上下文，定位却是局部问题，两者容易冲突。 SAM 3 引入一个全局 learned presence token，专门预测 noun phrase 是否存在于输入中，即全局 presence score。各个 object query 只负责在「该概念存在」的条件下定位候选实例，最终实例分数由 query score 和 presence score 相乘得到。这样 recognition 和 localization 被解耦，尤其有利于 hard negatives：当图中根本没有该概念时，presence head 可以整体压低预测，而不是让局部 query 硬找一个相似物体。

Image exemplar 让 SAM 3 具备交互式概念适配能力。一个 exemplar 由 bounding box 和二元标签组成，标签可以是 positive 或 negative。 Positive exemplar 表示「找和这个框中目标同类的所有实例」，negative exemplar 表示「不要找这类误检」。 Exemplar encoder 会融合 box 位置编码、正负标签编码和 ROI-pooled 视觉特征，再用小 Transformer 得到 exemplar prompt，最后和文本 prompt 拼接。这和 SAM/SAM2 的视觉提示不同：SAM 的框通常只定位一个实例，而 SAM 3 的 exemplar 会泛化成概念提示，例如给一个狗的正框后，模型应当找出图中所有狗。

视频部分可以理解为「detector 负责发现新实例，tracker 负责维持身份」。在每一帧，detector 根据概念 prompt 检测当前帧所有匹配对象；tracker 则沿用 SAM 2 风格的 memory-based propagation，把上一帧已有 masklets 传播到当前帧。随后，SAM 3 用 IoU-based matching 将传播结果和当前帧检测结果合并：已匹配的 masklet 更新位置，未匹配的新检测会 spawn 成新的 masklet。为了降低拥挤场景中的身份混淆，模型还使用 temporal disambiguation：一方面用 masklet detection score 衡量某个轨迹在时间窗口内是否持续被检测支持，低于阈值则抑制；另一方面周期性用高置信 detector mask 重新 prompt tracker，替换 tracker 自己可能漂移的预测，让 memory bank 保持新鲜可靠。用户也可以继续用正负 click 细化单个 mask 或 masklet，视频中修正后的 Mask 会继续传播到整段视频。

训练分四个阶段：先预训练 Perception Encoder，再做 detector pre-training，然后 detector fine-tuning，最后冻结 backbone 训练 tracker。数据引擎也对应地从图像走向视频。 Phase 1 使用 captioner/parser 提出 noun phrases，用开放词表检测器加 SAM 2 生成初始 Mask，人类执行 Mask Verification 和 Exhaustivity Verification，得到 4.3M image-NP pairs。 Phase 2 用 Phase 1 的人类验证数据微调 Llama 3.2，形成 AI verifiers 自动做 MV 和 EV，让人类专注困难样本；同时用 Llama-based pipeline 生成 hard negative NPs，并多轮更新 SAM 3，新增 122M image-NP pairs。 Phase 3 扩展到 15 个图像域，并从 alt-text 和基于 Wikidata 的 22.4M 节点 SA-Co ontology 中挖掘长尾细粒度概念，新增 19.5M image-NP pairs。 Phase 4 扩展到视频，通过运动/场景过滤和失败样本挖掘生成视频 masklets，最终得到 SA-Co/VIDEO。

SA-Co 数据集的规模很大。高质量图像数据 SA-Co/HQ 包含 5.2M images、4M unique NPs、146.1M image-NP pairs 和 52.3M masks。合成数据 SA-Co/SYN 由成熟数据引擎和 AI verifiers 生成，包含 39.4M images、38M NPs、1.7B image-NP pairs 和 1.4B masks。外部数据 SA-Co/EXT 包含 9.3M images、497.4K NPs 和 70.5M masks。视频数据 SA-Co/VIDEO 包含 52.5K videos、24.8K NPs、134K video-NP pairs 和 467K masklets。评测集覆盖 207K unique phrases、121K images/videos 和超过 3M media-phrase pairs，并显式包含大量 hard negatives。

实验上，SAM 3 在图像 PCS with text 中显著优于已有开放词表系统。在 SA-Co/Gold 实例分割上，SAM 3 的 cgF1 为 54.1，而最强基线 OWLv2* 为 24.6，Human oracle 为 72.8；也就是说 SAM 3 超过最强基线两倍，并达到约 74% 的人类表现。在 LVIS instance segmentation 上，SAM 3 的 cgF1/AP 为 37.2/48.5；在 box detection 上，LVIS cgF1/AP 为 40.6/53.6，COCO AP 为 56.4。语义分割上，SAM 3 在 ADE-847、PascalConcept-59 和 Cityscapes 上分别达到 13.8、60.8 和 65.2 mIoU，超过强 specialist baseline APE。

Exemplar 和交互结果体现了 SAM 3 的新接口价值。单个 exemplar 提示下，SAM 3 在 COCO、LVIS 和 ODinW13 上相对 T-Rex2 分别提升 +18.3、+10.3 和 +20.5 AP+。从文本 prompt 开始逐步添加 exemplar 时，3 次点击后 cgF1 比 text-only 高 +21.6，也比理想化的 PVS 单实例修正高 +2.0。原因是 PCS exemplar 不只是修正一个实例，而是会泛化到类似目标：正样本能补一类漏检，负样本能压一类误检。计数任务也受益于「先分割再计数」：SAM 3 在 CountBench 上 MAE 0.12、Accuracy 93.8%，并且能给出实例 Mask，而多数 MLLM 只能输出数字。

视频 PCS 中，SAM 3 也把文本概念扩展到开放词表视频分割。在 SA-Co/VEval 的三个子集上，SAM 3 分别达到 SA-V 30.3 cgF1 / 58.0 pHOTA、YT-Temporal-1B 50.8 / 69.9、SmartGlasses 36.4 / 63.6。在公开 benchmark 上，SAM 3 在 LVVIS test mAP 为 36.3，BURST test HOTA 为 44.5，OVIS val mAP 为 60.5，整体明显优于 GLEE、LLMDet + SAM 3 Tracker 以及 tracking-by-detection 替代方案。在传统 PVS/VOS 能力上，SAM 3 也没有退化：VOS 中在 MOSEv1、DAVIS17、LVOSv2、SA-V val/test、YTVOS19、MOSEv2 上分别达到 78.4、92.2、88.5、83.5、84.4、89.7、60.3，其中 MOSEv2 比 prior work 高 6.5 点。在 SA-37 交互式图像分割上，SAM 3 的 1/3/5-click mIoU 为 66.1、81.3、85.1，3-click 和 5-click 超过 SAM 2.1 L。

消融说明这篇论文的关键收益确实来自「识别-定位解耦、hard negatives、数据引擎」三件事。 Presence head 让 cgF1 从 50.7 提升到 52.2，IL_MCC 从 0.77 到 0.82。 Hard negatives 数量从 0 增加到 30/img 时，cgF1 从 28.3 提升到 43.0，主要提升来自 image-level recognition。训练数据方面，仅 EXT 为 23.7 cgF1，加入 SYN 后到 32.8，加入 HQ 后到 45.5，EXT+SYN+HQ 达到 47.4。 AI verifiers 也很关键：在伪标签上加入 EV verifier 可把 cgF1 从 54.0 提到 61.2，再加入 MV verifier 到 62.3，论文认为 AI verifiers 关闭了模型与人类表现差距的大约一半。

我觉得 SAM 3 的核心贡献是把 SAM 系列从「视觉位置提示」推进到「开放词表概念提示」。 SAM 解决单图实例分割，SAM 2 解决视频中同一实例的记忆与传播，SAM 3 则进一步解决「给一个概念，找出所有实例，并在视频里保持身份」的问题。局限也很清楚：它不擅长 out-of-domain 术语，需要额外 domain expansion 或 fine-tuning；文本输入被限制为简单 noun phrases，复杂推理查询要借助 MLLM agent；视频中推理成本随被跟踪对象数量线性增长；概念本身还存在天然歧义，例如类别边界、主观形容词和上下文依赖。所以 SAM 3 更像是开放词表实例分割/视频分割的基础接口，而不是通用视觉推理模型。

SAM 3D

这篇工作的核心动机是 3D 的「数据壁垒」。多视角几何或合成数据可以提供 3D 监督，但真实世界中大量物体只出现在单张自然图像里，而且常常有遮挡、场景杂乱、尺度变化和上下文依赖。已有 image-to-3D 模型多在 isolated object renders 上训练，对居中、干净的物体效果不错，但在自然场景中距离远、遮挡重、只露出一部分的物体上容易失败。 SAM 3D 的直觉是：人类能从单图恢复 3D，很大程度依赖 recognition cue 和 context cue；模型也应当从目标局部外观、完整场景上下文和物体类别先验中联合推断 3D。

模型输入编码分成 cropped object 和 full image 两路。第一路把目标 Mask 裁剪出的物体图像和裁剪后的 binary mask 一起送入 DINOv2 encoder，提供高分辨率、聚焦目标的细节信息。第二路把完整图像和 full-image binary mask 送入 encoder，提供全局场景上下文、尺度、遮挡关系和识别线索。模型还可以选择性接收 point map P，这个点图可以来自 LiDAR、iPhone 深度传感器或单目深度模型，用于辅助布局估计；但论文也强调形状和纹理质量并不强依赖 point map。

整体架构是两阶段 latent flow matching。第一阶段是 Geometry Model，建模 p(O, R, t, s | I, M)：其中 O 是 64^3 的 coarse shape voxel，R 使用 6D rotation representation，t 是平移，s 是尺度。 Geometry Model 是一个约 1.2B 参数的 flow transformer，采用 Mixture-of-Transformers 架构，在输入图像/Mask 条件下联合生成粗形状和布局。第二阶段是 Texture & Refinement Model，建模 p(S, T | I, M, O)：它先从 coarse shape 中抽取 active voxels，再用约 600M 参数的 sparse latent flow transformer 细化几何并合成纹理。最后，结构化 latent 可以通过两个 VAE decoder 输出 mesh 或 3D Gaussian splats；两个 decoder 共享同一个 VAE encoder，因此处在相同的 structured latent space 中。

训练流程非常像大模型训练范式：pretraining、mid-training、post-training，再加 alignment 和 distillation。 Pretraining 使用 isolated synthetic 3D assets，作者从 Objaverse-XL 和授权数据中收集 2.7M object meshes，每个物体渲染 24 个视角，构成 Iso-3DO，用 2.5T training tokens 学习基本形状和纹理生成能力。 Mid-training 构造 semi-synthetic 的 render-and-paste 数据 RP-3DO，把带纹理 mesh alpha-composite 到自然图像里，包含遮挡-被遮挡对，以及把真实物体替换成位置和尺度相似的合成物体。 RP-3DO 有 61M samples 和 2.8M unique meshes，用 2.7T training tokens 训练 mask-following、occlusion robustness、layout estimation 和 visual cue usage。这一步之后，模型已经见过所有输入/输出模态，但仍然主要是合成或半合成数据，因此需要真实图像 post-training。

Post-training 是 SAM 3D 最重要的数据飞轮。 3D 标注不像 2D Mask 标注，普通标注员很难直接建 mesh，但他们可以在多个候选 3D 模型里选择最像图中物体的那个，并给出质量评分。因此，数据引擎会先用当前模型和一组已有 learned / retrieval-based models 生成候选形状与纹理，再让人类从 N=8 个候选中选最好的一个。如果质量评分超过阈值，最佳候选成为正样本 D+ = (I, M, S, T, R, t, s)；其他较差候选变成偏好优化中的负样本 D-。早期由于模型还弱，候选主要来自 ensemble；随着迭代推进，SAM 3D 自己最终贡献了约 80% 的标注数据。整个真实数据收集最终覆盖接近 1M images，约 3.14M untextured meshes 和约 100K textured meshes。

真实数据引擎被拆成三个标注子任务。 Stage 1 选择目标物体 (I, M)：从多种真实图像数据源采样，并用 3D-oriented taxonomy 平衡物体分布，Mask 来自已有分割标注或人类选择。 Stage 2 选择形状和纹理 (S, T)：人类在多个模型候选中选择最符合输入图像和 Mask 的 3D object，并拒绝低质量候选。 Stage 2.5 处理 hard examples：当没有模型能生成合理形状时，样本会被路由给专业 3D artists 直接标注，形成高质量 Art-3DO。 Stage 3 标注布局 (R, t, s)：给定 Stage 2 的 object shape，标注员在 point cloud 中操作物体的平移、旋转和尺度，让 3D object 与 2.5D 场景对齐。

模型更新同样分阶段。 SFT 先用噪声较大的非专家 MITL-3DO 数据缩小 synthetic-to-real gap，再用更小但质量更高的 Art-3DO 数据强化审美和几何质量，减少 floaters、bottomless meshes、缺失对称性等常见失败。随后使用 DPO 做 preference alignment，把 Stage 2 中人类选择的 D+ 和较差候选 D- 作为偏好对，优化人类更敏感但普通 flow matching 难以直接刻画的属性，例如闭合性、对称性和整体可用性。最后，Geometry Model 做 distillation，将推理时的 function evaluations 从 25 降到 4，使 shape 和 layout 可以做到 sub-second 级生成。

实验中，作者构建了新的 SA-3DAO benchmark：1000 个由专业 3D artists 从自然图像恢复并对齐的无纹理 3D objects。这个 benchmark 比 isolated render 更接近真实使用场景，包含室内外场景、遮挡、小物体、稀有文化物体、衣物、滑雪缆车、自动扶梯等复杂目标。在 SA-3DAO shape 指标上，SAM 3D 明显优于 Trellis、Hunyuan3D、Direct3D-S2、TripoSG、Hi3DGen 等方法：F1@0.01 为 0.2344，vIoU 为 0.2311，Chamfer 为 0.0400，EMD 为 0.1211。相比最强基线，F1 和 vIoU 提升很大，Chamfer / EMD 也显著更低，说明它不仅能生成看起来像的形状，也更接近 artist ground truth 几何。在 ISO3D isolated object 上，SAM 3D 的 Uni3D 为 0.3707，基本达到或略超 SOTA，说明它强化真实场景能力的同时没有牺牲干净物体能力。

布局估计是 SAM 3D 区别于普通 image-to-3D 生成器的重要部分。在 SA-3DAO 上，SAM 3D joint layout 的 3D IoU 为 0.4254、ICP-Rot 为 20.77、ADD-S 为 0.2661、ADD-S@0.1 为 0.7232，显著优于「先生成 mesh 再用 FoundationPose/Megapose 对齐」的 pipeline。在 Aria Digital Twin 上，SAM 3D 的 3D IoU 为 0.4970、ADD-S@0.1 为 0.7673；论文强调这相当于把真实场景 joint shape+layout 能力从非常低的可用率提升到大幅可用。如果再做 test-time layout optimization，ADT 上 3D IoU 可从 0.4837 提到 0.5258，2D IoU 从 0.5143 提到 0.6487。

人类偏好实验也支持这个结论。在真实物体和场景中，SAM 3D 的 object reconstruction 相比 prior SOTA 至少有 5:1 win rate，scene reconstruction 有约 6:1 win rate。纹理评价中，在给定 SAM 3D shape 的条件下，标注员也明显偏好 SAM 3D 的 Texture & Refinement：相对 Trellis，在 ISO3D、Preference Set、SA-3DAO、LVIS 上胜率分别为 81.1%、87.0%、86.2%、89.1%；相对 Hunyuan3D-2.1，在后三个真实/偏好集合上也都是 86% 以上。

消融实验说明多阶段训练是必要的。只做 Iso-3DO pretraining 时，SA-3DAO F1@0.01 只有 0.1349，vIoU 0.1202。加入 RP-3DO mid-training 后提升到 0.1705 / 0.1683；加入 MITL-3DO SFT 到 0.2027 / 0.2025；MITL DPO 到 0.2156 / 0.2156；Art-3DO SFT 到 0.2331 / 0.2337；最终 Art-3DO DPO 达到 0.2344 / 0.2311，同时 Chamfer 降到 0.0400。去掉 MITL-3DO、Art-3DO 或 DPO 都会退化，其中去掉 Art-3DO 影响最大，说明高质量 artist data 对真实世界形状质量非常关键。

这篇论文对我的启发是：3D foundation model 的核心瓶颈不是网络结构本身，而是如何把真实图像和可信 3D supervision 连接起来。 SAM 3D 的数据引擎把「让人直接建模」改成了「让人从模型候选中选择并评分」，再把选择结果变成 SFT 数据和 DPO 偏好对，这和 RLHF / data flywheel 的思想非常接近。因此它不是简单的 image-to-3D 模型，而是一套把 2D Mask、候选 3D、point map、人类偏好和专业 artist 数据组合起来的真实世界 3D 对齐系统。局限也很明确：Geometry Model 的 coarse shape 是 64^3，细结构、薄结构、手和脸等对分辨率敏感的部分可能失真；模型逐物体预测 layout，不显式推理多物体接触、稳定性、互穿或共平面；texture 预测不知道最终 pose，所以旋转对称物体有时会出现纹理朝向错误。总体看，SAM 3D 是 SAM 系列从「分割物体」走向「把分割出的物体 3D 化」的重要一步，尤其适合机器人、AR/VR、游戏、影视和交互式媒体中的真实场景 3D 感知。

PointNet

分类任务中，PointNet 先得到全局 feature 再做 object classification；分割任务中，则把全局 feature 拼回每个点的局部 feature 上，再逐点预测 part / semantic label。代表结果是 ModelNet40 overall accuracy 89.2%，ShapeNet part segmentation mean IoU 83.7%。它的意义不在于复杂结构，而在于证明「共享 MLP + max pooling」就能直接吃 unordered point set，并成为后续点云网络的基本 building block。

PointNet++

PointNet++ 的动机很直接：PointNet 虽然解决了点集无序性，但它主要做全局聚合，没有显式建模 metric space 中的局部邻域结构。点云里的局部几何非常重要，例如椅子腿、桌面边缘、墙角和家具边界；同时真实扫描点云往往采样密度不均匀，固定尺度的局部特征很容易失效。 PointNet++ 把 PointNet 变成层级局部算子。每个 set abstraction level 包含三步：Sampling layer 用 farthest point sampling 选 centroids，保证覆盖整个点集；Grouping layer 用 ball query 按半径找局部邻域；PointNet layer 在每个局部邻域内运行 mini-PointNet，把可变数量的邻域点编码成固定长度 local feature。堆叠多个 set abstraction level 后，点的数量逐层减少，receptive field 逐层增大，类似点云版本的层级 CNN。

为了解决非均匀密度，论文提出两种 density adaptive 设计。 MSG 在同一层用多个半径做 grouping，然后拼接多尺度特征；训练时使用 random input dropout，让模型学会在稀疏/稠密采样下选择合适尺度。 MRG 则把当前层局部 PointNet 特征和下一层更粗分辨率的特征拼接，计算更省，在低密度区域更依赖粗尺度信息，在高密度区域保留细节。分割任务中，PointNet++ 还用 feature propagation，把高层稀疏点特征通过 kNN inverse-distance interpolation 传播回原始点，并和 skip features 拼接后逐点分类。

代表结果上，PointNet++ 在 ModelNet40 上达到 90.7% accuracy，加入 normal 后达到 91.9%，超过 PointNet 的 89.2%。在 ScanNet scene labeling 中，它比 PointNet 更能分出家具等局部物体，而不是只抓住房间整体布局。总体来看，PointNet 是点云深度学习的「集合函数」基线，PointNet++ 则补上了局部结构、多尺度和密度鲁棒性，是后续点云 backbone 的重要起点。

Point-BERT

直观理解：Point-BERT 的贡献是定义了「点云词表 + masked token prediction」这条路线，让标准 Transformer 能通过自监督预训练获得点云表征。缺点也比较明显：dVAE tokenizer 训练复杂、依赖额外 DGCNN/FoldingNet，整体预训练流程不够简洁。

Point-MAE

结果上，Point-MAE 在 ModelNet40 上达到 93.8%（8k 点为 94.04%），ScanObjectNN PB-T50-RS 达到 85.18%，比 Point-BERT 高 2.11%；Few-shot 四个设置也全面超过 Point-BERT；ShapeNetPart instance mIoU 为 86.1%。它的经验结论也很重要：点云 MAE 更适合 random masking + 较高 mask ratio（约 60%–80%），让模型必须从稀疏可见局部推理整体结构。

总体看，Point-BERT 证明了点云 masked pretraining 可行；Point-MAE 则说明不需要复杂离散词表，直接做几何重建也能学到更强、更简洁的 3D 表征。

PointGPT

PointGPT 关心的是：既然 BERT/MAE 式 masked modeling 已经能用于点云，那么 GPT 式 auto-regressive pretraining 能不能也迁移过来。难点在于点云没有天然序列顺序，而且点云局部冗余较高，简单预测下一个 patch 可能不需要真正理解整体形状。

方法上，它先用 FPS + kNN 把点云分成 point patches，再用 Morton-order curve 按空间邻近关系排序，把无序点云变成 patch 序列。随后用 extractor-generator Transformer decoder 做自回归生成：extractor 学表征，generator 负责预测后续 patch；预训练后 generator 可以丢掉，主要保留 extractor 给下游任务用。论文还提出 dual masking，在因果 mask 之外额外遮住一部分可 attending 的历史 tokens，降低点云冗余带来的捷径；同时用 relative direction prompts 给 generator 提示相邻 patch 的方向，但避免直接泄漏目标位置。生成目标是后续 patch 的点坐标，loss 使用 l1 + l2 Chamfer Distance。

结果上，PointGPT-L 在 ModelNet40 达到 94.9%，ScanObjectNN PB-T50-RS 达到 93.4%，ShapeNetPart instance mIoU 达到 86.6%；few-shot 四个设置也达到当时很强的结果。需要注意，这些最佳结果来自更大模型、混合数据预训练和 post-pre-training；单纯的 PointGPT-S 更适合作为与 Point-MAE/Point-BERT 同量级比较。总体看，PointGPT 的价值是把点云预训练从「补洞/重建」推进到「按空间序列自回归生成」，但其排序方式和扩展训练流程也让实现复杂度上升。

Point Transformer V3

Point Transformer V3 的出发点很有意思：它不是追求更复杂的 attention 机制，而是重新权衡 3D backbone 的准确率、速度、显存和可扩展性。论文认为，在多数据集联合训练和大感受野成为趋势后，性能更可能来自 scale，而不是精细但昂贵的局部邻域设计。

核心做法是 point cloud serialization。 PTv3 不再坚持完全 permutation invariant 的 KNN 邻域搜索，而是用 space-filling curves 把点云序列化，包括 Z-order、Hilbert 以及 Trans Z-order / Trans Hilbert。点按 serialization code 排序后，在序列上划分 non-overlapping patches，并做高效 dot-product patch attention。这样会牺牲一点精确 KNN 邻域，但换来更大的 patch size、更低延迟和更低显存；论文的关键判断是「效率提升后可以靠扩大感受野把精度补回来」。

为了让不同 patch 之间交互，PTv3 在不同 attention block 中切换或打乱 serialization order，其中 Shuffle Order 效果最好。位置编码方面，它放弃昂贵的相对位置编码 RPE，改用 xCPE：在 attention 前加一层 sparse convolution 和 skip connection，兼顾位置感知与效率。整体网络仍是 U-Net 风格的四阶段 encoder-decoder。

结果上，PTv3 把有效感受野从 PTv2 的 16 点扩到 1024 点，同时相对 PTv2 约有 3× 速度提升和 10× 显存效率提升。语义分割中，scratch PTv3 / 预训练 PTv3 在 ScanNet test 上为 77.9% / 79.4%，S3DIS 6-fold 为 77.7% / 80.8%，nuScenes test 为 82.7% / 83.0%，SemanticKITTI test 为 74.2% / 75.5%。所以 PTv3 的意义不是提出一个更花哨的 Transformer，而是把点云 Transformer 做成真正可规模化、可作为通用 3D backbone 使用的版本。

PointCLIP

PointCLIP 是把 2D CLIP 迁移到 3D 点云的早期代表。它不训练 3D backbone，而是把点云从多个固定视角在线投影成 depth maps，再送入 CLIP image encoder；类别名则放进手写 prompt，比如 point cloud depth map of a [CLASS].，由 CLIP text encoder 得到分类权重。每个视角独立得到 image-text matching logits，最后用手工 view weights 加权融合。

零样本版本完全不需要 3D 训练，但性能还比较初步：ModelNet10 为 30.23%，ModelNet40 为 20.18%，ScanObjectNN 为 15.38%。论文真正有用的部分是 few-shot adapter：冻结 CLIP 的图像和文本编码器，只训练一个三层 inter-view adapter。它先拼接多视角特征得到 global feature，再用残差方式把 global-guided adapted feature 加回每个 view feature，使少量 3D 样本学到的知识和 CLIP 的 2D 预训练知识融合。在 ModelNet40 上，16-shot PointCLIP 能从 zero-shot 20.18% 提升到 87.20%。

PointCLIP 还有一个有趣发现：它和传统 3D 全监督网络具有互补性。例如 16-shot PointCLIP 与 PointNet++ ensemble，可把 PointNet++ 从 89.71% 提升到 92.10%；与 CurveNet ensemble，可从 93.84% 提升到 94.08%。总体看，PointCLIP 的价值不是性能最强，而是证明了「多视角投影 + CLIP 对齐」可以作为 3D open-vocabulary / low-shot 学习的入口。

PointCLIP V2

PointCLIP V2 是对 PointCLIP 的系统升级：它认为原版主要卡在两个 domain gap 上。第一是 visual gap，原版投影得到的是稀疏散点 depth map，和 CLIP 预训练时看到的真实图像差异太大；第二是 language gap，a photo of a [CLASS] 或简单加 depth map 的文本不足以描述 3D 形状。

为了解决 visual gap，V2 提出 realistic projection，流程是 Quantize、Densify、Smooth、Squeeze。它先把点云放入 3D voxel grid，再用 minimum pooling 做 densify，让投影更像有遮挡关系的实体表面；随后用 Gaussian filter 平滑噪声，最后沿深度维 squeeze 成更连续、更像真实图像的 depth map。消融里，直接正交投影只有 57.35% ModelNet40 zero-shot；加入完整 realistic projection 后到 64.22%。

为了解决 language gap，V2 用 GPT-3 根据 3D command 生成类别相关描述，而不是只用类别名模板。命令包括 caption generation、question answering、paraphrase generation、words-to-sentence 四类；最终每个类别可得到大量 3D-specific descriptions，再送入 CLIP text encoder。在 ModelNet40 zero-shot 上，不用 GPT prompt 是 39.11%，四类命令全用后达到 64.22%，说明文本侧对齐非常关键。

结果上，V2 在 zero-shot 3D classification 上大幅超过 PointCLIP：ModelNet10 73.13%，ModelNet40 64.22%，ScanObjectNN PB_T50_RS 35.36%。它还把同一框架扩展到更多 open-world 任务：ShapeNetPart zero-shot part segmentation instance mIoU 从 PointCLIP 的 31.0% 提升到 49.5%；ScanNet V2 zero-shot detection 达到 AP25 18.97%、AP50 11.53%。 Few-shot 中，V2 还可把 smoothing 变成可学习的 3D 卷积模块，并结合 inter-view adapter；ModelNet40 16-shot 达到 89.55%。

总体看，PointCLIP V2 的核心贡献是同时 prompt CLIP 的视觉侧和语言侧，把原本只能做 3D 分类的 PointCLIP 扩展成统一的 3D open-world learner。不过它仍依赖投影质量、GPT 生成文本和 CLIP 的 2D 先验，因此对细粒度几何和真实复杂场景的能力仍受 2D-3D 对齐上限约束。

ULIP

ULIP 的核心思想是：不再只在点云内部做自监督，而是把 3D encoder 对齐到 CLIP 已经学好的 image-text feature space。它从 ShapeNet55 构造 image-text-point triplets：点云来自 CAD 模型采样；图像来自多视角渲染，每个物体有 30 张 RGB 和 30 张 depth 候选；文本来自 metadata，并用 64 个 prompt template 生成描述。训练时冻结 CLIP image/text encoders，只更新 3D backbone，用 point-image 和 point-text contrastive loss 把点云特征拉进同一个语义空间。

ULIP 是 backbone-agnostic 的，可以套在 PointNet++、PointBERT、PointMLP 等网络上。标准分类中，它在 ScanObjectNN 上把 PointBERT 从 83.1% 提到 86.4%，把 PointMLP 从 85.7% 提到 88.8%；在 ModelNet40 上，PointMLP* + ULIP 达到 94.7%。 Zero-shot 3D classification 是更关键的结果：ModelNet40 上 PointBERT + ULIP 达到 60.4% top-1，而 PointCLIP 只有 20.2%；ScanObjectNN 上 PointNet++(msg) + ULIP 达到 49.9%，也远高于 PointCLIP 的 15.4%。消融还显示，同时对齐 point-image-text 三种模态总是优于只对齐其中两种。

总体看，ULIP 是 3D 多模态预训练的重要转折点：它证明了 3D backbone 可以通过少量三元组数据继承 CLIP 的开放词表语义，而不必把点云硬投影成 2D 图像再分类。

Point-Bind & Point-LLM

Point-Bind 可以看成 ULIP 的多模态扩展：ULIP 主要对齐 image-text-point，Point-Bind 则借助 ImageBind，把 3D point cloud 对齐到图像、文本、音频等更多模态的联合空间。训练数据由 3D-image-text-audio pairs 构成，其中 3D encoder 使用 I2P-MAE，后接两层 linear projection；ImageBind 的图像、文本、音频 encoders 冻结。目标函数很直接：让 F_3D 分别和 F_2D、F_T、F_A 做 contrastive alignment；如果某些类别没有合理音频，就忽略 audio loss。

对齐完成后，Point-Bind 展示了一系列 emergent 能力。在 ModelNet40 zero-shot classification 上，Point-Bind + I2P-MAE 达到 78.0%，高于 ULIP2 的 66.4% 和 PointCLIP V2 的 64.2%。在跨模态检索上，Point-Bind 的 mAP 为：3D→3D 63.23，2D→3D 34.59，3D→2D 42.83，Text→3D 64.50；其中 2D→3D 和 Text→3D 分别比 ULIP 高 14.29% 和 13.99%。它还可以把 3D embedding 与 audio embedding 相加做组合检索，或者把多模态 encoder 接到 CLIP-Forge 这类 decoder 上做 any-to-3D generation。

Point-LLM 是在 Point-Bind 之上的 3D LLM 尝试。它参考 ImageBind-LLM，把 Point-Bind 的 3D embedding 通过 bind network、visual cache 和 zero-initialized gating 接入 LLaMA；训练阶段不需要 3D instruction data，只用公开 vision-language 数据做参数高效微调。因此它可以用英文/中文回答关于 3D 点云的问题，也可以把点云和图像/音频一起作为条件进行跨模态推理。总体看，这篇更像一个系统展示：从 3D 多模态对齐，到 3D 生成、检索、zero-shot 识别，再到 3D 指令跟随。

OpenScene

OpenScene 关注的是开放词表 3D scene understanding，而不是单物体点云分类。它的目标是给每个 3D point 预测一个和 CLIP/text/image pixel 共嵌入的 dense feature，这样任意文本 query 都可以通过 cosine similarity 在 3D 场景里生成热力图或语义分割。

方法分三步。首先，用 OpenSeg 或 LSeg 这类开放词表 2D segmentation model 提取每张 RGB 图像的 dense pixel features；然后利用相机位姿和深度，把多视角 pixel features back-project 到 3D points，并做 multi-view average fusion，得到 F_2D。其次，训练一个 MinkowskiNet18A 只从 3D geometry 输入预测 F_3D，用 cosine loss 蒸馏到 F_2D，这样没有 RGB 时也能做开放词表查询。最后，用文本 prompt 与 2D/3D features 的相似度决定每个点采用 2D fusion 还是 3D distill feature，形成 2D-3D ensemble。

结果上，在 ScanNet 4 个 unseen 类别的 zero-shot segmentation 中，OpenScene-LSeg 达到 62.8% mIoU，而 3DGenZ 是 7.7%，MSeg voting 是 53.4%。在标准场景语义分割中，OpenScene-OpenSeg zero-shot 在 nuScenes 上达到 42.1% mIoU / 61.8% mAcc，在 ScanNet 上为 47.5% / 70.7%，在 Matterport 上为 42.6% / 59.2%。消融显示 2D-3D ensemble 通常优于只用 2D fusion 或 3D distillation；并且随着 label set 扩大，OpenScene 对长尾类别比全监督模型更稳。总体看，OpenScene 把 CLIP 空间从 2D 图像和单物体 3D 扩展到真实 3D 场景，是开放词表 3D 场景理解的关键基线。

OpenMask3D

OpenMask3D 解决的是 OpenScene 的一个自然短板：OpenScene 学的是 per-point semantic feature，适合做语义热力图，但不能天然区分同类物体的多个 instance。 OpenMask3D 因此提出 open-vocabulary 3D instance segmentation：先拿到 class-agnostic 3D instance masks，再给每个 mask 计算一个开放词表 CLIP feature。

具体流程是两阶段。第一阶段使用预训练 Mask3D 的 mask proposal module，只保留 binary instance masks，丢掉 closed-set class labels 和 confidence scores。第二阶段对每个 3D mask 计算 mask feature：先根据可见点数量和深度遮挡选择 top-k RGB-D views；再把 3D mask 投影到 2D，并用 SAM 根据投影点生成更干净的 2D object mask；随后围绕 2D mask 做多尺度 crop，用 CLIP visual encoder 提取 crop features，最后跨 crop 和 view 平均，得到 per-mask feature。查询时只需要把文本或图像 query 编成 CLIP feature，与每个 mask feature 做相似度匹配。

ScanNet200 validation 上，OpenMask3D 达到 AP 15.4、AP50 19.9、AP25 23.1，明显高于用 OpenScene features 加 mask 聚合的 open-vocabulary baselines；尤其 tail AP 为 14.9，而 OpenScene 2D Fusion + masks 是 9.9。在 Replica 跨数据集测试中，OpenMask3D AP 为 13.1，也高于 OpenScene 变体。如果 mask proposal 只用 ScanNet20 训练、再评估 ScanNet200，OpenMask3D 在 novel classes 上仍有 11.9 AP，说明它对未见类别主要依赖 CLIP mask feature，而不是 closed-set class head。消融显示 SAM 2D mask refinement 和 multi-scale crops 都有帮助；oracle masks 实验中，OpenMask3D 的 tail AP 达到 32.9，甚至超过 fully supervised Mask3D 的 tail AP 17.9，说明瓶颈主要在 3D mask proposal 质量。

总体看，OpenMask3D 是从开放词表 3D 语义理解走向开放词表 3D 实例级交互的重要一步：它把 CLIP 的开放语义绑定到 object mask，而不是散落在每个 point 上。

Ubuntu OpenSSH 远程服务器配置教程

Mon, 01 Jun 2026 00:00:00 GMT

有一台已经装好 Ubuntu 的机器后，最常见的下一步就是把它当作远端服务器使用：本地电脑通过 ssh 登录，在服务器上跑代码、部署服务、传文件或远程开发。

这篇文章整理一套从零开始的 OpenSSH 配置流程，目标是：

局域网内可以 SSH 登录
公网或云服务器场景知道该放行哪些端口
支持 SSH 密钥登录
关闭高风险登录方式，减少被爆破的概率
遇到连不上时能快速定位问题

默认环境：

服务器：Ubuntu 22.04 / 24.04 或相近版本
客户端：Linux / macOS / Windows PowerShell 均可
SSH 服务端：OpenSSH Server

1. 安装 OpenSSH Server

在 Ubuntu 服务器上执行：

sudo apt update
sudo apt install -y openssh-server

安装完成后启动 SSH 服务，并设置开机自启：

sudo systemctl enable --now ssh

查看服务状态：

sudo systemctl status ssh

如果看到 active (running)，说明 SSH 服务已经正常运行。

也可以用下面的命令确认 22 端口是否在监听：

sudo ss -tlnp | grep ':22'

正常情况下会看到类似：

LISTEN 0 128 0.0.0.0:22 0.0.0.0:* users:(("sshd",pid=1234,fd=3))

2. 创建一个普通登录用户

如果你现在只是在本机上用安装系统时创建的用户，也可以直接用这个用户登录。
如果这台机器之后要长期当服务器用，推荐单独创建一个普通用户。

例如创建 hana 用户：

sudo adduser hana

如果这个用户需要执行 sudo：

sudo usermod -aG sudo hana

之后就可以用这个用户远程登录：

ssh hana@服务器IP

不推荐直接用 root 远程登录。服务器日常运维最好使用普通用户登录，需要管理员权限时再通过 sudo 提权。

3. 查看服务器 IP

局域网 IP

如果你只需要在同一个 Wi-Fi / 路由器 / 实验室内网里连接，先查看服务器的内网 IP：

hostname -I

输出可能类似：

192.168.1.20 172.17.0.1

一般使用 192.168.x.x、10.x.x.x 或 172.16.x.x 到 172.31.x.x 这一类地址。

然后在本地电脑上连接：

ssh hana@192.168.1.20

第一次连接时会看到主机指纹确认提示：

Are you sure you want to continue connecting (yes/no/[fingerprint])?

确认 IP 没写错后输入：

yes

之后再输入服务器用户密码即可登录。

公网 IP

如果是云服务器，公网 IP 通常在云厂商控制台里可以直接看到。

如果是放在家里或实验室的物理机器，则需要区分两件事：

机器自己的内网 IP，例如 192.168.1.20
路由器对外的公网 IP

可以在服务器上查看对外出口 IP：

curl ifconfig.me

但能看到公网 IP 不代表外部一定能连进来。很多校园网、公司网络、家庭宽带可能处在 NAT 后面，没有可直接访问的公网入口。

4. 开放防火墙端口

Ubuntu 常用防火墙是 ufw。如果你启用了它，需要允许 SSH 流量。

查看防火墙状态：

sudo ufw status

放行 OpenSSH：

sudo ufw allow OpenSSH

或者明确放行 22 端口：

sudo ufw allow 22/tcp

如果 ufw 还没启用，可以启用它：

sudo ufw enable

再次确认：

sudo ufw status numbered

如果后面你把 SSH 改到了非默认端口，例如 2222，记得提前放行新端口：

sudo ufw allow 2222/tcp

重点：先放行新端口，再改 SSH 配置。 否则可能把自己锁在服务器外面。

5. 从本地电脑连接服务器

最基本的 SSH 命令格式是：

ssh 用户名@服务器IP

例如：

ssh hana@192.168.1.20

如果 SSH 服务不是默认的 22 端口，需要加 -p：

ssh -p 2222 hana@192.168.1.20

Windows PowerShell、macOS Terminal、Linux Terminal 都可以直接使用这个命令。
如果 Windows 提示找不到 ssh，可以在系统设置的“可选功能”里安装 OpenSSH Client。

6. 配置 SSH 密钥登录

密码登录能用，但不适合长期暴露在公网。更推荐使用 SSH 密钥。

6.1 在本地电脑生成密钥

在本地电脑执行，不是在服务器上执行：

ssh-keygen -t ed25519 -C "your_email@example.com"

默认会生成：

私钥：~/.ssh/id_ed25519
公钥：~/.ssh/id_ed25519.pub

看到 passphrase 提示时：

想安全一些：设置一个私钥密码
想省事：直接回车留空

更推荐设置 passphrase，然后配合 ssh-agent 使用。

6.2 把公钥上传到服务器

Linux / macOS 通常可以直接用：

ssh-copy-id -i ~/.ssh/id_ed25519.pub hana@192.168.1.20

如果服务器端口不是 22：

ssh-copy-id -i ~/.ssh/id_ed25519.pub -p 2222 hana@192.168.1.20

Windows PowerShell 没有 ssh-copy-id 时，可以手动追加公钥：

type $env:USERPROFILE\.ssh\id_ed25519.pub | ssh hana@192.168.1.20 "mkdir -p ~/.ssh && cat >> ~/.ssh/authorized_keys && chmod 700 ~/.ssh && chmod 600 ~/.ssh/authorized_keys"

上传完成后测试密钥登录：

ssh hana@192.168.1.20

如果不再要求输入服务器用户密码，说明密钥登录已经生效。
如果你设置了私钥 passphrase，系统可能会要求输入私钥密码，这是正常的。

7. 配置本地 SSH 别名

每次输入 ssh -p 2222 hana@1.2.3.4 很麻烦，可以在本地电脑配置 ~/.ssh/config。

Linux / macOS：

nano ~/.ssh/config

Windows：

notepad $env:USERPROFILE\.ssh\config

添加：

Host my-server
  HostName 192.168.1.20
  User hana
  Port 22
  IdentityFile ~/.ssh/id_ed25519
  ServerAliveInterval 60
  ServerAliveCountMax 5

之后直接连接：

ssh my-server

如果是 Windows，也可以把私钥路径写成：

IdentityFile C:/Users/YourName/.ssh/id_ed25519

这套配置对 scp、rsync、VSCode Remote SSH 也都有效。

8. 公网访问需要额外做什么

局域网能连，不代表公网能连。公网访问取决于你的机器放在哪里。

云服务器

云服务器通常需要检查三层：

Ubuntu 里的 SSH 服务是否正常运行
Ubuntu 防火墙是否放行 SSH 端口
云厂商安全组是否放行 SSH 端口

云厂商安全组里至少需要一条入站规则：

协议：TCP
端口：22 或你的自定义端口
来源：你的本地公网 IP，或临时使用 0.0.0.0/0

更安全的做法是只允许自己的公网 IP，而不是长期开放给所有地址。

家里或实验室物理机

如果服务器在路由器后面，需要在路由器里设置端口转发：

公网 TCP 2222 -> 192.168.1.20:22

外部连接时写：

ssh -p 2222 hana@你的公网IP

这里推荐把公网端口设成 2222 这类非默认端口，再转发到内网的 22 端口。
这不能替代密钥和安全配置，但可以减少一些默认端口扫描噪音。

如果你的网络没有公网 IP，或者被校园网 / 公司网 NAT 隔离，可以考虑：

Tailscale / ZeroTier 这类内网穿透组网工具
WireGuard 自建 VPN
云服务器反向 SSH 隧道

不要为了省事把路由器后台、服务器密码登录和弱密码一起暴露到公网。

9. 安全加固 SSH 服务端

确认密钥登录已经成功后，再进行安全加固。

Ubuntu 的 OpenSSH 配置主文件是：

/etc/ssh/sshd_config

更推荐把本地自定义配置放到：

/etc/ssh/sshd_config.d/99-local.conf

这样以后系统升级时更清晰。

创建配置文件：

sudo nano /etc/ssh/sshd_config.d/99-local.conf

写入：

PermitRootLogin no
PubkeyAuthentication yes
PasswordAuthentication no
KbdInteractiveAuthentication no
X11Forwarding no
AllowUsers hana

含义：

PermitRootLogin no：禁止 root 远程登录
PubkeyAuthentication yes：允许公钥登录
PasswordAuthentication no：禁止密码登录
KbdInteractiveAuthentication no：关闭键盘交互式密码认证
X11Forwarding no：关闭不常用的图形转发
AllowUsers hana：只允许指定用户登录

如果你有多个用户，可以写成：

AllowUsers hana deploy ubuntu

保存后先检查配置语法：

sudo sshd -t

没有输出通常表示语法正确。然后重载 SSH：

sudo systemctl reload ssh

不要立刻关闭当前 SSH 窗口。
请打开一个新的终端窗口，再测试一次：

ssh my-server

确认新连接可以登录后，再退出旧连接。

10. 是否需要修改默认端口

修改默认端口不是必须项。它不能真正替代密钥登录和防火墙策略，但能减少自动化扫描日志。

如果要把 SSH 端口改成 2222，先放行新端口：

sudo ufw allow 2222/tcp

然后编辑本地配置文件：

sudo nano /etc/ssh/sshd_config.d/99-local.conf

添加或修改：

Port 2222

检查配置并重载：

sudo sshd -t
sudo systemctl reload ssh

新开一个终端测试：

ssh -p 2222 hana@服务器IP

确认新端口可用后，再考虑删除旧的防火墙规则。

11. 安装 fail2ban（可选）

如果服务器必须暴露在公网，并且你还保留了密码登录，建议至少安装 fail2ban。
即使已经关闭密码登录，fail2ban 也可以减少日志里的暴力扫描噪音。

安装：

sudo apt update
sudo apt install -y fail2ban
sudo systemctl enable --now fail2ban

查看状态：

sudo systemctl status fail2ban

查看 SSH jail：

sudo fail2ban-client status sshd

如果只是内网服务器，可以先不装，避免引入额外变量。

12. 常见问题排查

12.1 Connection timed out

一般是网络路径不通，重点检查：

IP 是否写对
端口是否写对
服务器是否开机
ufw 是否放行
云服务器安全组是否放行
路由器端口转发是否正确
是否处在不可入站的 NAT 网络后面

服务器上看端口监听：

sudo ss -tlnp | grep ssh

本地测试端口连通性：

nc -vz 服务器IP 22

Windows PowerShell 可以用：

Test-NetConnection 服务器IP -Port 22

12.2 Connection refused

通常说明网络到了服务器，但目标端口没有服务在监听。检查：

sudo systemctl status ssh
sudo ss -tlnp | grep ':22'

如果 SSH 没启动：

sudo systemctl restart ssh

12.3 Permission denied

这类错误通常是认证失败。检查：

用户名是否正确
公钥是否写入服务器的 ~/.ssh/authorized_keys
服务器是否禁用了密码登录
本地是否用了正确的私钥
~/.ssh 权限是否正确

在服务器上修复权限：

chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys

在本地指定私钥测试：

ssh -i ~/.ssh/id_ed25519 hana@服务器IP

12.4 改配置后彻底连不上

如果是云服务器，优先使用云厂商控制台的 VNC / Web Terminal 登录修复。
如果是物理机，需要接显示器或通过管理口进入。

常见恢复动作：

sudo sshd -t
sudo systemctl status ssh
sudo nano /etc/ssh/sshd_config.d/99-local.conf
sudo systemctl reload ssh

所以修改 SSH 配置时，一定要遵守这个顺序：

保留当前 SSH 会话
修改配置
执行 sudo sshd -t
执行 sudo systemctl reload ssh
新开终端测试新连接
确认无误后再关闭旧会话

13. 一套推荐的最终配置

如果是个人长期使用的 Ubuntu 服务器，我通常会采用：

普通用户登录，不允许 root 登录
SSH 密钥登录
禁止密码登录
ufw 只放行必要端口
云服务器安全组只允许自己的 IP 访问 SSH
本地配置 ~/.ssh/config 别名
长任务放在 tmux 里跑

最小可用服务端配置：

PermitRootLogin no
PubkeyAuthentication yes
PasswordAuthentication no
KbdInteractiveAuthentication no
X11Forwarding no
AllowUsers hana

本地客户端配置：

Host my-server
  HostName 服务器IP
  User hana
  Port 22
  IdentityFile ~/.ssh/id_ed25519
  ServerAliveInterval 60
  ServerAliveCountMax 5

以后连接只需要：

ssh my-server

到这里，这台 Ubuntu 机器就已经可以作为一台基础远端服务器使用了。后续可以继续接上 VSCode Remote SSH、scp、rsync、tmux 等工具，形成完整的远程开发工作流。

Paper Reading: CV 2

Fri, 26 Dec 2025 00:00:00 GMT

import { ArxivRating, RatingCriteria } from '@/components/advanced'

import { ManualTOC } from '@/components/advanced'

前言

VGGT

DUSt3R

MASt3R

Spann3R

MonST3R

CUT3R

3D Gaussian Splatting

Depth Anything

Depth Anything V2

Depth Anything 3

Video Depth Anything

Metric3D V2

UniDepth

MoGe

FoundationStereo

Florence-2

YOLO-World

Grounding DINO 1.5

OWL-ViT

GLIP

SEEM

X-Decoder

Sapiens

InternImage

V-JEPA

Paper Reading: Embodied AI 5

Sun, 24 May 2026 00:00:00 GMT

import { ArxivRating, RatingCriteria } from '@/components/advanced'

import { ManualTOC } from '@/components/advanced'

前言

RL菜鸡开始进军Embodied AI，慢慢积累，提升自己。

Scale Balanced Grasp

EconomicGrasp

RNGNet

AnyGrasp

GSNet

HGGD

FlexLoG

GraNet

TransGrasp

S4G

GtG 2.0

Paper Reading: Embodied AI 4

Fri, 10 Apr 2026 00:00:00 GMT

import { ArxivRating, RatingCriteria } from '@/components/advanced'

import { ManualTOC } from '@/components/advanced'

前言

RL菜鸡开始进军Embodied AI，慢慢积累，提升自己。

4D-VLA

D(R,O) Grasp

Fast-in-Slow

NavDP

Nav $A^3$

StreamVLN

V-JEPA 2

MolmoAct

MimicGen

SpatialVLA

TraceVLA

Hume

RICL

OmniVTLA

Spatial Traces

Embodied-R1

RynnEC

RoboRefer

Discrete Diffusion VLA

G0

InternScenes

GraspNet

<ArxivRating id='https://openaccess.thecvf.com/content_CVPR_2020/papers/Fang_GraspNet-1Billion_A_Large-Scale_Benchmark_for_General_Object_Grasping_CVPR_2020_paper.pdf' publication='CVPR2020' tldr='' rank={0}

GraspNet-1Billion

<ArxivRating id='https://journals.sagepub.com/doi/10.1177/02783649231193710' publication='IJRR2023' tldr='' rank={0}

PointNetGPD

High Precision Grasp Pose Detection

共享服务器下 Git 版本管理实战（Linux/macOS/Windows）

Wed, 22 Apr 2026 00:00:00 GMT

这个场景非常典型：

代码仓库：https://github.com/your-username/your-repo.git
服务器：固定为 Linux
使用方式：多人共用同一个 Linux 系统用户
本地电脑：可能是 Linux / macOS / Windows
目标：既要规范用 Git 管理版本，又不能把个人凭证留在共享机器上

这篇教程把完整流程整理成可复用版本：所有仓库操作都在 Linux 服务器执行，本地电脑相关步骤按 Linux / macOS / Windows 分别给出命令。

一、先确认仓库状态（Linux 服务器）

先进入项目目录，确认当前分支、远程地址、工作区状态：

cd /path/to/your/project
git branch --show-current
git remote -v
git status

预期重点：

当前分支是 main
origin 指向你的仓库
先识别是否有不该提交的大目录（如 checkpoints/、outputs/、external/）

二、先做提交边界清理：补 `.gitignore`

这一步的目的不是“立刻提交”，而是先把实验产物和本地依赖从源码中隔离。

示例（按你项目实际调整）：

# local configs
configs/paths.sh

# experiment artifacts
checkpoints/
outputs/
logs/

# caches
data/
.cache/

# local external deps
external/

补完后再看状态：

git status

如果结果里主要剩下源码和文档改动，说明提交边界已经干净。

三、共享账号场景下的 Git 身份配置（只配当前仓库）

多人共用一个 Linux 用户时，不要用全局身份，避免污染他人项目。

先做前置检查：git config user.email 里要填的邮箱，必须先在 GitHub 账号里添加并完成验证。

GitHub 邮箱设置路径：

Settings -> Emails -> Add email address -> Verify

然后再回到服务器配置仓库级身份：

git config user.name "your-github-username"
git config user.email "your-email@example.com"

验证：

git config --get user.name
git config --get user.email

推荐原则：

用仓库级配置（不加 --global）
不使用 credential.helper store
不在共享机器长期保存个人 PAT/私钥
如果开启了 GitHub 邮箱隐私策略，优先使用 GitHub 提供的 noreply 邮箱做 user.email

四、把远程切到 SSH

GitHub SSH URL 固定格式：

git@github.com:<用户名>/<仓库名>.git

例如：

git@github.com:your-username/your-repo.git

设置并验证：

git remote set-url origin git@github.com:your-username/your-repo.git
git remote -v

五、核心安全做法：用 SSH Agent Forwarding（不在服务器留私钥）

5.1 在本地电脑准备 SSH key（按你的本机系统执行）

如果你本地还没有 key，先生成：

Linux / macOS

ssh-keygen -t ed25519 -C "your-email@example.com"

Windows（PowerShell）

ssh-keygen -t ed25519 -C "your-email@example.com"

加载 key 到 agent：

Linux / macOS

ssh-add ~/.ssh/id_ed25519
ssh-add -l

Windows（PowerShell）

Get-Service ssh-agent | Set-Service -StartupType Automatic
Start-Service ssh-agent
ssh-add $env:USERPROFILE\.ssh\id_ed25519
ssh-add -l

5.2 配置 SSH 别名并开启转发（本地电脑）

配置文件路径：

Linux / macOS：~/.ssh/config
Windows：C:\Users\<你用户名>\.ssh\config

配置示例：

Host <server-alias>
  HostName <你的服务器IP或域名>
  User <服务器用户名>
  IdentityFile ~/.ssh/id_ed25519
  ForwardAgent yes

然后登录服务器（任意系统本机都一样）：

ssh -A <server-alias>

5.3 在 GitHub 账号里添加 SSH 公钥（关键主步骤）

先在本地电脑读取公钥（按你的本机系统执行）：

Linux / macOS

cat ~/.ssh/id_ed25519.pub

Windows（PowerShell）

Get-Content $env:USERPROFILE\.ssh\id_ed25519.pub

然后到 GitHub 网页完成绑定：

右上角头像 -> Settings
左侧进入 SSH and GPG keys
点击 New SSH key
Key type 选择 Authentication Key
Title 填一个容易识别的名称（例如 my-laptop-agent-forward）
Key 粘贴整行公钥
点击 Add SSH key

这一段必须完成，否则后面的 ssh -T git@github.com 很可能出现 Permission denied (publickey)。

5.4 在服务器上验证 agent 转发

ssh-add -l

如果能看到你本地 key 的指纹，说明转发已生效。

六、第一次连 GitHub 的认证与排错

在服务器上测试：

ssh -T git@github.com

你遇到过的报错是：

git@github.com: Permission denied (publickey).

这通常表示“这把公钥还没绑定到目标 GitHub 账号”，不是服务器命令错了。

解决步骤：

确认你已经完成上面的 Settings -> SSH and GPG keys -> New SSH key
检查粘贴的是完整公钥（包含开头 ssh-ed25519 和中间长串内容）
保存后重新测试：

ssh -T git@github.com

通过标志通常是类似：Hi your-username! You've successfully authenticated...

七、开始版本管理并推送

建议每个明确阶段做一次小提交：

git add <files>
git commit -m "feat: your change"
git push origin main

针对你的这类实验项目，推荐把提交拆小：

chore: add gitignore for artifacts and local deps
docs: add api compatibility notes
feat: add baseline scripts

这样回滚和审阅都会轻松很多。

如果 git push 因邮箱策略被拒绝（常见于开启了 “Block command line pushes that expose my email”）：

到 GitHub Settings -> Emails 确认邮箱已验证，或复制你的 noreply 邮箱
在仓库重新设置：

git config user.email "your-noreply-email@users.noreply.github.com"

用新邮箱重做提交并推送：

git commit --amend --reset-author --no-edit
git push origin main

八、共享机器最佳实践清单

Git 身份用仓库级配置，不用全局。
不把个人私钥长期放在共享 Linux 账号目录。
不使用 credential.helper store 明文落盘 PAT。
用 ssh -A 转发本地凭证，断开会话即失效。
按功能阶段做小提交，避免把大文件和临时产物混入历史。

结语

这套流程本质上做了两件事：

把“代码版本管理”做规范（清晰提交边界 + 小步提交）
把“共享账号安全”做正确（本地持有私钥 + 会话转发认证）

如果后续你要继续在这个仓库迭代，直接复用这一套即可。

Linux 无图形界面服务器代理配置（Clash Verge 方案）

Wed, 22 Apr 2026 00:00:00 GMT

你这个场景是“Linux 服务器只有 SSH，没有图形桌面”。

先说结论：无 GUI 环境不能直接运行 Clash Verge（它是基于 WebView 的图形客户端）。在服务器上应改为使用它的内核方案：mihomo 命令行。

这篇给你一套纯命令行流程，目标是：

不依赖图形界面
可开机自启
默认不走全局代理，需要时再临时 export
终端里的 curl / apt / git 可按命令局部走代理

0. 前置条件

服务器系统：Linux（Ubuntu / Debian / CentOS）
你有一个可用的 Clash 订阅链接
你有 sudo 权限

1. 安装 mihomo（替代 Clash Verge GUI）

不要先手写通配符解压。先把文件下载到当前目录，再解压。

下面脚本会自动识别架构并从官方最新 release 获取下载链接：

https://github.com/MetaCubeX/mihomo/releases/latest

mkdir -p ~/downloads/mihomo
cd ~/downloads/mihomo

ARCH="$(uname -m)"
if [ "$ARCH" = "x86_64" ]; then
  PATTERN='mihomo-linux-amd64[^"]*\.gz'
elif [ "$ARCH" = "aarch64" ] || [ "$ARCH" = "arm64" ]; then
  PATTERN='mihomo-linux-arm64[^"]*\.gz'
else
  echo "Unsupported arch: $ARCH"
  exit 1
fi

URL="$(curl -fsSL https://api.github.com/repos/MetaCubeX/mihomo/releases/latest \
  | grep -oE "https://[^\"]+${PATTERN}" \
  | head -n 1)"

if [ -z "$URL" ]; then
  echo "Failed to resolve download url"
  exit 1
fi

curl -L "$URL" -o mihomo.gz
gunzip -f mihomo.gz
chmod +x mihomo
sudo install -m 755 mihomo /usr/local/bin/mihomo

验证安装：

mihomo -v

你遇到的这类错误：

gzip: mihomo-linux-amd64-*.gz: No such file or directory

本质是当前目录里没有匹配文件，常见原因有两个：

还没下载 mihomo 压缩包
文件名和通配符不一致

先 ls -lh 看目录里实际文件名，再执行解压。

2. 准备配置目录与 `config.yaml`

创建工作目录：

sudo mkdir -p /etc/mihomo/providers

新建 /etc/mihomo/config.yaml（最小可用模板）：

mixed-port: 7890
allow-lan: false
bind-address: 127.0.0.1
mode: rule
log-level: info
external-controller: 127.0.0.1:9090
secret: "your-strong-secret"

proxy-providers:
  mysub:
    type: http
    url: "https://your-subscription-url"
    path: ./providers/mysub.yaml
    interval: 3600
    health-check:
      enable: true
      interval: 300
      url: https://www.gstatic.com/generate_204

proxy-groups:
  - name: Proxy
    type: select
    use:
      - mysub

rules:
  - MATCH,Proxy

如果你“只有一个订阅链接”，只需要改这两处：

secret：改成你自己的随机字符串（例如 16~32 位）
url：改成你的订阅链接原文

示例（只演示要改的行）：

secret: "8e1d3f4a5b6c7d8e"
url: "https://your-subscription-url"

url 必须带引号，避免 &、? 等字符导致 YAML 解析错误。

写入文件：

sudo tee /etc/mihomo/config.yaml >/dev/null <<'YAML'
mixed-port: 7890
allow-lan: false
bind-address: 127.0.0.1
mode: rule
log-level: info
external-controller: 127.0.0.1:9090
secret: "your-strong-secret"

proxy-providers:
  mysub:
    type: http
    url: "https://your-subscription-url"
    path: ./providers/mysub.yaml
    interval: 3600
    health-check:
      enable: true
      interval: 300
      url: https://www.gstatic.com/generate_204

proxy-groups:
  - name: Proxy
    type: select
    use:
      - mysub

rules:
  - MATCH,Proxy
YAML

如果你的机场给的是“完整配置文件”而不是订阅 URL，可以直接把完整 YAML 覆盖到 /etc/mihomo/config.yaml。

2.1 只有订阅链接时，怎么判断用哪种方式

先看订阅返回的前几行：

curl -L "你的订阅链接" | head -n 20

如果能看到 proxies:、proxy-groups:、rules:，说明这是完整配置。直接保存为 /etc/mihomo/config.yaml 即可。
如果主要是节点列表，没有完整规则组，就用本文上面的 proxy-providers 模板，把链接填到 url。

3. 先前台启动测试

sudo mihomo -d /etc/mihomo -t
sudo mihomo -d /etc/mihomo

关注是否有报错；确认正常后用 Ctrl+C 停止，继续做 systemd 常驻。

4. 配置 systemd 开机自启

创建服务文件 /etc/systemd/system/mihomo.service：

[Unit]
Description=mihomo Daemon, Another Clash Kernel.
After=network.target NetworkManager.service systemd-networkd.service iwd.service

[Service]
Type=simple
LimitNPROC=500
LimitNOFILE=1000000
CapabilityBoundingSet=CAP_NET_ADMIN CAP_NET_RAW CAP_NET_BIND_SERVICE CAP_SYS_TIME CAP_SYS_PTRACE CAP_DAC_READ_SEARCH CAP_DAC_OVERRIDE
AmbientCapabilities=CAP_NET_ADMIN CAP_NET_RAW CAP_NET_BIND_SERVICE CAP_SYS_TIME CAP_SYS_PTRACE CAP_DAC_READ_SEARCH CAP_DAC_OVERRIDE
Restart=always
ExecStartPre=/usr/bin/sleep 1s
ExecStart=/usr/local/bin/mihomo -d /etc/mihomo
ExecReload=/bin/kill -HUP $MAINPID

[Install]
WantedBy=multi-user.target

执行：

sudo systemctl daemon-reload
sudo systemctl enable mihomo
sudo systemctl start mihomo
sudo systemctl status mihomo

4.1 不开机自启，只手动启动

如果你不希望开机自动拉起，只想“需要时再开”：

sudo systemctl daemon-reload
sudo systemctl disable mihomo

之后按需手动控制：

sudo systemctl start mihomo
sudo systemctl stop mihomo
sudo systemctl restart mihomo
sudo systemctl status mihomo

开机自启和手动启动并不冲突：

enable / disable 决定“开机是否自动启动”
start / stop 决定“当前这一刻是否运行”

查看日志：

journalctl -u mihomo -o cat -f

5. 无 GUI 下切换节点（API）

先在当前 shell 定义变量（推荐）：

export MIHOMO_API="http://127.0.0.1:9090"
export MIHOMO_SECRET="your-strong-secret"

config.yaml 里的 secret 仍然是固定字符串；这里用环境变量只是为了命令行调用更方便。

可选：写入 ~/.bashrc，每次登录自动可用：

echo 'export MIHOMO_API="http://127.0.0.1:9090"' >> ~/.bashrc
echo 'export MIHOMO_SECRET="your-strong-secret"' >> ~/.bashrc
source ~/.bashrc

如果是多人共用账号，不建议把 MIHOMO_SECRET 长期明文写在共享用户的 ~/.bashrc。

先注意请求头写法，必须是：

-H "Authorization: Bearer ${MIHOMO_SECRET}"

错误写法（会返回 {"message":"Unauthorized"}）：

-H "your-strong-secret"

查看策略组节点：

curl -s -H "Authorization: Bearer ${MIHOMO_SECRET}" \
  "${MIHOMO_API}/proxies" | head

把 Proxy 组切到指定节点（例如 HK-01）：

curl -s -X PUT \
  -H "Authorization: Bearer ${MIHOMO_SECRET}" \
  -H "Content-Type: application/json" \
  -d '{"name":"HK-01"}' \
  "${MIHOMO_API}/proxies/Proxy"

用完后清理变量（可选）：

unset MIHOMO_API MIHOMO_SECRET

6. 让终端命令走代理

当前 shell 临时生效：

export http_proxy=http://127.0.0.1:7890
export https_proxy=http://127.0.0.1:7890
export all_proxy=socks5://127.0.0.1:7890

验证：

curl https://ipinfo.io
curl -I https://www.google.com

取消：

unset http_proxy https_proxy all_proxy

服务器场景不建议写进 ~/.bashrc 全局生效，推荐做成手动开关函数：

proxy_on() {
  export http_proxy=http://127.0.0.1:7890
  export https_proxy=http://127.0.0.1:7890
  export all_proxy=socks5://127.0.0.1:7890
}

proxy_off() {
  unset http_proxy https_proxy all_proxy
}

proxy_status() {
  env | grep -i proxy || echo "proxy is off"
}

把上面函数放进 ~/.bashrc 或 ~/.zshrc 后，按需执行 proxy_on / proxy_off。

7. 常见工具代理

APT（单次命令局部代理）

sudo env \
  http_proxy=http://127.0.0.1:7890 \
  https_proxy=http://127.0.0.1:7890 \
  apt update

安装包也是同理：

sudo env \
  http_proxy=http://127.0.0.1:7890 \
  https_proxy=http://127.0.0.1:7890 \
  apt install -y <package-name>

Git（单次命令局部代理）

git -c http.proxy=http://127.0.0.1:7890 \
    -c https.proxy=http://127.0.0.1:7890 \
    clone <repo-url>

pull / push 也可以同样加 -c：

git -c http.proxy=http://127.0.0.1:7890 \
    -c https.proxy=http://127.0.0.1:7890 \
    pull

8. 排障速查

1) `curl` 仍然直连

env | grep -i proxy
ss -lntp | grep 7890

确认代理变量已设置，且 mihomo 确实监听在 127.0.0.1:7890。

2) 服务起不来

systemctl status mihomo
journalctl -u mihomo -o cat -e

大多数情况是 config.yaml 语法错误或订阅 URL 无效。

3) API 连接被拒绝

检查 external-controller 是否是 127.0.0.1:9090，以及 secret 是否和请求头一致。

如果返回：

{"message":"Unauthorized"}

通常不是端口错了，而是认证头格式错误。应使用：

curl -s -H "Authorization: Bearer ${MIHOMO_SECRET}" \
  "${MIHOMO_API}/proxies" | head

4) `mihomo.service not found` / `Unit file does not exist`

这表示 systemd 服务文件还没创建成功，或文件名不对。

先确认二进制路径存在：

which mihomo
ls -l /usr/local/bin/mihomo

再重新创建服务文件：

sudo tee /etc/systemd/system/mihomo.service >/dev/null <<'UNIT'
[Unit]
Description=mihomo Daemon, Another Clash Kernel.
After=network.target NetworkManager.service systemd-networkd.service iwd.service

[Service]
Type=simple
Restart=always
ExecStart=/usr/local/bin/mihomo -d /etc/mihomo
ExecReload=/bin/kill -HUP $MAINPID

[Install]
WantedBy=multi-user.target
UNIT

然后加载并启动：

sudo systemctl daemon-reload
sudo systemctl enable mihomo
sudo systemctl start mihomo
sudo systemctl status mihomo

如果你只想手动启动，不开机自启，把 enable 换成：

sudo systemctl disable mihomo
sudo systemctl start mihomo

9. 最小闭环（无 GUI）

# 1) 启动服务
sudo systemctl start mihomo

# 2) 配置终端代理
export http_proxy=http://127.0.0.1:7890
export https_proxy=http://127.0.0.1:7890
export all_proxy=socks5://127.0.0.1:7890

# 3) 验证
curl https://ipinfo.io

到这里，你在纯 SSH 服务器上的代理就可用了。

Vim 详细使用教程：从入门到高频操作

Wed, 22 Apr 2026 00:00:00 GMT

如果你经常在 Linux 服务器、终端或 SSH 环境里工作，Vim 仍然是最值得掌握的编辑器之一。

它的学习曲线确实比普通文本编辑器陡，但一旦掌握核心操作，你会明显感受到两个变化：

手不用频繁离开键盘
编辑速度和文本控制力都会上一个台阶

这篇教程按“先能独立编辑文件，再逐步提升效率”的顺序来讲，尽量把高频操作一次讲清楚。

1. Vim 是什么，适合什么场景

Vim 是一个以键盘操作为核心的文本编辑器，尤其适合：

远程服务器上快速改配置
在终端里直接编辑代码或脚本
处理大量文本、日志、配置文件
希望减少鼠标依赖的人

如果你只是偶尔改一两行文本，图形编辑器当然更直观；但如果你经常 SSH 到远端机器，Vim 基本属于必备技能。

2. 安装与启动

Ubuntu / Debian:

sudo apt update
sudo apt install -y vim

CentOS / RHEL:

sudo yum install -y vim

macOS (Homebrew):

brew install vim

查看版本：

vim --version

打开文件：

vim filename.txt

如果文件不存在，保存时会自动创建。

3. 先理解 Vim 的核心：模式

Vim 最重要的概念不是命令本身，而是模式。

3.1 普通模式

打开 Vim 后默认进入普通模式。
这个模式主要用于：

移动光标
删除、复制、粘贴
搜索
跳转
执行命令

你可以把普通模式理解成“控制模式”。

3.2 插入模式

插入模式就是正常输入文字的模式。

常见进入方式：

i：在光标前插入
a：在光标后插入
I：跳到行首并插入
A：跳到行尾并插入
o：在下一行新开一行并插入
O：在上一行新开一行并插入

退出插入模式：

按 Esc

3.3 可视模式

可视模式用于选中文本。

v：字符级选择
V：整行选择
Ctrl+v：块选择（列编辑非常有用）

3.4 命令行模式

在普通模式下输入 : 进入命令行模式，用于保存、退出、替换、设置选项等。

例如：

:w
:q
:wq

4. 第一次使用的最小闭环

你至少先记住这几步：

vim test.txt 打开文件
按 i 进入插入模式
输入内容
按 Esc 回到普通模式
输入 :wq 保存并退出

如果你不想保存：

:q!

如果文件没改动，直接退出：

:q

5. 光标移动：真正决定效率的部分

很多人学 Vim 只记编辑命令，但真正拉开差距的是移动。

5.1 基础移动

h：左
j：下
k：上
l：右

这四个键是最基础的移动方式。

5.2 按单词移动

w：跳到下一个单词开头
b：跳到上一个单词开头
e：跳到当前或下一个单词末尾

如果你在代码里频繁移动，w b e 比方向键高效很多。

5.3 按行移动

0：跳到行首
^：跳到本行第一个非空字符
$：跳到行尾

5.4 按屏幕和文档移动

gg：跳到文件开头
G：跳到文件末尾
:10：跳到第 10 行
10G：跳到第 10 行
Ctrl+d：向下翻半页
Ctrl+u：向上翻半页
Ctrl+f：向下翻一页
Ctrl+b：向上翻一页

5.5 行内快速跳转

f{字符}：向右找到本行中下一个指定字符
F{字符}：向左找到本行中上一个指定字符
t{字符}：跳到目标字符前一位
T{字符}：跳到目标字符后一位
;：重复上一次 f/F/t/T
,：反向重复

例如你想跳到这一行下一个 )，直接按：

f)

6. 编辑文本的高频操作

6.1 删除

x：删除当前字符
dd：删除当前整行
dw：删除到下一个单词
d$：删除到行尾
d0：删除到行首

6.2 复制与粘贴

yy：复制当前行
yw：复制一个单词
p：在光标后粘贴
P：在光标前粘贴

6.3 修改

change 系列本质上是“删除后立刻进入插入模式”。

cw：修改一个单词
cc：修改整行
c$：从当前位置改到行尾

6.4 撤销与重做

u：撤销
Ctrl+r：重做

6.5 重复上一次操作

.：重复上一次修改

这是 Vim 里非常强的一个键。

例如你刚执行过一次 cw 把某个变量名改掉，接着移动到下一个变量，按 . 就能重复同样的修改动作。

7. 数字前缀：批量操作的关键

Vim 大量命令都支持“数字 + 动作”。

例如：

3j：向下移动 3 行
5x：删除 5 个字符
3dd：删除 3 行
2yy：复制 2 行
4w：向前跳 4 个单词

这个机制很重要，因为它能把重复操作压缩成一个动作。

8. 文本对象：Vim 真正强大的地方

文本对象的思路是：不是按字符编辑，而是按语义结构编辑。

8.1 单词对象

ciw：修改当前单词
diw：删除当前单词
yiw：复制当前单词

这里的 iw 是 inner word。

8.2 括号对象

ci(：修改圆括号里的内容
di(：删除圆括号里的内容
yi(：复制圆括号里的内容

8.3 引号对象

ci"：修改双引号内内容
ci'：修改单引号内内容
输入 ci 后再接反引号键：修改反引号内内容

例如：

name = "hana_blog"

光标放在引号内部任意位置，按：

ci"

就会直接清空引号内内容并进入插入模式。

8.4 around 与 inner

i：inside / inner，不包括边界
a：around，包括边界

例如：

ci"：只改引号内部内容
ca"：连引号一起替换

9. 可视模式：选中、缩进、批量编辑

9.1 基础选择

v 进入字符选择
V 进入行选择
选中后按 d 删除、按 y 复制、按 > 缩进、按 < 反缩进

9.2 块选择

按 Ctrl+v 进入块选择后，可以做列级编辑。

常见场景：

同时给多行前面加注释
同时删除多行开头的相同前缀
做整列对齐

例如给多行前面加 #：

Ctrl+v 选中多行的第一列
按 I
输入 #
按 Esc

Vim 会把这段内容批量插入到所有选中的行前面。

10. 搜索与替换

10.1 搜索

向下搜索：

/keyword

向上搜索：

?keyword

搜索结果跳转：

n：下一个
N：上一个

10.2 高亮与取消高亮

开启搜索高亮：

:set hlsearch

取消当前高亮：

:nohlsearch

10.3 替换

替换当前行第一个匹配：

:s/old/new/

替换当前行所有匹配：

:s/old/new/g

替换全文所有匹配：

:%s/old/new/g

替换全文并逐个确认：

:%s/old/new/gc

这里的 c 表示 confirm。

11. 多文件与多窗口操作

11.1 同时打开多个文件

vim file1.txt file2.txt

在 Vim 内切换缓冲区：

:bn：下一个 buffer
:bp：上一个 buffer
:ls：查看 buffer 列表
:b 2：跳到第 2 个 buffer

11.2 分屏

水平分屏：

:split

垂直分屏：

:vsplit

打开指定文件：

:split another.txt
:vsplit another.txt

窗口切换：

Ctrl+w 然后 h/j/k/l

关闭当前窗口：

:q

11.3 标签页

:tabnew
:tabnext
:tabprev
:tabclose

不过对很多人来说，buffer + split 已经够用了。

12. 寄存器：理解复制粘贴背后的机制

Vim 的复制、删除内容其实会进入寄存器。

查看寄存器：

:registers

常见寄存器：

"：默认寄存器
0：最近一次复制内容
%：当前文件名
/：最近一次搜索内容

指定寄存器复制：

"ayy

表示把当前行复制到 a 寄存器。

从 a 寄存器粘贴：

"ap

如果你经常复制一段内容，期间又做了删除操作，寄存器会非常有用。

13. 宏：把重复编辑自动化

宏适合处理“同一种编辑动作重复很多次”的场景。

13.1 录制宏

按：

qa

表示开始录制到寄存器 a。

完成操作后按：

结束录制。

13.2 执行宏

执行一次：

@a

执行 10 次：

10@a

举例：如果你有很多格式相似的行，需要逐行插入固定前缀或做相同替换，宏会比手工操作快很多。

14. 实用命令汇总

保存：

:w

另存为：

:w newfile.txt

退出：

:q

保存并退出：

:wq

强制退出不保存：

:q!

显示行号：

:set number

显示相对行号：

:set relativenumber

开启语法高亮：

:syntax on

15. 推荐的基础配置

你可以先从一个最小 .vimrc 开始：

set number
set relativenumber
set tabstop=2
set shiftwidth=2
set expandtab
set autoindent
set hlsearch
set incsearch
set ignorecase
set smartcase
syntax on

配置文件位置通常是：

Linux / macOS: ~/.vimrc

这套配置的作用分别是：

显示绝对行号与相对行号
Tab 宽度设为 2
用空格代替 Tab
自动缩进
搜索时高亮、增量显示
搜索默认忽略大小写，但如果输入大写则大小写敏感

16. 新手最容易踩的坑

16.1 忘记自己还在插入模式

一旦发现快捷键都不生效，第一反应先按 Esc，回到普通模式再说。

16.2 不会退出

这个几乎是每个 Vim 新手都踩过的坑。记住：

:q! 不保存退出
:wq 保存退出

16.3 只会用方向键

如果一直依赖方向键，你会很难真正体会 Vim 的效率。
至少先强迫自己多用：

hjkl
w b e
0 ^ $
gg G

16.4 把 Vim 当普通编辑器硬用

Vim 的效率来自“动作组合”，不是单个命令。

比如下面这些都应该当成组合去理解：

ciw
d$
yi(
3dd
:%s/old/new/gc

17. 一条推荐学习路径

如果你不想一次记太多，可以按这个顺序学：

先学进入 / 退出插入模式：i a o Esc
再学保存退出：:w :q :wq :q!
再学基础移动：hjkl w b 0 $ gg G
再学删除复制粘贴：x dd yy p u
再学高频组合：ciw dw cw .
最后学搜索替换、可视块、寄存器、宏

这样会比一次背完整命令表更容易真正用起来。

18. 结语

Vim 最难的不是命令本身，而是接受它的编辑思维：

普通模式负责控制
插入模式只负责输入
大部分高效操作都来自“动作 + 对象”的组合

当你开始习惯 ciw、dd、p、.、/、:%s///gc 这类操作后，很多文本编辑任务会变得非常顺手。

如果你正在服务器上工作，最值得先练熟的不是全部功能，而是下面这组最小集合：

i  a  o  Esc
:wq  :q!
hjkl  w  b  0  $
dd  yy  p  u
/  n  N
ciw  cw  .

把这些练熟，再继续扩展到可视块、宏和寄存器，Vim 就会开始真正好用起来。

在本地电脑上配置 GitHub 权限（SSH/HTTPS）

Wed, 22 Apr 2026 00:00:00 GMT

如果你要在自己的电脑上把代码推到 GitHub，核心其实只需要配对三件事：

Git 身份是谁
你的电脑拿什么方式向 GitHub 认证
凭证是临时输入、系统托管，还是长期缓存

很多人把这三件事混在一起，所以一遇到 Permission denied、Authentication failed、推错账号，就很容易卡住。

这篇教程专门讲“本地电脑如何配置 GitHub 权限”，按 SSH 和 HTTPS 两条路线都给一套可用流程。

0. 先区分两个概念

配置 GitHub 权限时，最容易混淆的是下面两件事：

0.1 Git 身份

这是提交记录里显示的作者信息：

git config --global user.name "your-name"
git config --global user.email "your-email@example.com"

它决定的是 commit 里写谁，不等于“你有没有权限 push 到 GitHub”。

0.2 GitHub 认证

这是你电脑连接 GitHub 时真正用到的授权方式，常见有两种：

SSH key
HTTPS + Personal Access Token (PAT)

也就是说：

user.name / user.email 解决“你是谁”
SSH / PAT 解决“你有没有权限访问这个仓库”

1. 先检查本地环境

先确认 Git 和 SSH 工具都可用。

Linux / macOS:

git --version
ssh -V

Windows（PowerShell）：

git --version
ssh -V

如果 git 不存在，先安装 Git。

如果 ssh 不存在：

Windows: 安装 Git for Windows 或启用 OpenSSH Client
macOS / Linux: 通常系统自带

2. 配置 Git 身份

如果这台电脑主要由你自己使用，通常直接配置全局身份就够了：

git config --global user.name "your-github-username"
git config --global user.email "your-email@example.com"

检查结果：

git config --global --get user.name
git config --global --get user.email

如果你希望提交记录绑定到 GitHub 账号，user.email 最好使用：

你在 GitHub 已验证过的邮箱
或者 GitHub 提供的 noreply 邮箱

查看某个仓库当前实际生效的身份：

git config --get user.name
git config --get user.email

如果你只想对当前仓库单独配置，不要加 --global。

3. 推荐路线 A：使用 SSH key

对个人电脑来说，SSH 通常是最省心的一种方式：

不需要每次输入 Token
更适合长期使用
配合 ssh-agent 后体验最好

4. 生成 SSH key

推荐使用 ed25519。

Linux / macOS:

ssh-keygen -t ed25519 -C "your-email@example.com"

Windows（PowerShell）：

ssh-keygen -t ed25519 -C "your-email@example.com"

执行过程中会看到几项提示：

Enter file in which to save the key (...)
Enter passphrase (...)

建议：

路径直接用默认值
passphrase 最好设置，不要留空

默认路径通常是：

Linux / macOS: ~/.ssh/id_ed25519
Windows: C:\Users\你的用户名\.ssh\id_ed25519

对应公钥文件是：

id_ed25519.pub

5. 把公钥加到 GitHub

先查看公钥内容。

Linux / macOS:

cat ~/.ssh/id_ed25519.pub

Windows（PowerShell）：

Get-Content $HOME\.ssh\id_ed25519.pub

复制整行公钥后，到 GitHub 页面：

右上角头像 -> Settings
进入 SSH and GPG keys
点击 New SSH key
Title 随便填，例如 My Laptop
把刚才复制的公钥粘进去
点击 Add SSH key

这一步完成后，你的 GitHub 账号才真正认识这台电脑的密钥。

6. 启动 ssh-agent 并加载私钥

6.1 Linux / macOS

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

6.2 Windows（PowerShell）

先启动 OpenSSH Agent 服务：

Get-Service ssh-agent
Start-Service ssh-agent
Set-Service -Name ssh-agent -StartupType Automatic
ssh-add $HOME\.ssh\id_ed25519

如果你设置了 passphrase，这里会要求你输入一次。

7. 测试 SSH 认证是否成功

执行：

ssh -T git@github.com

第一次连接时，可能会看到主机指纹确认：

Are you sure you want to continue connecting (yes/no/[fingerprint])?

输入：

yes

如果认证成功，常见输出类似：

Hi your-username! You've successfully authenticated...

8. 把仓库远程地址切到 SSH

查看当前远程地址：

git remote -v

如果是 HTTPS，例如：

https://github.com/your-username/your-repo.git

可以改成 SSH：

git remote set-url origin git@github.com:your-username/your-repo.git
git remote -v

之后推送：

git push -u origin main

9. 备选路线 B：使用 HTTPS + PAT

如果你暂时不想配 SSH，也可以直接走 HTTPS，但现在不能再用 GitHub 登录密码，必须用 Personal Access Token。

10. 创建 PAT

GitHub 页面路径：

右上角头像 -> Settings
Developer settings
Personal access tokens
选择 Tokens (classic) 或 Fine-grained Token

如果你是新手，本地个人电脑使用 Tokens (classic) 会更直接。

创建时至少注意：

设定过期时间
给出需要的仓库权限
私人仓库常见需要 repo

生成后要立刻保存，因为 GitHub 通常只显示一次。

11. HTTPS 推送时怎么填用户名和密码

当你执行：

git push

如果提示输入：

Username for 'https://github.com':
Password for 'https://github.com':

应该这样填：

Username：你的 GitHub 用户名
Password：你的 PAT，不是 GitHub 登录密码

12. 让系统记住凭证

如果你每次都输 PAT，会比较烦。更合理的做法是让系统凭证管理器接管。

12.1 Windows

Git for Windows 通常可配 manager-core：

git config --global credential.helper manager-core

之后凭证会进入 Windows Credential Manager。

12.2 macOS

git config --global credential.helper osxkeychain

12.3 Linux

如果你没有桌面凭证管理器，最简单是：

git config --global credential.helper cache

这只做内存缓存，安全性通常比明文存盘好。

不推荐：

git config --global credential.helper store

因为它可能把 Token 明文写到本地文件里。

13. 多 GitHub 账号怎么处理

这是本地电脑最常见的进阶需求之一：工作号一个，私人号一个。

13.1 SSH 多账号方案

思路是：

每个账号各自一把 SSH key
在 ~/.ssh/config 里用不同 Host 别名
不同仓库绑定不同远程地址

示例：

Host github-personal
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_ed25519_personal

Host github-work
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_ed25519_work

然后你的远程地址可以写成：

git@github-personal:yourname/repo.git
git@github-work:company/repo.git

这样不同仓库就会走不同密钥。

13.2 Git 身份也分仓库设置

例如：

git config user.name "work-account"
git config user.email "work@example.com"

这样只影响当前仓库。

14. 最常见的报错与处理

14.1 `Permission denied (publickey)`

通常说明：

公钥没加到 GitHub
ssh-agent 没加载私钥
仓库远程地址和你预期账号不一致
你实际用了另一把 key

优先检查：

ssh-add -l
git remote -v
ssh -T git@github.com

14.2 `Authentication failed`

这通常发生在 HTTPS 路线下，常见原因：

你输入的是 GitHub 登录密码，不是 PAT
PAT 权限不够
PAT 已过期
系统里缓存了旧凭证

14.3 提交记录不显示在 GitHub 账号下

通常不是权限问题，而是邮箱不匹配。

检查：

git config --get user.email

确认这个邮箱已经在 GitHub 账号中添加并验证。

14.4 推到了错误账号

通常是：

系统缓存了另一个账号的 PAT
SSH 走了另一把 key
仓库配置的 user.name / user.email 与预期不一致

15. 一条推荐工作流

如果你是“自己的电脑 + 长期使用 GitHub”，我更推荐：

配 Git 全局身份
生成 ed25519 SSH key
把公钥加到 GitHub
用 ssh-agent 管理私钥
把远程地址改成 SSH

也就是：

git config --global user.name "your-name"
git config --global user.email "your-email@example.com"
ssh-keygen -t ed25519 -C "your-email@example.com"
ssh-add ~/.ssh/id_ed25519
ssh -T git@github.com
git remote set-url origin git@github.com:your-username/your-repo.git

这套组合通常是最稳的。

16. 结语

在本地电脑上配置 GitHub 权限，本质上不是“装一个工具就完事”，而是把下面三层关系理顺：

Git 提交身份
GitHub 认证方式
本地凭证管理方式

如果你希望长期稳定使用，优先选 SSH。
如果你只是临时使用或公司流程要求 HTTPS，再用 PAT + 系统凭证管理器。

只要把这套关系理顺，以后遇到 GitHub 权限问题，基本都能很快定位。

用 scp 向远程服务器传送文件

Wed, 22 Apr 2026 00:00:00 GMT

scp 是最常见的远程传文件命令之一。
如果你已经能通过 ssh 登录服务器，那么通常也可以直接用 scp 把本地文件传到远程机器上。

这篇文章只解决一个实际问题：如何把本地文件或目录上传到远程 Linux 服务器。默认场景如下：

本地电脑：Linux / macOS / Windows（PowerShell）
远程机器：Linux 服务器
远程登录方式：用户名 + IP（或域名）+ SSH 端口

1. `scp` 最基本的命令格式

上传文件的基本写法是：

scp 本地文件 用户名@服务器IP:远程路径

例如，把当前目录下的 notes.txt 上传到服务器家目录：

scp notes.txt username@192.168.1.20:~

这条命令的含义：

notes.txt：本地文件
username：远程服务器用户名
192.168.1.20：远程服务器 IP
~：远程用户家目录

如果服务器要求密码，执行后会提示你输入远程登录密码。

如果你已经在本地 ~/.ssh/config 里给服务器配了 SSH 别名，那么这里也可以直接用别名替代 username@服务器IP。例如：

scp notes.txt my-server:~

2. 上传到指定目录

如果你想把文件上传到远程机器上的某个明确目录，可以直接写完整路径：

scp notes.txt username@192.168.1.20:/home/username/uploads/

再比如上传一个压缩包：

scp project.tar.gz username@192.168.1.20:/home/username/projects/

建议先确认远程目录确实存在，否则可能报错：

ssh username@192.168.1.20 "mkdir -p /home/username/projects"

3. 上传目录而不是单个文件

如果要上传整个文件夹，需要加 -r：

scp -r my_project username@192.168.1.20:/home/username/projects/

说明：

-r 表示递归复制
my_project 可以是目录
远程目标目录建议提前创建好

如果目录里文件较多，这个命令可能会执行一段时间。

4. 服务器不是 22 端口时怎么写

很多云服务器或实验室机器不会使用默认的 22 端口。
这时要用大写 -P 指定端口：

scp -P 2222 notes.txt username@192.168.1.20:/home/username/uploads/

注意这里是：

scp 用 -P 指定端口
ssh 通常用小写 -p

这两个地方很容易写混。

5. 使用 SSH 密钥上传

如果你的服务器用私钥登录，可以用 -i 指定私钥文件：

scp -i ~/.ssh/id_ed25519 notes.txt username@192.168.1.20:/home/username/uploads/

如果服务器端口也不是默认值，可以一起写：

scp -P 2222 -i ~/.ssh/id_ed25519 notes.txt username@192.168.1.20:/home/username/uploads/

如果你已经在 ~/.ssh/config 里配置了 SSH Host 别名，那么命令可以进一步简化。

例如配置：

Host my-server
  HostName 192.168.1.20
  User username
  Port 2222
  IdentityFile ~/.ssh/id_ed25519

之后就可以直接写：

scp notes.txt my-server:/home/username/uploads/

这个写法在日常使用里通常最省事。

6. Windows / macOS / Linux 上是否都能用

Linux / macOS

终端里通常直接可用：

scp -V

Windows

Windows 10 / 11 一般自带 OpenSSH Client，可以在 PowerShell 里直接执行：

scp .\notes.txt username@192.168.1.20:/home/username/uploads/

如果提示 scp 不是内部或外部命令，先检查 OpenSSH Client 是否已安装。

7. 文件名带空格时怎么处理

如果本地文件名里有空格，建议加引号：

scp "my notes.txt" username@192.168.1.20:/home/username/uploads/

如果远程目录路径里有空格，也建议整体加引号：

scp notes.txt "username@192.168.1.20:/home/username/my uploads/"

最稳妥的做法仍然是：文件名和目录名尽量避免空格。

8. 如何确认上传成功

上传完成后，可以登录服务器检查：

ssh username@192.168.1.20
ls -lh /home/username/uploads/

也可以直接一条命令验证：

ssh username@192.168.1.20 "ls -lh /home/username/uploads/"

如果你上传的是目录，也可以用：

ssh username@192.168.1.20 "du -sh /home/username/projects/my_project"

9. 常见报错与处理

`ssh: connect to host ... port ...: Connection refused`

通常说明：

IP 或域名写错
端口写错
远程服务器 SSH 服务没开
防火墙没有放行对应端口

优先检查你是否能先正常执行：

ssh username@192.168.1.20

或者：

ssh -p 2222 username@192.168.1.20

`Permission denied`

通常有两种情况：

用户名、密码或私钥不对
你没有目标目录的写权限

先确认登录是否正常，再确认上传目标是否是你有权限写入的位置，例如：

/home/username/
/home/username/uploads/
~/projects/

不要一开始就传到 /root/ 或系统目录。

`No such file or directory`

通常表示：

本地文件路径写错
远程目标目录不存在

处理方式：

本地先 ls
远程先 ssh 登录确认目录
需要时先执行 mkdir -p

10. 实用命令速查

上传单个文件：

scp file.txt username@server:~

上传到指定目录：

scp file.txt username@server:/home/username/uploads/

上传整个目录：

scp -r mydir username@server:/home/username/projects/

指定端口：

scp -P 2222 file.txt username@server:/home/username/uploads/

指定私钥：

scp -i ~/.ssh/id_ed25519 file.txt username@server:/home/username/uploads/

使用 SSH Host 别名：

scp file.txt my-server:/home/username/uploads/

11. 什么时候不建议继续用 `scp`

scp 很适合：

临时上传文件
上传脚本、压缩包、配置文件
快速把本地项目丢到服务器上

但如果你要：

长时间断点续传
大量文件同步
频繁增量更新目录

那么通常更推荐 rsync。

12. 一句话总结

记住这一条就够你先用起来：

scp 本地文件 用户名@服务器IP:远程路径

如果再多记两个参数：

-r：传目录
-P：指定端口

大多数 scp 上传场景就已经能覆盖了。

纯 SSH 服务器配置 RustDesk（命令行方案）

Wed, 22 Apr 2026 00:00:00 GMT

如果你现在只有一台远程 Linux 服务器的 SSH 权限，想把它接入 RustDesk，先记住一个关键前提：

只有命令行可以操作，不等于这台机器没有图形桌面
如果机器真的只有纯终端、没有图形会话，RustDesk 也不能凭空远控出一个“桌面”

RustDesk 官方 Linux 文档明确提到两件事：

Linux 端优先使用发行版原生包安装
登录界面远控仍然要求 X11

另外，RustDesk 官方仓库的 Headless Linux 说明页提到：Linux headless 支持默认关闭，只在 Ubuntu 上做过测试，并要求 GNOME、xserver-xorg-video-dummy 和 lightdm 这类前置条件。

所以这篇文章分两种情况写：

服务器本来就有桌面，只是你现在只能 SSH 上去
服务器真的没有桌面，需要先补一个最小可远控的图形环境

本文主线以 Ubuntu / Debian 为例。

0. 先判断你是哪一种机器

如果下面命令里能看到 GNOME、Xorg、display manager 之类的包，通常说明机器已经有图形环境：

dpkg -l | rg 'ubuntu-desktop|gnome-shell|xorg|gdm3|lightdm'
systemctl get-default

如果输出里已经有桌面组件，可以直接跳到“安装 RustDesk”
如果基本什么都没有，而且默认 target 是 multi-user.target，按“先补桌面”处理

1. 机器完全没有桌面时：先补图形环境

如果你的远程机本质上是一台“纯 CLI 服务器”，先装一套 RustDesk 更稳的官方建议组合。

sudo apt update
sudo apt install -y ubuntu-desktop xserver-xorg-video-dummy lightdm
sudo systemctl set-default graphical.target
sudo systemctl enable lightdm
sudo reboot

这一步的作用分别是：

ubuntu-desktop：提供 GNOME 桌面
xserver-xorg-video-dummy：没有物理显示器时，提供 dummy display
lightdm：给无头场景一个更稳定的图形登录管理器

这里我遵循 RustDesk 官方 headless 说明页的口径，优先写 GNOME + dummy driver + lightdm。
如果你打算用更轻的 xfce4，社区里有人跑通，但官方页只明确写了 GNOME，稳定性就别混着赌。

2. 安装 RustDesk

RustDesk 官方文档在 Linux 上推荐优先用发行版原生包：Ubuntu / Debian 用 .deb。

下面这段命令会自动识别架构，并从 RustDesk GitHub 最新 release 拉对应的 Debian 包：

mkdir -p ~/downloads/rustdesk
cd ~/downloads/rustdesk

ARCH="$(dpkg --print-architecture)"
if [ "$ARCH" = "amd64" ]; then
  PATTERN='rustdesk-[^"]*-x86_64\.deb'
elif [ "$ARCH" = "arm64" ]; then
  PATTERN='rustdesk-[^"]*-aarch64\.deb'
else
  echo "Unsupported arch: $ARCH"
  exit 1
fi

URL="$(curl -fsSL https://api.github.com/repos/rustdesk/rustdesk/releases/latest \
  | grep -oE "https://[^\"]+${PATTERN}" \
  | head -n 1)"

if [ -z "$URL" ]; then
  echo "Failed to resolve RustDesk release url"
  exit 1
fi

curl -L "$URL" -o rustdesk.deb
sudo apt install -fy ./rustdesk.deb

验证：

rustdesk --version
systemctl status rustdesk --no-pager

如果 systemctl status rustdesk 提示服务不存在，也不用慌，先试：

sudo systemctl enable --now rustdesk

3. 开启 headless 选项、设置固定密码、拿到 ID

如果这台机子没有物理显示器，或者你就是想让它长期作为“无人值守远控节点”，把下面三步做完：

sudo rustdesk --option allow-linux-headless Y
sudo rustdesk --password 'YourStrongPassword123'
sudo rustdesk --get-id

你真正要记住的是两样东西：

RustDesk ID
你刚设置的固定密码

然后在你本地电脑上的 RustDesk 客户端里，输入这个 ID 和密码即可连接。

allow-linux-headless 是 RustDesk 官方 headless Linux 说明页明确要求开启的选项。
如果你的机器本来就有显示器和完整桌面，这一步通常不是必须，但开了也没坏处。

4. 如果你想重启后还能连登录界面：切到 X11

RustDesk 官方 Linux 文档写得很明确：登录界面远控仍然需要 X11。
也就是说，哪怕新版本已经有实验性的 Wayland 支持，登录界面这块仍然不要指望 Wayland。

如果你装的是 gdm3，直接改：

sudo nano /etc/gdm3/custom.conf

把这一行改成：

WaylandEnable=false

保存后重启：

sudo reboot

如果你前面按本文装的是 lightdm，通常会比 gdm3 + Wayland 少一层坑。

5. 如果你用的是自建 RustDesk Server

如果你不是走 RustDesk 官方公共服务器，而是用自己的 hbbs / hbbr，CLI 场景下最省事的方式不是手改 GUI，而是直接注入配置字符串。

RustDesk 官方部署文档里的 Linux 脚本就是这么做的：

RUSTDESK_CFG='你的 config string'
sudo rustdesk --config "$RUSTDESK_CFG"
sudo systemctl restart rustdesk

然后再重新确认：

rustdesk --get-id

这里有两个实用建议：

config string 最好从你已经配好的 RustDesk 客户端或管理端导出，避免手敲 ID Server / Relay Server / Key
先执行 --config，再执行 systemctl restart rustdesk，不要反过来

如果你暂时还没有现成的 config string，可以先用 RustDesk 官方公共服务器把链路打通，再切到自建服务。

6. 一套可直接复制的最小闭环

如果你的目标只是“把一台只有 SSH 的 Ubuntu 服务器接进 RustDesk”，最短路径就是下面这套：

sudo apt update
sudo apt install -y ubuntu-desktop xserver-xorg-video-dummy lightdm
sudo systemctl set-default graphical.target
sudo systemctl enable lightdm
sudo reboot

重连 SSH 后继续：

mkdir -p ~/downloads/rustdesk
cd ~/downloads/rustdesk

ARCH="$(dpkg --print-architecture)"
if [ "$ARCH" = "amd64" ]; then
  PATTERN='rustdesk-[^"]*-x86_64\.deb'
elif [ "$ARCH" = "arm64" ]; then
  PATTERN='rustdesk-[^"]*-aarch64\.deb'
else
  echo "Unsupported arch: $ARCH"
  exit 1
fi

URL="$(curl -fsSL https://api.github.com/repos/rustdesk/rustdesk/releases/latest \
  | grep -oE "https://[^\"]+${PATTERN}" \
  | head -n 1)"

curl -L "$URL" -o rustdesk.deb
sudo apt install -fy ./rustdesk.deb

sudo systemctl enable --now rustdesk
sudo rustdesk --option allow-linux-headless Y
sudo rustdesk --password 'YourStrongPassword123'
sudo rustdesk --get-id

到这里，这台服务器就已经具备“被 RustDesk 连接”的最小条件了。

7. 常见问题

7.1 `rustdesk --get-id` 没输出

优先检查：

systemctl status rustdesk --no-pager
journalctl -u rustdesk -n 100 --no-pager

常见原因：

RustDesk 服务没起来
机器外网不通，无法连到官方服务器或你的自建 hbbs
你切了自建服务，但没执行 rustdesk --config

7.2 能连上，但黑屏

这类问题大概率不是 RustDesk “安装失败”，而是没有可用图形会话。按这个顺序检查：

有没有安装桌面环境
有没有安装 xserver-xorg-video-dummy
当前是不是 graphical.target
登录界面是不是还在 Wayland

7.3 重启后能 SSH，但 RustDesk 进不去登录界面

优先怀疑两件事：

没切到 graphical.target
登录管理器还在 Wayland

也就是说，下面两条至少要成立：

systemctl get-default
grep -n 'WaylandEnable' /etc/gdm3/custom.conf

7.4 这台机器根本不需要桌面，我还该不该装 RustDesk？

如果你只是想：

跑训练
部署服务
改代码
看日志

那其实 SSH + tmux + VSCode Remote SSH 往往更合适。
RustDesk 真正擅长的是“图形桌面远控”，不是替代终端运维。

8. 参考

RustDesk Linux 文档：rustdesk.com/docs/en/client/linux/
RustDesk Client Deployment（Linux --config 脚本）： rustdesk.com/docs/en/self-host/client-deployment/
RustDesk Headless Linux Support（官方仓库 Wiki）： github.com/rustdesk/rustdesk/wiki/Headless-Linux-Support

Vibe Coding For AI 2: Claude CLI 安装与使用指南

Sat, 18 Apr 2026 00:00:00 GMT

本文内容由 AI 生成，主要供博主自用参考，不保证完全准确，请以官方文档为准。

什么是 Claude CLI？

Claude CLI（也叫 Claude Code）是 Anthropic 官方推出的命令行 AI 编程助手。和 IDE 插件不同，它直接运行在终端里，能够读取、修改你的代码文件，执行命令，甚至帮你管理 Git 工作流。对于习惯在终端工作的开发者来说，这是目前体验最好的 Coding Agent 之一。

本文面向 macOS 和 Linux 用户，带你从零开始安装并熟练使用 Claude CLI。

安装前准备

安装 Node.js

Claude CLI 通过 npm 分发，所以首先需要确保系统上有 Node.js（版本 >= 18）。

macOS（推荐用 Homebrew）：

brew install node

Linux（Ubuntu/Debian）：

curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt-get install -y nodejs

Linux（Arch）：

sudo pacman -S nodejs npm

安装完成后验证：

node --version   # 应该 >= 18
npm --version

检查网络环境

Claude CLI 需要访问 Anthropic 的 API，国内用户需要确保终端走代理。可以用以下命令检查当前 IP：

curl ipin.io

如果返回的是国内 IP，需要先配置好终端代理再继续。

安装 Claude CLI

npm install -g @anthropic-ai/claude-code

安装完成后验证：

claude --version

出现版本号即为安装成功。

配置 API Key

获取 API Key

前往 Anthropic Console 注册账号，进入 API Keys 页面创建一个新的密钥。

如果不想直接使用官方 API（价格较贵），也可以使用 Ikuncode 等中转服务，配置方式相同。

设置环境变量

临时设置（当前终端会话有效）：

export ANTHROPIC_API_KEY="sk-ant-xxxxxxxx"

永久设置（推荐）：

macOS/Linux 用户将以下内容添加到 ~/.zshrc 或 ~/.bashrc：

export ANTHROPIC_API_KEY="sk-ant-xxxxxxxx"

然后重新加载配置：

source ~/.zshrc   # 或 source ~/.bashrc

使用中转 API

如果使用第三方中转服务，还需要额外设置 API 地址：

export ANTHROPIC_BASE_URL="https://你的中转地址/v1"

启动 Claude CLI

进入你的项目目录，直接运行：

cd /path/to/your/project
claude

首次启动会进入一个交互式 TUI 界面，类似下图的对话框。你可以直接用自然语言描述你想做的事，Claude 会自动读取项目文件、执行命令、修改代码。

核心使用模式

交互模式（默认）

直接运行 claude 进入对话界面，这是最常用的模式。在这里你可以持续对话，Claude 会记住整个会话的上下文。

claude

单次执行模式

如果只想执行一个任务，不需要进入交互界面：

claude -p "帮我写一个读取 CSV 文件的 Python 函数"

-p 是 --print 的缩写，执行完毕后直接退出，适合脚本集成。

管道模式

Claude CLI 支持从标准输入读取内容，非常适合配合其他命令使用：

cat error.log | claude -p "分析这个错误日志，告诉我问题在哪里"

git diff | claude -p "帮我写一个 commit message"

常用斜杠命令

在交互模式下，输入 / 可以触发内置命令。

会话管理

| 命令 | 功能 | |------|------| | /help | 查看所有可用命令及说明 | | /clear | 清空当前对话上下文，重新开始 | | /compact [说明] | 压缩对话历史节省 token，可附加保留说明 | | /cost | 查看当前会话的 token 消耗和费用估算 | | /quit 或 /exit | 退出 Claude CLI |

模型与配置

| 命令 | 功能 | |------|------| | /model | 交互式切换当前使用的模型 | | /doctor | 检查环境配置、API 连通性是否正常 | | /init | 在当前项目生成 CLAUDE.md 配置文件 | | /config | 查看或修改 Claude CLI 的配置项 | | /vim | 切换到 Vim 键位模式（再次输入关闭） |

记忆与上下文

| 命令 | 功能 | |------|------| | /memory | 查看和管理跨会话的持久记忆内容 | | /context | 查看当前上下文窗口的使用情况 |

代码与项目

| 命令 | 功能 | |------|------| | /review | 对当前 git 改动进行代码审查 | | /pr_comments | 拉取并展示当前 PR 的评论 | | /bug | 快速进入 bug 报告模式，引导描述问题 | | /terminal-setup | 配置终端 shell 集成（如 iTerm2 / zsh） |

权限管理

| 命令 | 功能 | |------|------| | /permissions | 查看当前会话的工具权限设置 | | /allowed-tools | 列出当前允许自动执行的工具列表 |

自定义 Slash 命令

除了内置命令，你还可以在 .claude/commands/ 目录下创建自定义命令。每个 .md 文件对应一个命令，文件名即命令名：

.claude/
└── commands/
    ├── deploy.md      # /deploy
    └── test-all.md    # /test-all

文件内容就是发给 Claude 的 prompt 模板，支持 $ARGUMENTS 占位符接收参数：

# deploy.md
运行 `bun build` 构建项目，然后执行 `$ARGUMENTS` 部署到对应环境。
部署前先确认没有未提交的改动。

使用时：

/deploy production

CLAUDE.md：项目级配置

/init 命令会在项目根目录生成一个 CLAUDE.md 文件，这是 Claude 的"项目说明书"。你可以在里面写：

项目架构说明
常用命令（如何启动、测试、构建）
代码规范和约定
不希望 Claude 修改的文件或目录

每次启动 Claude CLI，它都会自动读取这个文件，从而更好地理解你的项目。

# CLAUDE.md 示例

## 项目说明
这是一个 FastAPI 后端项目，使用 PostgreSQL 数据库。

## 常用命令
- `uvicorn main:app --reload` - 启动开发服务器
- `pytest` - 运行测试
- `alembic upgrade head` - 执行数据库迁移

## 注意事项
- 不要修改 `migrations/` 目录下的文件
- 所有 API 接口需要添加类型注解

权限控制

Claude CLI 在执行文件操作或运行命令时，默认会弹出确认提示。你可以通过以下方式调整权限策略：

自动允许所有操作（谨慎使用）：

claude --dangerously-skip-permissions

只允许读取，不允许写入：

在对话中告诉 Claude "只读模式，不要修改任何文件" 即可，它会遵守这个约束。

针对特定工具设置权限：

在 CLAUDE.md 或项目的 .claude/settings.json 中可以精细控制哪些操作自动允许、哪些需要确认。

实用技巧

多文件操作

Claude CLI 可以同时处理多个文件，直接描述需求即可：

帮我把项目里所有的 console.log 替换成 logger.info，
并且确保 logger 已经在每个文件里正确导入

结合 Git 工作流

帮我查看最近 5 个 commit 的改动，
然后写一个总结性的 release note

当前分支有哪些改动还没有提交？帮我整理成一个 commit

代码审查

帮我审查 src/auth.py 这个文件，
重点关注安全漏洞和性能问题

调试辅助

python main.py 2>&1 | claude -p "程序报错了，帮我分析原因并给出修复方案"

常见问题

Q: 提示 command not found: claude

检查 npm 全局安装路径是否在 PATH 里：

npm config get prefix
# 将输出的路径加上 /bin 添加到 PATH
export PATH="$(npm config get prefix)/bin:$PATH"

Q: API 请求失败，提示 401

检查 ANTHROPIC_API_KEY 是否正确设置，可以用以下命令确认：

echo $ANTHROPIC_API_KEY

Q: 响应很慢或超时

检查网络代理是否正常，确保终端流量走代理：

export https_proxy=http://127.0.0.1:7890
export http_proxy=http://127.0.0.1:7890

Q: 如何更新到最新版本

npm update -g @anthropic-ai/claude-code

小结

Claude CLI 的核心优势在于它能直接操作你的代码库，而不只是给你看代码片段。配置好之后，日常的重构、调试、写测试、整理 commit 这些事情都可以交给它来做，你只需要用自然语言描述目标就好。

如果你之前用过 Cursor 或者 GitHub Copilot，Claude CLI 更像是一个能主动干活的同事，而不只是一个代码补全工具。上手之后，工作流会有质的变化。

Vibe Coding For AI 3: Codex CLI 安装与使用指南

Sat, 18 Apr 2026 00:00:00 GMT

本文内容由 AI 生成，主要供博主自用参考，不保证完全准确，请以官方文档为准。

什么是 Codex CLI？

Codex CLI 是 OpenAI 推出的命令行 Coding Agent。它可以直接在终端中读取和修改项目文件、执行命令、完成代码任务，也支持非交互模式用于脚本化流程。

本文基于 codex-cli 0.121.0 编写，面向 macOS 和 Linux 用户。

安装前准备

安装 Node.js

Codex CLI 通过 npm 分发，先确保系统有 Node.js。当前 @openai/codex 的 engines 要求是 node >= 16，建议使用更高版本（如 Node 20 LTS）。

macOS（Homebrew）：

brew install node

Ubuntu/Debian：

curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt-get install -y nodejs

Arch：

sudo pacman -S nodejs npm

验证安装：

node --version
npm --version

检查网络环境

如果终端无法正常访问外网，安装和登录都可能失败。可以先测试当前出口 IP：

curl ipin.io

安装 Codex CLI

方式 1：npm 安装（推荐）

npm install -g @openai/codex

验证是否安装成功：

codex --version

出现版本号即为成功。

方式 2：Homebrew 安装（可选）

brew install --cask codex

这条路径适合习惯用 Homebrew 管理工具的用户，但版本更新节奏可能和 npm 不一致。

登录与鉴权

Codex CLI 需要先登录才能使用。

交互登录

codex login

查看登录状态：

codex login status

使用 API Key 登录

如果你已有 API Key，可以通过 stdin 方式登录：

export OPENAI_API_KEY="sk-xxxx"
printenv OPENAI_API_KEY | codex login --with-api-key

退出登录：

codex logout

启动方式

交互模式（最常用）

进入项目目录后直接运行：

cd /path/to/your/project
codex

也可以在启动时附带首条需求：

codex "帮我先梳理这个仓库的目录结构，然后给出重构计划"

非交互模式（自动化）

适合 CI、脚本、批处理任务：

codex exec "检查 src 下的 TypeScript 类型错误并给出修复建议"

管道模式（stdin）

把其他命令输出直接喂给 Codex：

git diff | codex exec "根据这份改动写一个规范的 commit message"

常用子命令速查

| 命令 | 作用 | |------|------| | codex | 启动交互式 TUI | | codex exec | 非交互执行一次任务 | | codex review | 非交互代码审查 | | codex login | 登录管理 | | codex logout | 清除本地登录凭据 | | codex resume | 恢复历史会话 | | codex fork | 从历史会话分叉新会话 | | codex apply <TASK_ID> | 应用某个任务产出的 diff | | codex mcp | 管理 MCP 服务 | | codex completion | 生成 shell 补全脚本 | | codex sandbox | 在 Codex 提供的沙箱中运行命令 |

高频命令示例

1) 审查当前未提交改动

codex review --uncommitted

2) 和指定基线分支做审查

codex review --base main

3) 继续最近一次会话

codex resume --last

4) 在指定目录启动

codex -C /path/to/repo

5) 指定模型启动

codex -m gpt-5.4

6) 开启 web search 能力

codex --search

常见运行参数说明

沙箱与安全

-s, --sandbox read-only|workspace-write|danger-full-access 控制命令执行权限范围。
--full-auto 低摩擦自动执行（默认沙箱是 workspace-write）。
--dangerously-bypass-approvals-and-sandbox 跳过审批与沙箱，风险极高，只建议在外部已隔离环境使用。

上下文与目录

-C, --cd <DIR> 指定工作目录。
--add-dir <DIR> 给当前会话增加额外可写目录。

模型与配置

-m, --model <MODEL> 指定模型。
-p, --profile <CONFIG_PROFILE> 使用配置文件中的 profile。
-c, --config key=value 临时覆写 ~/.codex/config.toml 的配置项。

Shell 补全（可选）

以 zsh 为例：

codex completion zsh

可以把输出重定向到你的补全目录并在 shell 配置中加载，之后 Tab 补全会更顺手。

常见问题

Q: 提示 command not found: codex

检查 npm 全局 bin 目录是否在 PATH 中：

npm config get prefix
export PATH="$(npm config get prefix)/bin:$PATH"

Q: 如何升级 Codex CLI？

npm update -g @openai/codex

Q: 如何确认当前有哪些命令可用？

codex --help

小结

Codex CLI 的核心价值是把 AI 代理能力直接带到终端工作流里。如果你习惯命令行开发，先掌握这三件事就够用了：

codex（交互）
codex exec（自动化）
codex review（审查改动）

剩下的能力，再根据项目需求逐步加上就行。

Vibe Coding For AI 4: Gemini CLI 安装与使用指南

Sat, 18 Apr 2026 00:00:00 GMT

本文内容由 AI 生成，主要供博主自用参考，不保证完全准确，请以官方文档为准。

什么是 Gemini CLI？

Gemini CLI 是 Google 官方推出的命令行 AI 助手。它不仅是一个简单的聊天界面，更是一个深度集成到开发流程中的 Coding Agent。它能够感知项目上下文，读取和修改文件，执行 Shell 命令，并支持通过 Agent Skills 和 MCP（Model Context Protocol）进行扩展。

对于追求极致性能和谷歌生态集成的开发者来说，Gemini CLI 是 Vibe Coding 的又一利器。

安装前准备

安装 Node.js

Gemini CLI 要求 Node.js 20.0.0+。

macOS（Homebrew）：

brew install node

Linux（Ubuntu/Debian）：

curl -fsSL https://deb.nodesource.com/setup_23.x | sudo -E bash -
sudo apt-get install -y nodejs

验证安装：

node --version   # 确保版本 >= 20
npm --version

检查网络环境

确保你的终端可以顺畅访问 Google 的 API 服务。

curl ipin.io

安装 Gemini CLI

推荐方式：npm 全局安装

npm install -g @google/gemini-cli

其他方式

Homebrew: brew install gemini-cli
npx (无需安装直接运行): npx @google/gemini-cli

安装完成后验证：

gemini --version

配置与鉴权

获取 API Key

前往 Google AI Studio 获取你的 Gemini API Key。

设置环境变量

将密钥添加到你的 shell 配置文件（如 ~/.zshrc 或 ~/.bashrc）：

export GEMINI_API_KEY="你的_API_KEY"

如果使用中转服务，可以设置基础 URL：

export GEMINI_BASE_URL="https://你的中转地址/v1"

启动与基本用法

交互模式（REPL）

在项目根目录运行：

gemini

进入交互界面后，你可以像在网页端一样与 Gemini 对话，但它现在拥有操作你本地文件的权限。

非交互模式（单次查询）

gemini -p "分析当前目录结构并总结项目功能"

管道模式

cat error.log | gemini "解释这个错误并给出修复方案"

恢复会话

gemini -r latest

核心功能特性

1. 上下文感知

Gemini CLI 会自动读取项目中的文件结构，并尊重 .geminiignore 文件（类似于 .gitignore）。你可以通过 GEMINI.md 文件为 AI 提供项目特定的指令和规范。

2. 快捷文件引用

在对话中，你可以使用 @ 符号快速引用文件内容： 帮我重构一下 @src/utils/date.ts 里的格式化函数

3. Shell 集成

在交互界面中，可以使用 ! 前缀直接执行 Shell 命令： !npm test

4. 自动任务执行

你可以给 Gemini 下达复杂的指令，它会自动拆解步骤并执行，例如： 帮我把项目中所有的 React 组件从 Class 组件重构成 Function 组件，并添加 Vitest 测试

常用斜杠命令

| 命令 | 功能 | |------|------| | /help | 显示所有可用命令 | | /model set <model> | 切换使用的 Gemini 模型版本 | | /resume | 搜索并恢复历史会话 | | /rewind | 在历史记录中回溯，甚至可以撤销代码更改 | | /settings | 配置 CLI 的外观和行为 | | /quit | 退出当前会话 |

进阶技巧：Agent Skills

Gemini CLI 支持通过 Agent Skills 扩展功能。你可以通过编写简单的脚本或配置，让 Gemini 具备特定领域的专家知识（如特定框架的优化技巧、复杂的部署流程等）。

小结

Gemini CLI 凭借其强大的多模态处理能力和 Google 的模型优势，在处理大规模代码重构和复杂逻辑理解上表现出色。它是目前命令行 Coding Agent 中最全能的选手之一。

如果你已经习惯了在前几篇教程中提到的 Claude CLI 或 OpenCode，Gemini CLI 的强大工具链和恢复机制（Rewind）绝对值得你一试。

SSH 断连不掉任务：tmux 入门教程

Fri, 17 Apr 2026 00:00:00 GMT

远程开发最常见的痛点之一：

本地网络波动
SSH 会话断开
正在跑的脚本一起中断

如果你经常在服务器上跑训练、部署或长时间任务，tmux 基本是必备工具。

1. tmux 能解决什么

tmux 是终端复用器。你可以把它理解成“可恢复的终端容器”：

任务跑在 tmux 会话里，不依赖当前 SSH 连接
你断网、关电脑、重连后都能继续接上原来的终端状态
一个 SSH 连接里还能开多个窗口和分屏

一句话：把任务和网络连接解耦。

2. 安装 tmux

Ubuntu / Debian:

sudo apt update
sudo apt install -y tmux

CentOS / RHEL:

sudo yum install -y tmux

macOS (Homebrew):

brew install tmux

检查版本：

tmux -V

3. 第一次使用（最小闭环）

下面这套流程，够你马上上手：

登录服务器后创建会话

tmux new -s work

在会话里启动任务（例如训练脚本）

python train.py

需要离开时，分离会话（任务继续跑）

按 Ctrl+b，松开后再按 d

以后重连服务器，恢复会话

tmux attach -t work

4. 你会用到的核心命令

列出所有会话：

tmux ls

新建会话：

tmux new -s session_name

连接会话：

tmux attach -t session_name

分离当前会话：

tmux detach

关闭会话：

tmux kill-session -t session_name

5. 常用快捷键（先记这几个）

tmux 默认前缀键是 Ctrl+b，后面所有快捷键都以它开头。

Ctrl+b 然后 d：分离会话
Ctrl+b 然后 c：新建窗口
Ctrl+b 然后 n / p：切换下一个 / 上一个窗口
Ctrl+b 然后 %：左右分屏
Ctrl+b 然后 "：上下分屏
Ctrl+b 然后 x：关闭当前 pane

6. SSH 场景下的推荐习惯

习惯 A：任务一律在 tmux 里启动

不要直接在普通 SSH shell 里跑长任务。先 tmux new -s xxx，再启动脚本。

习惯 B：会话命名有语义

例如：train, deploy, debug，方便你 tmux ls 后快速找到目标。

习惯 C：用日志文件做双保险

python train.py 2>&1 | tee train.log

即使你暂时没 attach，也能通过日志确认任务状态。

7. 常见问题

Q1: `tmux attach` 提示找不到会话

先看会话列表：

tmux ls

如果确实不存在，说明之前的会话已经退出，需要重新创建。

Q2: 连接时提示 `sessions should be nested with care`

你可能在一个 tmux 里又 attach 了另一个 tmux。通常先分离当前层，回到普通 shell 再 attach 目标会话。

Q3: 如何退出 tmux 并结束任务

在 tmux 的 shell 中执行 exit（或终止前台任务），该 pane 关闭；会话所有 pane 都退出后，会话会自动结束。

8. 一条推荐工作流

ssh your_server
tmux new -s train
python train.py 2>&1 | tee train.log
# 按 Ctrl+b, d 分离

之后任意时间：

ssh your_server
tmux attach -t train

这样即使 SSH 中断，你的任务也不会跟着掉。

Ubuntu 24.04 安装 MATLAB R2024a

Thu, 16 Apr 2026 00:00:00 GMT

这篇记录整理了我在 Ubuntu 24.04 上安装 MATLAB R2024a 的流程，重点是可复现和后续维护方便。

0. 准备条件

安装前请先确认：

你有有效的 MathWorks 账号与许可证（个人/学校/单位均可）
系统是 Ubuntu 24.04 x86_64
磁盘空间建议至少 25 GB
有图形界面（或你能通过远程桌面运行图形安装器）

1. 下载 MATLAB R2024a 安装包（官方）

建议使用 MathWorks 官方渠道下载，避免镜像被篡改或版本不一致：

官网下载入口：https://www.mathworks.com/downloads/
产品页（Linux）：https://www.mathworks.com/products/matlab.html

想省事，可以直接在终端使用 aria2c 下载（非官方）：

aria2c "magnet:?xt=urn:btih:5C78E38581C13CE9D63EA0222BEE4A6BF10328D3&tr=http%3A%2F%2Fbt4.t-ru.org%2Fann%3Fmagnet"

当然，博主也是用这个链接下载的，下载完成后会得到一个压缩包，解压后里面有 R2024a_Linux.iso 安装镜像和 Crack 文件夹。

2. 挂载安装镜像

如果你已经拿到官方安装镜像（例如 R2024a_Linux.iso），可以先挂载：

sudo mkdir -p /mnt/matlab
sudo mount -o loop R2024a_Linux.iso /mnt/matlab
ls /mnt/matlab

能看到 install 等文件说明挂载成功。

3. 启动安装器

在挂载目录中运行官方安装程序：

cd /mnt/matlab
sudo ./install

如果没有问题，就会进入向导。首先，会要求你进行登陆。如果有账号直接登就好，如果没有账号就注册一个，博主是使用 gmail 注册的。登陆后，就会进入这个页面，让你输入密钥。这个时候先点击左上角的切换为 I have a File Installation Key。然后，打开 Crack 文件夹，找到 readme.txt，里面有若干密钥，选择 Full desktop 版本的密钥输入即可。接着，下一个页面会让你选择许可证，许可证的在 Crack 文件夹里，选择 license.lic 文件即可。选择安装路径，这里一般使用 home/your_username/MATLAB/R2024a，也可以自定义路径。选择需要的 Product，如果不清楚可以默认全选。把共享信息和错误报告选项都取消勾选，保护隐私。等待安装完成即可，安装过程可能需要一些时间，耐心等待。

4. 配置命令行启动

安装完成后，为了在任意路径直接启动 MATLAB，可以创建软链接，确保你在 Crack 路径下，执行以下命令。

sudo cp libmwlmgrimpl.so ~/MATLAB/R2024a/bin/glnxa64/matlab_startup_plugins/lmgrimpl/
sudo ln -s ~/MATLAB/R2024a/bin/matlab /usr/local/bin/matlab

然后测试：

matlab

如果能正常打开，说明安装与路径配置都已完成。

5. 卸载镜像

安装结束后可以卸载挂载点：

sudo umount /mnt/matlab

6. 删除（卸载）MATLAB R2024a

如果你需要完整卸载当前用户目录下的 MATLAB R2024a，可以按下面顺序执行：

sudo pkill -f MATLAB
sudo rm /usr/local/bin/matlab
sudo rm -rf ~/MATLAB/R2024a
sudo rm -rf ~/.matlab
ps aux | grep matlab

如果 ps 仍有 MATLAB 相关进程，使用：

kill -9 <PID>

如何把本地项目上传到 GitHub 仓库（完整教程）

Thu, 16 Apr 2026 00:00:00 GMT

很多同学第一次上传项目时，最容易卡在三件事：

没初始化 Git
远程仓库地址配错
首次认证失败（SSH key / Token）

这篇教程按「从 0 到可用」整理，跟着做一遍就可以把自己的项目稳定上传到 GitHub。

0. 准备工作

先确认你已经安装好 Git：

git --version

如果能看到版本号（例如 git version 2.x.x），就可以继续。

1. 在 GitHub 上创建空仓库

打开 GitHub，点击右上角 + -> New repository
填写仓库名（例如 my-first-project）
选择 Public 或 Private
先不要勾选 Add a README file（避免和本地历史冲突）
点击 Create repository

创建后页面会给你一个仓库地址，通常有两种：

HTTPS：https://github.com/你的用户名/仓库名.git
SSH：git@github.com:你的用户名/仓库名.git

2. 本地项目初始化 Git

进入你的项目目录，然后执行：

git init
git add .
git commit -m "init: first commit"

如果你还没有配置 Git 身份，先设置（只需一次）：

git config --global user.name "你的名字"
git config --global user.email "你的邮箱"

3. 添加 `.gitignore`（强烈建议）

上传前，建议把不该入库的文件排除掉，比如依赖、构建产物、环境变量。

常见示例（按你的项目类型调整）：

node_modules/
dist/
.env
.DS_Store

如果你在 git add . 之前忘了加 .gitignore，先补上，然后再执行一次：

git add .
git commit -m "chore: add gitignore"

4. 绑定远程仓库并推送

把 origin 指向你刚创建的 GitHub 仓库：

git remote add origin <你的仓库地址>

查看是否添加成功：

git remote -v

然后推送：

git branch -M main
git push -u origin main

首次成功后，后续只需要：

git add .
git commit -m "feat: your message"
git push

5. 认证方式选择：HTTPS 还是 SSH

方式 A：HTTPS（简单）

优点：配置快。

注意：GitHub 不再支持账号密码直登，通常要用 Personal Access Token。

`git push` 后提示输入 password，应该填什么？

如果你的远程地址是 HTTPS（https://github.com/...），这里的 password 不是 GitHub 登录密码，而是 Personal Access Token (PAT)。

GitHub 右上角头像 -> Settings
Developer settings -> Personal access tokens
选择 Tokens (classic)（新手更容易上手）
点击 Generate new token，勾选 repo 权限
生成后复制 token（只显示一次）
下次 git push 时输入：
- Username：你的 GitHub 用户名
- Password：刚才生成的 PAT

可以先确认远程地址类型：

git remote -v

如果显示的是 https://github.com/...，就一定要用 PAT。

方式 B：SSH（推荐长期使用）

生成密钥：

ssh-keygen -t ed25519 -C "your_email@example.com"

拷贝公钥内容（~/.ssh/id_ed25519.pub）
到 GitHub -> Settings -> SSH and GPG keys -> New SSH key
添加后测试：

ssh -T git@github.com

看到 Hi <username>! 类似提示说明配置成功。

6. 常见报错与解决

`remote origin already exists`

说明你之前加过远程地址：

git remote remove origin
git remote add origin <你的仓库地址>

`src refspec main does not match any`

通常是你还没提交过代码。先提交一次：

git add .
git commit -m "init"
git branch -M main
git push -u origin main

`Permission denied (publickey)`

说明 SSH 密钥未配置好。按上面的 SSH 步骤重新检查：

本地是否有密钥文件
GitHub 是否已添加公钥
远程地址是否为 SSH 格式

`rejected` / `non-fast-forward`

远程有新提交，本地没同步：

git pull --rebase origin main
git push

7. 最小工作流（记住这 3 行）

日常开发最常用：

git add .
git commit -m "feat: 描述你这次改了什么"
git push

到这里，你的项目已经可以稳定托管在 GitHub 上了。后续再学习分支协作（git checkout -b）、Pull Request、CI/CD 就会顺很多。

A800 服务器深度学习环境标准配置教程

Wed, 15 Apr 2026 00:00:00 GMT

这篇教程按一套固定标准来配 A800 服务器，目标是“可复现、可维护、少踩坑”。

标准配置（本文统一口径）

GPU: NVIDIA A800
Driver: 570+
CUDA Toolkit: 12.8
cuDNN: 9.x (for CUDA 12)
PyTorch: cu128

1. 基础系统初始化

sudo apt update && sudo apt upgrade -y
sudo apt install -y git curl wget vim tmux htop btop unzip zip build-essential dkms linux-headers-$(uname -r)

2. 驱动检查（A800）

nvidia-smi

重点看两项：

Driver Version
GPU 是否识别到 A800

只要驱动正常，后续 PyTorch GPU 通常就能跑起来。

2.1 已安装过旧驱动时：卸载并重装（推荐流程）

如果你之前装过其他版本驱动，建议按下面流程“先卸载，再安装目标版本”。

下面命令会卸载现有 NVIDIA 驱动并重启，建议在有控制台（云厂商 VNC/管理终端）保障的前提下执行。

第一步：卸载旧驱动

sudo systemctl stop nvidia-persistenced || true
sudo apt remove --purge -y '^nvidia-.*' '^libnvidia-.*'
sudo apt autoremove -y
sudo apt autoclean

可选：重启一次，确保旧模块完全退出。

sudo reboot

第二步：安装目标驱动（A800 推荐 570）

先看系统推荐：

sudo ubuntu-drivers devices

然后二选一：

自动安装推荐版本（最稳）：

sudo ubuntu-drivers autoinstall

手动指定 570（你当前目标）：

sudo apt install -y nvidia-driver-570-server

如果 nvidia-driver-570-server 不存在，可改用：

sudo apt install -y nvidia-driver-570

安装后重启：

sudo reboot

第三步：验收

nvidia-smi

确认点：

能识别 A800
Driver Version 为目标版本（如 570.x）

通过后再继续下面 CUDA Toolkit 与 cuDNN 的安装步骤。

3. 清理旧 CUDA Toolkit

先检查当前 nvcc：

nvcc --version
which nvcc

如果是旧版本，先清理旧工具链：

sudo apt remove --purge -y "cuda*" "nvidia-cuda-toolkit" "libcudnn*"
sudo apt autoremove -y
sudo apt autoclean

4. 安装 CUDA Toolkit 12.8

wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-keyring_1.1-1_all.deb
sudo dpkg -i cuda-keyring_1.1-1_all.deb
sudo apt update
sudo apt install -y cuda-toolkit-12-8

写入环境变量（非常关键）：

echo 'export PATH=/usr/local/cuda-12.8/bin:$PATH' >> ~/.bashrc
echo 'export LD_LIBRARY_PATH=/usr/local/cuda-12.8/lib64:$LD_LIBRARY_PATH' >> ~/.bashrc
source ~/.bashrc

验证：

nvcc --version

应该看到 release 12.8。

5. 安装 cuDNN 9（CUDA 12 系）

sudo apt install -y libcudnn9-cuda-12 libcudnn9-dev-cuda-12

5.1 验证 cuDNN 是否安装成功

先看系统层是否有 cuDNN 动态库：

sudo ldconfig
ldconfig -p | grep cudnn

预期输出应该至少包含类似下面的行（版本号可能不同）：

libcudnn.so.9 (libc6,x86-64) => /usr/lib/x86_64-linux-gnu/libcudnn.so.9
libcudnn_ops.so.9 (libc6,x86-64) => /usr/lib/x86_64-linux-gnu/libcudnn_ops.so.9
libcudnn_cnn.so.9 (libc6,x86-64) => /usr/lib/x86_64-linux-gnu/libcudnn_cnn.so.9

如果没有任何输出，通常说明 cuDNN 没装好，或者库路径没被系统识别。

再看包管理器是否安装到位：

dpkg -l | grep -E "libcudnn9|libcudnn9-dev"

6. 安装 Miniconda 与终端初始化

wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
bash Miniconda3-latest-Linux-x86_64.sh
rm -f Miniconda3-latest-Linux-x86_64.sh

安装完成后，做终端初始化并使其生效：

~/miniconda3/bin/conda init bash
source ~/.bashrc
conda --version

如果你用的是 zsh，把 bash 换成 zsh：conda init zsh。

后续环境创建与包安装放在下一节进行。

7. 安装 PyTorch（cu128）

pip install --upgrade pip
pip install torch torchvision torchaudio \
  --index-url https://download.pytorch.org/whl/cu128 \
  --extra-index-url https://pypi.tuna.tsinghua.edu.cn/simple

如果你网络到官方源很慢，可以先临时设置国内镜像，再执行安装：

pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
pip config set global.extra-index-url https://download.pytorch.org/whl/cu128

常用国内镜像（任选其一）：

清华：https://pypi.tuna.tsinghua.edu.cn/simple
中科大：https://pypi.mirrors.ustc.edu.cn/simple
阿里云：https://mirrors.aliyun.com/pypi/simple
腾讯云：https://mirrors.cloud.tencent.com/pypi/simple
华为云：https://repo.huaweicloud.com/repository/pypi/simple

例如改成中科大：

pip config set global.index-url https://pypi.mirrors.ustc.edu.cn/simple
pip config set global.extra-index-url https://download.pytorch.org/whl/cu128

安装完成后，如需恢复默认：

pip config unset global.index-url
pip config unset global.extra-index-url

验证 GPU：

python - <<'PY'
import torch
print('torch:', torch.__version__)
print('cuda available:', torch.cuda.is_available())
if torch.cuda.is_available():
    print('device:', torch.cuda.get_device_name(0))
PY

8. 常用科研包（按需）

pip install numpy scipy pandas matplotlib seaborn scikit-learn
pip install jupyterlab ipykernel tqdm pyyaml rich einops opencv-python
pip install tensorboard wandb

在 VSCode 上配置 SSH 远程开发

Tue, 14 Apr 2026 00:00:00 GMT

在本地写代码、在远程 Linux 机器上跑环境，是现在很常见的开发方式。
这篇教程按“能快速用起来”的思路整理，覆盖 Windows / macOS / Linux 三个平台，默认你已经有一台可登录的 Linux 服务器（云主机 / 学校实验室机器均可）。

1. 安装 VSCode Remote SSH 插件

在 VSCode 扩展市场安装：

Remote - SSH（作者 Microsoft）

安装完成后，左侧活动栏会出现远程图标。

2. 生成 SSH 密钥（本地，按系统）

Windows（PowerShell）

先确认 OpenSSH 客户端可用：

ssh -V

如果提示找不到命令，请在「设置 -> 可选功能」安装 OpenSSH Client。然后生成密钥：

ssh-keygen -t ed25519 -C "your_email@example.com"

默认路径通常是：

私钥：C:\Users\你的用户名\.ssh\id_ed25519
公钥：C:\Users\你的用户名\.ssh\id_ed25519.pub

macOS / Linux（Terminal）

ssh-keygen -t ed25519 -C "your_email@example.com"

默认路径：

私钥：~/.ssh/id_ed25519
公钥：~/.ssh/id_ed25519.pub

关于 passphrase 提示（你遇到的这个）

当你看到：

Enter passphrase for "/Users/xxx/.ssh/id_ed25519" (empty for no passphrase):

这是在询问你的私钥密码（不是服务器密码）。

想要更安全：输入一个 passphrase（推荐）
想省事：直接回车留空（不推荐）

如果你已经设置了 passphrase，又不想每次都输入，可以把密钥加入 ssh-agent。

3. 把公钥上传到服务器（按系统）

这一步会让你先输入一次服务器登录密码。输入后如果没有报错，就是成功。

ssh-copy-id -i ~/.ssh/id_ed25519.pub -p your_port username@your_server_ip

4. 配置 SSH Host（本地）

编辑 SSH 配置文件：

Windows：C:\Users\你的用户名\.ssh\config
macOS / Linux：~/.ssh/config

添加：

Host my-server
  HostName your_server_ip
  User username
  Port your_port
  IdentityFile ~/.ssh/id_ed25519
  ServerAliveInterval 60
  ServerAliveCountMax 5

如果是 Windows，IdentityFile 也可以写完整路径，例如：

IdentityFile C:/Users/YourName/.ssh/id_ed25519

这样你后面直接 ssh my-server 就能连，不用每次敲完整 IP。

5. 在 VSCode 连接远程机器

在 VSCode 中：

Cmd/Ctrl + Shift + P
输入 Remote-SSH: Connect to Host...
选择 my-server
首次连接时确认 fingerprint
如果弹出密码框，输入你的服务器密码

连接成功后，左下角会显示 SSH: my-server。

说明：即使你配置了密钥，首次仍可能要求你输入一次密码或 passphrase，属于正常现象。

Vibe Coding For AI 1: Windows 上配置 Coding Agent 指南

Sat, 04 Apr 2026 00:00:00 GMT

什么是 Vibe Coding？

Vibe Coding 是一种新兴的编程范式，旨在通过 AI 助手（Coding Agent）来提升开发效率和代码质量。在 Vibe Coding 中，开发者与 AI 助手进行实时互动，AI 可以根据上下文提供代码建议、自动补全、错误检查等功能。这种方式不仅加快了开发速度，还能帮助开发者更好地理解和优化代码。在这篇文章中，教会你如何在 Windows 上配置 Vibe Coding。对于 AI 供应商，考虑到经济实惠和易用性，推荐使用 Ikuncode 的中转服务。本教程中使用的 CLI 工具是 OpenCode，支持多种 AI 供应商，提供了丰富的功能和良好的用户体验。

OpenCode CLI 配置

首先，需要在 Windows 系统上打开终端，推荐使用 PowerShell。在启动栏中搜索 PowerShell 即可，记得使用管理员权限运行。咱们使用 npm 来安装 OpenCode，所以先要确保 Windows 上安装好了 npm。在安装之前，建议确认终端的代理情况，可以使用以下命令检查当前的代理设置：

curl ipin.io

如果代理设置正确，会返回你的 IP 地址信息。如果没有魔法，下载 OpenCode 可能会遇到网络问题。接下来，使用以下命令安装 Node.js

curl -o node-installer.msi https://nodejs.org/dist/v20.11.0/node-v20.11.0-x64.msi
node-installer.msi

安装完成后，可以使用以下命令验证安装，出现版本号即为成功。

node --version
npm --version

接下来，就可以安装 OpenCode 啦，使用以下命令全局安装。

npm install -g opencode-ai

安装完成后，可以使用以下命令验证安装，出现以下页面即为成功。

opencode

其实，到这里就可以尝试进行 Vibe Coding 了，因为 OpenCode 内置了一些免费的 AI 模型，可以直接使用。不过，免费模型的性能和功能可能有限，如果想要更好的体验，建议配置一个更强大的 AI 供应商。

IkunCode 中转站配置

IkunCode 是一个提供 AI 模型中转服务的平台，支持多种 AI 供应商，价格合理，使用方便。首先，需要在 Ikuncode 官网注册一个账号，完成注册后登录。 Ikuncode 涵盖了多个 AI 供应商的模型，例如 Anthropic、OpenAI、Google 等。这里以 OpenAI 的 Codex-5.1 模型为例，演示如何配置 OpenCode 使用 Ikuncode 的中转服务。当然，天下没有免费的午餐，想要使用这些模型，是需要烧钱的，这里选择 Codex-5.1 也是因为比较实惠。接下来，点击上方的 控制台，可以看到自己的账户余额，点击 钱包管理，即可进行充值。充值完毕后，点击左侧的 令牌管理，再点击 添加令牌，即可创建一个新的 API 令牌。按照下图选择，即可配置出 OpenAI 的密钥。

CC-Switch 密钥管理

CC-Switch 是一个开源的密钥管理工具，可以帮助开发者安全地存储和管理 API 密钥。首先啦，就是要安装 CC-Switch，进入 CC-Switch 发布页面，选择安装 msi 版本，下载并安装。接下来打开 CC-Switch，点击上方的 OpenCode，再点击 添加密钥，按照咱的配置方案，输入以下信息，然后保存就好啦。

OpenCode 配置验证

配置完成后，就可以开始使用 OpenCode 进行 Vibe Coding 了。进入你的项目文件夹，运行 opencode 命令启动 OpenCode 啦。首先，可以使用 /models 命令查看当前可用的 AI 模型，确认 OpenAI 的 Codex-5.1 模型已经成功配置，然后选择切换。

OpenCode 提供了两种模型，分别是 Build 和 Plan，其中 Build 模型适合生成代码，而 Plan 模型适合生成开发计划和任务分解，使用 Tab 键进行切换。接下来，向 Agent 打个招呼，如果有回应，那么就配置成功啦！恭喜你进入 Vibe Coding 的世界了！

Paper Reading: Embodied AI 3

Fri, 26 Dec 2025 00:00:00 GMT

import { ArxivRating, RatingCriteria } from '@/components/advanced'

import { ManualTOC } from '@/components/advanced'

前言

RL菜鸡开始进军Embodied AI，慢慢积累，提升自己。

RoboVerse

AgiBot World Colosseo

UniVLA

GraspVLA

GRAPE

A0

OneTwoVLA

RDT-1B

Octo

FAST

Magma

ChatVLA

ChatVLA-2

RoboBrain

CoT-VLA

Interleave-VLA

Knowledge Insulating Vision-Language-Action Models

Hi Robot

Scenethesis

LBM

UniVLA

SmolVLA

ThinkAct

VIDAR

DreamVLA

RL笔记（29）：推理模型的崛起 (GRPO & PRM)

Wed, 07 Jan 2026 00:00:00 GMT

引言（Introduction）

在上一篇笔记中，我们介绍了经典的 PPO + RLHF 流程。虽然 PPO 非常有效，但在训练超大规模语言模型时，它面临两个挑战：

资源消耗巨大：PPO 需要维护 Actor、Ref、Reward、Critic 四个模型，显存开销极高。
结果导向的局限：传统的奖励模型只对最终答案评分（ORM），而不关心推理过程。如果模型凑巧猜对了答案，也会得到高分，这会导致“走捷径”和幻觉。

本章将介绍 GRPO ——一种更轻量、更高效的策略优化算法，以及 PRM ——一种对思维过程进行细粒度监督的奖励机制。

GRPO (Group Relative Policy Optimization)

论文：DeepSeekMath: Pushing the Limits of Mathematical Reasoning in LLMs 应用：DeepSeek-V3 / DeepSeek-R1

GRPO 的核心创新在于：彻底丢弃了 Critic 模型，利用组内相对排名来估计优势函数（Advantage）。

核心思想：组内相对评价

在 PPO 中，我们需要 Critic 网络来预测状态价值 $V(s)$，从而计算优势 $A = Q - V$。而在 GRPO 中，对于每一个提示词（Prompt）$q$：

让模型生成一组不同的回复 ${o_1, o_2, o_3, ..., o_G}$（组大小为 $G$）。
利用奖励模型（或规则奖励）计算出这一组回复的分数 ${r_1, r_2, r_3, ..., r_G}$。
通过这组分数的相对强弱来直接得出每个回复的优势。

优势函数计算

第 $i$ 个回复的优势函数 $A_i$ 计算公式为：

$$ A_i = \frac{r_i - \text{mean}(r_1, r_2, ..., r_G)}{\text{std}(r_1, r_2, ..., r_G)} $$

💡 直觉理解：这就像是在班级里考试。我们不需要一个绝对的“满分标准”（Critic），只需要看你在班级里的排名。如果你比班级平均分高，我们就增加你这种行为的概率；反之则降低。

GRPO 损失函数

$$ L_{GRPO}(\theta) = \frac{1}{G} \sum_{i=1}^G \left[ \min\left( \frac{\pi_\theta(o_i|q)}{\pi_{\text{old}}(o_i|q)} A_i, \text{clip}\left(\frac{\pi_\theta(o_i|q)}{\pi_{\text{old}}(o_i|q)}, 1-\epsilon, 1+\epsilon\right) A_i \right) - \beta D_{KL}(\pi_\theta || \pi_{\text{ref}}) \right] $$

优势：由于省去了 Critic 网络，在大模型训练中可以节省约 50% 的梯度计算相关显存，从而允许更长的上下文或更大的 Batch Size。

PRM (Process Reward Models)

传统的奖励模型被称为 ORM (Outcome Reward Models)：只看结果。 PRM (Process Reward Models) 则是对推理链条中的每一个步骤进行打分。

核心动机

在复杂的数学推导或编程任务中：

中间错一步，步步错：即使最终答案对，中间逻辑也可能有毒。
奖励稀疏：只有到最后才给分，模型很难学会长链条的逻辑。

训练与运作机制

步骤拆解：将模型生成的思维链（CoT）利用换行符或特殊 token 拆分为 $S_1, S_2, ..., S_n$。
细粒度标注：通过人类专家或更强模型（如 GPT-4）对每一个 $S_i$ 标注“正确”、“错误”或“中性”。
模型预测：PRM 模型学习预测每一步的正确概率。

强化学习中的应用

在 RL 过程中，奖励函数不再是标量，而是一个序列： $$ \mathcal{R} = {r(S_1), r(S_2), ..., r(S_n)} $$ 这允许 PPO 或 GRPO 进行更密集的奖励信号反馈，显著提升模型处理复杂推理问题的逻辑严密性。

案例分析：DeepSeek-R1 的强化学习范式

DeepSeek-R1 展示了 GRPO 结合“规则奖励”的惊人效果：

规则导向的 PRM

在推理任务中，我们有时不需要神经网络做奖励模型，而是使用硬规则：

准确性奖励 (Accuracy)：答案必须对（例如数学题，提取最后的结果比对）。
格式奖励 (Format)：思维链必须放在 <think> 和 </think> 标签之间。

涌现能力

DeepSeek 发现，通过这种简单的 GRPO + 规则奖励，模型在训练过程中会出现自我反思（Self-reflection）。

当模型发现之前的推导有问题时，它会自发地写下“Wait, that's not right...”（等一下，这不对……），然后重新推导。
这种能力并不是通过 SFT（监督微调）刻意教出来的，而是通过 RL 最大化奖励的过程中自发进化出来的。

总结与对比：PPO vs. GRPO

启示

强化学习在大模型时代的进化方向非常明确：

算力优化：通过像 GRPO 这样的算法减少训练开销。
逻辑监督：通过 PRM 或规则奖励强化模型的推理过程，而不仅仅是最终答案。

RL笔记（28）：大语言模型与强化学习 (LLM + RLHF)

Tue, 06 Jan 2026 00:00:00 GMT

引言（Introduction）

在之前的笔记中，我们一直在研究如何让智能体在物理环境或博弈环境（如 Atari, MuJoCo, SMAC）中拿高分。而现在，我们要处理的对象是 大语言模型 (LLM)。

大模型的训练通常分为三个阶段：

预训练 (Pre-training)：在海量文本上通过自监督学习“知识”。
指令微调 (SFT, Supervised Fine-Tuning)：在高质量问答对上学习“对话格式”。
人类对齐 (Alignment)：通过强化学习，让模型生成符合人类价值观（有用、诚实、无害）的内容。

为什么要用 RL 而不是 SFT？

难以写出标准答案：对于“写一首诗”这种开放性问题，不存在唯一的正解（Label）。人类可以很容易判断谁写得更好，但很难写出完美的示范。
分布偏移问题：SFT 属于行为克隆（BC），如果模型在生成时产生了一个没见过的词，误差会迅速累积。RL 则让模型在“试错”中学会从各种回复中找到最优路径。

核心映射：将 LLM 建模为 RL 问题

要用强化学习训练 LLM，我们首先需要将文本生成过程对应到 MDP 五元组中：

状态 (State, $s$)：当前输入的提示词（Prompt）以及模型已经生成的 Token 序列。
动作 (Action, $a$)：模型预测的下一个 Token。动作空间就是词表（Vocab Size，通常为 3w ~ 10w）。
策略 (Policy, $\pi$)：大语言模型本身，输入提示词，输出下一个词的概率分布。
奖励 (Reward, $R$)：反映生成的一整段话好不好。这个奖励不是环境给的，而是由 奖励模型 (Reward Model) 评分。

RLHF 的三大步骤

RLHF (Reinforcement Learning from Human Feedback) 通常包含以下经典流程：

阶段一：监督微调 (SFT)

在预训练模型的基础上，使用人类编写的高质量 (Prompt, Answer) 数据集进行微调。此时模型学会了基本的指令遵循能力。

阶段二：奖励模型训练 (Reward Modeling)

给同一个 Prompt，让 SFT 后的模型生成多个不同的回复 ${y^1, y^2, y^3, y^4}$。
让人类对这些回复进行排序（例如 $y^2 > y^1 > y^4 > y^3$）。
训练一个标量奖励模型 $r_\theta(x, y)$，使其输出的分数符合人类的排序规律。损失函数通常采用 Pairwise Ranking Loss： $$ L(\theta) = - \mathbb{E}{(x, y_w, y_l) \sim \mathcal{D}} \left[ \log \sigma \left( r\theta(x, yw) - r\theta(x, y_l) \right) \right] $$ 其中 $y_w$ 是胜出的回复，$y_l$ 是失败的回复。

阶段三：强化学习对齐 (PPO)

利用奖励模型给出的分数，通过 PPO 算法调整 LLM 的参数。

RLHF 中的 PPO 目标函数

在对齐阶段，我们的目标是最大化奖励模型的分数。但如果只考虑奖励，模型可能会学会“钻空子”（Reward Hacking），生成一些人类看不懂但奖励模型给高分的乱码。

因此，我们需要约束模型，使其不要偏离原始模型太远。目标函数定义为：

$$ J(\phi) = \mathbb{E}{x \sim \mathcal{D}, y \sim \pi\phi(y|x)} \left[ r_\theta(x, y) - \beta \log \left( \frac{\pi_\phi(y|x)}{\pi_{\text{ref}}(y|x)} \right) \right] $$

公式拆解：

$r_\theta(x, y)$：奖励模型对生成的完整句子 $y$ 给出的预测分数。
$\log \left( \frac{\pi_\phi(y|x)}{\pi_{\text{ref}}(y|x)} \right)$：这是新策略 $\pi_\phi$ 与参考模型（通常是 SFT 后的模型）$\pi_{\text{ref}}$ 之间的 KL 散度（准确说是 KL 惩罚项）。
$\beta$：KL 惩罚系数。$\beta$ 越大，模型越保守，越像原始模型。

💡 直觉理解：这一项的作用是：“你可以尽量讨好人类，但不能忘了怎么说话。”

LLM-PPO 的训练架构

在这一阶段，显存中通常需要同时加载四个模型（通常采用参数共享或层冻结来优化）：

Actor (Policy Network)：当前正在训练的 LLM，参数为 $\phi$。
Reference Model：冻结的 SFT 模型，用于计算 KL 惩罚。
Critic (Value Network)：一个额外的头部，输入 Token 序列，预测从当前位置开始能获得的未来总奖励（即 $V(s)$）。
Reward Model：冻结的评分模型。

训练循环：

采样 (Rollout)：输入 Prompt $x$，Actor 生成回复 $y$。
评分 (Evaluation)：Reward Model 对 $(x, y)$ 打分。
计算优势 (Advantage)：利用序列中的每一个 Token 的 TD Error 来计算优势 $\hat{A}$。注意：在 LLM 中，奖励通常是在最后一个 Token 给出的，而前面的 Token 奖励为 0（除了 KL 惩罚）。
更新 (Update)：利用 PPO 的 Clip 损失函数更新 Actor，利用 MSE 损失更新 Critic。

进阶：DPO (Direct Preference Optimization)

论文：Direct Preference Optimization: Your Language Model is Secretly a Reward Model

PPO 虽然经典，但非常复杂（需要 4 个模型，显存开销巨大，训练极不稳定）。 2023 年提出的 DPO 彻底简化了这个过程。

DPO 的核心发现：我们可以通过数学变换，直接将奖励函数 $r$ 表达为最优策略 $\pi^*$ 的函数。这意味着我们不需要训练奖励模型，也不需要强化学习，直接在偏好数据 $(y_w, y_l)$ 上进行监督式学习即可。

DPO 损失函数：

$$ L_{DPO}(\pi_\phi; \pi_{\text{ref}}) = - \mathbb{E}{(x, y_w, y_l) \sim \mathcal{D}} \left[ \log \sigma \left( \beta \log \frac{\pi\phi(y_w|x)}{\pi_{\text{ref}}(y_w|x)} - \beta \log \frac{\pi_\phi(y_l|x)}{\pi_{\text{ref}}(y_l|x)} \right) \right] $$

直觉：如果模型在好回复 $y_w$ 上的概率提升比在坏回复 $y_l$ 上快，Loss 就变小。

总结

LLM + RL 的结合标志着强化学习从“解决玩具问题”走向了“赋能通用人工智能”。

RLHF 建立了模型行为与人类偏好的桥梁。
PPO 提供了稳定的优化框架，通过 KL 惩罚保证了语言的自然性。
DPO 等后续算法进一步降低了对齐的门槛，使得中小型团队也能进行模型对齐。

Paper Reading: Embodied AI 2

Fri, 26 Dec 2025 00:00:00 GMT

import { ArxivRating, RatingCriteria } from '@/components/advanced'

import { ManualTOC } from '@/components/advanced'

前言

RL菜鸡开始进军Embodied AI，慢慢积累，提升自己。

LLARVA

LLARVA 是一种 OpenVLA-like 的 VLA，使用 Instruction Tuning 进行微调，并通过输出 2D Visual Trace 去引导 Action 生成。

LLARVA 的输入指令被规范化为 Prompt，详细见图。 LLM 的主干为 LLaMA2 7B，并使用 LoRA 进行微调。先预测 2D Visual Trace 再生成 Action Chunk，本质上是基于 CoT 的思想。

ATM

ATM 的亮点在于仅可以使用 Action-free 的数据去训练机器人操作策略。 ATM 是一种 Pipeline 方法，分为任意点轨迹建模与轨迹引导策略学习两个部分。在任意点轨迹建模部分，ATM 利用了大量 Label-free 的视频训练了一个 Points-Tracker，输入是当前观察 Obs、任务 Instruction 以及初始 Points，输出是未来的 Points-Trajectory。在轨迹引导策略学习部分，策略网络以上个步骤预测的 Points-Trajectory 以及当前 Obs 为输入，输出机器人的 Action。

任意点轨迹建模：在数据处理部分，ATM 使用了离线的 Points-Tracker 模型去得出的 Label。同时，过滤掉了大部分静止的 Points，只保留了 32 个高频活动的 Points。对于当前 Obs，使用 ViT 将图像切分为 Patches，并随机 Mask 掉 50% 的 Patches，得出 Image Token。对于任务 Instruction，使用 BERT 进行信息提取 Language Token。对于初始 Points，在文中是有32个，编码为 Track Token。以 Obs 以及 Instruction 为 Base 的 Points-Tracker 被定义为一个 Transformer，输入为 Image Token、Language Token 以及 Track Token，输出为未来的 Points-Trajectory。按照题主的理解，输出的 Points-Trajectory 其实就是任务导向的 Vision-Language Fusion。

轨迹引导策略学习：首先，使用了 BERT-like 的 Transformer 对 Image Token 以及 Track Token 进行 Fusion，得出特征 [CLS]。然后，策略网络设定为 MLP，以 [CLS] 以及 Track Token 为输入，输出机器人的 Action。在策略学习的过程中，并没有引入 Instruction 的信息，因为在轨迹建模阶段已经引入了。同时，对 Track Token 进行了两次 Fusion，这样会有更好的效果，详细见原文。

Track2Act

Track2Act 本质上和 ATM 是一样的，都是以 Points-Trajectory 去引导动作的生成。 Track2Act 主要分为三个阶段：Points-Trajectory 预测、Open-loop 动作求解以及 Residual Policy 闭环修正。

在 Points-Trajectory 预测阶段，Track2Act 使用了 DiT 生成模型。 DiT 的 Condition 被设置为初始图像 $I_0$ 以及目标图像 $\mathcal{G}$ 的表征，给定随机采样的查询点集 $P_0$，生成 Points-Trajectory。

在 Open-loop 动作求解阶段，Track2Act 使用了一个确定性的算法进行刚性动作的求解，不涉及神经网络训练。这个算法的输入是 Points-Trajectory，输出一系列的刚性变换 $[\textbf{T}t]{t=1}^H$。具体求解算法见原文，这里不详细展开。最后，基于刚性变换，可以求解出机器人的 Open-loop 动作序列 $[\bar{a}t]{t=1}^H$。

在 Residual Policy 闭环修正阶段，Track2Act 使用一个 Residual Policy 去修正 Open-loop 动作。其实就是使用一个 Transformer-Encoder 去预测误差，最后加在一起。

最后简单瑞萍一下，其实博主觉得后面两个阶段完成可以使用神经网络进行表征，有点多余，虽然残差修正动作这个思想是好的。

ECoT

ECoT 这篇工作指出 LLM 那边的 CoT 是无法直接迁移到 Embodied 任务环境中的。若只是简单的语义推理，那么就会出现大量不符合实际物理环境的幻觉。因此，ECoT 在 CoT 的基础上添加了智能体对环境的感知，从而使得 CoT 具有 Embodied 性质。 ECoT 的具体设置见上图，和 CoT 类似，只是加入了 Embodied 的感知。 ECoT 使用的模型基座是 OpenVLA，使用 ECoT 后效果得到了很好的改善。

ECoT 还提出了一套使用机器人数据产生 CoT 训练数据的 Pipeline。具体就不多说了，图里面说的很清楚。

这种推理过程是显式的，具有一定的解释性，缺点就是这样会降低推理的速度，文中也给了一些解决方案。

VoxPoser

VoxPoser 是一种 Code for Robotic 的方法。简单的来说，VoxPoser 使用 LLM 去生成 Python 代码，这里的代码会调用 VLM 的 API 生成 3D Value Map，然后进行 MPC。

首先，VoxPoser 会告诉 LLM 任务的文本描述以及一些 VLM 具有的 API函数，让它去产生能够基于 RGB-D 图像计算 3D Value Map 的 Python 代码。然后，使用 Python 执行器去执行代码，过程中会调用 VLM 的 API，其实就是 OWL-ViT 获取边框还有 SAM 获取 Mask，然后重建 3D Points Cloud，计算得出 3D Value Map。最后，有了 3D Value Map 作为价值引导，就可以使用 MPC 的方法合成轨迹，进行规划。在文中，提供了在线训练 MPC 以及启发式 MPC 两种方式，前者需要环境交互，后者则无需训练。

PIVOT

PIVOT 的思想很简单，就是把机器人的低级 Action 投影到图像中，并采用 VQA 的形式让 VLM 去选择 Action 集合。

PIVOT 维护一个 Action 的分布，初始化为均匀分布，有点像 MPC 中的交叉熵方法。 PIVOT 使用的是 Zero-Shot 的迭代算法，不断去优化 Action 的分布，直到收敛。首先，PIVOT 从分布中采样一系列的 Action，然后将 Action 投影到 2D 图像上，详细见图，每个 Action 都对应了序号。然后，给定任务描述文本以及 2D 图像，编写合适的 Prompt 让 VLM 去选择最优 Action 集合。接着，根据选取的 Action 集合去维护 Action 分布，类似于 MPC 中的交叉熵方法。经过不断迭代，可以得出较好的 Action 候选集合。

PIVOT 的思路很有启发性，但缺陷也是明显的。比如，3D 歧义理解、细粒度控制以及 VLM 的幻觉问题。

Code As Policies

CaP 核心思想不是训练策略网络，而是通过 Prompt 让 LLM 去调用机器人 API，从而完成任务。

首先，CaP 进行了 LMP 形式化，其实就是让策略利用 Python 语言的一些特性。然后，为了处理复杂任务代码过长或者逻辑复杂的问题，CaP 使用了层次化代码生成的方法，其实就是自下而上分而治之的思想。最后，CaP 进行了感知与动作的对齐。 LLM 会基于 Prompt 得出一些预定义的感知 API 以及控制 API。 LLM 可以通过感知 API 去获取视觉信息的变量。 LLM 会计算控制 API 的参数，并执行。

CaP 的工作虽然简单，但它将高层规划和底层执行联系在了一起。

RoboPoint

RoboPoint 通过构建一套程序化合成数据生成流水线，将通用视觉语言模型（VLM）微调为能根据自然语言指令预测精确 2D 空间操作点（Spatial Affordance）的模型，从而实现了无需真实世界数据训练的机器人零样本（Zero-shot）操控与导航。

在数据生成阶段，RoboPoint 利用程序化生成技术构建多样化的 3D 仿真场景，通过利用模拟器中的精确几何信息自动计算物体间的空间关系，并创造性地采用“移除目标物体再采样”的策略来自动标注自由空间（Free Space），从而低成本地生成了海量包含“图像-指令-像素坐标点”的高质量合成训练数据。

在指令微调阶段，RoboPoint 套用 LLaVA 的架构，冻住视觉层只练语言模型，把“找坐标”直接转化成“文本生成”任务，让模型直接输出坐标数字同时，为了防止了 VLM 的遗忘，加入了 VQA 数据进行 Co-Training。

在真实执行阶段，先使用 RoboPoint 计算出 RGB 图像上的 2D 坐标，然后结合深度图转换为 3D 坐标，最后直接套用一个预设好的抓取姿态，把目标传给传统的运动规划算法去解算路径，机械臂照做就行了。

RoboPoint 其实也是一种高层决策的规划，也是一种 System 2 的方法。

GR-1

GR-1 证明了视频生成是策略学习的高效代理任务，它通过大规模视频生成式预训练迫使 GPT 模型内化环境动态与物理先验，从而在下游机器人任务中实现了卓越的小样本学习与零样本泛化能力。

GR-1 采用 GPT-style Causal Transformer 架构处理多模态交织序列，先通过大规模视频生成预训练学习环境动态，再经由动作与未来帧联合预测任务进行微调，实现端到端的自回归策略学习。

在预训练阶段，GR-1 利用大规模人类第一视角视频数据集（Ego4D）执行语言条件下的视频预测任务，旨在无需动作标注即可习得通用物理动态。模型架构上冻结了 CLIP 文本编码器与 MAE-ViT 视觉编码器（辅以 Perceiver Resampler 压缩特征），将语言指令、历史图像帧与可学习的 [OBS] Token 交织输入至 GPT 主干网络。训练过程中，模型屏蔽 [ACT] Token，仅通过因果掩码注意力机制利用 [OBS] Token 驱动视觉解码器（Vision Decoder）重建未来帧像素，从而迫使模型内化视觉演变规律与视语对齐关系，为下游机器人操作任务提供具备强泛化能力的 World Model 初始化权重。

在微调阶段，GR-1 加载预训练权重并扩展输入序列，将机器人本体状态（Proprioceptive State）与语言、图像交织输入，引入 [ACT] Token 用于回归 7-DoF 机械臂动作与夹爪状态。训练采用多任务联合优化策略，在执行行为克隆（Behavior Cloning）学习策略分布的同时，保留未来帧预测（Video Prediction）作为辅助任务，通过联合最小化动作回归损失与图像重建损失，迫使策略在决策时显式利用预训练阶段习得的物理世界动态（World Model），从而实现感知到动作的高效迁移与对齐。

GR-1 的 Limitation 也是明显的。因为要处理高维图像，所以导致推理延迟较高。同时预训练的人类视频与机械臂控制之间存在形态鸿沟（Embodiment Gap），目前仅依靠微调隐式对齐而缺乏显式的动作重定向机制。

HPT

HPT 使用一种模块化 Token 对齐机制将异构机器人的 Proprioception 与 Vision 映射到共享潜空间到通用策略架构，并在大规模 Cross-Embodied 数据上验证了机器人策略学习的 Scaling Laws 以及迁移能力。

HPT 采用了一种高度模块化的 Stem-Trunk-Head 设计范式来解决 Cross-Embodied 难题。

在 Stem 模块中，利用 Cross-Attention 将异构的 Proprioception 与 Vision 对齐到统一的 Embodied 潜在表征。首先，机器人的 Vision 信息被编码成 Cross-Attention 中的 K 与 V，并与一组可学习的 Q 进行聚合得出 Vision Token。同样，机器人的 Proprioception 也经过相同的操作，得出 Proprio. Token。不同的 Embodied 对应了不同 Stem，是分别进行学习的。

在 Trunk 模块中，所有 Embodied 任务共享一个 Transformer，负责将 Stem 对齐后的多模态 Token 进行深度融合和推理。最终，经过池化后得出最终 Latent。

在 Head 模块中，负责将 Trunk 得出 Latent 进行解码，这里的解码器可以是 MLP、DP 以及 ACT，得出机器人的 Action。请注意，异构的机器人分别对应了不同的 Head。

在训练数据上，HPT 使用 OXE、Simulation 以及 Human Videos 等。 HPT 使用了最暴力的 BC 方法，证明了其 Scaling Law 的存在。

RoboDual

RoboDual 的整体架构由负责 High-level 决策的 Generalist 与负责 Low-level 决策的 Speicalist 组成。其中，Generalist 是类似于 OpenVLA 的 VLA 模型，虽然具有一定的泛化能力，但推理效率比较低。而 Specialist 是一种类似于 ACT 或是 DiT 的决策模型，在特定领域上有比较好的效果，且推理效率高，但难以适应新的任务环境。 RoboDual 做的事情就是将两者结合在一起，Generalist 负责 High-level 的任务规划，而 Specialist 进行 Low-level 的实时决策。

RoboDual 的具体实现很简单，就是将 Generalist 归纳出的 Task Latent 与 Action Latnet 作为 Specialist 的 Condition，然后让 Specialist 输出 Action Chunk。在文章中，Generalist 是 OpenVLA 架构，Specialist 是 DiT 架构。由于 Generalist 和 Specialist 的推理效率不同，RoboDual 在推理过程中使用双线程的方式，即 Generalist 和 Specialist 分别使用独立的线程。在实际的使用中，Specialist 拿到的 Generalist 的提示总是有延迟的。因此，RoboDual 在实际训练中采用了延迟感知训练的 Trick。

实际上，RoboDual 在对 OpenVLA 进行了一定修改，让其输出 Action Chunk。因此，Specialist 是有一段比较粗略的动作轨迹作为指导的，它只是进一步地细化这段动作轨迹，相当于 Specialist 对 Generalist 的输出结果进行插值。

GR-2

GR-2 的思路和 GR-1 的一样，只是扩展了更多的优质数据集。具体做法分为两个阶段。首先，在大规模的 Web 级别的 Video 数据集预训练一个 World Model。然后，在机器人数据上进行微调，得出一个 End-to-end 的 VLA 模型。

Humanoid Manipulation

{/* 这篇工作对 DP3 进行改进，并将其应用到通用机器人操作任务。 /} {/ 该研究使用 Fourier GR1 作为实验平台，并固定住双腿，以确保稳定性。 /} {/ 在数据采集方面，使用了遥操作收集。 /} {/ 观测主要包含了 Camera 的 3D 点云以及机器人本体感知。 /} {/ 在策略学习中，因为机器人的 Camera 并不是固定的，所以该研究提出了 iDP3，也就是以 Camera 作为参考系去调整 3D 点云的坐标，以适应任务环境。 /} {/ 同时，使用卷积去代替 MLP 处理视觉信息会更加的平滑。 /} {/ 最后，延长预测时域使得策略更加的平稳一致。 */}

这项工作对 DP3 算法进行了针对性改进，目的是让其能更好地服务于通用机器人的操作任务。研究使用了 Fourier GR1 作为实验载体，为了保证操作过程中的绝对稳定，机器人的双腿被固定住，数据则通过遥操作的方式进行收集。系统的输入端主要包含相机的 3D 点云以及机器人的本体感知数据。在策略学习阶段，作者注意到机器人的相机并非固定不动，因此提出了名为 iDP3 的新方法，即以相机自身作为参考系去标准化 3D 点云的坐标，以此适应动态的任务环境。此外，为了让视觉信息的处理更加平滑，算法使用卷积层代替了传统的 MLP。最后配合延长的预测时域，成功使得机器人生成的策略动作更加平稳和连贯。

Surfer

Surfer 提出了一个基于世界模型（World Model）的架构，旨在通过接收历史图像帧（History Frames）、语言指令（Instruction）以及机器人的本体感知信息（Proprioception）来预测下一步的动作（Action）及执行后的未来帧。在多模态特征编码方面，Surfer 采用了高效的处理策略：对于视觉输入，利用冻结的 CLIP 编码器将图像帧转化为 Tokens，并引入 TokenLearner 进行压缩以提升推理效率；对于文本输入，使用冻结的 Text Encoder 提取 Text Latent；对于本体感知信息，则通过 MLP 编码得到 Proprio Latent。

Surfer 的世界模型主体由两个基于多层 Transformer 的模块构成，分别负责动作预测与场景预测。在动作预测模块中，模型以历史帧的 Visual Tokens 作为 Query，将拼接后的 Text Latent 和 Proprio Latent 作为 Key 和 Value，通过 Cross-Attention 机制生成当前时间步的 Action。随后，帧预测模块复用历史帧 Tokens 作为 Query，并将刚刚预测出的 Action 作为 Key 和 Value，同样利用 Cross-Attention 推导出执行动作后的未来帧 Tokens，并采用 L2 Loss 进行监督训练。

总结来看，Surfer 的核心亮点在于引入了未来帧预测作为动作决策的辅助监督信号。这种设计符合直觉：如果模型生成的动作能够准确预测出环境的未来状态，说明该动作决策本身是符合物理逻辑的。然而，这种方法的局限性也显而易见：一旦帧预测模块不够准确，错误的预测反而会引入噪声，形成负面监督。此外，该工作尚未验证模型在 Scaling up（扩大规模）后的表现，其在大规模数据下的潜力仍有待探索。

{/* Surfer 构建了一个 World Model，以历史 Frame、语言 Instruction 以及机器人感知 Proprio 为输入，输出下一步的 Action 以及 Frame。 /} {/ 在 Vision 处理方面，Surfer 使用用冻结的 CLIP 将 Frame 处理成 Tokens，并使用 TokenLearner 对这些 Tokens，以提高推理效率。 /} {/ 在 Text 处理方面，Surfer 使用冻结的 Text Encoder 处理成 Text Latent。 /} {/ 在 Proprio 处理方面，Surfer 使用 MLP 去学习得出 Proprio Latent。 /} {/ /} {/ Surfer 的 World Model 分为两个部分，分别负责预测当前时间步的 Action 以及执行后的 Frame。 /} {/ 这两个部分都是由多层的 Transformer 模块组成。 /} {/ 在 Action 预测模块，使用经过 CLIP 处理的历史 Frame Tokens 作为 Query，[Text Latent, Proprio Latent] 作为 Key 和 Value，经过 Cross-Attention 得出 Action。 /} {/ 在 Frame 预测模块，使用经过 CLIP 处理的历史 Frame Tokens 作为 Query，预测的 Action 作为 Key 和 Value，经过 Cross-Attention 得出执行 Action 后的 Frame Tokens，并使用 L2 Loss 来进行训练。 /} {/ /} {/ 小结一下，Surfer 的亮点在于使用未来的 Frame 作为训练 Action 决策的监督信号，这相当于就是说如果执行这个 Action 能够预测出未来的 Frame，那么我的预测就是合理的，相当的符合直觉。缺点也是明显的，如果 Frame 预测得不准，那么这种监督反而还是一种负面的，且 Surfer 并没有验证 Scaling up 后的效果。 */}

SceneVerse

SceneVerse 是一个大型的 3D-VL 数据集，总共包含 2.5M 个场景-语言对，由 ScanNet、ARKitScenes、HM3D、3RScan、MultiScan、Structured3D、ProcTHOR 等多个 3D 数据集集合而成。

为了确保不同数据源之间的一致性，每个 Scan 处理成了 $\mathbb{R}^{N \times 8}$ 的维度，分别为 3D 坐标、RGB 颜色、实例 ID 和语义标签定义。首先，SceneVerse 将 3D 场景建模为 Graph，Object 为 Node，Object 之间的空间关系被建模为 Edge。接着，SceneVerse 使用一种基于 Prompt 的 Pipeline 方法去生成不同纬度的 Caption，详细见图。

最后，SceneVerse 训练了一个叫 GPS 的 Transformer，用于对齐 3D 场景和文本信息，类似于 3D 领域中的 CLIP。 SceneVerse 的工作量还是很足的，值得肯定。

Robot See Robot Do

Robot See Robot Do 是一种 Pipeline 方法，用于完成 Articulated Object Manipulation 任务，只需单目人类示例即可完成学习。

RSRD 分为 See 和 Do 两个部分。在 See 的过程中，首先对静态 Object 进行特征学习。具体流程如下，基于环绕待操作 Object 的视频，先使用 3D Gaussian Splatting 转换为 3D 点云，再使用 GARField 对点进行聚类，最后使用 DINOv2 学习点的特征表示。

最后，从人类演示视频中，反解出这每个部件在每一帧的 3D 位姿。具体流程如下，首先对每时间步可优化的部件姿态参数渲染出 DINO 特征和深度，并与输入帧中提取的 DINO 特征和单目深度进行比较。然后，使用 ARAP 损失惩罚高斯分布偏离其初始配置过远的情况，相对于邻近点。这些损失共同反向传播至部件姿态，并通过梯度下降进行优化，以恢复 3D 部件运动。在 Do 的过程中，则将物体的运动轨迹映射到机器人的操作中去。

Robot See Robot Do 的方法虽然无需训练，但无法进行泛化，只能做一些简单的任务。

ReKep

来自斯坦福大学李飞飞团队（一作 Wenlong Huang）的这项工作提出了 ReKep 框架，通过利用视觉语言模型（VLM）将自然语言指令转化为基于语义关键点的 Python 时空约束函数，并结合实时优化求解器，实现了无需特定任务训练即可完成多阶段、双臂协同及动态响应的复杂机器人操作任务（如倒茶、叠衣服）。

Rekep 是一种 Pipeline 方法，主要分为「关键点提取」、「约束生成」以及「优化求解」。在「关键点提取」阶段，Rekep 采用了 DINOv2 和 SAM 提取 Frame 中的关键点。在「约束生成」阶段，Rekep 将带有关键点覆盖的 Frame 以及文本指令输入到 GPT-4o 中，让其输出 Python 代码，以计算约束。在「优化求解」阶段，Rekep 采用分层优化求解的形式，使用「寻找子目标」和「规划路径」两种优化结构。

Rekep 比较的工程，像是各种模型的结合体，在实现上也比较合理，是一篇合格的工作。

OmniManip

OmniManip 的设计逻辑围绕「如何将自然语言转化为稳健的物理约束」展开。该系统并非试图让模型学会复杂的控制律，而是通过构建一个“对象中心”的规范坐标系，让模型在最适合描述物体功能的空间内进行推理。这张图展示了 OmniManip 系统的整体架构图，可以将其分为三个主要阶段：任务感知与分解阶段：数据流的起点是用户的自然语言指令（如 "Pour tea into the cup"）和摄像头捕获的 RGB-D 原始图像。首先，系统使用 VFM 进行物体锚定（Object Grounding），具体做法是先用 Grounding DINO 计算得出 Object 的 Bounding Boxes，再使用 SAM 对 Object 生成像素级的 Mask。随后，系统使用 VLM 进行任务划分（Stage Partitioning），根据 VLM 的知识将任务分解为多个阶段（Stages），每个阶段都明确了动作类型以及主动物体（Active）和被动物体（Passive）的角色分配。例如，在“倒茶”任务的第一阶段，主动物体是机器人夹持器，被动物体是茶壶，动作是“抓取”；而在第二阶段，主动物体变为茶壶，被动物体变为茶杯，动作变为“倾倒” 。这种基于物体的角色分配为后续提取交互原语奠定了逻辑基础。

对象中心交互原语提取阶段：这是系统的核心，旨在将语义指令转化为精确的几何约束。首先，系统利用 3D AIGC 技术从单图生成物体的 3D 网格模型，再通过 6D 姿态估计器（6D Pose Estimator）确定物体当前的位姿，并将其映射到功能性的「规范空间」中，使后续的推理具有视角无关性。随后，系统使用 VLM 提取交互原语，也就是在规范空间内识别出关键的交互点（如壶嘴、壶柄、杯口）和交互方向（如壶嘴喷出的轴线），上图展示了其中的技术细节。左图展示了系统如何从 2D 图像中确定 3D 空间中的关键交互位置。系统将交互点分为「可见且可触及」（Visible and Tangible，如壶柄）和「不可见或不可触及」（Invisible or Intangible，如杯底中心或被遮挡的部分）两类。为了帮助 VLM 克服 3D 感知不足，系统借助了 SCAFFOLD 提示机制，也就是在图像上覆盖了一层笛卡尔坐标网格（点阵），这样 VLM 就可以通过网格坐标来精确定位目标点位。对于不可见的点，系统引导模型通过主视角定位，并结合正交视角（Orthogonal View）的几何关系来推断其在 3D 空间中的确切深度和位置。右图详细解释了系统如何从无数种可能的动作角度中筛选出最合适的一个。系统不再进行全空间搜索，而是首先提取物体在规范空间中的主几何轴线作为候选方向（图中红箭头所示）。 VLM 会为每一个候选轴生成具体的自然语言描述（Captioning），例如「该轴穿过茶壶中心并垂直于注水口」。大语言模型（LLM）接收这些语义描述，并根据当前任务（如「倒茶」）的需求对各个轴进行相关性评分。最终输出一个排序列表，分值最高的轴（靠近 1）将被选定为执行任务的空间约束方向。最后，系统将实现闭环规划。系统基于 VLM 去生成具体的空间约束（CONSTRAINTS），例如「主动轴与被动轴对齐」或「点间距小于 5cm」。并基于 RRC 机制，根据生成的约束去预先渲染一张模拟交互后的 Frame，并使用 VLM 去 Checking 这张 Frame，如果不合理就重新采样，直到成功。

在线轨迹规划与执行阶段：系统将逻辑约束转化为物理运动的执行过程。系统根据上一阶段确定的几何约束，实时求解一个优化方程。该方程同时考虑了约束损失（确保动作对齐）、避障损失（防止碰撞）和平滑损失（确保运动不突兀）。在执行过程中，系统输出一系列末端执行器的位姿序列，驱动机器人动作。同时，6D 位姿追踪器（6D Pose Tracker）持续监测物体的实时位置。如果物体发生了意外移动，追踪器会将最新的位姿反馈给优化算法，动态更新动作，从而实现极高的鲁棒性。

OmniManip 结合了之前 ViLA、VoxPoser、ReKep、CoPa 等多项技术的优势，提出了一个从语义理解到物理执行的完整解决方案。通过对比可见，OmniManip 的先进性主要体现在将「高级常识验证」与「底层姿态优化」通过「对象中心表示」深度耦合，从而在保证通用性的同时，显著提升了执行的确定性和精度。

SOFAR

SOFAR 通过引入「语义取向」概念，将自然语言指令直接映射为 3D 空间中的几何取向向量，揭示了通过「语义-几何」深度对齐来实现具身智能开放世界 6-DoF 精细操控的核心路径。为了训练模型理解「语义取向」，SOFAR 构建了一个大规模的「语义-几何」对齐数据集，名为 OrienText300K。该数据集基于 VLM 与 Objaverse 生成，包含了 350K 个物体配对的语义取向标签。OrienText300K 的数据由三元组 [3D 网络模型, 语言描述, 语义取向] 构成，其中语义取向表示为语言描述对应的单位方向向量。随后，SOFAR 基于 OrienText300K 训练了一个名为 PointSO 的 Transformer 模型，专门用于从自然语言指令和 3D 点云中预测对应的语义取向向量。由于原始点云数据量巨大，PointSO 使用最远点采样（FPS）方法将点云压缩为若干关键点，并使用 K-最近邻（KNN）算法为每个关键点寻找相邻的点，形成局部点云块（Patches）。在语言嵌入方面，PointSO 使用冻结的 CLIP 文本编码器将输入的自然语言指令转化为全局文本 Token。在 Fusion 方面，PointSO 没有采用复杂的交叉注意力，而是直接将文本 Token 投影到与几何 Token 相同的维度后，进行逐 Token 相加（Token-wise Addition）。这种策略能更有效地将语义偏置注入到每一个几何局部表征中。最后，PointSO 通过一个 MLP 层将融合后的特征映射到一个单位向量空间，输出最终的语义取向向量。 SOFAR 的工作流水线展示了从非结构化视觉输入到结构化控制输出的完整过程。首先，系统接受 RGB-D 图像以及用户自然语言指令作为输入。然后，系统使用 VLM 解析得出物品列表 (Object List) 以及取向信息提示 (Orientation Info)，这样可以将抽象的人类意图分解为具体的处理对象和语义约束，为后续的感知模块提供指引。接着，系统使用 VFM 进行物品锚定，具体做法是先用 Florence-2 得出物品的 Bounding Boxes，再使用 SAM 生成物品 Mask，并使用相机内参将 2D 坐标转换为 3D 点云。随后，系统将自然语言指令与点云输入到预训练的 PointSO 模型中，预测得出语义取向向量。最终，系统将这些信息整理成 JSON 格式的场景图以及标记图像 (Annotated Image)，以便 VLM 可以高效阅读和处理，后面就是常规的基于 VLM 的 Task Planning 或是 Manipulation 了。

SOFAR 通过语义取向实现 6-DoF 对齐，其自动标注方案极具启发性。但流水线解耦易导致误差累积（占比约 74%），且 5° 精度与 8.5s 延迟制约了高精度实时任务的应用，仍需闭环优化。

PIVOT-R

PIVOT-R 是 Surfer 的改进版本，通过引入原语建模航点（Primitive-modeled Waypoints）强化了物理逻辑，并使用异步多模型架构完成任务拆解、场景预测和动作预测，从而提升了复杂机器人操作任务的执行效率和鲁棒性。

PIVOT-R 系统基于异步分层执行器（AHE），并通过三条并行的模块实现高效推理。首先，原语解析模块接受用户自然语言指令和当前视觉观察，并使用预训练的 VLM 结合 Prompt 对场景进行语义理解，并将抽象指令转化为具体的动作原语（如「接近目标」或「抓取」）。接着，航点感知模块接受动作原语以及历史视觉观察，分别使用 Text Encoder 和 Image Encoder 进行嵌入，经过特殊设计的 Cross-Attention 模块进行融合，最终预测完成动作原语后的 Frame。最后，动作预测模块接受当前视觉观察特征、经过 MLP 投影的历史机器人状态以及源自航点感知模块的未来帧特征，经过 Cross-Attention 机制生成当前时间步的动作输出。这三个模块之间通过异步执行器进行协调，允许它们以不同的频率独立更新，从而提高系统的响应速度和效率。

不同于 Surfer 逐帧对环境建模导致计算冗余，而 PIVOT-R 仅聚焦关键「航点（Waypoints）」，有效过滤了噪声并捕捉了本质物理逻辑。同时，凭借异步分层执行器（AHE），PIVOT-R 实现了 28 倍的推理效率提升，解决了 Surfer 难以实时部署的痛点。总得来说，是篇不错的改进工作，但仍然存在一些局限性，如对航点的定义和选择依赖较大，且在复杂场景下可能仍会面临误差累积的问题。

ManipGen

ManipGen 是一种基于局部策略空间不变性的框架，旨在实现长程操纵任务 sim2real 的零样本迁移。这张流程图展示了 ManipGen 框架的三个核心阶段：从大规模仿真专家获取，到通用视觉策略蒸馏，最后到零样本长程任务部署。在第一阶段，ManipGen 引入大规模 3D 模型数据库，并使用最远点采样（FPS）提取关键点，同时结合 Affordance 信息确定交互区域，最后在仿真环境中利用「特权信息」使用 RL 训练大量的「专家策略」，并得出大量的「专家经验」。在第二阶段，由于特权信息在现实中不可得，此阶段利用多任务 DAgger 算法将专家经验「蒸馏」给仅依赖视觉的通用模型。该策略接受来自腕部相机的实时 RGB-D、初始 RGB-D、物品分割 Mask 以及机器人本体感知作为输入，经过 ResNet18 以及 MLP 处理后输出动作。在第三阶段，ManipGen 使用 VLM 接受自然语言指令和全局视图，并解析为一系列的 [object, skill] 元组。对于每个元组，使用 Neural MP 计算从当前位置到目标物体交互区域的避障轨迹。到达目标区域后，则激活阶段二中「局部策略」，完成具体的交互动作。不断重复这一过程，直到完成整个长程任务。

ManipGen 展现了很典型的 sim2real 思路，通过局部策略的空间不变性实现了长程操纵任务的零样本迁移。其创新点在于引入了「特权信息」来训练专家策略，并通过多任务 DAgger 将其蒸馏给视觉模型，从而克服了 sim2real 中的感知鸿沟。然而，该方法仍然依赖于高质量的仿真数据和专家策略的有效性，在复杂环境下可能面临泛化能力不足的问题。

DemoGen

DemoGen 是一种基于 One-shot 人类演示生成大规模合成演示数据的框架，其核心思想是将机器人轨迹分解为多段 Skill Segments 和 Motion Segments，并利用点云在空间中的等变性以及连接性质来实现从单一演示到大规模数据的生成。DemoGen 的方法分为以下几个阶段。

源演示的感知与语义解析。首先，DemoGen 方法接收一段使用单目 RGBD 相机记录的源轨迹作为输入，并使用一系列的点云预处理方法降低噪声与冗余。接着，DemoGen 使用 Grounded SAM 模型对点云进行分割，将点云划分为 Object Clusters 和 Effector Clusters。随后，DemoGen 根据 Effector 与 Object 几何中心距离将轨迹分解为 Skill Segments（机器人与物体接触的部分）和 Motion Segments（机器人在空中运动的部分）。基于 TAMP 的动作轨迹迁移。针对一个新的场景，DemoGen 通过计算变换矩阵将源轨迹中的 Object Cloud 映射到新场景中的 Object 位置。同时，DemoGen 对 Skill Segments 进行迁移，保持机器人与物体的相对位置关系不变。针对 Effector 操作 Object 的过程，其 Object Cloud 会与 Effector Cloud 进行绑定，确保在迁移过程中保持一致的交互关系。对于 Motion Segments，DemoGen 则通过调用运动规划器（如 RRT-Connect）在 SE(3) 空间中重新规划轨迹，生成无碰撞的运动路径。

根据上述流程，DemoGen 能够从单一的人类演示中生成大规模的合成 3D 演示数据，从而为机器人学习提供丰富的训练样本。最终，DemoGen 训练了 DP3 模型，并在多个长程操纵任务中验证了其生成数据的有效性和泛化能力。局限也很明显，DemoGen 提出的几何平移假设难以建模复杂的非刚性交互，比如布料操作或液体处理等任务。

ArticuBot

ArticuBot 是一种 Sim2Real 方法，主要贡献了一个对 Articulation Object 操作的仿真数据生成方案，以及一个基础的分层策略模型。仿真演示生成。ArticuBot 在仿真环境中引入了 PartNet-Mobility 数据集，使用 Franka 机械臂生成示范数据。进一步，ArticuBot 将轨迹分为三个阶段。首先是「Grasp Sampling」，给定 Articulation Object，利用标注获取连接件 Point Cloud 的，并使用采样方法生成多个抓取候选点。接着是「Motion Planning」，有了抓取候选点，那么就可以使用运动规划器（如 RRT-Connect）在 SE(3) 空间中生成无碰撞的运动轨迹。最后是「Opening Action」，在前两个阶段的基础上，可以计算末端执行器的位姿序列，完成对 Articulation Object 的操作。这一阶段最终输出了 4.23 万条高质量的演示轨迹（Observation-Action Pairs）作为后续学习的基石。

分层策略学习。ArticuBot 的策略模型采用了分层设计，分为 High-level Policy 和 Low-level Policy 两个层次。 High-level Policy 负责预测「机器人应该移动到何处」，ArticuBot 使用了一种 Weighted Displacement Model，接受分割后的 Object Point Cloud 为输入，输出末端子目标位姿 (Predicted Sub-goal eef)。 Low-level Policy 则负责预测「如何使用末端执行器去解决任务」，ArticuBot 使用了 DP3 模型，接受多源输入，最终输出一系列的 Action。

LAPA

LAPA 是一种基于 Latent Action 的 VLA 预训练方法，旨在通过引入一个中间的 Latent Action 表征来指导 VLA 模型的学习，从而提升其在复杂任务中的表现和泛化能力。首先，LAPA 采用大量无动作标签的视频数据进行预训练，使用一个专门设计的 VQVAE 模型来学习从视觉输入到 Latent Action 的映射关系。 Latent Action 被设计为多个离散的变量序列，和 Dreamer 一样类似。接着，很容易将 data 处理为 [Frame, Instruction, Latent Action] 的形式，用于去训练 VLLA 模型，其实就是在 VLM 的基础接上一层 MLP 去预测 Latent Action。具体训练细节为，冻结视觉编码器，只微调主干和后续的 MLP 层。最终，LAPA 使用机器人数据进行微调，将 Latent Action 的 MLP 层替换为直接预测机器人 Action 的 MLP 层。同样，也是冻结视觉编码器，只微调主干和后续的 MLP 层。后续的 GR00T 工作就是在 LAPA 的基础上，扩展了更多的优质数据集。

GR00T

GROOT N1 是继承了 LAPA 思想的工作。该研究将异构训练语料库构建为一个金字塔结构，特点是从底层到顶层，数据量逐渐减少，但针对性逐渐增强。在数据金字塔最底层，这些数据包含了基础常识与视觉先验。例如，包括了 Reddit、Wikipedia、Common Crawl 等的互联网规模 Web 数据，以及包括了 Ego4D、EPIC-KITCHENS、HOI4D 等的人类视角视频。在数据金字塔中层，主要是一些多样性增强与合成轨迹的数据。例如，GROOT 使用 DexMimicGen 系统，在 RoboCasa 等物理引擎中生成的合成轨迹，以及使用视频生成模型（如 WAN2.1）扩充的 Counterfactual 视频数据。在数据金字塔顶层，则是一些真实的机器人数据。例如，GROOT 使用了 OXE 以及 AgiBot-Alpha 数据，这些都是源自真实机器人操作的高质量数据集。

GROOT N1 采用 PI-like 架构，虽然文中说是 Double System，但实际上只是个快慢 System，和 RoboDual 的双线程有点类似。在预训练阶段，GROOT N1 实现了异构数据对齐。针对无标签数据，GROOT N1 采用了 LAPA 的思想，使用 VQ-VAE 去编码 Latent Action，并作为监督信号。同时，对于视频生成模型产生的神经轨迹，GROOT N1 采用逆动力学模型去还原 Action。而对于那些带有动作标签的数据，则直接使用动作标签作为监督信号。

RL笔记（27）：MARL 最后的波纹 (MAT & HASAC)

Mon, 05 Jan 2026 00:00:00 GMT

引言（Introduction）

在之前的笔记中，我们看到了 MARL 的发展脉络：

MAPPO：On-Policy，稳定但样本效率低。
HAPPO：引入序列更新，解决了异构和单调性问题，但仍是 On-Policy。
Decision Transformer：将单智能体 RL 变成了序列预测。

本章将介绍两个集大成者：

MAT (Multi-Agent Transformer)：将 "Transformer" 和 "序列决策" 引入 MARL，把多智能体博弈变成了一个自回归（Auto-Regressive）的序列生成问题。
HASAC (Heterogeneous-Agent SAC)：将 HAPPO 的 "序列更新理论" 应用于 SAC，打造出兼具理论保证和极高样本效率的 Off-Policy 算法。

Multi-Agent Transformer (MAT)

论文：Multi-Agent Reinforcement Learning is a Sequence Modeling Problem (NeurIPS 2022)

核心思想：把“并发”变成“串行”

传统 MARL（如 QMIX, MAPPO）假设所有智能体在同一时刻同时采取行动，联合动作分布为 $\pi(\mathbf{a}|s) = \prod \pi(a^i|s)$（假设独立）。

MAT 提出了一种颠覆性的视角：联合策略可以分解为序列预测。利用概率链式法则，联合动作的概率可以写成：

$$ \pi(\mathbf{a}|s) = \prod_{i=1}^n \pi(a^i | s, a^1, a^2, ..., a^{i-1}) $$

这意味着：Agent 1 先动；Agent 2 看到 Agent 1 的动作后再动；Agent 3 看到 1 和 2 的动作后再动…… 这与 Transformer 的自回归生成（预测下一个单词）完全一致！

架构设计：Encoder-Decoder

MAT 使用了标准的 Transformer 架构：

Encoder（处理观测）：
- 输入：所有智能体的局部观测序列 $(o^1, o^2, ..., o^n)$。
- 作用：利用 Self-Attention 提取智能体之间的交互特征，生成联合状态表征。
Decoder（生成动作）：
- 输入：Encoder 的输出 + 之前的智能体动作序列 $(a^1, ..., a^{i-1})$。
- 输出：当前智能体 $i$ 的动作概率分布 $\pi(a^i | \dots)$。
- 机制：类似于 GPT，通过 Masked Attention 确保智能体 $i$ 只能看到它之前的队友动作，看不到未来的。

训练目标

MAT 使用 PPO 的目标函数进行端到端训练。

$$ L(\theta) = \min(r_t(\theta) \hat{A}_t, \text{clip}(r_t(\theta), 1-\epsilon, 1+\epsilon)\hat{A}_t) $$

优势：这种序列化建模天然地解决了非平稳性问题。对于 Agent $i$ 来说，它做决策时，队友 $1 \sim i-1$ 的动作已经是已知的（Fixed），环境不再是“薛定谔”的。
性能：MAT 在 SMAC 等基准测试中展现了惊人的性能，尤其是在需要复杂协调的任务中，且具有极强的 Zero-Shot 泛化能力。

Heterogeneous-Agent SAC (HASAC)

论文：Trust Region Policy Optimization in Multi-Agent Reinforcement Learning (ICLR 2022) 注：HASAC 是该论文提出的 HARL (Heterogeneous-Agent RL) 框架下的 Off-Policy 变体。

核心动机：效率至上

HAPPO 虽然理论完美（保证单调提升），但它是 On-Policy 的，数据利用率低，训练慢。 SAC 是单智能体中样本效率最高的 Off-Policy 算法。 HASAC = HAPPO 的序列更新理论 + SAC 的最大熵 Off-Policy 机制。

算法原理

HASAC 继承了 HAPPO 的 多智能体优势分解引理：

$$ A_{\boldsymbol{\pi}}^{\text{joint}}(s, \mathbf{a}) = \sum_{i=1}^n A_{\pi}^{i}(s, a^i, a^1, ..., a^{i-1}) $$

训练流程

随机排列：每一轮训练，随机打乱智能体更新顺序（例如 $1 \to 2 \to \dots \to n$）。
序列更新：
- 对于智能体 $i$，它的 Critic $Q_i$ 需要评估的是：在队友 $1 \sim i-1$ 已经更新了新策略，而队友 $i+1 \sim n$ 还在用旧策略的情况下的价值。
- 目标函数结合了 SAC 的熵正则化： $$ J(\pi^i) = \mathbb{E}{\mathcal{D}} \left[ Q^{\pi{\text{old}}}(s, a^1, ..., a^i, ..., a^n) - \alpha \log \pi^i(a^i|s) \right] $$
- 关键点：在计算 $Q$ 值时，输入的动作向量 $\mathbf{a}$ 是混合的：
  - $a^{1:i-1}$ 来自当前最新的策略。
  - $a^{i}$ 是当前正在优化的。
  - $a^{i+1:n}$ 来自旧策略（Replay Buffer 中的动作或旧策略采样）。

优缺点

优点：
- 极高的样本效率：Off-Policy 机制让它可以利用历史数据。
- 异构友好：不需要参数共享，适合不同类型的智能体协作。
- 收敛保证：继承了 HARL 的单调性证明。
缺点：计算复杂度较高，因为需要串行更新每个智能体，且 Critic 需要处理混合动作输入。

深度对比：四大天王

至此，我们已经集齐了 MARL 领域的四大顶级算法。

总结

如果你追求极致的性能和对复杂策略的建模能力，MAT 是首选，它代表了 RL 与 LLM 结合的趋势。
如果你追求训练速度和样本利用率，或者你的智能体是异构的（比如一个无人机配合一个机械臂），HASAC 是目前的最强选择。

RL笔记（26）：异构智能体信任区域优化 (HAPPO & HATRPO)

Sun, 04 Jan 2026 00:00:00 GMT

引言（Introduction）

在之前的笔记中，我们介绍了 MAPPO，它简单地让每个智能体运行 PPO，并共用一个中心化 Critic。虽然在工程上很成功，但它在理论上存在一个巨大的漏洞：

多智能体更新冲突。在单智能体中，PPO/TRPO 保证了每一步更新，策略性能 $J(\pi)$ 都是单调不减的。但在多智能体中，如果所有智能体同时更新策略，这就好比两个人抬桌子，A 想往左，B 想往右，虽然两人各自觉得自己的方向是对的，但合起来的结果可能导致桌子翻倒（联合策略性能下降）。

HAPPO (Heterogeneous-Agent PPO) 和 HATRPO 的核心贡献在于：提出了多智能体优势分解引理，并据此设计了序列更新方案，在理论上证明了联合策略的单调提升，特别适用于异构（Heterogeneous） 智能体场景。

理论基石：多智能体优势分解引理

我们希望优化联合策略 $\boldsymbol{\pi} = (\pi^1, \pi^2, ..., \pi^n)$ 以最大化联合回报 $J(\boldsymbol{\pi})$。类似于 TRPO，我们关注新旧策略的回报差 $J(\boldsymbol{\pi}{\text{new}}) - J(\boldsymbol{\pi}{\text{old}})$。

优势分解引理 (Multi-Agent Advantage Decomposition Lemma)

HAPPO 证明了，联合策略的优势函数（Joint Advantage）可以精确分解为每个智能体局部优势函数的累加，前提是这些优势是按顺序计算的。

$$ A_{\boldsymbol{\pi}}^{\text{joint}}(s, \mathbf{a}) = \sum_{i=1}^n A_{\pi}^{i}(s, a^i, a^1, a^2, ..., a^{i-1}) $$

这里的 $A_{\pi}^{i}$ 是第 $i$ 个智能体的优势函数，但有一个关键细节：它不仅依赖于当前状态 $s$ 和动作 $a^i$，还依赖于排在他前面的智能体 $(a^1, a^2, ..., a^{i-1})$ 的动作。

这意味着：如果我们按照某种顺序 $1, 2, ..., n$ 依次更新智能体，那么整体性能的提升等于每个人贡献的提升之和。

核心机制：序列更新 (Sequential Update)

为了利用上述引理，HAPPO 抛弃了 MAPPO 的“同步更新”模式，采用了 序列更新 模式。

流程

在每一次训练迭代中：

随机排列：随机生成一个智能体的更新顺序（例如：Agent 3 -> Agent 1 -> Agent 2）。
依次更新：
- Agent 3：基于旧策略 $\boldsymbol{\pi}{\text{old}}$ 计算自己的优势，更新策略，变为 $\pi^3{\text{new}}$。
- Agent 1：看到 Agent 3 已经更新了（环境变了），基于 $(\pi^3_{\text{new}}, \pi^1_{\text{old}}, \pi^2_{\text{old}})$ 计算自己的优势，更新为 $\pi^1_{\text{new}}$。
- Agent 2：看到 3 和 1 都变了，基于 $(\pi^3_{\text{new}}, \pi^1_{\text{new}}, \pi^2_{\text{old}})$ 更新自己。
循环结束：所有智能体更新完毕，进入下一轮采样。

为什么这样就稳了？

通过这种方式，对于每一个智能体 $i$ 来说，它在更新时，排在它前面的队友已经是“新策略”了，排在后面的还是“旧策略”。它只需要在当前这个固定的上下文中找到最优提升方向，就能保证整个团队的总分是增加的。

💡 直觉：就像多人过独木桥。大家一起跑容易挤掉下去（同步更新）。HAPPO 的做法是：第一个人先走稳，第二个人看准第一个人的位置再走，依次类推。

HATRPO 与 HAPPO

基于这个理论框架，衍生出了两个算法。它们都共享同一个中心化 Critic $V(s)$。

HATRPO (Trust Region)

这是 TRPO 的多智能体版本。

目标：最大化局部优势期望。
约束：严格限制每个智能体更新前后的 KL 散度： $$ \mathbb{E}[D_{KL}(\pi^i_{\text{old}} || \pi^i_{\text{new}})] \le \delta $$
求解：同样需要使用共轭梯度法（CG），计算量较大，但理论性质最强。

HAPPO (Proximal Policy)

这是 PPO 的多智能体版本，更实用。

目标：使用 Clip 技巧来替代 KL 约束。定义比率 $r_t^i(\theta) = \frac{\pi^i(a^i|s)}{\pi^i_{\text{old}}(a^i|s)}$，损失函数为： $$ L^{HAPPO}(\theta^i) = \mathbb{E} \left[ \min \left( r_t^i(\theta) \hat{M}^i, \text{clip}\left(r_t^i(\theta), 1-\epsilon, 1+\epsilon\right) \hat{M}^i \right) \right] $$
关键点 $\hat{M}^i$：这是修正后的优势函数。在计算 Agent $i$ 的优势时，必须扣除排在它前面的队友 $1, ..., i-1$ 已经拿走的优势，确保不重复计算功劳。

深度对比：HAPPO vs. MAPPO

这两个算法非常相似，都是 PPO + CTDE，很容易混淆。

| 维度 | MAPPO (Multi-Agent PPO) | HAPPO (Heterogeneous-Agent PPO) | | :----------- | :---------------------------- | :---------------------------------------------- | | 更新方式 | 同步更新 (Simultaneous) | 序列更新 (Sequential) | | 理论保证 | 无单调提升保证 (可能震荡) | 有单调提升保证 | | 参数共享 | 强烈依赖 (Parameter Sharing) | 不需要 (天生支持异构) | | 优势计算 | $A(s, a^i)$ (假设队友不变) | $A(s, a^i, a^1, ..., a^{i-1})$ (考虑队友更新) | | 适用场景 | 同质智能体 (如星际争霸小狗海) | 异构智能体 (如牧羊犬与羊、不同类型的机器人) | | 计算量 | 较小 | 稍大 (因为要串行计算) |

总结

HAPPO 系列算法在 MARL 领域具有重要的理论地位：

解决了 Heterogeneous (异构) 问题：以前的算法（如 QMIX, MAPPO）通常假设智能体共享参数以加速收敛。HAPPO 证明了即使每个智能体结构完全不同（异构），只要按顺序更新，也能高效协作。
解决了 Trust Region 问题：它将单智能体的“信任区域”概念成功推广到了多智能体，解决了多智能体同时更新导致的环境非平稳和信度分配难题。

如果你面对的任务中，智能体各不相同（例如一个无人机配合一个地面车），且协作极其复杂，HAPPO 往往比 MAPPO 表现更稳健。

Paper Reading: Embodied AI 1

Fri, 26 Dec 2025 00:00:00 GMT

import { ArxivRating, RatingCriteria } from '@/components/advanced'

import { ManualTOC } from '@/components/advanced'

前言

RL菜鸡开始进军Embodied AI，慢慢积累，提升自己。

ACT

DP

RT-1

RT-2

OpenVLA

OpenVLA基本继承了RT-2的思想，形成了OpenVLA-like的VLA范式。简单来说，就是使用LLM对Image观测以及Language指令进行Fusion，输出Action Token，最后再Detokenizer成机器人可执行的Action。 OpenVLA使用Prismatic-7B VLM作为主干，文中详细解释了为什么采用Prismatic-7B VLM。和RT-2一样，使用256个频率最低的词元作为Action Token。训练数据主要使用了OXE Dataset，并对数据进行了处理，以便于训练。最终，OpenVLA展示了在不同消费级和服务级的GPU上的运行效果。然而，OpenVLA也有着诸多Limitation。首先，它只接受单图像预测，无法处理异构的机器人设置。其次，它的吞吐量不够，无法实现高频率的控制。最后，同时也是最大的硬伤，和RT-2一样，在面对Co-Training时，选择频率最低的256个Token作为Action Token，会出现双峰学习问题。但不可否认的是，OpenVLA还是一份伟大的工作，开创了OpenVLA-like的VLA学习范式。

OXE | RT-X

Open X-Embodiment数据集包含超过100万个真实机器人轨迹，涵盖22种机器人实体，从单机械臂机器人到双臂机器人和四足机器人。该数据集是通过汇集来自全球 34 个机器人研究实验室的 60 个现有机器人数据集，并将它们转换为一致的数据格式以便于下载和使用而构建的。该团队还使用OXE训练了RT-1和RT-2，展现出泛化性能。工作量如此之大，伟大无需多言。

Unified Video Action Model

从数据流上看，UVA首先学习了Image与Action Chunk的Joint Latent，然后使用Diffusion模型解码出未来的Action Chunk以及观测Image。为了兼容多种类型的输入，并解耦出对应的Action Chunk以及Image，UVA采用了掩码学习。下面讲解学习Joint Latent的流程。对于每张历史Image使用预训练的VAE编码器进行编码，得出$N$个$d$维的Image Token。对于每个历史Action Chunk，为了对齐Image Token的维度，采用重复$M$次拼接的方式对齐到$N$维度，并经过一个MLP投影到$N\times d$。对于要预测的Image，处理方式与历史Image一样，但加上了定义好的掩码。最终，将三类Token拼接在一起，输入到Transformer中进行编码，得出Joint Latent。接下来讲解预测流程。对于预测Image，将每个Token作为Image Diffusion的Condition，经过去噪还原出局部的VAE的Latent，最后拼接经过VAE的解码器还原出Image。对于预测Action Chunk，则将所有的Token作为Action Diffusion的Condition，经过去噪得出Future Action Chunk。 UVA使用了灵活目标的掩码训练方法，有助于防止模型对特定任务产生过拟合，从而提升模型的整体通用性和鲁棒性。

Genie Envisioner

TinyVLA

TinyVLA首次提出了VLM+DP的VLA范式，这个范式后续被应用到了 $\pi$ 系列。在这个范式下，Action不再由LLM的Token Detokenize出来，而是直接由一个Action Expert（DP或是ACT）输出。这样做，可以避免RT-2以及OpenVLA中的双峰学习问题，能够避免灾难性遗忘，使得VLM和Action Expert各司其职。在TinyVLA中，选用了Pythia作为VLM主干，选用DP作为Action Expert。 Action Expert以VLM主干输出的信息为Condition，输出Action Chunk。在训练过程中，使用LoRA微调VLM，防止了VLM的灾难性遗忘，且可以进行高效的微调。在实验部分，TinyVLA超越了OpenVLA，且可以在OOD的场景下完成一些任务。 TinyVLA应该是最早提出PI-like架构的工作，算是祖师爷。

CogACT

CogACT也是一种PI-like的VLA，分为VLM Fusion和Action Expert模块。在VLM Fusion模块中，CogACT采用了一种BERT-like的方式进行Fusion，输入Image观测以及Language指令，输出类似于[CLS]的Cognition Feature。在Action Expert模块中，以Cognition Feature为Condition，经过一个DiT得出Action Chunk。 CogACT和ACT一样，使用了类似的Action Ensembling，但CogACT中的权重是自适应的，避免了不同模式中不合理地聚合Action。

PI-0

PI-0.5

PI-0.5 是 PI-0 的续作，主要在模型训练上做了一些改进。 PI-0.5 对 VLM 进行了大量的 Co-Training,包括使用了 VQA、Discretized Actions、Sub Tasks 以及 Boxes Bounding 等多种数据。这样做的话，可以让 VLM 在 Inference 过程中先拆分 Sub Tasks，然后再使用 Action Expert 去预测 Action Chunk。同时，Co-Training 可以有效预防 VLM 的灾难性遗忘。另外一点，PI-0.5 使用了 FAST 编码器，可以将 Token 转换为离散的动作，这样可以在预训练过程中输出离散动作。这样做可以使得 Pre-Training 与 Post-Training 的学习更加的耦合，以提高模型的泛化能力。

GR-3

GR-3 是字节继 GR-2 后的工作，整体采用了 PI-like 的架构，也就是使用 VLM 进行 Fusion，并使用 Flow Matching 的 Action Expert 去输出 Action Chunk。 GR-3 的 VLM 使用的是 Qwen2.5-VL-3B-Instruct。在训练上，GR-3 采用了 Co-Training 的方式。对于无 Action 标签的 Web 数据，采用 VQA 的方式进行训练。对于有 Action 标签的机器人数据，采用 Flow Matching 损失进行训练。这样使用 Co-Training 的方式，可以让 VLM 在训练过程中同时学习 Web 数据和机器人数据的知识，同时能避免破坏 VLM 的知识。

InstructVLA

InstructVLA 采用了 PI-like 架构，也就是 VLM + Action Expert 的结构。如图，InstructVLA 采用了 Eagle2-2B 作为 VLM 主干，使用 SigLIP 将图像信息映射到语言空间。为了使得 VLM 能同时进行多模态推理和语言引导的 Latent Action 规划，InstructVLA 引入了一组可学习的 Action Query，这样就可以提取 Latent Action。同时，为了使得 VLM 能够在推理与操作之间切换，InstructVLA 引入了 MoE 设计的 LoRA 模块，来适应不同的输入模式。接着，Latent Action 被用于下游的 Flow Matching 进行 Action Chunk 的预测。具体做法就是，将 Latent Action 以 FiLM 的方式注入到 DinoV2 中，同时作为 Flow Matching 的 Condition，以预测 Action Chunk。

InstructVLA 的训练分为两个阶段，第一个阶段是动作预训练，第二个阶段是 VLA-IT。在动作预训练阶段，InstructVLA 使用异构机器人数据集，例如 OXE、Bridge等。训练时联合交叉熵与流匹配损失，冻结 VLM 主干的参数，只更新 MoE 设计的 LoRA 模型参数。在 VLA-IT 阶段，InstructVLA 冻结了 Flow Matching 模块的参数，新增了语言 LoRA 适配器和 MoE 适应缩放头。其中，MoE 模块是唯一可训练参数，并使用了 VLA-IT 数据集进行训练，详细可以见原文。

DinoV3

FiS-VLA

VIMA

VIMA 的具体做法就是将 Robotic Manipulation 任务规范为 Multi-Modal Prompt。 Multi-Modal Prompt 具体实现为 Vision 与 Text 的排列组合，文中考虑了6种任务类别。由于时代的局限，当时没有 Multi-Modal 的 Robotic Task 的 Benchmark。于是，该团队提出了VIMA-Bench，可以通过脚本化的 Oracle 智能体生成大量的模仿学习数据。

VIMA 这个工作比较早期，所以只使用了 T5 进行 Vision 与 Text 的 Fusion。对于 Text，采用预训练的 T5 词嵌入获取 Text Token。对于 Scene Vision，首先使用领域微调的 Mask R-CNN 来提取物体，然后经过 ViT 编码成 Scene Token。对于 Object Vision，和 Scene Vision一样的方式，编码为 Object Token。经过 T5 模型，可以得出 Prompt Tokens。

VIMA 控制器采用了 Decoder-Only 的架构，于 Decision Transformer 类似，采用序列建模的方式。 VIMA 控制器以 History 为输入，输出 Action。这部分与 Fusion 相似，被处理成了若干的 Vision Token，然后与机器人的 Joint Position 以及 Action 拼接，形成 History Token。在推理过程中，经过了多层的 Self-Attention 与 Cross-Attention 结构，自回归产生下一步的 Action。在 Cross-Attention 模块中，Prompt Tokens 被投影至 $K_{\mathcal{P}}$ 和 $V_{\mathcal{P}}$，并使用 History 投影的 $Q_{\mathcal{H}}$查询。

SayCan

SayCan 是任务规划的早期工作。任务规划就是给一个高级任务指令，分解为一系列机器人可执行的下游任务。很显然，具有强泛化能力的 LLM 非常适合做这个任务，但也有一些问题。最主要的问题就是 LLM 无法识别到物理世界，从而产生一些机器人无法执行的任务，也就是幻觉问题。

为了解决这个问题，SayCan 引入了 RL 中的 Value Function，表示为在当前状态下执行成功某个 skill 的成功率。在 SayCan设置的场景中，机器人有固定的 skill 集合，每次从里面选择一个 skill 执行。直接让 LLM 输出需要执行的 skill 是不保险的，因为可能输出 skill 集合中没有的 skill。所以，SayCan 不再让 LLM 去输出下一步执行的 skill，而是让 LLM 给所有的 skill 进行评分。同时，SayCan 会给 LLM 一些 Example Prompt，让 LLM 能够更加有效地提取知识。最后将两者结合，去选择机器人应该执行的 skill。

PaLM-E

PaLM-E 做的事情很简单，就是在 PaLM 的基础上添加若干的视觉编码组件，如 ViT、OSRT等。然后，使用 VQA 与机器人场景数据进行 Co-Training，这样就得到了一个通用的 VLM，可以处理多种任务。在机器人场景下，PaLM-E 可以发挥 Planning 的作用。

PaLM-E 其实没有多少的 insight，主要是在输入上做处理，具体可以去看原文。但 PaLM-E 的效果很好，在 Planning 任务中薄纱了当时的 SayCan，且有跨任务的能力。

ViLA

ViLA 的思路非常简单，就是告诉 VLM 当前要执行的 Task 以及 Obs，然后使用 Prompt 输出 CoT 形成 Task Planning，然后维护 TODO List，每次执行 TODO List 中的第一条 Low-level Task，不断循环直到任务结束。

ViLA 的思路虽然简单，但是有用且本质，非常具有启发性。

CoPa

CoPa 结合了许多种方法，让机器人直接输出 Action 去完成 high-level 任务。 CoPa 将大多数操作任务分为任务导向抓取和运动规划两个阶段。

在"任务导向抓取"中，分为粗粒度 Object 锚定和细粒度 Grasp 锚定。在粗粒度 Object 锚定中，先使用 SoM 去分割出 Obs 中的可抓取 Object，然后再使用 GPT-4V 去筛选最终抓取 Object。在细粒度 Grasp 锚定中，使用同样的方式去筛选最终 Grasp 的位置。

进一步，CoPa 使用 GraspNet 去生成机器人的候选抓取姿态，并使用 Grasp 锚定进行筛选。

在"任务运动规划"中，首先采用同样的锚定方式识别多个任务相关的部件。然后，使用 GPT-4V 生成操作约束限制。最后，可以得出一系列的 SE(3) 的矩阵，求可以得出抓取姿态。

PointLLM

PointLLM 主要有两个贡献，第一个是提出了基于 Prompt 的 3D LLM 问答数据标注方法，第二点是训练一个 3D 点云版本的 VLM。由于时代的局限性，当时没有用于 3D 点云用于 LLM 问答的数据集。于是，这篇工作基于 Cap3D 数据集，基于 Prompt 使用 VLM 对数据进行标注。随后，PointLLM 使用这份数据训练了一个 3D 点云版本的 VLM，如框架图所示。

EmbodiedGPT

EmbodiedGPT 是一个端到端的决策模型，并且具有跨任务的能力，如 TAMP、VQA 等。下面简单描述一下 EmbodiedGPT 的工作流，可以分为 Planning 和 low-level 决策执行阶段。

对于 Planning 阶段，EmbodiedGPT 首先使用 ViT 对图像信息进行编码得出 Vision Token。然后，Vision Token 与可学习的 Embodied Token 经过 Q-Former 进行 Fusion。最后，Fusion 后的信息与 Text Prompt 一同输入到 LLaMA3 中得出 Planning Text。

对于 low-level 决策执行阶段，Planning Token、Embodied Token 以及 Vision Token 再次在 Q-Former 进行 Fusion，得出 Instance Information。同时，为了捕获全局信息，图像信息经过 ImageNet 预训练的 ResNet50 进行全局平均池化特征提取，得出 Global Information。最后，这两个 Information 拼接在一起，并输入到 low-level 的决策网络中，以输出 low-level action。

EmbodiedGPT 的亮点是借助 Q-Former 将 Planning 的信息融入了 low-level 的决策中。

RT-Trajectory

RT-Trajectory 做的事情很简单，就是使用运动 Trajectory 去代替了 RT-1 中的 Text Instruction。在具体实现中，Trajectory 被表示为一张轨迹图像。在训练过程中，使用从数据集中标注的 Trajectory 图像，文中给出了详细的标注方法。而在推理过程中，提供了三种方式去得出 Trajectory 图像，详细见图。

RT-Trajectory 这篇工作证明了，在 low-level 控制中使用 Text 进行引导可能不是最优的选择，这种 Trajectory 引导能够处理更加细粒度的控制。同时，RT-Trajectory 缺点也很明显，在推理过程中，无法保证 Trajectory 是合理的，特别是将 3D Trajectory 映射为 2D 图像，会存在失真的现象。

Im2Flow2Act

Im2Flow2Act 是一个 End-to-End 的模型，其核心思想是基于 Object Flow 去生成 low-level policy。

Im2Flow2Act 首先基于 Task Description 以及初始 Frame 去生成 Object Flow。对于初始 Frame，使用 DINO 去检测出 Object 的框图，然后在框图中均匀采样 Points ，作为 Object Flow 的初始 Points。之后，以初始 Frame、初始 Points 以及 Task Description 为 Condition，使用视频生成模型 AnimateDiff 去生成 Object Flow。

为了确保实时感知，Im2Flow2Act 首先根据初始 Frame 以及当前 Frame 使用点追踪算法 TAPIR 去捕获 Object 的当前的 Keypoints。随后，使用 BERT-like 的状态编码器将 Keypoints 压缩为 [CLS]。同时，为了进行时间对齐，也就是让机器人自己做到哪里了，Im2Flow2Act 使用了一个 Transformer 将 Object Flow、[CLS]以及机器人 Joint Position 编码成 Latent。最后，以 Latent、[CLS]以及 Joint Position 为 Condition，使用 DP 去生成 Action Chunk。

这篇工作比 RT-Trajectory 更加有细粒度，但还是存在 3D 歧义的问题。

RL笔记（25）：多智能体策略梯度 (MADDPG & MAPPO)

Sat, 03 Jan 2026 00:00:00 GMT

引言：Actor-Critic 的群体进化

我们在之前的笔记中学习了 CTDE (中心化训练，分布式执行) 的思想。在 Value-Based 方法（如 QMIX）中，CTDE 体现在将 $Q_{tot}$ 分解为 $Q_i$。

而在 Actor-Critic 架构中，CTDE 的实现更加直观且灵活：

Actor (策略)：必须是局部的 ($\pi(a_i|o_i)$)，因为执行时只能靠自己。
Critic (价值)：必须是全局的 ($Q(s, \mathbf{a})$ 或 $V(s)$)，因为训练时我们可以利用上帝视角来更准地评估局势，从而指导 Actor。

本章将介绍这一范式下的两个里程碑算法：针对连续动作的 MADDPG 和目前最强的 Baseline MAPPO。

MADDPG (Multi-Agent DDPG)

论文：Multi-Agent Actor-Critic for Mixed Cooperative-Competitive Environments

MADDPG 是 DDPG 算法在多智能体环境下的自然延伸，由 OpenAI 在 2017 年提出。它主要解决了非平稳性问题。

核心思想：Critic 知道一切

在独立学习（Independent DDPG）中，Critic 只输入 $(o_i, a_i)$。当队友 $j$ 的策略 $\pi_j$ 改变时，环境对 $i$ 来说就变了，导致 Critic 震荡。

MADDPG 提出：Critic 应该输入所有人的动作。 $$ Q_i^{\boldsymbol{\pi}}(s, a_1, \dots, a_N) $$ 只要输入了联合动作 $\mathbf{a} = (a_1, \dots, a_N)$，环境的状态转移 $P(s'|s, \mathbf{a})$ 就是由物理规律决定的，是平稳 (Stationary) 的。

架构设计

对于 $N$ 个智能体，每个智能体 $i$ 维护两个网络：

Actor $\mu_{\theta_i}(o_i)$：
- 输入：仅局部观测 $o_i$。
- 输出：确定性动作 $a_i$。
- 特点：执行时完全独立。
Critic $Q_{\phi_i}(s, a_1, \dots, a_N)$：
- 输入：全局状态 $s$（或所有人的观测） + 所有人的动作。
- 输出：标量 Q 值。
- 特点：仅在训练时使用。

训练流程

Critic 更新：最小化贝尔曼误差。 $$ y = ri + \gamma Q_i'(s', a'_1, \dots, a'_N)|{a'_j = \mu'_j(o'_j)} $$ 注意：计算目标值时，需要用到每个智能体的 Target Actor 来预测下一步动作。
Actor 更新：确定性策略梯度。 $$ \nabla*{\theta_i} J = \mathbb{E} [\nabla*{ai} Q_i(s, a_1, \dots, a_N)|{ai=\mu_i(o_i)} \cdot \nabla{\theta_i} \mu_i(o_i)] $$ 注意：Critic 对 $a_i$ 求导，告诉 Actor $i$ 如何调整动作能提高集体（或个人）收益。

优缺点

优点：可以处理连续动作；适用于合作、竞争或混合任务（每个 Critic 可以最大化不同的奖励 $r_i$）。
缺点：Critic 的输入维度随人数线性增长，难以扩展到大规模集群。

MAPPO (Multi-Agent PPO)

论文：The Surprising Effectiveness of PPO in Cooperative Multi-Agent Games

长期以来，人们认为 Off-Policy（如 MADDPG/QMIX）在 MARL 中更高效。但 MAPPO (2021) 证明：只要调参得当，简单的 On-Policy PPO 也能吊打复杂的 Off-Policy 算法。

核心思想：Centralized Value Function

MAPPO 的结构极其简单，就是 PPO + CTDE。它与 IPPO（独立 PPO）唯一的区别在于 Critic。

IPPO Critic: $V(o_i)$ —— 只看自己，不仅视野窄，而且受队友策略变化干扰严重。
MAPPO Critic: $V(s)$ —— 看全局。Critic 学习的是全局状态价值函数。

为什么 $V(s)$ 比 $Q(s, \mathbf{a})$ 好？

MADDPG 使用 $Q(s, \mathbf{a})$，这需要输入巨大的联合动作空间。 MAPPO 使用 $V(s)$ 来计算优势函数： $$ \hat{A}i(t) = \sum (\gamma \lambda)^l (r{i, t+l} + \gamma V(s*{t+1+l}) - V(s*{t+l})) $$。 $V(s)$ 不需要输入动作，维度低，训练更容易收敛。

成功的关键：工程技巧 (Implementation Matters)

MAPPO 的成功不仅仅在于算法，更在于 5 个关键的工程实践：

输入特征处理：将 Agent ID 作为 One-hot 向量拼接到状态中（在参数共享时区分不同个体）。
参数共享 (Parameter Sharing)：所有智能体共用一个 Actor 和一个 Critic 网络（适用于同质智能体），极大加速收敛。
PopArt：对 Critic 的目标值（Value Target）进行归一化，处理奖励尺度差异大的问题。
数据并行：使用多个并行环境收集数据。
裁剪 (Clipping)：PPO 本身的 Clip 机制有效防止了非平稳环境下的策略崩塌。

深度对比：MADDPG vs. MAPPO

| 维度 | MADDPG | MAPPO | | :-------------- | :---------------------- | :--------------------------- | ---- | | 基础算法 | DDPG (Off-Policy) | PPO (On-Policy) | | 策略类型 | 确定性 ($\mu(o)$) | 随机性 ($\pi(a | o)$) | | 动作空间 | 连续 (擅长) | 连续 & 离散 (都擅长) | | Critic 形式 | $Q(s, a_1, \dots, a_N)$ | $V(s)$ | | 通信需求 | 训练时需知晓他人动作 | 训练时需知晓全局状态 | | 样本效率 | 较高 (Replay Buffer) | 较低 (需大量采样) | | 稳定性 | 较差 (超参数敏感) | 极高 (鲁棒性强) | | SOTA 表现 | 早期基准 | 目前 SMAC 等环境的主流强基准 |

总结

多智能体策略方法的发展经历了从“各自为战”到“全局协同”的过程。

MADDPG 解决了连续动作下的多智能体博弈问题，通过将“队友的动作”显式输入 Critic，在数学上恢复了平稳性。
MAPPO 则展示了“大道至简”的力量，证明了通过引入全局价值函数 $V(s)$ 并配合优秀的工程实现，On-Policy 算法也能在复杂的协作任务中达到 SOTA 水平。

至此，我们已经涵盖了 MARL 的两大主流流派：

Value-Based: QMIX, QPLEX (适合离散动作，强显式协作)。
Policy-Based: MADDPG, MAPPO (适合连续动作，通用性强)。

RL笔记（24）：超越单调性 (QTRAN, WQMIX, QPLEX)

Fri, 02 Jan 2026 00:00:00 GMT

引言（Introduction）

在上一章中，我们介绍了 QMIX，它通过强制混合网络的权重非负，实现了对 IGM 原则的单调性近似。然而，单调性是一个充分非必要条件。

局限性：QMIX 无法表示非单调的协作任务（例如：智能体 A 和 B 必须同时做动作 X 才能得分，单独做反而扣分。这种“异或”逻辑违反了单调性）。
挑战：我们需要一种方法，既能满足 IGM 原则（保证分布式执行），又能覆盖所有可能的联合价值函数空间。

本章将介绍三种试图突破 QMIX 天花板的进阶算法：QTRAN（基于变换）、WQMIX（基于加权）和 QPLEX（基于优势函数）。

QTRAN: Learning to Factorize with Transformation

论文：QTRAN: Learning to Factorize with Transformation for Cooperative MARL

核心思想：变换与松弛

QTRAN 认为，直接学习一个满足 IGM 的 $Q_{tot}$ 太难了。不如我们将 $Q_{tot}$ 拆解为两部分：

$Q'_{tot}$：一个易于分解的部分（如 VDN 的求和形式），用于指导动作选择。
$V_{tot}$：一个状态价值修正项，用于补足残差，确保逼近真实的 $Q^*$。

数学构造

我们定义变换后的目标函数：

$$ Q_{tot}(s, \mathbf{u}) \approx Q'{tot}(s, \mathbf{u}) + V{tot}(s, \mathbf{u}) $$

其中 $Q'{tot}(s, \mathbf{u}) = \sum{i=1}^n Q_i(u_i)$ 是我们实际用来选动作的函数。

为了保证 $\arg\max Q'{tot} = \arg\max Q{tot}$（IGM 原则），QTRAN 推导出了一组充分条件：

最优动作一致性：在最优动作 $\bar{\mathbf{u}}$ 处，两者相等。 $$ Q'{tot}(\bar{\mathbf{u}}) - Q{tot}(\bar{\mathbf{u}}) + V_{tot}(\bar{\mathbf{u}}) = 0 $$
非最优动作界限：在非最优动作 $\mathbf{u}$ 处，$Q'{tot}$ 不会“篡位”。 $$ Q'{tot}(\mathbf{u}) - Q_{tot}(\mathbf{u}) + V_{tot}(\mathbf{u}) \ge 0 $$

损失函数设计

QTRAN 将上述硬约束转化为软损耗（Soft Constraints）加入训练：

$$ L_{opt} = (Q'{tot}(\bar{\mathbf{u}}) - y{target})^2 + \lambda \sum_{\mathbf{u} \in \mathcal{U}, \mathbf{u} \ne \bar{\mathbf{u}}} (Q'{tot}(\mathbf{u}) - Q{tot}(\mathbf{u}) + V_{tot}(\mathbf{u}))^2 $$

总结

优点：理论上具有完全的表达能力 (Full Expressiveness)。
缺点：实际训练中，软约束很难被完美满足，且计算量巨大（涉及所有动作空间的求和）。在复杂任务上表现往往不如 QMIX。

Weighted QMIX (WQMIX)

论文：Weighted QMIX: Expanding Monotonic Value Function Factorisation

核心思想：非对称加权

WQMIX 指出 QMIX 的核心问题是 相对过泛化 (Relative Overgeneralization)：为了拟合某些非最优的低分动作，模型被迫拉低了最优动作的 Q 值。

WQMIX 提出：我们其实不在乎非最优动作的 Q 值准不准，我们只在乎最优动作的 Q 值准不准。 因此，我们可以给最优样本赋予极高的权重。

算法架构

无限制网络 $\hat{Q}^*$：使用一个普通的前馈网络（不加绝对值约束）来估计真实的联合 Q 值。这保证了表达能力，但不满足 IGM。
单调网络 $Q_{tot}$：使用标准的 QMIX 结构（满足 IGM），用来做策略执行。
加权投影：通过加权 Loss 强行让 $Q_{tot}$ 去逼近 $\hat{Q}^*$。

损失函数

$$ \mathcal{L} = \sum_{i=1}^b w(s, \mathbf{u}) \left( \hat{Q}^*(s, \mathbf{u}) - Q_{tot}(s, \mathbf{u}) \right)^2 $$

权重函数 $w$ 的设计体现了乐观主义：

如果 $\hat{Q}^*$ 认为当前动作很好的（可能是潜在的最优解），给大权重 $w=1$。
如果 $\hat{Q}^*$ 认为当前动作很差，给小权重 $w=\alpha \ll 1$。

这使得 $Q_{tot}$ 即使受限于单调性，也会优先保证在最优动作附近的形状是正确的，从而突破了结构瓶颈。

QPLEX: Duplex Dueling Multi-Agent Q-Learning

论文：QPLEX: Duplex Dueling Multi-Agent Q-Learning

核心思想：基于优势的 IGM

QPLEX 是目前的 SOTA 方法之一。它借鉴了 Dueling DQN 的思想，指出 IGM 原则其实只关乎 优势函数 (Advantage)，与状态价值 $V(s)$ 无关。

$$ Q*{tot}(s, \mathbf{u}) = V*{tot}(s) + A_{tot}(s, \mathbf{u}) $$

只要保证 $A_{tot}$ 和局部 $A_i$ 在“正负号”上的一致性，就能满足 IGM，而不需要限制权重的正负。

数学构造

QPLEX 构造了如下形式的联合优势函数：

$$ A_{tot}(s, \mathbf{u}) = \sum_{i=1}^n \lambda_i(s, \mathbf{u}) A_i(s, u_i) $$

关键点：只要系数 $\lambda_i(s, \mathbf{u}) > 0$，那么 $A_{tot}$ 的符号就由 $A_i$ 决定。
- 如果所有 $u_i$ 都是局部最优（$A_i=0$），那么 $A_{tot}=0$（全局最优）。
- 如果有任何一个 $u_i$ 不是最优（$A_i < 0$），那么 $A_{tot} < 0$（全局非最优）。

网络架构

QPLEX 使用 多头注意力机制 (Multi-Head Attention) 来动态生成权重 $\lambda_i$。

这不仅保证了 $\lambda_i > 0$，还赋予了模型根据当前状态动态调整每个智能体权重的能力。
通过这种严格的数学构造，QPLEX 在理论上实现了完全表达能力，同时保留了 VDN 般高效的计算效率。

总结与对比

| 算法 | 核心机制 | 表达能力 | IGM 保证 | 计算复杂度 | | :-------- | :--------------------- | :------------ | :------------------ | :--------- | | QMIX | 单调性约束 (权重 $>0$) | 受限 (单调类) | 严格 | 低 | | QTRAN | 软约束松弛 + 罚项 | 完全 | 近似 (软约束) | 极高 | | WQMIX | 双网络 + 非对称加权 | 近似完全 | 严格 (投影后) | 中 | | QPLEX | 优势分解 + 注意力权重 | 完全 | 严格 (数学构造) | 中 |

演进脉络：从 QMIX 的“削足适履”（为了 IGM 牺牲表达能力），到 QPLEX 的“量体裁衣”（通过精巧的数学构造同时实现 IGM 和完全表达能力），值分解算法在 MARL 领域已经发展得相当成熟。

RL笔记（23）：多智能体值分解 (VDN & QMIX)

Thu, 01 Jan 2026 00:00:00 GMT

引言（Introduction）

在上一篇笔记中，我们讨论了 MARL 的两种极端：JAL（完全中心化） 理论完美但不可计算，IPPO（完全独立） 计算简单但理论有毒。

我们需要一种折中方案：CTDE（中心化训练，分布式执行）。对于 Value-Based 方法来说，CTDE 的核心挑战在于：如何利用全局 $Q_{tot}$ 来指导局部 $Q_i$ 的更新，同时确保局部贪婪决策能导致全局最优？

这就是 值分解 (Value Decomposition) 算法的核心使命。本章将介绍这一流派的开山之作 VDN 和经典之作 QMIX。

理论基石：Dec-POMDP 与 IGM

问题形式化：Dec-POMDP

我们将多智能体协作任务建模为 去中心化部分可观测马尔可夫决策过程 (Dec-POMDP)。元组定义为 $G = \langle \mathcal{S}, N, U, P, R, Z, O, \gamma \rangle$：

$s \in \mathcal{S}$：全局状态。
$u_i \in U$：智能体 $i$ 的动作，联合动作 $\mathbf{u} \in U^n$。
$z_i \in Z$：智能体 $i$ 的局部观测。
$\tau_i$：动作-观测历史（因为是部分可观测，智能体需要记住历史）。
$Q_{tot}(s, \mathbf{u})$：全局联合价值函数，代表集体的利益。

核心原则：IGM (Individual-Global-Max)

为了保证“分布式执行”的有效性，我们必须确保：当每个智能体都最大化自己的局部利益 $Q_i$ 时，集体的利益 $Q_{tot}$ 也同时被最大化。

这被称为 IGM 原则，数学表达为：

$$ \arg\max_{\mathbf{u}} Q_{tot}(\boldsymbol{\tau}, \mathbf{u}) = \begin{pmatrix} \arg\max_{u_1} Q_1(\tau_1, u_1) \ \vdots \ \arg\max_{u_n} Q_n(\tau_n, u_n) \end{pmatrix} $$

直觉：就像一支理想的足球队，如果前锋拼命进球（局部最优），后卫拼命防守（局部最优），那么整支球队的胜率（全局最优）也应该是最高的。如果满足 IGM，我们就不需要复杂的协调通信，各自为战即可。

VDN (Value-Decomposition Networks)

论文：Value-Decomposition Networks For Cooperative Multi-Agent Learning

VDN 是值分解领域的奠基之作。它的思路非常简单粗暴：假设全局价值就是局部价值的直接加和。

核心假设

$$ Q_{tot}(\boldsymbol{\tau}, \mathbf{u}) = \sum_{i=1}^n Q_i(\tau_i, u_i; \theta_i) $$

训练与执行

训练时：我们最小化 $Q_{tot}$ 与真实回报的 TD 误差： $$ \mathcal{L}(\theta) = \left( r + \gamma \max*{\mathbf{u}'} Q*{tot}(\boldsymbol{\tau}', \mathbf{u}'; \theta^-) - Q*{tot}(\boldsymbol{\tau}, \mathbf{u}; \theta) \right)^2 $$ 注意：这里的 $\max*{\mathbf{u}'} Q_{tot}$ 可以很容易计算，因为 $\max \sum Q_i = \sum \max Q_i$。
执行时：每个智能体只需选择 $u_i^* = \arg\max_{u_i} Q_i$，即可保证选择了全局最优动作。

局限性

VDN 满足 IGM 原则，但求和的假设太强了。它限制了 $Q_{tot}$ 只能表示局部价值的线性组合，无法处理复杂的非线性协作（例如：只有当 A 和 B 同时做某事时，奖励才会暴增）。

QMIX

论文：QMIX: Monotonic Value Function Factorisation for Deep Multi-Agent Reinforcement Learning

QMIX 放宽了 VDN 的限制。它指出，要满足 IGM 原则，并不需要严格的线性求和，只需要满足 单调性约束 (Monotonicity Constraint) 即可。

核心假设

$$ \frac{\partial Q_{tot}}{\partial Q_i} \ge 0, \quad \forall i \in {1, \dots, n} $$

即：局部价值 $Q_i$ 越高，全局价值 $Q_{tot}$ 也就越高。 只要满足这个条件，$\arg\max Q_{tot}$ 就一定等价于 $\arg\max Q_i$ 的组合。

网络架构

QMIX 使用一个 混合网络 (Mixing Network) 来拟合 $Q_{tot}$，它以所有 $Q_i$ 为输入，以 $Q_{tot}$ 为输出。为了保证单调性（权重非负），QMIX 引入了一个 超网络 (Hypernetwork)。

Agent Network: 输入局部观测 $\tau_i$，输出 $Q_i$。
Mixing Network:
- 这是一个前馈神经网络，输入是 ${Q_1, \dots, Q_n}$，输出是 $Q_{tot}$。
- 关键点：这个网络的权重 (Weights) 是由 Hypernetwork 生成的，且被强制取绝对值（保证非负）。
Hypernetwork:
- 输入是全局状态 $s$。
- 输出是 Mixing Network 的权重 $W$ 和偏置 $b$。
- 公式：$W_{mix} = | \text{Hyper}(s) |$。

通过这种设计，QMIX 实现了：

非线性能力：Mixing Network 可以是复杂的非线性函数。
状态依赖：全局状态 $s$ 决定了混合的方式（例如在某些状态下，$Q_1$ 更重要；在另一些状态下，$Q_2$ 更重要）。
单调性保证：由于权重恒为正，混合网络对输入 $Q_i$ 保持单调递增。

损失函数

QMIX 的训练也是标准的 DQN 风格：

$$ \mathcal{L}(\theta) = \left( r + \gamma Q_{tot}(\boldsymbol{\tau}', s', \mathbf{u}{max}'; \theta^-) - Q{tot}(\boldsymbol{\tau}, s, \mathbf{u}; \theta) \right)^2 $$

其中 $\mathbf{u}_{max}'$ 是通过各个 $Q_i$ 贪婪选出的动作组合。

总结与对比

QMIX 的地位：它是 MARL 领域最经典的算法之一。虽然它只能处理满足单调性假设的任务（有些任务可能局部最优不等于全局最优），但在《星际争霸》(SMAC) 等主流测试平台上，QMIX 及其变体长期占据统治地位。

RL笔记（22）：初入多智能体强化学习 (MARL)

Wed, 31 Dec 2025 00:00:00 GMT

引言（Introduction）

在之前的 19 篇笔记中，我们研究的都是 单智能体强化学习 (Single-Agent RL)。但在现实世界中，任务往往涉及多个个体。多智能体强化学习 (MARL) 将问题扩展到了随机博弈（Stochastic Games）的领域。

在进入复杂的 SOTA 算法之前，我们必须先理解解决 MARL 问题的两种最朴素、最极端的思路：

完全中心化 (JAL)：把所有人看作一个人。
完全去中心化 (IPPO)：把队友看作空气（或环境噪声）。

这两种思路分别对应了 MARL 的两大核心难题：维度灾难 与 非平稳性。

理论模型：随机博弈

定义为一个元组 $(N, \mathcal{S}, \mathcal{A}, \mathcal{P}, \mathcal{R}, \gamma)$：

$N$：智能体数量。
$\mathcal{S}$：全局状态空间。
$\mathcal{A} = \mathcal{A}_1 \times \dots \times \mathcal{A}_N$：联合动作空间 (Joint Action Space)。
- 状态转移取决于所有人的动作组合 $\mathbf{a} = (a_1, \dots, a_N)$。
- 即 $s' \sim \mathcal{P}(\cdot | s, \mathbf{a})$。

极端一：联合动作学习 (JAL)

Joint Action Learning (JAL) 代表了 完全中心化 (Fully Centralized) 的思路。

核心思想

既然环境受所有人的动作 $\mathbf{a}$ 影响，那我们就构建一个拥有上帝视角的 “超级智能体” (Super Agent)，它接收全局状态 $s$，直接输出联合动作 $\mathbf{a}$ 来控制所有单位。

方法

直接套用标准的 PPO 算法：

输入：$s$
输出：$\mathbf{a} = (a_1, a_2, \dots, a_N)$
策略：$\Pi_\theta(\mathbf{a} | s)$

理论分析

优势：环境平稳。对于这个超级智能体来说，外界环境是静止的（Stationary），因为没有“其他人”在干扰它。因此，马尔可夫性质成立，RL 的收敛性理论依然有效。
致命缺陷：维度灾难 (Curse of Dimensionality)。假设每个智能体有 $|A|$ 个动作，共有 $N$ 个智能体。联合动作空间的大小为 $|A|^N$。
- $|A|=5, N=10 \Rightarrow 5^{10} \approx 9,765,625$。
- 输出层需要预测近一千万个概率值，这在计算上是不可行的。

极端二：独立学习 (Independent RL / IPPO)

Independent PPO (IPPO) 代表了 完全去中心化 (Fully Decentralized) 的思路。

核心思想

“把队友当空气”。每个智能体 $i$ 都是一个独立的个体，它只关心自己的观测 $o_i$ 和奖励 $r_i$。它把所有“其他智能体”都视为环境的一部分。

方法

同时运行 $N$ 个独立的 PPO 算法（参数可以共享，也可以不共享）：

对于智能体 $i$：
- 输入：局部观测 $o_i$
- 输出：独立动作 $a_i$
- 策略：$\pi_{\theta_i}(a_i | o_i)$

理论分析

优势：线性扩展。计算复杂度随人数 $N$ 线性增长。无论有多少人，每个网络只输出 $|A|$ 个概率。这完美解决了维度灾难。
致命缺陷：非平稳性 (Non-Stationarity)。从智能体 $i$ 的视角看，状态转移概率变成了： $$ P(s'|s, ai) = \sum{\mathbf{a}{-i}} P(s'|s, a_i, \mathbf{a}{-i}) \pi*{-i}(\mathbf{a}*{-i}|s) $$ 注意公式里的 $\pi_{-i}$（队友的策略）。在训练过程中，队友也在学习，$\pi_{-i}$ 一直在变。这意味着：对于智能体 $i$ 来说，昨天有用的策略，今天可能就没用了，因为环境（队友）变了。 这破坏了马尔可夫假设，理论上算法无法收敛。

总结与对比

| 维度 | 联合动作学习 (JAL) | 独立学习 (IPPO) | | :------------- | :--------------------------- | :----------------------------------------------- | --- | ---------------------- | --- | --- | | 控制方式 | 完全中心化 (Super Agent) | 完全去中心化 (Independent Agents) | | 动作空间 | 联合动作 $\mathbf{a}$ | 独立动作 $a_i$ | | 空间复杂度 | 指数级爆炸 $ | A | ^N$ | 线性增长 $N \times | A | $ | | 环境性质 | 平稳 (Stationary) | 非平稳 (Non-Stationary) | | 理论保证 | 有收敛保证 | 无收敛保证 | | 实际表现 | 规模稍大即无法运行 | 尽管没理论保证，但在实践中往往是 Strong Baseline |

这一章的启示

我们陷入了两难境地：

选 JAL，理论稳但算不动。
选 IPPO，算得快但理论虚。

这就引出了 MARL 研究的圣杯——CTDE (集中式训练，分布式执行)。我们需要一种折中的方法：在训练时利用 JAL 的上帝视角来缓解非平稳性，在执行时利用 IPPO 的独立结构来避免维度灾难。

这正是后续 MAPPO 和 QMIX 等算法的核心动机。

RL笔记（21）：目标导向的强化学习 (Goal-Conditioned RL)

Tue, 30 Dec 2025 00:00:00 GMT

引言（Introduction）

在标准的强化学习设定中，我们通常训练一个智能体去完成一个特定的任务（例如：打赢一局游戏，或者让机器人走到特定的坐标 $(x,y)$）。如果任务目标变了（例如：走到新的坐标 $(x', y')$），我们通常需要重新训练网络。

目标导向的强化学习 (Goal-Conditioned RL, GCRL) 旨在打破这一限制。我们希望训练一个智能体，它不仅能根据状态 $s$ 做出决策，还能根据输入的目标 $g$ 动态调整策略。

即策略函数变为 $\pi(a|s, g)$，价值函数变为 $Q(s, a, g)$。这使得智能体具备了多任务泛化的能力。

问题形式化 (Problem Formulation)

我们将标准的马尔可夫决策过程 (MDP) 扩展为 目标增强的 MDP (Augmented MDP)。

扩展元组

新的元组定义为 $\mathcal{M} = (\mathcal{S}, \mathcal{A}, \mathcal{P}, \mathcal{G}, r, \gamma)$。

$\mathcal{G}$：目标空间（通常是状态空间 $\mathcal{S}$ 的子集）。
$r(s, a, g)$：目标导向的奖励函数。

奖励函数的设计

在 GCRL 中，最常见的奖励函数有两种形式：

稀疏奖励 (Sparse Reward)：只有当智能体真正达成目标时才给奖励（通常用于机械臂抓取等精确任务）。

$$ r(s, a, g) = \mathbb{I}(\phi(s) = g) = \begin{cases} 0 & \text{if } ||\phi(s) - g|| < \epsilon \ -1 & \text{otherwise} \end{cases} $$

(注：这里用 0/-1 奖励结构比 1/0 更常见，因为这样价值函数代表了“到达目标的期望步数”的负值)
稠密奖励 (Dense Reward)：基于当前状态与目标的距离。 $$ r(s, a, g) = -||\phi(s) - g||_2 $$

目标：UVFA

我们的优化目标是找到一个最优策略 $\pi^*$，最大化所有可能的起始状态和目标的期望回报：

$$ J(\pi) = \mathbb{E}{g \sim p(g), s_0 \sim p(s_0), \tau \sim \pi} \left[ \sum{t=0}^\infty \gamma^t r(s_t, a_t, g) \right] $$

这种能够同时泛化状态 $s$ 和目标 $g$ 的价值函数近似器，被称为 通用价值函数近似 (Universal Value Function Approximators, UVFA)。 $$ V(s, g; \theta) \approx \mathbb{E} [R | s, g] $$ 神经网络结构通常是将状态特征 $\phi(s)$ 和目标特征 $\psi(g)$ 拼接后输入。

稀疏奖励难题

尽管 UVFA 提供了理论框架，但在实际训练中，如果使用稀疏奖励，学习会极其困难。

问题：在一个高维环境中（例如机械臂控制），随机探索碰到目标 $g$ 的概率几乎为 0。这意味着：

经验回放池 $\mathcal{D}$ 中几乎所有的样本，其奖励 $r$ 都是 -1（或 0）。
智能体收不到任何正反馈，梯度无法指引优化的方向。

这被称为 稀疏奖励问题 (Sparse Reward Problem)。

事后经验回放 (Hindsight Experience Replay, HER)

HER 是 GCRL 领域最核心的算法创新。它的灵感来源于人类的“精神胜利法”。

💡 直觉：假设你的目标是射中靶心，但你射偏了，射到了旁边的树上。虽然作为“射靶心”的任务你失败了，但如果我们事后回顾（Hindsight），假设原本的目标就是“射中那棵树”，那你通过刚才的动作序列，完美地完成了任务！

理论推导

HER 的核心在于重标记 (Relabeling) 经验回放池中的目标。

假设智能体在目标 $g$ 的指导下，产生了一条轨迹： $$ \tau = {s_0, a_0, r_0, s_1, \dots, s_T} $$ 其中，最后的状态 $s_T$ 并没有到达预设目标 $g$，所以所有的 $r_t = -1$。

HER 的操作：我们构造一个新的虚假目标 $g' = s_T$（即把最后实际达到的状态当作目标）。对于轨迹中的每一个转换 $(s_t, a_t, s_{t+1})$，我们根据新目标 $g'$ 重新计算奖励：

$$ r't = r(s_t, a_t, g') = \begin{cases} 0 & \text{if } s{t+1} = g' \ -1 & \text{otherwise} \end{cases} $$

由于 $g'$ 就是 $s_T$，那么在轨迹结束时，智能体必然获得了正奖励。

我们将原始数据 $(s_t, a_t, r_t, s_{t+1}, g)$ 和修改后的数据 $(s_t, a_t, r't, s{t+1}, g')$ 都存入 Replay Buffer。

为什么数学上是成立的？(Off-Policy 的重要性)

HER 只能用于 离线策略 (Off-Policy) 算法（如 DQN, DDPG, SAC）。

原因：我们原本产生的轨迹 $\tau$ 是由策略 $\pi(\cdot | s, g)$ 生成的。但在训练时，我们将其强行解释为是由策略 $\pi(\cdot | s, g')$ 生成的。这本质上是一种极端的 Off-Policy 学习：行为策略的目标与更新时的目标完全不同。

只要算法支持 Off-Policy（即不仅可以利用自己产生的旧数据，还可以利用“别人”产生的数据），HER 就是数学上合法的。因为对于 $(s_t, a_t, s_{t+1})$ 这个物理转换来说，它只遵循环境动力学 $P(s'|s,a)$，与目标 $g$ 无关。环境的物理规律是不随心中的目标而改变的。

HER 的变种与理论解释

不同的重标记策略 (Replay Strategy)

在将数据存入 Buffer 时，我们可以选择不同的重标记方式：

Future: 从当前时间步 $t$ 之后的轨迹中随机选取一个状态作为新目标 $g'$。（这是标准做法，效果最好）。
Final: 仅使用轨迹的最后一个状态 $s_T$ 作为 $g'$。
Episode: 从整个轨迹中随机选取一个状态。
Random: 随机生成一个全新的目标（效果通常不好）。

隐式课程学习 (Implicit Curriculum Learning)

从理论上讲，HER 实现了一种自动的课程学习。

初期：智能体很笨，只能碰到离起始点很近的状态。HER 把这些近的状态设为目标，智能体学会了如何“走一小步”。
中期：学会走一小步后，智能体能探索到稍远一点的状态。HER 再次把稍远的状态设为目标。
后期：随着能力扩展，智能体最终能学会到达真正的远距离目标 $g$。

这种奖励信号从容易到困难的自动传播，是 HER 解决稀疏奖励问题的本质原因。

总结

目标导向 RL 将强化学习从“解决一个问题”提升到了“解决一类问题”。

UVFA 提供了网络结构的理论基础，让 $V(s,g)$ 成为可能。
HER 解决了最为棘手的稀疏奖励问题，通过事后重标记，将每一次失败的尝试都转化为另一次成功的训练数据。

至此，我们已经掌握了让智能体学会“指哪打哪”的关键技术。

Paper Reading: LLM 1

Fri, 26 Dec 2025 00:00:00 GMT

import { ArxivRating, RatingCriteria } from '@/components/advanced'

GPT 1.0

BERT

GPT 2.0

Megatron-LM

T5

ZeRO

Scaling Law

GPT 3.0

Switch Transformers

Codex

COT

InstructGPT

PaLM

LLaMA

GPT 4

DPO

ToT

LLaMA2

Mistral 7B

Mamba

Mamba2

Qwen2.5

DeepSeek-V3

DeepSeek-R1

Kimi K2

DFT

Paper Reading: LLM 2

Fri, 26 Dec 2025 00:00:00 GMT

import { ArxivRating, RatingCriteria } from '@/components/advanced'

MMaDA

Paper Reading: MLLM 1

Fri, 26 Dec 2025 00:00:00 GMT

import { ArxivRating, RatingCriteria } from '@/components/advanced'

CLIP

SigLip

SigLipV2

Dino V1

Dino V2

Dino V3

ViLT

ALBEF

VLMo

BLIP

CoCa

BEiT V3

BLIP2

LLava

Flamingo

Visual Instruction Tuning

Qwen-VL

Gemini

GPT-4V

LISA

Cambrian-1

Qwen2-VL

Qwen2.5-VL

InstructBLIP

LLaMA-Adapter

VisionLLM

Paper Reading: MLLM 2

Fri, 26 Dec 2025 00:00:00 GMT

import { ArxivRating, RatingCriteria } from '@/components/advanced'

LLaVA-OneVision

GPT 5

Paper Reading: Unify MLLM 1

Fri, 26 Dec 2025 00:00:00 GMT

import { ArxivRating, RatingCriteria } from '@/components/advanced'

前言

速览一些统一多模态大模型的论文。

SEED

LaVIT

SEED-X

Emu

Emu2

Chameleon

Transfusion

Emu3

MMAR

Janus

PUMA

Show-o

VILA-U

MIO

JanusFlow

Orthus

TokenFlow

Liquid

MUSE-VL

SILMM

ILLUME

Visual Lexicon

LatentLM

SynerGen-VL

MetaMorph

Paper Reading: Unify MLLM 1

Fri, 26 Dec 2025 00:00:00 GMT

import { ArxivRating, RatingCriteria } from '@/components/advanced'

前言

速览一些统一多模态大模型的论文。

LMFusion

UniToken

VARGPT

Janus-Pro

BLIP3-o

Show-o2

Qwen-Image

RL笔记（20）：Decision Transformer

Mon, 29 Dec 2025 00:00:00 GMT

引言（Introduction）

在之前的笔记中，无论是有模型还是无模型，在线还是离线，我们解决 RL 问题的核心思路都是基于 动态规划 (Dynamic Programming) 的：

我们要估计价值函数 $V(s)$ 或 $Q(s,a)$。
利用贝尔曼方程进行迭代更新（自举）。
通过最大化价值来获得策略。

Decision Transformer (DT) 提出了一种完全不同的视角：如果我们拥有大量的离线轨迹数据，为什么不把它看作是一个 序列建模 (Sequence Modeling) 问题呢？就像 GPT 预测下一个单词一样，能不能根据过去的轨迹和期望的回报，直接预测下一个动作？

核心思想：强化学习 $\approx$ 在给定期望回报 (Target Return) 条件下的行为克隆 (Conditional Behavior Cloning)。

轨迹表示与 Return-to-Go

为了将 RL 问题转化为 Transformer 可以处理的序列问题，我们需要重新定义模型的输入。

轨迹 (Trajectory)

一条标准的 RL 轨迹由状态、动作和奖励组成： $$ \tau = (s_1, a_1, r_1, s_2, a_2, r_2, \dots, s_T, a_T, r_T) $$

剩余回报 (Return-to-Go, RTG)

传统的 RL 使用即时奖励 $r_t$。但在做序列预测时，我们更关心“未来还能拿多少分”。定义 $t$ 时刻的 Return-to-Go (RTG) $\hat{R}_t$ 为从当前时刻到回合结束的累积回报：

$$ \hat{R}t = \sum{k=t}^T r_k $$

模型的输入序列

DT 的核心创新在于将 RTG 作为一种条件 (Condition) 输入给模型。输入序列被组织为三元组的序列（K-V-Q 模式）：

$$ \tau_{input} = (\hat{R}_1, s_1, a_1, \hat{R}_2, s_2, a_2, \dots, \hat{R}_T, s_T, a_T) $$

直觉：这就像是在告诉模型：“我现在状态是 $s_1$，我想在未来总共获得 $\hat{R}_1$ 分，请告诉我该做什么动作 $a_1$？”

网络架构

DT 直接使用了 GPT (Generative Pre-trained Transformer) 的架构，即因果掩码 Transformer (Causal Transformer)。

嵌入层 (Embeddings)

由于 $R, s, a$ 的模态不同（标量、图像/向量、离散/连续），我们需要先将它们映射到同一个维度 $d$：

状态嵌入：CNN 或 MLP 处理 $s_t$。
动作嵌入：Embedding 层或 MLP 处理 $a_t$。
回报嵌入：MLP 处理 $\hat{R}_t$。
时间步嵌入 (Timestep Embedding)：为了让模型知道当前处于轨迹的哪个阶段，额外加入一个可学习的时间位置编码。

上下文窗口 (Context Window)

由于轨迹可能很长，Transformer 无法处理整个 Episode。DT 使用一个固定的上下文窗口 $K$（context length），只把最近的 $K$ 步输入模型：

$$ \text{Input}t = [\hat{R}{t-K}, s_{t-K}, a_{t-K}, \dots, \hat{R}_t, s_t] $$

预测目标

模型的目标是预测下一个 token。在 DT 中，我们主要关注预测动作 $a_t$。

$$ a_t = \text{DecisionTransformer}(\hat{R}{t-K}, s{t-K}, a_{t-K}, \dots, \hat{R}_t, s_t) $$

训练与推断

训练 (Training)

DT 的训练过程完全是监督学习 (Supervised Learning)，不需要计算梯度，不需要贝尔曼误差，不需要目标网络。

从离线数据集 $\mathcal{D}$ 中采样轨迹片段，最小化预测动作与真实动作的误差：

离散动作：交叉熵损失 (Cross-Entropy Loss)。
连续动作：均方误差 (MSE Loss)。

$$ \mathcal{L}(\theta) = \mathbb{E}{\tau \sim \mathcal{D}} \left[ \sum{t=1}^T (a_t - \hat{a}_t)^2 \right] $$

💡 注意：虽然数据集中可能包含低分的轨迹（“臭棋”），但模型学习的是条件概率 $P(a_t | \hat{R}_t, s_t, \dots)$。也就是说，模型学会了“如果想要低分该怎么做”以及“如果想要高分该怎么做”。

推断 (Inference)

这是 DT 最神奇的地方。训练完成后，我们可以通过提示 (Prompting) 来控制智能体。

我们给智能体设定一个目标回报 (Target Return) $\hat{R}_{target}$（通常设为数据集中最高分的那个回报，或者更高）。

自回归生成过程：

初始时刻 $t=1$：输入 $(\hat{R}_{target}, s_1)$，模型输出动作 $a_1$。
环境交互：执行 $a_1$，环境返回即时奖励 $r_1$ 和新状态 $s_2$。
更新目标：既然已经拿到了 $r_1$，剩下的目标就要减去它： $$ \hat{R}_2 = \hat{R}_1 - r_1 $$
下一时刻：输入 $(\dots, \hat{R}_1, s_1, a_1, \hat{R}_2, s_2)$，预测 $a_2$。
重复直至结束。

理论对比：DT vs. CQL

为了理解 DT 的位置，我们将它与上一篇笔记中的 CQL 进行对比：

| 维度 | Conservative Q-Learning (CQL) | Decision Transformer (DT) | | :----------------- | :------------------------------------- | :--------------------------------------- | | 核心范式 | 动态规划 (DP) | 序列建模 (SL) | | 学习目标 | 逼近最优价值函数 $Q^*(s,a)$ | 拟合条件分布 $P(a|\hat{R}, s)$ | | 训练方式 | 最小化贝尔曼误差 (TD Error) | 最大化动作似然 (Supervised) | | OOD 处理 | 显式惩罚未知动作的 Q 值 (悲观主义) | 依靠 Transformer 的泛化能力 (无显式约束) | | 长时序信用分配 | 依靠 $Q$ 值的自举传播 (Bootstrapping) | 依靠 Attention 机制直接关联过去与未来 | | 优点 | 理论下界保证，擅长拼接轨迹 (Stitching) | 训练极其稳定，易于扩展，能够处理稀疏奖励 |

总结

Decision Transformer 的提出证明了：只要模型足够强（Transformer），强化学习可以被简化为监督学习。

它不需要复杂的 Actor-Critic 架构。
它不需要处理“过高估计”等死板的数值问题。
它通过 Return-to-Go 实现了类似于“事后诸葛亮”的条件控制：利用这一局最终的得分作为条件，来学习这一局中的动作。

RL笔记（19）：离线强化学习 (Offline RL)

Sun, 28 Dec 2025 00:00:00 GMT

引言（Introduction）

在之前的章节（DQN, SAC, DDPG）中，我们讨论的都是 在线 (Online) 或 离线策略 (Off-Policy) 算法。

Online: 边玩边学。
Off-Policy: 可以利用之前的经验回放池（Replay Buffer），但仍然需要不断与环境交互来补充新数据，纠正价值估计。

离线强化学习 (Offline RL)，又称 Batch RL，面临的是一个更严苛的场景： 智能体完全不能与环境交互，只能从一个固定的、历史的数据集 $\mathcal{D}$ 中学习策略。

这就像是“仅仅通过看别人下棋的棋谱（而且可能含有臭棋），就要学会成为棋圣”。

核心挑战：分布偏移 (Distribution Shift)

既然 Off-Policy 算法（如 SAC）可以使用 Replay Buffer，为什么不能直接把静态数据集 $\mathcal{D}$ 当作 Buffer 跑 SAC 呢？

答案是：外推误差 (Extrapolation Error)。

贝尔曼更新的陷阱

回顾 Q-Learning 的贝尔曼更新目标：

$$ \mathcal{T}Q(s, a) = r + \gamma \max_{a'} Q(s', a') $$

或者 Actor-Critic 中的：

$$ y = r + \gamma Q(s', \pi(s')) $$

这里存在一个致命的 反事实查询 (Counterfactual Query) 问题：

数据集 $\mathcal{D}$ 是由行为策略 $\pi_\beta$ 产生的。
我们学习的新策略 $\pi$ 通常会与 $\pi_\beta$ 不同（为了变得更好）。
在计算目标值时，我们需要查询 $Q(s', \pi(s'))$。
如果 $\pi(s')$ 选出的动作 $a'$ 从未在数据集 $\mathcal{D}$ 中出现过（OOD, Out-of-Distribution），Q 网络对这个从未见过的 $(s', a')$ 会输出什么？
- 根据神经网络的特性，它会输出一个随机的、无意义的值。
最大化的诅咒：由于 $\max$ 操作的存在，优化器会倾向于选择那些被错误高估的 OOD 动作。
误差传播：这个高估的误差会通过贝尔曼方程回传，导致整个 Q 函数崩溃。

这就是 分布偏移：训练数据的分布 $(s, a) \sim \pi_\beta$ 与学习策略的分布 $(s, a) \sim \pi$ 不一致，导致 Q 值在未知区域严重高估。

解决方案一：基于约束的方法 (BCQ)

BCQ (Batch-Constrained deep Q-learning) 的思路非常直观：既然 OOD 动作会导致 Q 值高估，那我就禁止智能体选择那些在数据集中没出现过的动作。

理论推导

我们希望优化策略 $\pi$，使其在最大化 $Q$ 值的动作，同时满足它生成的动作分布接近行为策略 $\pi_\beta$：

$$ \pi(s) = \arg\max_{a} Q(s,a) \quad \text{s.t.} \quad P(a|s, \mathcal{D}) > \tau $$

算法实现逻辑

由于 $\pi_\beta$ 未知，BCQ 训练一个 生成模型 (VAE) 来拟合数据集中的状态-动作分布。

生成 (Generation)：使用 CVAE 根据状态 $s$ 生成一组“在该状态下可能出现过的”候选动作 ${a_1, \dots, a_n}$。
扰动 (Perturbation)：训练一个扰动网络 $\xi_\phi(s,a)$，对生成的动作进行微调（在小范围内寻找更优解），得到 ${a_1+\xi_1, \dots, a_n+\xi_n}$。
选择 (Selection)：在这些动作中，选择 Q 值最大的那个作为最终输出。

💡 评价：BCQ 是一种保守策略，它消除了外推误差，但也限制了策略的泛化能力（只能在见过的数据附近微调）。

解决方案二：基于价值的保守方法 (CQL)

CQL (Conservative Q-Learning) 是目前理论最完备的 Offline RL 算法之一。它的思路是：修改贝尔曼更新的目标函数，显式地惩罚 OOD 动作的 Q 值。

目标函数设计

标准的贝尔曼误差是最小化 $\mathbb{E}_{(s,a)\sim\mathcal{D}} [(Q - \mathcal{T}Q)^2]$。 CQL 增加了一个正则项，用于最小化策略 $\mu$（新策略）产生的动作的 Q 值，同时最大化数据集 $\mathcal{D}$ 中动作的 Q 值：

$$ \min_Q \alpha \left( \underbrace{\mathbb{E}{s\sim\mathcal{D}, a\sim\mu(a|s)} [Q(s,a)]}{\text{压低 OOD 动作的 Q 值}} - \underbrace{\mathbb{E}{s\sim\mathcal{D}, a\sim\pi\beta(a|s)} [Q(s,a)]}{\text{拉高数据中动作的 Q 值}} \right) + \frac{1}{2} \mathbb{E}{\mathcal{D}} [(Q - \mathcal{B}^{\pi}Q)^2] $$

$\mu(a|s)$：可以是当前学习的策略，也可以是随机分布。
通过这种“压低未知，拉高已知”，CQL 迫使 Q 函数在 OOD 区域产生低估。

理论推导：Q 值下界 (Lower Bound)

CQL 的核心理论贡献在于证明了上述目标函数学习到的 Q 值 $\hat{Q}$ 是真实 Q 值 $Q^\pi$ 的下界。

令 $\mathcal{B}^\pi$ 为贝尔曼算子。CQL 的不动点迭代可以近似写作：

$$ \hat{Q}_{k+1} \leftarrow \mathcal{B}^\pi \hat{Q}k - \alpha (\mu - \pi\beta) $$

(这里省略了复杂的采样误差项，仅关注期望行为)

当 $\alpha$ 足够大时，可以证明：

$$ \mathbb{E}{\pi(a|s)} [\hat{Q}(s,a)] \le \mathbb{E}{\pi(a|s)} [Q^\pi(s,a)] $$

这意味着 CQL 学习到的 Q 值是保守的 (Conservative)。

如果策略想去一个未知区域，CQL 会告诉它：“那个地方 Q 值很低（哪怕实际上可能很高）”。
因此，策略会倾向于留在数据覆盖的“安全区域”内。

广义 CQL (Generalization)

对于连续动作空间，CQL 将第一项正则化改为 $\log\sum\exp$ 形式（Soft-max），以覆盖所有可能的动作：

$$ \min_Q \alpha \mathbb{E}{s \sim \mathcal{D}} \left[ \log \sum_a \exp(Q(s,a)) - \mathbb{E}{a \sim \pi_\beta}[Q(s,a)] \right] + \text{Bellman Error} $$

这等价于压低整个 Q 值函数的配分函数，确保没有任何一个 OOD 动作能由于外推误差而获得异常高的 Q 值。

总结：从乐观到悲观

| 维度 | 在线/离线策略 RL (DQN/SAC) | 离线 RL (Offline RL) | | :----------- | :--------------------------------- | :----------------------------------------------------------- | | 心态 | 乐观 (Optimistic) | 悲观 (Pessimistic) / 保守 | | 对待未知 | 未知动作 = 潜在的高回报 (探索红利) | 未知动作 = 潜在的风险 (外推误差) | | 核心算法 | $\max Q$ | $\max Q$ s.t. $a \in \mathcal{D}$ (BCQ) $\min Q_{OOD}$ (CQL) | | 适用场景 | 模拟器、低成本试错环境 | 医疗、工业控制、自动驾驶 (试错成本极高) |

离线强化学习的本质：在无法验证真伪的情况下，宁可错过（低估），不可做错（高估）。 只有当数据充分证明某个策略好时，我们才敢信任它。

RL笔记（18）：基于模型的策略优化 (MBPO)

Sat, 27 Dec 2025 00:00:00 GMT

引言（Introduction）

在强化学习的谱系中，存在一对矛盾：

Model-Free (如 SAC)：渐进性能好（能收敛到很高的分数），但样本效率极低（需要几百万次交互）。
Model-Based (如 Dyna)：样本效率高（利用模型生成数据），但往往受限于模型偏差 (Model Bias)，导致渐进性能较差。

模型偏差的诅咒在于：模型也是从数据中拟合出来的，它必然存在误差。当智能体在模型中进行长距离推演时，微小的误差会像滚雪球一样迅速放大（Compound Error），导致智能体在“虚构的完美世界”里表现很好，但在“残酷的现实世界”里一塌糊涂。

MBPO (Model-Based Policy Optimization) 的核心贡献在于它通过严格的理论推导，定量地分析了模型误差与策略性能的关系，并提出了一种分支推演 (Branched Rollout) 机制，在保证单调提升的前提下，最大化地利用模型。

理论推导：回报差的上界

我们希望找到一个策略 $\pi$，最大化真实环境中的期望回报 $\eta[\pi]$。但我们只能优化模型环境中的期望回报 $\hat{\eta}[\pi]$。我们需要推导两者之间的误差上界，从而找到一个安全优化的 下界 (Lower Bound)。

定义与假设

真实环境的状态转移分布：$p(s'|s,a)$
学习模型的状态转移分布：$\hat{p}(s'|s,a)$
模型误差 $\epsilon_m$：假设模型在分布上的最大误差是有界的（TV 散度）： $$ \max*{s,a} D*{TV}(p(\cdot|s,a) || \hat{p}(\cdot|s,a)) \le \epsilon_m $$

状态分布的差异

策略 $\pi$ 在真实动力学下的状态访问分布为 $\rho_\pi$，在模型动力学下的状态访问分布为 $\hat{\rho}_\pi$。根据 Simulation Lemma，两者之间的差异上界为：

$$ D_{TV}(\rho_\pi || \hat{\rho}_\pi) \le \frac{\gamma \epsilon_m}{(1-\gamma)^2} $$

⚠️ 警示：注意这里的 $(1-\gamma)^2$。这意味着状态分布的误差是随着时间视界（Horizon）二次方增长的。这就是为什么在传统 Model-Based RL 中，长距离推演会导致极其严重的偏差。

真实回报与模型回报的差异

基于上述状态分布差异，我们可以推导出真实回报 $\eta[\pi]$ 与模型回报 $\hat{\eta}[\pi]$ 的差值上界：

$$ \left| \eta[\pi] - \hat{\eta}[\pi] \right| \le 2 r_{\max} \frac{\gamma \epsilon_m}{(1-\gamma)^2} $$

这个上界告诉我们：如果我们只是简单地训练一个模型，然后在模型里从头跑到尾（Full Rollout）来训练策略，那么真实性能和模型性能的差距可能会非常大，优化 $\hat{\eta}$ 并不代表能提升 $\eta$。

核心突破：分支推演 (Branched Rollout)

为了打破上述的“二次方误差诅咒”，MBPO 提出改变推演的方式。

什么是分支推演？

传统的 Dyna 风格是从初始状态 $s_0$ 开始，一直推演到 $s_T$。 MBPO 的 $k$-步分支推演 是：从策略在真实环境中访问过的状态分布 $\mathcal{D}_{\text{env}}$ 中采样一个状态 $s$，作为推演的起点，然后仅在模型中推演 $k$ 步。

修正后的误差边界

在 $k$-步分支推演下，回报差的上界被显著收紧了：

$$ \left| \eta[\pi] - \hat{\eta}k[\pi] \right| \le 2 r{\max} \left[ \frac{\gamma^{k+1} \epsilon_\pi}{(1-\gamma)^2} + \frac{\gamma^k \epsilon_m}{1-\gamma} + \frac{k}{1-\gamma}\epsilon_m \right] $$

(注：公式略作简化以直观展示核心项)

关键在于最后一项 $\frac{k}{1-\gamma}\epsilon_m$。这表明：在分支推演下，模型误差 $\epsilon_m$ 对总回报误差的贡献是随 $k$ 线性增长的，而不是二次方增长。

$k$ 的权衡 (Trade-off)

这个理论边界揭示了超参数 $k$ 的物理意义：

当 $k$ 很小时：误差界很紧（线性），我们可以放心地信任模型数据。但是模型能提供的“远见”有限。
当 $k$ 很大时：误差界变松（趋向二次方），模型偏差开始主导，导致策略性能下降。

因此，MBPO 动态调整 $k$：在训练初期模型不准时，$k=1$；随着模型精度提高，逐渐增加 $k$（通常从 1 增加到 15 左右），在保证偏差可控的前提下最大化利用模型。

算法架构设计

MBPO 的实现是围绕上述理论构建的，由三个核心模块组成。

概率模型集成 (Ensemble of Probabilistic Models)

为了准确估计模型误差并防止过拟合，MBPO 训练一组（如 7 个）高斯概率网络。 $$ \hat{p}\theta(s'|s,a) = \mathcal{N}(\mu\theta(s,a), \Sigma_\theta(s,a)) $$

不确定性感知：预测时随机从集成模型中选择一个成员，这模拟了贝叶斯后验采样，能够捕捉认知不确定性 (Epistemic Uncertainty)。

混合策略优化 (Model-Based Policy Optimization)

MBPO 使用 SAC (Soft Actor-Critic) 作为底层的策略优化器。为了克服模型偏差，SAC 的训练数据由两部分组成：

真实数据 $\mathcal{D}_{\text{env}}$：占比很小（如 5%）。
模型数据 $\mathcal{D}_{\text{model}}$：由分支推演产生的海量数据，占比很大（如 95%）。

算法流程 (伪代码)

$$ \begin{aligned} & \bullet ; \text{Initialize policy } \pi_\phi, \text{ ensemble models } {p_{\theta_1}, \dots, p_{\theta_B}} \ & \bullet ; \text{Initialize empty buffers } \mathcal{D}{\text{env}}, \mathcal{D}{\text{model}} \ & \bullet ; \textbf{For } N \text{ epochs} \textbf{ do}: \ & \bullet \qquad \textbf{1. Collect Real Data (Exploration)} \ & \bullet \qquad \text{Rollout policy in real environment, add transitions to } \mathcal{D}{\text{env}} \ & \bullet \qquad \textbf{2. Train Models (Supervised Learning)} \ & \bullet \qquad \text{Train ensemble } {p\theta} \text{ on } \mathcal{D}{\text{env}} \text{ via Max Likelihood} \ & \bullet \qquad \textbf{3. Branched Rollout (Data Augmentation)} \ & \bullet \qquad \text{Sample states } s \sim \mathcal{D}{\text{env}} \ & \bullet \qquad \text{Rollout } k \text{ steps using models, add to } \mathcal{D}{\text{model}} \ & \bullet \qquad \textbf{4. Policy Optimization (SAC)} \ & \bullet \qquad \textbf{For } G \text{ gradient steps} \textbf{ do}: \ & \bullet \qquad \qquad \text{Sample batch } B \text{ from } \mathcal{D}{\text{env}} \cup \mathcal{D}{\text{model}} \text{ (e.g., 95% model data)} \ & \bullet \qquad \qquad \text{Update } \pi\phi, Q_\psi \text{ using SAC loss} \ & \bullet \qquad \textbf{End For} \ & \bullet ; \textbf{End For} \end{aligned} $$

总结：MBPO 的启示

MBPO 是 Model-Based RL 的一个转折点，它通过理论证明回答了**“我们该多大程度信任模型？”**这个问题。

单调性保证：通过限制推演步长 $k$，MBPO 将模型误差控制在线性增长范围内，从而保证了策略改进的单调性（类似 TRPO 的 Trust Region 思想，但应用在 Rollout Length 上）。
数据增强：MBPO 本质上是把学到的模型当作一个超级数据增强器。它从有限的真实数据出发，通过短步推演，扩散出海量的虚拟数据供 SAC 训练。
结果：MBPO 在 MuJoCo 等基准测试中，以 1/10 甚至更少的样本量，达到了与 SAC 相当的渐进性能，打破了“Model-Based 也就是学得快但分不高”的刻板印象。

Paper Reading: VLM 1

Fri, 26 Dec 2025 00:00:00 GMT

import { ArxivRating, RatingCriteria } from '@/components/advanced'

前言

浅浅学习一下VLM相关的知识。

Paper Reading: VLM 2

Fri, 26 Dec 2025 00:00:00 GMT

import { ArxivRating, RatingCriteria } from '@/components/advanced'

前言

浅浅学习一下VLM相关的知识。

Paper Reading: Basic Method 1

Fri, 26 Dec 2025 00:00:00 GMT

import { ArxivRating, RatingCriteria } from '@/components/advanced'

前言

这里主要是一些比较基础性的文章。

VAE

Transformer

Diffusion

Paper Reading: MARL 1

Fri, 26 Dec 2025 00:00:00 GMT

import { ArxivRating, RatingCriteria } from '@/components/advanced'

前言

博主制作这篇博客时，已弃坑MARL，仅留作纪念，怀念最初的感觉。

VDN

QMIX

Qatten

QTRAN

QPLEX

RQN

GraphMix

Weighted QMIX

MAVEN

HAPPO

MAT

RODE

EMC

EMU

HPN

RL笔记（17）：模型预测控制 (MPC)

Fri, 26 Dec 2025 00:00:00 GMT

引言（Introduction）

在之前的笔记中，我们探讨了无模型 (Model-Free) 算法（如 Q-Learning, PPO, SAC）如何通过试错学习。我们也初步接触了基于模型 (Model-Based) 的 Dyna-Q，它通过学习环境模型来生成模拟数据辅助学习。

今天我们深入 Model-Based RL 的另一个重要分支：模型预测控制 (Model Predictive Control, MPC)。 MPC 的核心优势在于，它直接利用环境模型进行前向规划，像一个经验丰富的棋手一样“预判”未来，然后根据预测结果做出当前最优的决策。

MPC 不仅仅是生成模拟数据（像 Dyna-Q），它是在每一个状态下，都重新规划一次未来的动作序列。

MPC 的核心思想

MPC 是一种控制策略，它假设我们拥有一个精确的环境模型 $M(s,a) \to (r, s')$。

预测与规划 (Prediction & Planning)

在当前状态 $s_t$，MPC 并不直接选择一个动作。而是：

预测未来：假设从当前状态 $s_t$ 开始，执行一系列动作 $\pi = {a_t, a_{t+1}, \dots, a_{t+H}}$（称为预测时域 (Prediction Horizon) $H$）。
模拟轨迹：利用模型 $M$，模拟出这一系列动作可能产生的轨迹及其累积奖励。
优化规划：找到能最大化累积奖励的动作序列 $\pi^*$。

滚动优化 (Rolling Optimization)

MPC 的决策过程是滚动的：

在状态 $s_t$，MPC 找到最优动作序列 $\pi^* = {a_t^, a_{t+1}^, \dots, a_{t+H}^*}$。
只执行第一个动作 $a_t^*$。
智能体进入新状态 $s_{t+1}$。
重新规划：基于新的状态 $s_{t+1}$，重复步骤 1-3。

💡 直觉： MPC 就像一个有预见性的决策者。它不会一次性把所有步骤都定死，而是每走一步，都根据当前情况重新规划下一步的最佳路径。这使得它能很好地应对环境变化。

MPC 与强化学习的结合

MPC 本身是一种控制方法，如何与 RL 结合呢？

学习模型

在 Model-Based RL 中，我们首先需要学习一个环境模型 $M_\theta$。

监督学习：用收集到的真实数据 $(s, a, r, s')$ 来训练模型。
- 预测奖励：$r \approx R_\phi(s,a)$
- 预测状态：$s' \approx M_\theta(s,a)$
模型类型：可以是概率模型（如 PETS 使用的概率 GP 回归）来估计模型的不确定性，也可以是确定性模型（如简单的神经网络）。

MPC 规划

一旦有了模型 $M_\theta$，就可以进行规划：

在当前状态 $s_t$，MPC 在所有可能的 $H$ 步动作序列中搜索，找到能最大化模拟累积奖励的序列 $\pi^* = {a_t^, a_{t+1}^, \dots, a_{t+H}^*}$。
执行 $a_t^*$。

优化策略

MPC 产生的动作序列 $\pi^$ 本身就可以看作是当前状态下的一个“策略”。我们可以用标准的 RL 算法（如 PPO, SAC）来优化**生成这个 $\pi^$ 的参数**。

例如，MPC-SAC 的做法：

训练一个模型 $M_\theta$。
训练 Actor-Critic：
- Critic 学习 $Q$ 值。
- Actor 学习策略 $\pi_\phi$。
- 在 Actor 的更新时，使用 MPC 规划 $H$ 步，获得更准确的奖励信号来更新 Actor。

PETS 算法示例 (Probabilistic Embeded Trajectory Sampling)

PETS 是一个经典的 Model-Based RL 算法，它使用了概率模型来处理模型不确定性。

概率模型

PETS 使用高斯过程 (Gaussian Process, GP) 或其他概率模型来学习奖励函数 $R_\phi$ 和状态转移函数 $M_\theta$。

优点：GP 不仅能给出预测值，还能给出预测的不确定性（方差）。

采样与规划

在 MPC 规划时，PETS 会从学到的概率模型中采样多条可能的未来轨迹。

如果模型预测某一步不确定性很高（方差大），意味着未来可能有很多种情况，MPC 会倾向于选择风险更小的路径。

策略学习

PETS 也会用学习到的模型和规划结果来训练一个 Actor-Critic 策略。

MPC 的优势与劣势

优势

高样本效率：通过模型可以“预演”大量场景，大大减少与真实环境的交互次数。
可解释性：模型可以被检查，知道智能体为什么这么规划。
安全性：在规划时可以预见潜在的危险状态，并加以避免。

劣势

模型偏差 (Model Bias)：这是 Model-Based 方法的软肋。如果模型不准确，规划的结果可能完全错误。
计算成本：MPC 规划本身需要大量的计算，尤其是在动作空间连续、预测时域长的情况下。

总结

MPC 提供了一种强大的在已知模型下进行序列决策的方法。它通过向前看（预测）和滚动优化，能够做出比直接 RL 更明智的决策。将 MPC 与 RL 结合，是 Model-Based RL 的重要研究方向，其目标是学好模型，并用好模型，从而以最高的样本效率解决复杂任务。

我们之前的笔记主要聚焦于 Model-Free 方法（Q-Learning, REINFORCE, PPO, SAC）。Model-Based 方法（Dyna-Q, MPC）提供了另一种思路，它们往往在样本效率上具有优势，但在模型精度要求上较高。

RL笔记（16）：模仿学习 (Imitation Learning)

Thu, 25 Dec 2025 00:00:00 GMT

引言（Introduction）

在传统的强化学习中，智能体通过最大化累积奖励来学习。然而，在很多复杂任务中，“定义奖励”比“解决任务”本身还要难。

例子：自动驾驶。你很难用数学公式精确定义什么叫“开得稳且安全”。但是，我们可以很容易地收集到人类老司机的驾驶数据。

模仿学习 (Imitation Learning) 的目标是：给定一组专家演示数据 $\tau_E = {(s_1, a_1), (s_2, a_2), \dots }$，训练一个策略 $\pi_\theta$，使其行为尽可能接近专家策略 $\pi_E$。

我们不需要知道背后的奖励函数是什么，只需要“照猫画虎”。

行为克隆 (Behavioral Cloning, BC)

这是最简单、最直观的模仿学习方法。

核心思想

把模仿学习看作一个监督学习 (Supervised Learning) 问题。

输入：状态 $s$（特征）。
标签：动作 $a$（专家在 $s$ 下做的动作）。

我们的目标是训练一个分类器（离散动作）或回归器（连续动作）$\pi_\theta(s)$，使其输出拟合专家的动作。

目标函数

使用最大似然估计 (MLE)：

$$ \max_\theta \mathbb{E}{(s,a) \sim \pi_E} [\log \pi\theta(a|s)] $$

即最小化负对数似然损失：

$$ L(\theta) = - \sum_{i=1}^N \log \pi_\theta(a_i|s_i) $$

局限性：协变量偏移 (Covariate Shift)

虽然 BC 简单有效，但它有一个致命弱点：误差累积。

训练分布：策略是在专家访问过的状态 $s \sim P(\pi_E)$ 上训练的。
测试分布：在实际运行时，策略 $\pi_\theta$ 可能会犯一点小错。
恶性循环：这一点小错会导致智能体进入一个专家从未去过的状态（Out-of-Distribution）。在这种陌生状态下，BC 策略可能会胡乱行动，导致更大的错误，最终迅速偏离轨道（比如自动驾驶车偏离一点点后，不知道怎么修回去，直接冲出跑道）。

💡 总结：BC 只是单纯地拟合动作，而不理解“为什么要这么做”。

逆强化学习 (Inverse RL, IRL)

为了解决 BC 的问题，IRL 提出了一个更深层的思路：专家之所以这么做，是因为他在最大化某个未知的奖励函数 $R$。

如果我们能把这个 $R$ 反推（Inverse）出来，再用标准的 RL 算法（如 PPO/SAC）去最大化这个 $R$，不就能学会专家的策略了吗？

核心流程

假设：存在一个参数化的奖励函数 $R_\phi(s,a)$。
目标：找到参数 $\phi$，使得在该奖励函数下，专家的轨迹获得的累积回报高于其他任何策略。 $$ \mathbb{E}{\pi_E} [R\phi] \ge \mathbb{E}{\pi} [R\phi] $$
内层循环：给定当前的 $R_\phi$，通过 RL 训练一个最优策略 $\pi^*$。
外层循环：更新 $R_\phi$，使得专家轨迹和 $\pi^*$ 轨迹的差距变大（让专家得分更高）。

难点

IRL 是一个不适定 (Ill-posed) 问题：

很多奖励函数都能解释同一种行为（例如：如果 $R=0$，任何策略都是最优的）。
因此，IRL 通常需要引入最大熵 (Maximum Entropy) 假设：在所有能解释专家行为的奖励函数中，选择那个对策略分布约束最少（熵最大）的。

💡 总结：IRL 试图理解专家的“动机”。但它计算极其昂贵，因为每更新一次奖励函数，就要重新跑一遍完整的 RL 训练。

生成式对抗模仿学习 (GAIL)

Ho & Ermon (2016) 证明了：我们其实不需要显式地把奖励函数 $R$ 恢复出来。 如果我们直接训练一个策略，让它的状态-动作分布 $\rho_\pi(s,a)$ 和专家的分布 $\rho_E(s,a)$ 难以区分，不就达到目的了吗？

这正是 GAN (生成对抗网络) 的思想。

核心架构

GAIL 包含两个网络进行博弈：

判别器 (Discriminator) $D_w(s,a)$：
- 任务是找茬。它接收一个 $(s,a)$ 对，判断这是专家产生的（输出 1），还是智能体产生的（输出 0）。
生成器 (Generator) $\pi_\theta(a|s)$：
- 即我们的策略网络。任务是欺骗判别器，让自己的行为看起来像专家。

目标函数

GAIL 的优化目标与 GAN 几乎一致：

$$ \min_\pi \max_D V(\pi, D) = \mathbb{E}{\pi_E}[\log D(s,a)] + \mathbb{E}{\pi}[\log(1 - D(s,a))] $$

训练流程

训练判别器 $D$：
- 采样专家数据 $(s_E, a_E)$ 和智能体数据 $(s_\pi, a_\pi)$。
- 让 $D(s_E, a_E) \to 1$，让 $D(s_\pi, a_\pi) \to 0$。
训练策略 $\pi$：
- 我们使用 $D$ 的输出作为一种替代奖励 (Surrogate Reward)。
- 定义奖励函数：$r(s,a) = - \log(1 - D(s,a))$ （或者其他变体，如 $\log D(s,a)$）。
- 如果 $D$ 认为当前动作像专家（$D \approx 1$），奖励就高；不像专家，奖励就低。
- 使用 PPO 或 TRPO 来最大化这个奖励。

优势

解决了 Covariate Shift：因为 $\pi$ 是在环境中交互训练的（RL），遇到偏离的状态时，判别器会给低分，RL 算法会学会如何修正回到正轨。
效率高：不需要像 IRL 那样反复求解最优策略，策略和判别器是同步更新的。

总结与对比

💡 思考：如果专家的数据也不是完美的（比如偶尔手滑），BC 会傻傻地把错误也学进去，而 IRL/GAIL 由于有奖励函数的平滑作用，通常能学出比专家更好的策略。

RL笔记（15）：SAC

Wed, 24 Dec 2025 00:00:00 GMT

引言（Introduction）

Soft Actor-Critic (SAC) 是一种基于最大熵强化学习的 Off-Policy（离线策略） 算法，于 2018 年提出。 SAC 的前身是 Soft Q-learning (SQL)。相比于 SQL 需要复杂的采样过程，SAC 引入了 Actor-Critic 架构，使其训练更加稳定且高效。SAC 在各类 Benchmark 及真实机器人任务中表现出色，以其极强的抗干扰能力和对超参数的鲁棒性著称，是现代深度强化学习的基石算法之一。

最大熵强化学习 (Maximum Entropy RL)

熵的定义

熵 (Entropy) 表示对一个随机变量的随机程度的度量。如果 $X$ 是一个随机变量，它的概率密度记为 $p$，那么它的熵 $H$ 定义为：

$$ \begin{align} H(X)&=\mathbb{E}{x\sim p}[-\log p(x)]\notag \ &=-\int{x}p(x)\log p(x) \mathrm{d}x \notag \end{align} $$

在强化学习中，可以使用 $H(\pi(\cdot|s))$ 来表示策略 $\pi$ 在状态 $s$ 下的随机程度。

目标函数

最大熵强化学习（maximum entropy RL）的思想是除了最大化累计奖励，还要使得策略更加随机。如此，强化学习的目标中加入了一项熵的正则项，定义为：

$$ \begin{align} \pi_{\textbf{MaxEnt}}^*=\arg\max_{\pi}\mathbb{E}{\pi}\left[\sum{t=0}^\infty r(s_t,a_t)+\alpha H(\pi(\cdot|s_t))\right]\notag \end{align} $$

其中，$\alpha$ 是一项正则项系数，用来权衡熵的重要程度。 SAC 算法加入熵正则项，有利于增加强化学习算法的探索，$\alpha$ 越大，探索性越强，有助于加速策略的学习，降低策略陷入局部最优的可能性。

基于能量的模型 (Energy-Based Model, EBM)

基于能量的模型（Energy-Based Model，EBM）是一类基于统计物理学原理的概率模型，通过能量函数为每个可能的状态分配一个标量能量值，低能量区域对应高概率区域。在强化学习中，EBM 将状态-动作对 $(s,a)$ 映射到能量值 $\mathcal{E}$，从而表示策略分布，定义为：

$$ \begin{align} \pi(a|s)=\frac{\exp(-\mathcal{E}(s,a))}{Z(s)}\notag \end{align} $$

其中，$Z(s)=\int_{A}\exp(-\mathcal{E}(s,a))\mathrm{d}a$ 是配分函数，负责归一化能量值以形成有效的概率分布。

Soft 策略迭代 (Soft Policy Iteration)

Soft 贝尔曼方程

$$ \begin{align} V_{\textbf{soft}}^\pi(s)&=\mathbb{E}{a\sim\pi(\cdot|s)}[Q^{\pi}{\textbf{soft}}(s,a)-\alpha\log\pi(a|s)]\notag \ &=\mathbb{E}{a\sim \pi(a|s)}[Q^{\pi}{\textbf{soft}}(s,a)]+\alpha H(\pi(\cdot|s)) \notag \end{align} $$

$$ \begin{align} Q^{\pi}{\textbf{soft}}(s,a)=r(s,a)+\gamma \mathbb{E}{s^\prime\sim p(\cdot|s,a)}[V_{\textbf{soft}}^\pi(s^\prime)]\notag \ \end{align} $$

Soft 策略评估 (Soft Policy Evaluation)

在 SAC 算法中，Soft 价值函数定义为：

$$ \begin{align} V_{\textbf{soft}}^\pi(s)\triangleq\mathbb{E}{a\sim\pi(\cdot|s)}[Q^{\pi}{\textbf{soft}}(s,a)-\alpha\log\pi(a|s)]\notag \end{align} $$

Soft 动作价值函数定义为：

$$ \begin{align} Q^{\pi}{\textbf{soft}}(s,a)\triangleq r(s,a)+\gamma \mathbb{E}{s^\prime\sim p(\cdot|s,a)}[V_{\textbf{soft}}^\pi(s^\prime)]\notag \ \end{align} $$

动作价值函数的 Soft 贝尔曼迭代算子定义为：

$$ \begin{align} \mathcal{T}^\pi Q^{k}{\textbf{soft}}(s,a)&\triangleq r(s,a)+\gamma \mathbb{E}{s^\prime\sim p(\cdot|s,a)}[V_{\textbf{soft}}^{k}(s^\prime)]\notag \ &\triangleq r(s,a)+\gamma \mathbb{E}{s^\prime\sim p(\cdot|s,a)}[\mathbb{E}{a^\prime\sim\pi(\cdot|s^\prime)}[Q^{k}_{\textbf{soft}}(s^\prime,a^\prime)-\alpha\log\pi(a^\prime|s^\prime)]]\notag \end{align} $$

Soft 策略评估定理：基于上述的算子 $\mathcal{T}^\pi$ 以及初始化的映射 $Q^0_{\textbf{soft}}:S\times A\rightarrow \mathbb{R}$，且 $|A|<\infty$，$Q^{k+1}{\textbf{soft}}=\mathcal{T}^\pi Q^k{\textbf{soft}}$。那么当 $k\rightarrow\infty$ 时，序列 ${Q^k_{\textbf{soft}}}$ 会收敛至 $Q_{\textbf{soft}}^\pi$。

接下来证明这是一个压缩映射。文章重新定义了奖励 $r_\pi(s,a)$：

$$ \begin{align} r_{\pi}(s,a)\triangleq r(s,a)+\mathbb{E}_{s^\prime\sim p(\cdot|s,a)}[H(\pi(\cdot|s^\prime))]\notag \ \end{align} $$

迭代式可以重写为：

$$ \begin{align} \mathcal{T}^\pi Q^{k}{\textbf{soft}}(s,a)\triangleq r\pi(s,a)+\gamma \mathbb{E}{s^\prime\sim p(\cdot|s,a), a^\prime \sim \pi(\cdot|s^\prime)}[Q^{k}{\textbf{soft}}(s^\prime,a^\prime)]\notag \ \end{align} $$

在算法中，我们假设 $|A|<\infty$，那么 $r_\pi(s,a)$ 就是有界的，那么只需要证明此不等式：

$$ \begin{align} \big|\big|\mathcal{T}^\pi Q^N_{\textbf{soft}}(s,a)-\mathcal{T}^\pi Q^M_{\textbf{soft}}(s,a)\big|\big|\infty \le k\big|\big| Q^N{\textbf{soft}}(s,a)-Q^M_{\textbf{soft}}(s,a)\big|\big|_\infty ,\quad\exists k\in(0,1)\notag \end{align} $$

左式化简为：

$$ \begin{align} \big|\mathcal{T}^\pi Q^N_{\textbf{soft}}(s,a)-\mathcal{T}^\pi Q^M_{\textbf{soft}}(s,a)\big| &=\gamma\big|\mathbb{E}{s^\prime\sim p(\cdot|s,a), a^\prime\sim\pi(\cdot|s^\prime)}\left[Q^N{\textbf{soft}}(s^\prime,a^\prime)-Q^M_{\textbf{soft}}(s^\prime,a^\prime)\right]\big|\notag \ &\le \gamma\mathbb{E}{s^\prime\sim p(\cdot|s,a), a^\prime\sim\pi(\cdot|s^\prime)}\left[\big|Q^N{\textbf{soft}}(s^\prime,a^\prime)-Q^M_{\textbf{soft}}(s^\prime,a^\prime)\big|\right] \notag \ &\le \gamma\mathbb{E}{s^\prime\sim p(\cdot|s,a)}\left[\max{a^\prime\in A}\big|Q^N_{\textbf{soft}}(s^\prime,a^\prime)-Q^M_{\textbf{soft}}(s^\prime,a^\prime)\big|\right] \notag \ &\le \gamma \max_{s^\prime\in S,a^\prime\in A} \big|Q^N_{\textbf{soft}}(s^\prime,a^\prime)-Q^M_{\textbf{soft}}(s^\prime,a^\prime)\big| \notag \end{align} $$

最终可以得出：

$$ \begin{align} \max_{s\in S,a\in A}\big|\mathcal{T}^\pi Q^N_{\textbf{soft}}(s,a)-\mathcal{T}^\pi Q^M_{\textbf{soft}}(s,a)\big| \le \gamma \max_{s^\prime\in S,a^\prime\in A} \big|Q^N_{\textbf{soft}}(s^\prime,a^\prime)-Q^M_{\textbf{soft}}(s^\prime,a^\prime)\big| \notag \ \end{align} $$

其中，折扣因子 $\gamma\in(0,1)$，可以证明 $\mathcal{T}^\pi$ 是压缩映射。

Soft 策略提升 (Soft Policy Improvement)

Soft 策略提升定理：对于任意 $\pi_{\text{old}} \in \Pi$，并以下式优化 $\pi_{\text{new}}$。假设 $|A|<\infty$，那么对于 $\forall (s,a) \in S \times A$，有 $Q_{\textbf{soft}}^{\pi_{\text{new}}}(s,a)\ge Q_{\textbf{soft}}^{\pi_{\text{old}}}(s,a)$。

$$ \begin{align} \pi_{\text{new}}(\cdot|s)=\arg \min_{\pi^\prime\in\Pi}D_{\textbf{KL}}\left(\pi^\prime(\cdot|s)\Big|\Big|\frac{\exp(\frac{1}{\alpha}Q^{\pi_{\text{old}}}{\textbf{soft}}(s,\cdot))}{Z^{\pi{\text{old}}}(s)}\right)\notag \ \end{align} $$

其中 $Z^{\pi_{\text{old}}}(s)$ 是配分函数，负责归一化分布。

定义 $J(\pi(\cdot|s);\pi_{\text{old}})$ 为：

$$ \begin{align} J(\pi(\cdot|s);\pi_{\text{old}})&= D_{\textbf{KL}}\left(\pi(\cdot|s)\Big|\Big|\frac{\exp(\frac{1}{\alpha}Q_{\textbf{soft}}^{\pi_\text{old}}(s,\cdot))}{Z^{\pi_\text{old}}(s)}\right)\notag \ &=\int_a \pi(a|s)\log\frac{\pi(a|s)}{\exp(\frac{1}{\alpha}Q_{\textbf{soft}}^{\pi_\text{old}}(s,a)-\log Z^{\pi_{\text{old}}}(s))}\text{d}a \notag \ &=\mathbb{E}{a\sim\pi(\cdot|s)}\left[\log\pi(a|s)-\frac{1}{\alpha}Q{\textbf{soft}}^{\pi_\text{old}}(s,a)+\log Z^{\pi_\text{old}}(s)\right] \notag \end{align} $$

那么对于 $\pi_\text{old}$ 和 $\pi_\text{new}$，满足 $J(\pi_\text{new}(\cdot|s);\pi_\text{old})\le J(\pi_\text{old}(\cdot|s);\pi_\text{old})$，即：

$$ \begin{align} \mathbb{E}{a\sim\pi\text{new}(\cdot|s)}\left[\log\pi_\text{new}(a|s)-\frac{1}{\alpha}Q_{\textbf{soft}}^{\pi_\text{old}}(s,a)+\log Z^{\pi_\text{old}}(s)\right] \le \mathbb{E}{a\sim\pi\text{old}(\cdot|s)}\left[\log\pi_\text{old}(a|s)-\frac{1}{\alpha}Q_{\textbf{soft}}^{\pi_\text{old}}(s,a)+\log Z^{\pi_\text{old}}(s)\right] \notag \ \end{align} $$

$Z^{\pi_\text{old}}(s)$ 与 $a$ 无关，相约后得：

$$ \begin{align} \mathbb{E}{a\sim\pi\text{new}(\cdot|s)}\left[\log\pi_\text{new}(a|s)-\frac{1}{\alpha}Q_{\textbf{soft}}^{\pi_\text{old}}(s,a)\right] \le \mathbb{E}{a\sim\pi\text{old}(\cdot|s)}\left[\log\pi_\text{old}(a|s)-\frac{1}{\alpha}Q_{\textbf{soft}}^{\pi_\text{old}}(s,a)\right] \notag \ \end{align} $$

化简为：

$$ \begin{align} \mathbb{E}{a\sim\pi\text{new}(\cdot|s)}\left[Q_{\textbf{soft}}^{\pi_\text{old}}(s,a)-\alpha\log\pi_\text{new}(a|s)\right] \ge \mathbb{E}{a\sim\pi\text{old}(\cdot|s)}\left[Q_{\textbf{soft}}^{\pi_\text{old}}(s,a)-\alpha\log\pi_\text{old}(a|s)\right] = V_{\textbf{soft}}^{\pi_\text{old}}(s) \notag \ \end{align} $$

接下来证明 $Q_{\textbf{soft}}^{\pi_{\text{new}}}(s,a)\ge Q_{\textbf{soft}}^{\pi_{\text{old}}}(s,a)$，我们利用上式进行迭代展开：

$$ \begin{align} Q_{\textbf{soft}}^{\pi_{\text{old}}}(s,a) &= r_0 + \gamma \mathbb{E}{s_1\sim p(\cdot|s,a)}\left[ V{\textbf{soft}}^{\pi_\text{old}}(s_1)\right]\notag \ &\le r_0 + \gamma \mathbb{E}{s_1\sim p(\cdot|s,a)}\left[\mathbb{E}{a_1\sim \pi_\text{new}(\cdot|s_1)}\left[Q_{\textbf{soft}}^{\pi_\text{old}}(s_1,a_1) - \alpha \log \pi_\text{new}(a_1|s_1)\right]\right] \notag \ &= r_0 + \gamma \mathbb{E}{s_1\sim p(\cdot|s,a)}\left[\mathbb{E}{a_1\sim \pi_\text{new}(\cdot|s_1)}\left[r(s_1, a_1) + \gamma \mathbb{E}{s_2}[V{\textbf{soft}}^{\pi_\text{old}}(s_2)] + \alpha H(\pi_\text{new}(\cdot|s_1))\right]\right] \notag \ &\cdots \notag \ &\le \sum_{t=0}^\infty \gamma^t \mathbb{E}{(s_t,a_t)\sim \rho^{\pi\text{new}}}\left[r(s_t,a_t)+\alpha H(\pi_\text{new}(\cdot|s_t))\right]\notag \ &=Q_{\textbf{soft}}^{\pi_\text{new}}(s,a) \notag \end{align} $$

证明完毕。

Soft 策略迭代定理

假设 $|A|<\infty$，对于任意 $\pi \in \Pi$，重复应用 Soft 策略评估和 Soft 策略提升，会收敛到 $\pi^$，使得对于任意 $\pi \in \Pi$ 以及 $(s,a)\in S\times A$，都有 $Q^{\pi^}\textbf{soft}(s,a)\ge Q^{\pi}\textbf{soft}(s,a)$。

证明过程：令 $\pi_i$ 为第 $i$ 轮迭代的策略，根据 Soft 策略迭代定理，序列 ${Q^{\pi_i}\textbf{soft}}$ 是单调递增的。对于任意 $\pi \in \Pi$， $Q^\pi\textbf{soft}$ 是有上界的（奖励与熵均是有界的），因此序列会收敛到某个 $\pi^$，接下来需要证明 $\pi^$ 是最优的。在收敛时，必然满足：对于任意 $\pi\in\Pi$ 且 $\pi\neq \pi^$，都有 $J(\pi^(\cdot|s);\pi^) < J(\pi(\cdot|s);\pi^)$，即：

$$ \begin{align} \mathbb{E}{a\sim\pi^(\cdot|s)}\left[\log\pi^(a|s)-\frac{1}{\alpha}Q{\textbf{soft}}^{\pi^}(s,a)\right] < \mathbb{E}{a\sim\pi(\cdot|s)}\left[\log\pi(a|s)-\frac{1}{\alpha}Q{\textbf{soft}}^{\pi^}(s,a)\right] \notag \ \end{align} $$

化简为：

$$ \begin{align} V_\textbf{soft}^{\pi^}(s) > \mathbb{E}{a\sim \pi(\cdot|s)}\left[Q\textbf{soft}^{\pi^}(s,a)-\alpha \log \pi(a|s)\right]\notag \ \end{align} $$

接下来证明 $\pi^$ 是最优的，即证明 $Q_\textbf{soft}^{\pi^ }(s,a) > Q^\pi_\textbf{soft}(s,a)$：

$$ \begin{align} Q_\textbf{soft}^{\pi^* }(s,a)&=r_0+\gamma\mathbb{E}{s_1\sim p(\cdot|s,a)}\left[V\textbf{soft}^{\pi^}(s_1)\right]\notag \ &>r_0+\gamma\mathbb{E}{s_1\sim p(\cdot|s,a)}\left[\mathbb{E}{a_1\sim \pi(\cdot|s_1)}\left[Q_\textbf{soft}^{\pi^}(s_1,a_1)-\alpha \log \pi(a_1|s_1)\right]\right] \notag \ &= r_0+\gamma\mathbb{E}{s_1\sim p(\cdot|s,a)}\left[\mathbb{E}{a_1\sim \pi(\cdot|s_1)}\left[r(s_1, a_1) + \gamma \mathbb{E}{s_2}[V\textbf{soft}^{\pi^*}(s_2)] + \alpha H(\pi(\cdot|s_1))\right]\right] \notag \ &> \sum_{t=0}^\infty \gamma^t \mathbb{E}{(s_t,a_t)\sim\rho^\pi}\left[r(s_t,a_t)+\alpha H(\pi(\cdot|s_t))\right] \notag \ &=Q^\pi\textbf{soft}(s,a)\notag \end{align} $$

证明完毕。

算法实现

在 SAC 算法中，我们为两个动作价值函数 $Q_\textbf{soft}$（参数分别 $\omega_1$ 为和 $\omega_2$）和一个策略函数 $\pi$（参数为 $\theta$）建模。基于 Double DQN 的思想，SAC 使用 $Q_\textbf{soft}$ 两个网络，但每次用 $Q_\textbf{soft}$ 网络时会挑选一个 $Q_\textbf{soft}$ 值小的网络，从而缓解 $Q_\textbf{soft}$ 值过高估计的问题。

动作价值函数 (Critic)

任意一个函数 $Q_\textbf{soft}$ 的损失函数为：

$$ \begin{align} L_{Q_\textbf{soft}}(\omega)&=\mathbb{E}{(s_t,a_t,r_t,s{t+1})\sim R}\left[\frac{1}{2}\left(Q_\textbf{soft}^\omega(s_t,a_t)-\left(r_t+\gamma V_{\textbf{soft}}^{\omega^-}(s_{t+1})\right)\right)^2\right]\notag \ &= \mathbb{E}{(s_t,a_t,r_t,s{t+1})\sim R}\left[\frac{1}{2}\left(Q_\textbf{soft}^\omega(s_t,a_t)-\left(r_t+\gamma\mathbb{E}{a{t+1}\sim \pi_\theta(\cdot|s_{t+1})}\left[\min_{j=1,2} Q_\textbf{soft}^{\omega_j^-}(s_{t+1},a_{t+1})-\alpha \log \pi_{\theta}(a_{t+1}|s_{t+1})\right]\right)\right)^2\right]\notag \end{align} $$

其中，$R$ 是策略过去收集的数据，因为 SAC 是一种离线策略算法。为了让训练更加稳定，这里使用了两个目标网络 $Q_\textbf{soft}^{\omega_j^-}$。目标网络的更新方式是 Soft 更新：

$$ \begin{align} \omega_j^-\leftarrow \tau \omega_j + (1-\tau) \omega_j^-, \quad j=1,2\notag \end{align} $$

策略函数 (Actor)

接下来根据 Soft 策略提升定理中的 KL 散度来推导策略 $\pi_\theta$ 的损失函数 $L_{\pi}(\theta)$：

$$ \begin{align} \theta&=\arg \min_{\theta} L_\pi(\theta) \notag \ &=\arg \min_{\theta} \mathbb{E}{s_t\sim R}\left[D\textbf{KL}\left(\pi_\theta(\cdot|s_t)\Big|\Big|\frac{\exp(\frac{1}{\alpha }Q_\textbf{soft}^\omega(s_t,\cdot))}{Z(s_t)}\right)\right]\notag \ &= \arg\min_\theta \mathbb{E}{s_t\sim R}\left[\mathbb{E}{a_t\sim \pi_\theta(\cdot|s_t)}\left[\log\left(\frac{\pi_\theta(a_t|s_t)Z(s_t)}{\exp(\frac{1}{\alpha}Q_\textbf{soft}^\omega(s_t,a_t))}\right)\right]\right] \notag \ &=\arg\min_\theta \mathbb{E}{s_t\sim R, a_t\sim \pi\theta(\cdot|s_t)}\left[\log \pi_\theta(a_t|s_t)-\frac{1}{\alpha}Q_\textbf{soft}^\omega(s_t,a_t)+\log Z(s_t)\right] \notag \ &=\arg\min_\theta \mathbb{E}{s_t\sim R, a_t\sim \pi\theta(\cdot|s_t)}\left[\log \pi_\theta(a_t|s_t)-\frac{1}{\alpha}Q_\textbf{soft}^\omega(s_t,a_t)\right] \notag \ &=\arg\min_\theta \mathbb{E}{s_t\sim R, a_t\sim \pi\theta(\cdot|s_t)}\left[\alpha\log \pi_\theta(a_t|s_t)-Q_\textbf{soft}^\omega(s_t,a_t)\right] \notag \ &=\arg\max_\theta \mathbb{E}{s_t\sim R}\left[V\textbf{soft}^\omega (s_t)\right]\notag \end{align} $$

考虑到两个 $Q_\textbf{soft}^\omega$ 网络，损失函数写为：

$$ \begin{align} L_\pi(\theta)=\arg\min_\theta \mathbb{E}{s_t\sim R, a_t\sim \pi\theta(\cdot|s_t)}\left[\alpha\log \pi_\theta(a_t|s_t)-\min_{j=1,2}Q_\textbf{soft}^{\omega_j}(s_t,a_t)\right] \notag \ \end{align} $$

重参数化技巧 (Reparameterization Trick)

对于连续动作空间的环境，策略输出 Gauss 分布的均值和标准差，但是 Gauss 分布采样动作的过程是不可导的。因此，我们使用了重参数化技巧。重参数化的做法是先从标准的 Gauss 分布 $\mathcal{N}$ 进行采样，然后再将采样值乘以标准差后加上均值，如下：

$$ \begin{align} a_t&=f_\theta(\epsilon_t;s_t) \notag \ &= \mu_\theta(s_t)+\epsilon_t\sigma_\theta(s_t), \quad \epsilon\sim\mathcal{N}(0,I)\notag \end{align} $$

这样就可以认为是从策略高斯分布采样，并且这样对于策略函数是可导的，损失函数写为：

$$ \begin{align} L_\pi(\theta)=\arg\min_\theta \mathbb{E}{s_t\sim R, \epsilon_t \sim \mathcal{N}}\left[\alpha\log \pi\theta(f_\theta(\epsilon_t;s_t)|s_t)-\min_{j=1,2}Q_\textbf{soft}^{\omega_j}(s_t,f_\theta(\epsilon_t;s_t))\right] \notag \ \end{align} $$

自动调整熵系数 (Automating Entropy Adjustment)

在 SAC 算法中，如何选择熵正则项的系数非常重要。在不同的状态下需要不同大小的熵：在最优动作不确定的某个状态下，熵的取值应该大一点；而在某个最优动作比较确定的状态下，熵的取值可以小一点。为了自动调整熵正则项，SAC 将强化学习的目标改写为一个带约束的优化问题：

$$ \begin{align} \arg\max_\theta\mathbb{E}{(s_t,a_t)\sim \rho^{\pi\theta}}\left[\sum_{t=0}^\infty r(s_t,a_t)\right] \quad \text{s.t.} \quad \mathbb{E}{(s_t,a_t)\sim\rho^{\pi\theta}}\left[-\log\pi_\theta(a_t|s_t)\right]\ge H_0\notag \ \end{align} $$

将上述问题转化为 KKT（Karush-Kuhn-Tucker）条件下的约束问题：

$$ \begin{align} \arg\min_\theta\mathbb{E}{(s_t,a_t)\sim \rho^{\pi\theta}}\left[-\sum_{t=0}^\infty r(s_t,a_t)\right] \quad \text{s.t.} \quad H_0-\mathbb{E}{(s_t,a_t)\sim\rho^{\pi\theta}}\left[-\log\pi_\theta(a_t|s_t)\right]\le 0\notag \ \end{align} $$

通过拉格朗日乘数法，转化为无约束问题，拉格朗日函数为：

$$ \begin{align} L(\theta,\alpha)=\mathbb{E}{(s_t,a_t)\sim \rho^{\pi\theta}}\left[-\sum_{t=0}^\infty r(s_t,a_t)\right] + \alpha\left[H_0-\mathbb{E}{(s_t,a_t)\sim\rho^{\pi\theta}}\left[-\log\pi_\theta(a_t|s_t)\right]\right] \notag \end{align} $$

其中 $\alpha\ge0$ 是拉格朗日乘数，将拉格朗日函数中与 $\alpha$ 相关的提取出来：

$$ \begin{align} L(\alpha)=\mathbb{E}{s_t\sim R,a_t\sim\pi\theta(\cdot|s_t)}\left[-\alpha\log\pi_\theta(a_t|s_t)-\alpha H_0\right] \notag \end{align} $$

即当策略的熵低于目标值 $H_0$ 时，训练目标 $L(\alpha)$ 会使 $\alpha$ 的值增大，进而在上述最小化损失函数 $L_\pi(\theta)$ 的过程中增加了策略熵对应项的重要性；而当策略的熵高于目标值 $H_0$ 时，训练目标 $L(\alpha)$ 会使 $\alpha$ 的值减小，进而使得策略训练时更专注于价值提升。

RL笔记（14）：SQL

Tue, 23 Dec 2025 00:00:00 GMT

引言（Introduction）

Soft Q-Learning (SQL) 是强化学习中结合 最大熵强化学习（Maximum Entropy Reinforcement Learning） 思想的 Q-Learning 扩展算法。它的核心目标不仅仅是找到那一条获得最高分的路，而是要找到所有能获得高分的路。它在最大化累积奖励的同时，强制策略保持随机性（即最大化策略的熵），从而提升策略的探索能力、鲁棒性和泛化性。

最大熵强化学习（Maximum Entropy RL）

基本定义

熵（Entropy） 是表示随机变量不确定性的度量。对于随机变量 $X$，如果其概率密度为 $p$，熵 $H$ 定义为：

$$ \begin{align} H(X)&=\mathbb{E}{x\sim p}[-\log p(x)]\notag \ &=-\int{X}p(x)\log p(x) \mathrm{d}x \notag \end{align} $$

在强化学习中，我们关注的是策略 $\pi$ 在状态 $s$ 下的随机程度，记为 $H(\pi(\cdot|s))$。

目标函数

最大熵强化学习的思想是：除了最大化累计奖励，还要使得策略更加随机。因此，目标函数中加入了一项熵正则项：

$$ \begin{align} \pi_{\textbf{MaxEnt}}^*=\arg\max_{\pi}\sum_{t=0}^\infty \mathbb{E}_{\pi}[ r(s_t,a_t)+\alpha H(\pi(\cdot|s_t))]\notag \end{align} $$

$\alpha$ (Temperature)：正则项系数，用来权衡熵的重要程度。
- $\alpha \to 0$：退化为标准 RL（贪婪）。
- $\alpha$ 越大：越鼓励探索，策略分布越平坦。

💡 直觉理解：这一项 $\alpha H$ 的加入，意味着智能体如果不去探索新的动作，或者太早确定一个动作（熵变低），就会受到“惩罚”。这能有效防止智能体陷入局部最优。

基于能量的模型 (Energy-Based Model, EBM)

SQL 使用基于能量的模型来建模策略。这源于统计物理学：能量越低的状态，出现的概率越高。

在强化学习中，我们将状态-动作对 $(s,a)$ 映射到能量值 $\mathcal{E}$。策略分布定义为：

$$ \begin{align} \pi(a|s)=\frac{\exp(-\mathcal{E}(s,a))}{Z(s)}\notag \end{align} $$

其中，$Z(s)$ 是配分函数（Partition Function），用于归一化，确保概率之和为 1：

$$ Z(s)=\int_{\mathcal{A}}\exp(-\mathcal{E}(s,a))\mathrm{d}a $$

在 Soft Q-Learning 中，我们通常用 Soft Q 值来代替负能量 $-\mathcal{E}(s,a)$，即 $Q_{soft}(s,a)$ 越大，选择该动作的概率越大。

Soft 贝尔曼方程 (Soft Bellman Equation)

为了推导 SQL，我们需要重新定义价值函数 $V$ 和 $Q$，将熵包含进去。

回顾：普通贝尔曼方程

普通 $Q$ 值：

$$ \begin{align} Q^\pi(s,a) &= r(s,a)+\gamma\mathbb{E}_{s^\prime \sim p(\cdot|s,a)}[V^\pi(s^\prime)] \notag \end{align} $$

普通 $V$ 值：

$$ \begin{align} V^\pi(s) &=\mathbb{E}_{a\sim \pi(\cdot|s)}[Q^\pi(s,a)] \notag \end{align} $$

定义：Soft 贝尔曼方程

在最大熵框架下，价值函数的定义发生了变化。

Soft 状态价值函数 $V_\text{soft}$ 推导： $V_\text{soft}$ 不仅包含未来的奖励，还包含未来的熵。

$$ \begin{align} V_{\textbf{soft}}^\pi(s) &=\mathbb{E}{\pi}[\sum{l=0}^\infty \gamma^l(R_{t+l}+\alpha H(\pi(\cdot|S_{t+l})))|S_t=s] \notag \ &=\mathbb{E}{\pi}[R_t+\alpha H(\pi(\cdot|S_t))|S_t=s]+\gamma \mathbb{E}{\pi}[\sum_{l=0}^\infty \gamma^l(R_{t+1+l}+\alpha H(\pi(\cdot|S_{t+1+l})))] \notag \ &=\mathbb{E}{a\sim\pi(\cdot|s)}[r(s,a)]+\alpha H(\pi(\cdot|s))+\gamma \mathbb{E}{a\sim\pi(\cdot|s),s^\prime\sim p(\cdot|s,a)}[V^{\pi}_{\textbf{soft}}(s^\prime)] \notag \end{align} $$

将 $H(\pi)$ 展开为期望形式 $\mathbb{E}[-\log \pi]$，可以合并项：

$$ \begin{align} V_{\textbf{soft}}^\pi(s) &=\mathbb{E}{a\sim\pi(\cdot|s)}[r(s,a)-\alpha\log\pi(a|s)+\gamma\mathbb{E}{s^\prime\sim p(\cdot|s,a)}[V^{\pi}{\textbf{soft}}(s^\prime)]] \notag \ &=\mathbb{E}{a\sim\pi(\cdot|s)}[r(s,a)+\gamma \mathbb{E}{s^\prime\sim p(\cdot|s,a)}[V^{\pi}{\textbf{soft}}(s^\prime)]]+\alpha H(\pi(\cdot|s)) \notag \end{align} $$

Soft 动作价值函数 $Q_\text{soft}$ 推导： 与 $V$ 类似，展开递归形式：

$$ \begin{align} Q_{\textbf{soft}}^\pi(s,a) &=r(s,a)+\gamma \mathbb{E}{s^\prime\sim p(\cdot|s,a),a^\prime\sim\pi(\cdot|s^\prime)}[Q^{\pi}{\textbf{soft}}(s^\prime,a^\prime)-\alpha\log\pi(a^\prime|s^\prime)] \notag \end{align} $$

两者关系总结：

V 与 Q 的关系：

$$ \begin{align} V_{\textbf{soft}}^\pi(s)&=\mathbb{E}{a\sim\pi(\cdot|s)}[Q^{\pi}{\textbf{soft}}(s,a)-\alpha\log\pi(a|s)]\notag \ &=\mathbb{E}{a\sim \pi(a|s)}[Q^{\pi}{\textbf{soft}}(s,a)]+\alpha H(\pi(\cdot|s)) \notag \end{align} $$

💡 笔记：这说明 $V$ 值等于 $Q$ 值的期望加上当前的熵红利。
Q 与 V 的关系（Soft Bellman）： $$ \begin{align} Q^{\pi}{\textbf{soft}}(s,a)=r(s,a)+\gamma \mathbb{E}{s^\prime\sim p(\cdot|s,a)}[V_{\textbf{soft}}^\pi(s^\prime)]\notag \ \end{align} $$

Soft 策略提升定理 (Soft Policy Improvement)

我们如何保证更新策略后，效果一定会变好？这里给出了详细证明。

定理：对于任意状态 $s$，如果我们按照以下规则更新策略：

$$ \begin{align} \tilde{\pi}(\cdot|s) \propto \exp(\frac{1}{\alpha}Q^{\pi}_{\textbf{soft}}(s,\cdot)), \quad \forall s \in \mathcal{S} \notag \ \end{align} $$

那么新策略 $\tilde{\pi}$ 的 Soft Q 值一定优于旧策略 $\pi$。

证明过程

首先，我们计算旧策略 $\pi$ 下的 $V$ 值，并尝试引入新策略 $\tilde{\pi}$ 的形式。

$$ \begin{align} V_{\textbf{soft}}^\pi(s)&=\mathbb{E}{a\sim \pi(\cdot|s)}[Q{\textbf{soft}}^\pi(s,a)]+\alpha H(\pi(\cdot|s)) \notag \ &=\int_a\pi(a|s)Q_{\textbf{soft}}^\pi(s,a)\text{d}a-\alpha\int_a\pi(a|s)\log\pi(a|s)\text{d}a\notag \end{align} $$

这里利用一个恒等变换。因为更新规则 $\tilde{\pi}(a|s) = \frac{\exp(\frac{1}{\alpha}Q(s,a))}{Z(s)}$，所以 $Q(s,a) = \alpha \log \tilde{\pi}(a|s) + \alpha \log Z(s)$。代入积分中：

$$ \begin{align} V_{\textbf{soft}}^\pi(s) &= \alpha\int_a \pi(a|s) \left[ \log \tilde{\pi}(a|s) + \log \int_{a^\prime}\exp(\frac{1}{\alpha}Q_{\textbf{soft}}^\pi(s,a^\prime))\text{d}a^\prime \right] \text{d}a - \alpha\int_a\pi(a|s)\log\pi(a|s)\text{d}a \notag \ &= \alpha \log \left[ \int_{a^\prime}\exp(\frac{1}{\alpha}Q_{\textbf{soft}}^\pi(s,a^\prime))\text{d}a^\prime \right] + \alpha \int_a \pi(a|s) \log \frac{\tilde{\pi}(a|s)}{\pi(a|s)} \text{d}a \notag \ &= \alpha \log \int_a\exp(\frac{1}{\alpha}Q_{\textbf{soft}}^\pi(s,a))\text{d}a - \alpha D_{\textbf{KL}}(\pi(\cdot|s)||\tilde{\pi}(\cdot|s)) \notag \end{align} $$

当 $\pi = \tilde{\pi}$ 时，KL 散度为 0，我们得到Soft Value Function 的解析解（LogSumExp 形式）：

$$ V_{\textbf{soft}}^{\tilde{\pi}}(s) = \alpha \log \int_a \exp(\frac{1}{\alpha}Q_{\textbf{soft}}^\pi(s,a))\text{d}a $$

因为 KL 散度非负（$D_{KL} \ge 0$），且 $\alpha > 0$，所以去掉 KL 项后，不等式成立：

$$ \begin{align} \alpha \log \int_a \exp(\frac{1}{\alpha}Q)\text{d}a \ge V_{\textbf{soft}}^\pi(s) + \alpha D_{\textbf{KL}} \ge V_{\textbf{soft}}^\pi(s) \notag \end{align} $$

这导出了关键不等式：

$$ \begin{align} \mathbb{E}{a\sim\tilde{\pi}(\cdot|s)}[Q{\textbf{soft}}^\pi(s,a)]+ \alpha H(\tilde{\pi}(\cdot|s))\ge \mathbb{E}{a\sim\pi(\cdot|s)}[Q{\textbf{soft}}^\pi(s,a)]+ \alpha H(\pi(\cdot|s)) \notag \end{align} $$

接下来的迭代推导证明了 $Q$ 值的单调递增性（通过不断展开贝尔曼算子）：

$$ \begin{align} Q_{\textbf{soft}}^\pi(s,a) &= r_0 + \gamma V_{soft}^\pi(s_1) \notag \ &\le r_0 + \gamma (\mathbb{E}{a_1 \sim \tilde{\pi}}[Q^\pi(s_1, a_1)] + \alpha H(\tilde{\pi})) \quad \text{(根据上述不等式)} \notag \ &\le \dots \notag \ &\le Q{\textbf{soft}}^{\tilde{\pi}}(s,a) \notag \end{align} $$

💡 结论：只要我们将策略更新为正比于 $\exp(Q/\alpha)$，新的策略在 Soft Q 值的评估下一定比旧策略更好（或持平）。

Soft 策略评估定理与收敛性证明

我们定义Soft 贝尔曼算子 $\mathcal{T}$，并证明反复应用它会收敛到最优值。

定义算子操作：

$$ \begin{align} \mathcal{T} Q_{\textbf{soft}}^\pi(s,a) \triangleq r(s,a)+\gamma \mathbb{E}{s^\prime\sim p(\cdot|s,a)}\left[\alpha\log\int{a^\prime}\exp (\frac{1}{\alpha}Q_{\textbf{soft}}^\pi(s^\prime,a^\prime))\text{d}a^\prime\right]\notag \end{align} $$

压缩映射证明 (Contraction Mapping)

我们要证明 $||\mathcal{T}Q_1 - \mathcal{T}Q_2|| \le k ||Q_1 - Q_2||$，其中 $k < 1$。

定义度量距离 $\epsilon = \max_{s,a}|Q_1(s,a) - Q_2(s,a)|$。这意味对于任意 $(s,a)$：

$$ Q_1(s,a) \le Q_2(s,a) + \epsilon $$

关键推导步骤：

利用指数单调性：

$$ \exp(\frac{1}{\alpha}Q_1) \le \exp(\frac{1}{\alpha}(Q_2 + \epsilon)) = \exp(\frac{Q_2}{\alpha}) \cdot \exp(\frac{\epsilon}{\alpha}) $$
积分保序性：

$$ \int \exp(\frac{Q_1}{\alpha}) \text{d}a' \le \exp(\frac{\epsilon}{\alpha}) \int \exp(\frac{Q_2}{\alpha}) \text{d}a' $$
取 $\alpha \log$（注意这里的常数提取）： $$ \begin{align} \alpha \log \int \exp(\frac{Q_1}{\alpha}) \text{d}a' &\le \alpha \log \left[ \exp(\frac{\epsilon}{\alpha}) \int \exp(\frac{Q_2}{\alpha}) \text{d}a' \right] \notag \ &= \alpha \left[ \log(\exp(\frac{\epsilon}{\alpha})) + \log \int \exp(\frac{Q_2}{\alpha}) \text{d}a' \right] \notag \ &= \alpha \left[ \frac{\epsilon}{\alpha} + \log \int \exp(\frac{Q_2}{\alpha}) \text{d}a' \right] \notag \ &= \epsilon + \alpha \log \int \exp(\frac{Q_2}{\alpha}) \text{d}a' \notag \end{align} $$
计算算子差值：

$$ \begin{align} |\mathcal{T}Q_1 - \mathcal{T}Q_2| &= \gamma \left| \mathbb{E}{s'} \left[ \alpha \log \int{a^\prime} \exp(\frac{Q_1(s^\prime,a^\prime)}{\alpha}) \text{d}a^\prime - \alpha \log \int_{a^\prime} \exp(\frac{Q_2(s^\prime,a^\prime)}{\alpha}) \text{d}a^\prime \right] \right| \notag \ &\le \gamma \mathbb{E}{s'} [\epsilon] \notag \ &= \gamma \max{s,a} |Q_1(s,a)-Q_2(s,a)| \notag \end{align} $$
结论： $$ ||\mathcal{T}Q_1 - \mathcal{T}Q_2||\infty \le \gamma ||Q_1 - Q_2||\infty $$

由于折扣因子 $\gamma \in (0,1)$，算子 $\mathcal{T}$ 是一个压缩映射，必然收敛到唯一的不动点 $Q^*_\text{soft}$。

实现困难与解决方案

理论很完美，但实际用神经网络实现时（Deep RL），有两个主要困难。

困难 1：处理积分 (The Integral Problem)

在计算 $V_\text{soft}(s)$ 时，需要计算 $\log \int \exp(Q) \text{d}a$。如果动作空间是连续的，这个积分通常无法解析计算。

解决方案：重要性采样 (Importance Sampling) 我们把积分转化为期望，通过采样来近似。引入一个采样分布 $q_a(a)$（通常可以是当前的策略网络）：

$$ \begin{align} V_{\textbf{soft}}^{\theta}(s)&= \alpha \log \int_a \exp(\frac{1}{\alpha}Q_{\textbf{soft}}^{\theta}(s,a))\text{d}a\notag \ &=\alpha\log\int_a q_a(a)\frac{\exp(\frac{1}{\alpha}Q_{\textbf{soft}}^{\theta}(s,a))}{q_a(a)} \text{d}a \notag \ &\approx \alpha \log \mathbb{E}{a\sim q_a(\cdot)}\left[\frac{\exp(\frac{1}{\alpha}Q{\textbf{soft}}^{\theta}(s,a))}{q_a(a)}\right] \notag \end{align} $$

于是，Soft Q-Learning 的目标函数（Bellman Error）变为：

$$ \begin{align} J_Q(\theta)&=\mathbb{E}{\mathcal{D}}\left[\frac{1}{2}\left(\hat{Q}{\textbf{soft}}(s_t,a_t)-Q_{\textbf{soft}}^\theta(s_t,a_t)\right)^2\right]\notag \end{align} $$

其中目标值 $\hat{Q}$ 使用上述的重要性采样估计来计算 $V$。

困难 2：策略采样 (Sampling from Energy-Based Policy)

理论上的最优策略是基于能量的：$\pi(a|s) \propto \exp(\frac{1}{\alpha}Q(s,a))$。这是一种复杂的分布，我们无法直接从 Q 网络中高效采样动作。

解决方案：Amortized Inference (近似推断) 我们训练一个显式的策略网络（Actor）$\pi_\phi(a|s)$（通常是高斯分布或由神经网络生成的分布），让它去逼近那个能量分布。

目标是最小化两者之间的 KL 散度：

$$ \begin{align} J_\pi(\phi;s_t)=D_{\textbf{KL}}\left(\pi_\phi(\cdot|s_t)\Big|\Big|\exp\left(\frac{1}{\alpha}(Q_{\textbf{soft}}^\theta(s_t,\cdot)-V_{\textbf{soft}}^\theta(s_t))\right)\right)\notag \end{align} $$

将 KL 散度展开并忽略常数项，等价于最大化：

$$ \mathbb{E}{a \sim \pi\phi}[Q^\theta(s,a) - \alpha \log \pi_\phi(a|s)] $$

💡 实现细节：在 SQL 原文中，作者使用了 SVGD (Stein Variational Gradient Descent) 方法来更新这个策略网络，这允许策略生成非常复杂的多模态分布。后续的 SAC 算法则使用了重参数化技巧（Reparameterization Trick）来简化这一步。

RL笔记（13）：DDPG

Mon, 22 Dec 2025 00:00:00 GMT

引言（Introduction）

我们之前学过 DQN（处理离散动作的价值方法）和 REINFORCE/PPO（处理连续/离散动作的随机策略方法）。如果我们将 DQN 的思想（Off-policy, Replay Buffer）应用到连续控制任务中，会遇到什么问题？

DQN 需要对动作取最大值 $\max_a Q(s,a)$。在连续空间中，这个最大化操作本身就是一个复杂的优化问题。

DDPG (Deep Deterministic Policy Gradient) 的出现解决了这个问题。你可以简单地把它理解为 “DQN + Actor-Critic”。它使用一个 Actor 网络来直接输出那个“让 Q 值最大的动作”，从而避免了复杂的积分或最大化计算。

策略类型的本质区别

在深入 DDPG 之前，我们需要明确两种策略的数学形式差异。

随机策略 (Stochastic Policy)

输出动作的概率分布（如高斯分布的均值和方差）。

离散动作：$\pi(a|s;\theta)=\frac{\exp(Q_\theta(s,a))}{\sum_{a^\prime}\exp(Q_\theta(s,a^\prime))}$ (Softmax)
连续动作：$\pi(a|s;\theta) \sim \mathcal{N}(\mu_\theta(s), \sigma_\theta(s))$

确定性策略 (Deterministic Policy)

对于同一个状态，永远输出同一个动作。

离散动作：$\pi(s;\theta)=\operatorname{argmax}{a} Q\theta(s,a)$ (不可微，无法用梯度下降直接优化)
连续动作：$a=\mu_\theta(s)$ (可微，这正是 DDPG 的基础)

💡 核心区别：

随机策略通过对数似然 (Log-Likelihood) 来更新参数：$\nabla \log \pi \cdot Q$。它试探性地增加高分动作的概率。

确定性策略通过链式法则 (Chain Rule) 来更新参数：$\nabla_a Q \cdot \nabla_\theta \mu$。它直接告诉动作“往哪个方向挪一点，Q 值会变大”。

确定性策略梯度定理 (DPG)

这是 DDPG 的理论基石。我们希望找到策略参数 $\theta$，最大化目标函数 $J(\theta) = \mathbb{E}[Q(s, \mu_\theta(s))]$。

定理推导：假设我们有一个 Critic 网络 $Q^w(s,a)$ 估得足够准。我们想调整 Actor $\mu_\theta(s)$，使得输出的动作 $a$ 能获得更大的 $Q$ 值。根据链式法则：

$$ \begin{align} \nabla_\theta J(\mu_\theta) &= \mathbb{E}{s \sim \rho^\pi} [\nabla\theta Q^w(s, \mu_\theta(s))] \notag \ &= \mathbb{E}{s \sim \rho^\pi} [\underbrace{\nabla_a Q^w(s,a)|{a=\mu_\theta(s)}}{\text{Critic 指出的方向}} \cdot \underbrace{\nabla\theta \mu_\theta(s)}_{\text{Actor 的梯度}}] \notag \end{align} $$

直觉：Critic 告诉 Actor：“动作 $a$ 往大变一点，Q 值能增加”。Actor 就计算如何调整 $\theta$ 才能让 $a$ 变大。

深度确定性策略梯度 (DDPG)

DDPG 是 Deep Q-Network (DQN) 在连续动作空间的自然延伸。

核心组件

Actor-Critic 架构：
- Actor $\mu(s; \theta)$：输出确定性动作。
- Critic $Q(s, a; w)$：评估 (状态, 动作) 的价值。
经验回放 (Replay Buffer)：与 DQN 一样，存储 $(s, a, r, s')$，打破数据相关性，实现 Off-Policy 训练。
目标网络 (Target Networks)：
- 为了稳定训练，建立了 Target Actor $\mu'$ 和 Target Critic $Q'$。
- 关键改进：软更新 (Soft Update)。 DQN 是每隔 $C$ 步硬拷贝参数。DDPG 使用滑动平均： $$ \theta' \leftarrow \tau \theta + (1-\tau)\theta' $$ 其中 $\tau \ll 1$ (如 0.001)。这使得目标值变化非常平滑。
探索策略 (Exploration)：
- 确定性策略本身不会探索。DDPG 必须在动作上加噪声来进行探索： $$ at = \mu\theta(s_t) + \mathcal{N}_t $$
- 原论文使用了 Ornstein-Uhlenbeck (OU) 噪声（具有时间相关性，适合惯性系统）。现在的实践通常直接使用简单的高斯噪声 $\mathcal{N}(0, \sigma)$。

DDPG 算法流程

$$ \begin{aligned} & \bullet ; \text{Initialize Actor } \mu_\theta, \text{Critic } Q_w, \text{Target nets } \mu', Q' \ & \bullet ; \textbf{For } \text{episode } = 1 \to E \textbf{ do}: \ & \bullet \qquad \text{Receive initial state } s \ & \bullet \qquad \textbf{For } t = 1 \to T \textbf{ do}: \ & \bullet \qquad \qquad \text{Select action } a = \mu_\theta(s) + \text{Noise} \ & \bullet \qquad \qquad \text{Execute } a, \text{ observe } r, s' \ & \bullet \qquad \qquad \text{Store } (s, a, r, s') \text{ in Buffer } \mathcal{R} \ & \bullet \qquad \qquad \text{Sample batch } N \text{ from } \mathcal{R} \ & \bullet \qquad \qquad \textbf{// Update Critic (minimize MSBE)} \ & \bullet \qquad \qquad y = r + \gamma Q'(s', \mu'(s')) \ & \bullet \qquad \qquad L_w = \frac{1}{N}\sum (y - Q_w(s,a))^2 \ & \bullet \qquad \qquad \textbf{// Update Actor (maximize Q)} \ & \bullet \qquad \qquad \nabla_\theta J = \frac{1}{N} \sum \nabla_a Q_w(s,a) \nabla_\theta \mu_\theta(s) \ & \bullet \qquad \qquad \textbf{// Soft Update Targets} \ & \bullet \qquad \qquad \theta' \leftarrow \tau \theta + (1-\tau)\theta' \ & \bullet \qquad \qquad w' \leftarrow \tau w + (1-\tau)w' \ & \bullet \qquad \textbf{End For} \ & \bullet ; \textbf{End For} \end{aligned} $$

双价值函数策略延时更新 (TD3)

DDPG 很强，但非常脆弱，对超参数敏感。它继承了 DQN 的过高估计 (Overestimation) 问题，甚至更严重。TD3 提出了三个技巧来修正它。

技巧 1：截断双 Q 学习 (Clipped Double Q-Learning)

问题：DQN 中 $y = r + \gamma \max Q$ 会导致价值高估。DDPG 中虽然没有 max，但 Actor 也是朝着 Q 值最大的方向更新的，效果一样。解决：学习两个 Critic ($Q_1, Q_2$)，计算目标值时取最小值。 $$ y = r + \gamma \min*{i=1,2} Q*{\phi_i'}(s', \tilde{a}) $$ 这体现了“悲观主义”原则，宁可低估也不要高估。

技巧 2：策略参数延迟更新 (Delayed Policy Updates)

问题：Critic 还在学习中，波动很大。如果 Actor 频繁根据错误的 Critic 调整方向，会导致策略震荡发散。解决：让 Critic 多练几次，Actor 再动。通常 Critic 更新 2 次（或更多），Actor 和目标网络才更新 1 次。

目标策略平滑 (Target Policy Smoothing)

问题：Critic 可能会对某些尖峰值（错误的 Q 值峰值）过拟合。解决：在计算目标值时，给动作加一点被截断的噪声，让 Q 函数在动作周围更平滑。

$$ \tilde{a} = \mu_{\theta'}(s') + \epsilon, \quad \epsilon \sim \text{clip}(\mathcal{N}(0, \sigma), -c, c) $$

$$ y = r + \gamma \min Q'(s', \tilde{a}) $$

💡 直觉：相似的动作应该有相似的价值。如果动作稍微变一点点，价值就剧烈变化，说明这个 Critic 是有问题的（过拟合）。

深度解析：DDPG/TD3 的定位

我们可以将 DDPG/TD3 放在整个 RL 家族谱系中进行对比：

| 维度 | DDPG / TD3 | PPO / A2C | DQN | | :----------- | :-------------------------------------------- | :----------------------------------- | :--------------- | ----------------- | | 动作空间 | 连续 (Continuous) | 离散或连续 | 离散 (Discrete) | | 策略类型 | 确定性策略 ($\mu(s)$) | 随机策略 ($\pi(a | s)$) | 确定性 (argmax Q) | | 样本效率 | 高 (Off-Policy) | 低 (On-Policy) | 高 (Off-Policy) | | 更新方式 | 链式法则 ($\nabla_a Q \nabla_\theta \mu$) | 对数似然 ($\nabla \log \pi \cdot A$) | 最小化 TD Error | | 稳定性 | 较低 (需精细调参) | 高 (鲁棒性强) | 中 | | 核心痛点 | Q 值高估、超参数敏感 | 采样慢、无法利用旧数据 | 无法处理连续动作 |

总结：

DDPG 是 DQN 在连续控制领域的继承者，引入了 Actor-Critic 架构。
TD3 是 DDPG 的“补丁版”，通过双 Q 网络和延迟更新，大大提升了算法的稳定性。
它们都是 Off-Policy 算法，适合需要极高样本效率的场景（如机器人控制）。

RL笔记（12）：PPO

Sun, 21 Dec 2025 00:00:00 GMT

引言（Introduction）

上一章提到的 TRPO 虽然理论优美（保证单调不减），但计算太复杂了（需要共轭梯度法求解 Hessian-Vector Product）。 OpenAI 提出的 PPO (Proximal Policy Optimization) 是 TRPO 的一阶近似版本。

核心思想：TRPO 使用 KL 散度作为硬约束 (Constraint)，而 PPO 将约束转化为惩罚项 (Penalty) 或者直接通过截断 (Clipping) 来限制策略更新幅度。
地位：PPO 是目前 Deep RL 的基准算法，平衡了实现复杂度、样本效率和性能。

变体 1：PPO-Clip (主流)

这是目前最常用的 PPO 版本，它不需要计算 KL 散度，直接在目标函数里动手脚。

重要性采样比率

定义新旧策略的比率为 $r_t(\theta)$：

$$ r_t(\theta) = \frac{\pi_\theta(a_t|s_t)}{\pi_{\theta_{\text{old}}}(a_t|s_t)} $$

当 $\theta = \theta_{\text{old}}$ 时，$r_t = 1$。
我们希望 $r_t$ 不要偏离 1 太多，这意味着新策略没有发生剧烈变化。

截断目标函数

PPO-Clip 的核心目标函数如下：

$$ L^{CLIP}(\theta)=\hat{\mathbb{E}}_t \left[ \min \left( r_t(\theta)\hat{A}_t, \text{clip}(r_t(\theta), 1-\epsilon, 1+\epsilon)\hat{A}_t \right) \right] $$

$\epsilon$ 是一个超参数（通常为 0.2），表示允许策略变化的幅度（Trust Region）。
$\text{clip}(r, 1-\epsilon, 1+\epsilon)$：把比率 $r$ 强制限制在 $[0.8, 1.2]$ 之间。

直观理解：为什么要 Min？

我们需要分两种情况来看优势函数 $\hat{A}_t$ 的正负：

情况 A：动作是好的 ($\hat{A}_t > 0$)
- 我们希望增加这个动作的概率，即 $r_t(\theta)$ 增大。
- 但不能无限增大。如果 $r_t > 1+\epsilon$，clip 函数会将其锁死在 $1+\epsilon$。
- 此时 $\min$ 操作生效，目标函数不再随 $r_t$ 增加而增加。这防止了策略更新步子太大。
情况 B：动作是坏的 ($\hat{A}_t < 0$)
- 我们希望减小这个动作的概率，即 $r_t(\theta)$ 减小。
- 但不能无限减小。如果 $r_t < 1-\epsilon$，clip 函数会将其锁死在 $1-\epsilon$。
- 此时 $\min$ 操作生效，防止策略过度修正（以此避免策略坍塌）。

💡 总结：只有当策略变化在“安全区域”内时，我们才进行奖励优化；一旦超出安全区域，就不再给予额外的梯度奖励。

变体 2：PPO-Penalty (自适应 KL)

这是另一种接近 TRPO 原义的方法，将 KL 散度作为正则项加入 Loss，并动态调整系数 $\beta$。

目标函数

$$ L^{KLPEN}(\theta)=\hat{\mathbb{E}}t \left[ r_t(\theta)\hat{A}t - \beta D{KL}(\pi{\theta_{\text{old}}}(\cdot|s_t) || \pi_\theta(\cdot|s_t)) \right] $$

自适应 $\beta$ 更新规则

我们在每次更新后计算平均 KL 散度 $d = \hat{\mathbb{E}}t [D{KL}]$，并与目标值 $d_{\text{targ}}$ 比较：

如果 $d < d_{\text{targ}} / 1.5$：说明策略变动太小，步子太保守。减小惩罚 $\beta \leftarrow \beta / 2$。
如果 $d > d_{\text{targ}} \times 1.5$：说明策略变动太大，步子太危险。增大惩罚 $\beta \leftarrow \beta \times 2$。

广义优势估计 (GAE)

在计算优势函数 $\hat{A}_t$ 时，简单的多步 TD 或蒙特卡洛都有局限。PPO 通常使用 GAE (Generalized Advantage Estimation) 来平衡偏差和方差。

我们定义 TD Error $\delta_t = r_t + \gamma V(s_{t+1}) - V(s_t)$。 GAE 是 $\delta$ 的加权几何平均：

$$ \hat{A}t^{GAE} = \sum{k=0}^{\infty} (\gamma \lambda)^k \delta_{t+k} $$

$\lambda = 0$：即单步 TD（偏差大，方差小）。
$\lambda = 1$：即蒙特卡洛（无偏差，方差大）。
$\lambda \in (0, 1)$：通常取 0.95，在两者之间取得最佳平衡。

完整的 PPO 损失函数

在实际代码实现（如 Actor-Critic 架构）中，PPO 的总 Loss 包含三部分：

策略损失 (Policy Loss)：即 $L^{CLIP}$，让策略变好。
价值损失 (Value Loss)：$L^{VF} = (V_\theta(s_t) - V_{target})^2$，让 Critic 估值更准。
熵奖励 (Entropy Bonus)：$S[\pi_\theta]$，鼓励策略保持随机性，防止过早收敛到局部最优。

$$ L^{Total}_t(\theta) = - L^{CLIP}_t(\theta) + c_1 L^{VF}_t(\theta) - c_2 S\pi_\theta $$

(注：通常深度学习框架是最小化 Loss，所以最大化目标前加负号)

PPO 算法流程

$$ \begin{aligned} & \bullet ; \text{Initialize policy parameters } \theta \text{ and value parameters } \phi \ & \bullet ; \textbf{For } \text{iteration } k = 1, 2, \dots \textbf{ do}: \ & \bullet \qquad \textbf{1. Data Collection:} \ & \bullet \qquad \text{Run policy } \pi_{\theta_{old}} \text{ in environment for } T \text{ steps} \ & \bullet \qquad \text{Compute advantage estimates } \hat{A}1, \dots, \hat{A}T \text{ using GAE} \ & \bullet \qquad \textbf{2. Optimization:} \ & \bullet \qquad \textbf{For } \text{epoch } = 1 \to K \textbf{ do}: \ & \bullet \qquad \qquad \text{Shuffle data and divide into mini-batches} \ & \bullet \qquad \qquad \textbf{For } \text{each mini-batch } B \textbf{ do}: \ & \bullet \qquad \qquad \qquad L = L^{CLIP}(\theta) - c_1 L^{VF}(\phi) + c_2 S[\pi\theta] \ & \bullet \qquad \qquad \qquad \text{Update } \theta, \phi \text{ using Adam optimizer} \ & \bullet \qquad \qquad \textbf{End For} \ & \bullet \qquad \textbf{End For} \ & \bullet \qquad \theta{old} \leftarrow \theta \ & \bullet ; \textbf{End For} \end{aligned} $$

总结

PPO 之所以能成为 OpenAI 的默认算法（Default Algorithm），是因为它：

简单：只需要对梯度进行简单的截断（Clip），不需要复杂的二阶优化。
稳定：截断机制保证了策略不会因为一次糟糕的更新而崩溃。
通用：既适用于离散动作（Atari），也适用于连续动作（机器人控制）。

至此，经典的 Policy Gradient 家族（REINFORCE $\to$ Actor-Critic $\to$ TRPO $\to$ PPO）已经梳理完毕。

RL笔记（11）：TRPO

Sat, 20 Dec 2025 00:00:00 GMT

引言（Introduction）

在 REINFORCE 和 A2C 等策略梯度算法中，我们通常使用固定的学习率 $\alpha$ 来更新参数：$\theta \leftarrow \theta + \alpha \nabla J$。但这有一个严重问题：策略参数的变化 $\Delta \theta$ 并不等同于策略行为的变化。

有时候参数改一点点，策略分布变动巨大（导致性能崩塌）。
有时候参数改很多，策略分布几乎没变（训练效率低）。

TRPO (Trust Region Policy Optimization) 的核心思想是：我们不直接控制参数的变化量，而是控制策略分布的变化量（用 KL 散度衡量）。我们在一个“信任区域”内进行优化，确保每一步更新后，策略的表现都是单调不减的。

策略优化的单调性证明

我们的目标是找到一个新策略 $\pi_{\theta'}$，使得它的期望回报 $J(\theta')$ 比旧策略 $J(\theta)$ 高。

性能差异引理 (Performance Difference Lemma)

首先推导新旧策略的目标函数之差：

$$ \begin{align} J(\theta^\prime)-J(\theta) &= \mathbb{E}{s_0}[V^{\pi{\theta^\prime}}(s_0)]-\mathbb{E}{s_0}[V^{\pi{\theta}}(s_0)]\notag\ &=\mathbb{E}{\pi{\theta^\prime}}[\sum_{t=0}^\infty \gamma^t r(s_t,a_t)] - \mathbb{E}{s_0}[\sum{t=0}^\infty \gamma^t V^{\pi_\theta}(s_t)-\sum_{t=1}^\infty \gamma^t V^{\pi_\theta}(s_t)] \notag \ &=\mathbb{E}{\pi{\theta^\prime}}[\sum_{t=0}^\infty \gamma^t r(s_t,a_t)] - \mathbb{E}{\pi{\theta^\prime}}[\sum_{t=0}^\infty \gamma^t (V^{\pi_\theta}(s_t)-\gamma V^{\pi_\theta}(s_{t+1}))] \notag \ &= \mathbb{E}{\pi{\theta^\prime}}[\sum_{t=0}^\infty \gamma^t (r(s_t,a_t)+\gamma V^{\pi_\theta}(s_{t+1})-V^{\pi_\theta}(s_t))] \notag \ &=\mathbb{E}{\pi{\theta^\prime}}[\sum_{t=0}^\infty \gamma^t A^{\pi_\theta}(s_t,a_t )] \notag \end{align} $$

将期望展开为状态访问分布 $\nu^{\pi_{\theta'}}$ 的形式：

$$ J(\theta^\prime)-J(\theta) = \sum_{t=0}^\infty \gamma^t \mathbb{E}{s_t\sim p^{\pi{\theta^\prime}} \, ; a_t\sim\pi_{\theta^\prime}(\cdot|s_t)}[ A^{\pi_\theta}(s_t,a_t)] = \frac{1}{1-\gamma} \mathbb{E}{s\sim\nu^{\pi{\theta^\prime}}\, ;a\sim\pi_{\theta^\prime}(\cdot|s)}[A^{\pi_\theta}(s,a)] $$

状态分布近似

上式很难计算，因为 $\nu^{\pi_{\theta'}}$ 依赖于新策略（而新策略还没求出来）。 TRPO 做了一个关键假设：当新旧策略差距很小时，状态访问分布变化不大，即 $\nu^{\pi_{\theta'}} \approx \nu^{\pi_\theta}$。

目标函数近似为：

$$ \begin{align} J(\theta^\prime)-J(\theta) &\approx \frac{1}{1-\gamma}\mathbb{E}{s\sim\nu^{\pi\theta}\,; a\sim\pi_{\theta^\prime}(\cdot|s)}[A^{\pi_\theta}(s,a)] \notag \ &= \frac{1}{1-\gamma}\mathbb{E}{s\sim\nu^{\pi\theta}\,; a\sim\pi_{\theta}(\cdot|s)}\left[\frac{\pi_{\theta^\prime}(a|s)}{\pi_\theta(a|s)}A^{\pi_\theta}(s,a)\right] \quad \text{(重要性采样)} \notag \end{align} $$

信任区域约束

为了让上述近似成立，必须限制 $\pi_{\theta'}$ 和 $\pi_\theta$ 不能差太多。我们使用 KL 散度 作为约束条件。

优化目标：

$$ \begin{align} \max_{\theta^\prime} \quad & \mathbb{E}{s\sim\nu^{\pi\theta}\,; a\sim\pi_{\theta}(\cdot|s)}\left[\frac{\pi_{\theta^\prime}(a|s)}{\pi_\theta(a|s)}A^{\pi_\theta}(s,a)\right] \notag \ \text{s.t.} \quad & \bar{D}{KL}(\theta || \theta') = \mathbb{E}{s\sim\nu^{\pi_\theta}}[D_{KL}(\pi_{\theta}(\cdot|s) || \pi_{\theta'}(\cdot|s))] \leqslant \delta \notag \end{align} $$

(注：忽略了常数系数 $\frac{1}{1-\gamma}$，因为它不影响梯度方向)

数学近似求解

为了求解这个带约束的优化问题，我们对其进行泰勒展开。

目标函数的一阶近似

令 $L(\theta') = \mathbb{E}[\frac{\pi_{\theta'}}{\pi_\theta} A^{\pi_\theta}]$。在 $\theta' = \theta$ 处展开：

$$ L(\theta') \approx L(\theta) + \nabla_{\theta'} L(\theta')|_{\theta'=\theta}^T (\theta' - \theta) $$

由于 $L(\theta) = \mathbb{E}[1 \cdot A^{\pi_\theta}] = 0$ (优势函数的期望为0)，且 $\nabla_{\theta'} L(\theta')|{\theta} = \nabla\theta J(\theta)$ (策略梯度)。记梯度为 $g$： $$ L(\theta') \approx g^T (\theta' - \theta) $$

约束条件的二阶近似

KL 散度在 $\theta'=\theta$ 处的一阶导数为 0（因为是极小值点），所以必须展开到二阶。

$$ \bar{D}_{KL}(\theta || \theta') \approx \frac{1}{2} (\theta' - \theta)^T \mathbf{H} (\theta' - \theta) $$

其中 $\mathbf{H}$ 是 KL 散度的 黑塞矩阵 (Hessian Matrix)（也是 Fisher Information Matrix）。

近似后的优化问题

令更新步长 $\Delta \theta = \theta' - \theta$，问题转化为：

$$ \begin{align} \max_{\Delta \theta} \quad & g^T \Delta \theta \notag \ \text{s.t.} \quad & \frac{1}{2} \Delta \theta^T \mathbf{H} \Delta \theta \leqslant \delta \notag \end{align} $$

解析解

利用拉格朗日乘数法（推导见你原笔记），解得：

$$ \Delta \theta = \sqrt{\frac{2\delta}{g^T \mathbf{H}^{-1} g}} \mathbf{H}^{-1} g $$

共轭梯度法 (Conjugate Gradient)

公式里需要计算 $\mathbf{H}^{-1} g$。

问题：$\mathbf{H}$ 是神经网络参数的 Hessian 矩阵。如果参数有 100万个，$\mathbf{H}$ 就是 $100w \times 100w$ 的矩阵，显式计算它的逆是不可能的。
思路：我们不需要算 $\mathbf{H}^{-1}$，我们只需要算向量 $x = \mathbf{H}^{-1} g$。这等价于求解线性方程组 $\mathbf{H}x = g$。

共轭梯度法 (CG) 是一种迭代算法，它可以只通过计算矩阵-向量乘积 ($\mathbf{H}v$)，在 $k$ 步内（$k \ll \text{参数维度}$）找到 $x$ 的近似解。

Hessian-Vector Product (HVP)

CG 算法需要计算 $\mathbf{H}v$。虽然我们算不起 $\mathbf{H}$，但可以利用反向传播算 $\mathbf{H}v$。

$$ \mathbf{H}v = \nabla_\theta (\nabla_\theta \bar{D}_{KL} \cdot v) $$

代码实现技巧：

先算 KL 散度的梯度 $\nabla \bar{D}_{KL}$。
算梯度和向量 $v$ 的点积：$scalar = \nabla \bar{D}_{KL}^T v$。
对这个标量再求一次梯度：$\nabla_\theta (scalar)$。这样只需要两次反向传播，就能算出 $\mathbf{H}v$，完全避免了存储巨大的 Hessian 矩阵。

线搜索 (Line Search)

虽然我们算出了更新方向 $\Delta \theta$ 和最大步长 $\beta = \sqrt{\frac{2\delta}{g^T \mathbf{H}^{-1} g}}$，但由于泰勒展开只是局部近似，直接走这么远可能会导致策略性能下降（KL 散度超标或目标函数下降）。

TRPO 采用 回溯线搜索 (Backtracking Line Search) 来确定最终步长：设 $\theta_{new} = \theta + \alpha^j \beta \Delta \theta$，其中 $\alpha \in (0, 1)$ 是衰减系数（如 0.5）。从 $j=0, 1, 2, \dots$ 开始尝试，直到满足以下两个条件：

KL 约束满足：$\bar{D}{KL}(\theta || \theta{new}) \leqslant \delta$
目标函数提升：$L(\theta_{new}) \geqslant 0$ (即性能确实提升了)

TRPO 算法流程总结

$$ \begin{aligned} & \bullet ; \text{Initialize policy parameters } \theta_0 \ & \bullet ; \textbf{For } k = 0, 1, 2, \dots \textbf{ do}: \ & \bullet \qquad \text{Collect trajectories } \tau \text{ using } \pi_{\theta_k} \ & \bullet \qquad \text{Estimate advantages } A^{\pi_{\theta_k}} \text{ (using GAE)} \ & \bullet \qquad \text{Compute policy gradient } g = \nabla_\theta L(\theta)|{\theta_k} \ & \bullet \qquad \text{Use CG to compute } x \approx \mathbf{H}^{-1} g \text{ with HVP} \ & \bullet \qquad \text{Compute max step length } \beta = \sqrt{\frac{2\delta}{x^T \mathbf{H} x}} \ & \bullet \qquad \text{Perform Line Search to find best step size } \eta \in {\beta, 0.5\beta, 0.25\beta \dots} \ & \bullet \qquad \text{Update } \theta{k+1} = \theta_k + \eta x \ & \bullet ; \textbf{End For} \end{aligned} $$

优缺点分析

优点：
- 理论保证：单调提升，不再担心学习率太大导致训练崩溃。
- 数据效率：比 REINFORCE 高，因为利用了二阶信息（自然梯度）。
缺点：
- 计算复杂：CG 和 HVP 实现复杂，且计算量大。
- 约束太硬：KL 散度是硬约束，处理起来不够灵活。

💡 预告： TRPO 虽然好，但太复杂了。有没有一种方法，既能保留 TRPO 的“信任区域”思想（稳定），又能像 SGD 一样简单（一阶优化）？这就是 PPO (Proximal Policy Optimization) 的由来（下一章内容）。

RL笔记（10）：Actor-Critic

Fri, 19 Dec 2025 00:00:00 GMT

引言（Introduction）

在之前的笔记中，我们学习了两种截然不同的强化学习路径：

Value-Based (如 Q-Learning)：通过学习价值函数 $Q(s,a)$ 来间接导出策略。优点是方差小（利用了 TD 的一步更新），缺点是无法处理连续动作。
Policy-Based (如 REINFORCE)：直接学习策略 $\pi_\theta$。优点是可以处理连续动作，缺点是方差极大（因为使用了蒙特卡洛回报 $G_t$），且只能在回合结束后更新。

Actor-Critic (AC) 架构旨在结合两者的优点：

Actor (演员)：即策略网络 $\pi_\theta(a|s)$，负责由状态输出动作。
Critic (评论家)：即价值网络 $V_w(s)$ 或 $Q_w(s,a)$，负责评估 Actor 的动作好不好，帮助 Actor 减小方差加速学习。

降低方差的技巧：基线 (Baseline)

回顾 REINFORCE 的梯度公式：

$$ \nabla_\theta J(\theta) = \mathbb{E}{\tau \sim \pi\theta} \left[ \sum_{t=0}^T \nabla_\theta \log \pi_\theta(a_t|s_t) G_t \right] $$

这里的 $G_t$ 是从 $t$ 时刻开始的累积回报。由于环境随机性和策略随机性，$G_t$ 的波动非常大，导致梯度估计不稳定。

为了减小方差，我们引入一个 基线函数 (Baseline) $b(s)$。基线函数只与状态有关，与动作无关。我们把梯度修改为：

$$ \nabla_\theta J(\theta) = \mathbb{E} \left[ \sum_{t=0}^T \nabla_\theta \log \pi_\theta(a_t|s_t) (G_t - b(s_t)) \right] $$

数学证明：引入基线不改变梯度期望

我们需要证明减去一项 $b(s_t)$ 后，梯度的期望值不变。即证明：

$$ \mathbb{E}{a_t \sim \pi\theta} [\nabla_\theta \log \pi_\theta(a_t|s_t) \cdot b(s_t)] = 0 $$

证明如下：

$$ \begin{align} \mathbb{E}{a \sim \pi} [\nabla\theta \log \pi(a|s) \cdot b(s)] &= \sum_{a} \pi(a|s) \frac{\nabla_\theta \pi(a|s)}{\pi(a|s)} b(s) \notag \ &= b(s) \sum_{a} \nabla_\theta \pi(a|s) \notag \ &= b(s) \nabla_\theta \sum_{a} \pi(a|s) \notag \ &= b(s) \nabla_\theta (1) \notag \ &= 0 \notag \end{align} $$

结论：只要 $b(s)$ 不依赖于动作 $a$，我们可以随意减去它而不改变梯度的方向，但能显著改变梯度的方差。通常，我们选择状态价值函数 $V(s)$ 作为基线。

Actor-Critic 架构演变

Q Actor-Critic

如果我们用一个神经网络 $Q_w(s,a)$ 来近似 REINFORCE 中的 $G_t$，梯度变为：

$$ \nabla_\theta J(\theta) \approx \mathbb{E} [\nabla_\theta \log \pi_\theta(a|s) Q_w(s,a)] $$

但这并没有解决问题，因为单纯拟合 $Q$ 值还是很难。

Advantage Actor-Critic (A2C)

为了利用 Baseline 减小方差，我们希望梯度形式为：

$$ \nabla_\theta J(\theta) \approx \mathbb{E} [\nabla_\theta \log \pi_\theta(a|s) (Q_w(s,a) - V_v(s))] $$

其中 $Q(s,a) - V(s)$ 被称为 优势函数 (Advantage Function)，记为 $A(s,a)$。它表示“在状态 $s$ 下，动作 $a$ 比平均情况好了多少”。

但是，如果我们需要同时维护两个网络（一个算 $Q$，一个算 $V$），训练会很麻烦。我们可以利用 TD Error 来近似优势函数。

根据贝尔曼方程： $$ Q(st, a_t) \approx r_t + \gamma V(s{t+1}) $$ 因此，优势函数可以写为：

$$ \begin{align} A(s_t, a_t) &= Q(s_t, a_t) - V(s_t) \notag \ &\approx r_t + \gamma V(s_{t+1}) - V(s_t) \notag \end{align} $$

这恰好就是 TD Error ($\delta_t$)！

因此，我们只需要维护一个 Actor 网络 $\pi_\theta(a|s)$ 和一个 Critic 网络 $V_w(s)$ 即可。

A2C 算法流程

在 Advantage Actor-Critic 中，Critic 的任务是把 $V_w(s)$ 估得越准越好，Actor 的任务是利用 Critic 提供的 TD Error 来更新策略。

Critic 的更新 (Value Update)

Critic 的目标是最小化 TD Error 的平方（即回归问题）：

$$ L_{critic}(w) = \frac{1}{2} \left( r_t + \gamma V_w(s_{t+1}) - V_w(s_t) \right)^2 $$

梯度更新： $$ w \leftarrow w + \alpha_c \delta_t \nabla_w V_w(s_t) $$

Actor 的更新 (Policy Update)

Actor 使用 TD Error 作为优势函数的估计值进行梯度上升：

$$ \nabla_\theta J(\theta) \approx \nabla_\theta \log \pi_\theta(a_t|s_t) \delta_t $$

梯度更新： $$ \theta \leftarrow \theta + \alphaa \delta_t \nabla\theta \log \pi_\theta(a_t|s_t) $$

💡 直觉理解：

如果 $\delta_t > 0$（惊喜，结果比预期好）：增加动作 $a_t$ 的概率。

如果 $\delta_t < 0$（失望，结果比预期差）：减小动作 $a_t$ 的概率。

这里的“预期”就是 Critic 提供的 $V(s_t)$。

A2C 伪代码

$$ \begin{aligned} & \bullet ; \text{Initialize Actor } \pi_\theta \text{ and Critic } V_w \ & \bullet ; \textbf{For } \text{episode } = 1 \to E \textbf{ do}: \ & \bullet \qquad \text{Initialize state } s \ & \bullet \qquad \textbf{For } \text{step } t = 1 \to T \textbf{ do}: \ & \bullet \qquad \qquad \text{Sample action } a \sim \pi_\theta(\cdot|s) \ & \bullet \qquad \qquad \text{Execute } a, \text{ observe } r, s' \ & \bullet \qquad \qquad \textbf{// Calculate TD Error (Advantage)} \ & \bullet \qquad \qquad \delta \leftarrow r + \gamma V_w(s') - V_w(s) \ & \bullet \qquad \qquad \textbf{// Update Critic} \ & \bullet \qquad \qquad w \leftarrow w + \alpha_c \delta \nabla_w V_w(s) \ & \bullet \qquad \qquad \textbf{// Update Actor} \ & \bullet \qquad \qquad \theta \leftarrow \theta + \alpha_a \delta \nabla_\theta \log \pi_\theta(a|s) \ & \bullet \qquad \qquad s \leftarrow s' \ & \bullet \qquad \textbf{End For} \ & \bullet ; \textbf{End For} \end{aligned} $$

偏差与方差的权衡 (Bias-Variance Tradeoff)

我们可以总结一下不同计算 Advantage 的方法，它们体现了 RL 中核心的权衡：

蒙特卡洛 (REINFORCE)：
- $A_t \approx G_t - V(s_t)$
- 无偏差：$G_t$ 是真实回报。
- 高方差：受整个序列随机性影响。
Actor-Critic (TD)：
- $A_t \approx r_t + \gamma V(s_{t+1}) - V(s_t)$
- 低方差：只受一步随机性影响。
- 有偏差：依赖于 Critic 的估计 $V(s_{t+1})$，如果 Critic 还没练好，Actor 就会被带偏。

为了平衡两者，我们可以使用 多步 TD 或者 GAE (Generalized Advantage Estimation)，这是 PPO 等进阶算法的核心技巧。

总结

Actor-Critic 架构是现代深度强化学习的主流架构。

它解决了 REINFORCE 方差大、更新慢的问题。
它解决了 DQN 无法处理连续动作的问题。
它是后续 A3C, DDPG, TRPO, PPO, SAC 等高级算法的共同祖先。

RL笔记（9）：REINFORCE

Thu, 18 Dec 2025 00:00:00 GMT

引言（Introduction）

在之前的 DQN 等算法中，我们都是先学习价值函数 $Q(s,a)$，再根据价值函数推导出策略（例如 $\epsilon$-Greedy）。这类方法称为 Value-Based 方法。

但这类方法有一些局限：

无法处理连续动作空间：在连续动作中找 $\max_a Q(s,a)$ 非常困难。
无法学习随机策略：DQN 最终学到的是确定性策略，但在某些博弈场景（如剪刀石头布），随机策略才是最优的。

因此，我们引入 Policy-Based 方法：直接参数化策略 $\pi_\theta(a|s)$，通过调整参数 $\theta$ 来最大化期望回报。

策略的表示

我们需要用一个函数（通常是神经网络）来表示策略。

随机策略 (Stochastic Policy)

输入状态 $s$，输出动作的概率分布。

离散动作（如 Softmax）： $$ \pi(a|s;\theta)=\frac{\exp(Q*\theta(s,a))}{\sum*{a^\prime}\exp(Q_\theta(s,a^\prime))} $$
连续动作（如高斯分布）： $$ \pi(a|s;\theta) = \frac{1}{\sqrt{2\pi}\sigma} \exp\left(-\frac{(a-\mu*\theta(s))^2}{2\sigma^2}\right) $$ 通常网络输出均值 $\mu*\theta(s)$ 和标准差 $\sigma_\theta(s)$。

确定性策略 (Deterministic Policy)

输入状态 $s$，直接输出动作值。

离散动作：$$ a=\operatorname{argmax}{a} Q\theta(s,a) $$ （不可微，无法直接用梯度下降）
连续动作：$$ a=\mu_\theta(s) $$ （可微，用于 DDPG 等算法）

策略梯度定理 (Policy Gradient Theorem)

这是 Policy-Based 方法的基石。我们的目标是最大化期望回报 $J(\theta)$，通过计算梯度 $\nabla_\theta J(\theta)$ 来更新参数。

目标函数

$$ J(\theta) = \mathbb{E}{s_0}[V^{\pi\theta}(s_0)] $$

其中 $s_0$ 是初始状态。

梯度推导 (The "Hard" Part)

我们需要计算 $\nabla_\theta V^{\pi_\theta}(s)$。根据贝尔曼方程展开：

$$ \begin{align} \nabla_\theta V^{\pi_\theta}(s) &= \nabla_\theta \sum_{a\in \mathcal{A}} \pi_\theta (a|s) Q^{\pi_\theta}(s,a) \notag \ &= \sum_{a\in\mathcal{A}}\left[\nabla_\theta \pi_\theta (a|s) Q^{\pi_\theta}(s,a) +\pi_\theta (a|s) \nabla_\theta Q^{\pi_\theta}(s,a) \right] \notag \end{align} $$

这里的难点在于 $\nabla_\theta Q^{\pi_\theta}(s,a)$，因为 $Q$ 值本身也依赖于策略参数 $\theta$（未来的动作会变）。我们继续展开 $Q$：

$$ \begin{align} \nabla_\theta Q^{\pi_\theta}(s,a) &= \nabla_\theta \sum_{r,s^\prime} P(s^\prime, r| s, a) (r + \gamma V^{\pi_\theta}(s^\prime)) \notag \ &= \sum_{s^\prime} P(s^\prime| s, a) \gamma \nabla_\theta V^{\pi_\theta}(s^\prime) \notag \end{align} $$

注意：环境的动力学 $P$ 和奖励 $r$ 与 $\theta$ 无关，所以导数为 0。

代回原式，得递归形式：

$$ \begin{align} \nabla_\theta V^{\pi_\theta}(s) &= \underbrace{\sum_{a\in\mathcal{A}}\nabla_\theta\pi_\theta(a|s) Q^{\pi_\theta}(s,a)}{\phi(s)} + \gamma \sum{a\in\mathcal{A}}\pi_\theta (a|s) \sum_{s^\prime \in \mathcal{S}} P(s^\prime| s, a) \nabla_\theta V^{\pi_\theta}(s^\prime) \notag \end{align} $$

定义转移概率 $d^{\pi_\theta}(s \to s', k)$ 为策略 $\pi_\theta$ 从 $s$ 出发走 $k$ 步到达 $s'$ 的概率。反复迭代上述递归式：

$$ \begin{align} \nabla_\theta V^{\pi_\theta}(s) &= \phi(s) + \gamma \sum_{s'} d(s \to s', 1) \nabla_\theta V(s') \notag \ &= \phi(s) + \gamma \sum_{s'} d(s \to s', 1) [\phi(s') + \gamma \sum_{s''} d(s' \to s'', 1) \nabla_\theta V(s'')] \notag \ &= \dots \notag \ &= \sum_{x \in \mathcal{S}} \sum_{k=0}^\infty \gamma^k d^{\pi_\theta}(s \to x, k) \phi(x) \notag \end{align} $$

引入状态访问分布

回到总目标函数 $J(\theta)$ 的梯度：

$$ \begin{align} \nabla_\theta J(\theta) &= \mathbb{E}{s_0} [\nabla\theta V^{\pi_\theta}(s_0)] \notag \ &= \sum_{s \in \mathcal{S}} \left( \sum_{k=0}^\infty \gamma^k d^{\pi_\theta}(s_0 \to s, k) \right) \phi(s) \notag \end{align} $$

利用状态访问分布 $\nu^{\pi_\theta}(s)$ 的定义： $$ \sum*{k=0}^\infty \gamma^k d^{\pi*\theta}(s0 \to s, k) \propto \nu^{\pi\theta}(s) $$

我们得到了极其优雅的 策略梯度定理：

$$ \begin{align} \nabla_\theta J(\theta) &\propto \sum_{s \in \mathcal{S}} \nu^{\pi_\theta}(s) \phi(s) \notag \ &= \sum_{s \in \mathcal{S}} \nu^{\pi_\theta}(s) \sum_{a \in \mathcal{A}} \nabla_\theta \pi_\theta(a|s) Q^{\pi_\theta}(s,a) \notag \end{align} $$

对数导数技巧 (Log-Derivative Trick)

为了能在采样中计算，我们利用恒等式 $\nabla \pi = \pi \frac{\nabla \pi}{\pi} = \pi \nabla \log \pi$：

$$ \begin{align} \nabla_\theta J(\theta) &= \mathbb{E}{s \sim \nu^{\pi\theta}} \left[ \sum_{a \in \mathcal{A}} \pi_\theta(a|s) \nabla_\theta \log \pi_\theta(a|s) Q^{\pi_\theta}(s,a) \right] \notag \ &= \mathbb{E}{\pi\theta} [\nabla_\theta \log \pi_\theta(a|s) Q^{\pi_\theta}(s,a)] \notag \end{align} $$

核心结论：我们不需要知道环境的状态转移 $P$，也不需要对状态分布 $\nu(s)$ 求导。只要让智能体在环境里玩，收集数据，就可以计算梯度！

REINFORCE 算法

REINFORCE 是最基础的策略梯度算法，它使用 蒙特卡洛方法 (Monte-Carlo) 来估计 $Q^{\pi_\theta}(s,a)$。

对于一条完整的轨迹 $\tau = {s_1, a_1, r_1, \dots, s_T, a_T, r_T}$，时刻 $t$ 的真实回报 $G_t$ 是 $Q(s_t, a_t)$ 的无偏估计： $$ Q^{\pi*\theta}(s_t, a_t) \approx G_t = \sum*{k=t}^T \gamma^{k-t} r_k $$

参数更新公式： $$ \theta \leftarrow \theta + \alpha \gamma^t Gt \nabla\theta \log \pi_\theta(a_t|s_t) $$

直觉：如果某个动作 $a_t$ 带来了高回报 $G_t$，我们就增加它的概率（$\nabla \log \pi$ 方向）；如果回报低（甚至是负的），就减少它的概率。

算法伪代码

$$ \begin{aligned} & \bullet ; \text{Initialize policy parameters } \theta \ & \bullet ; \textbf{For } \text{episode } e = 1 \to E \textbf{ do}: \ & \bullet \qquad \text{Generate trajectory } \tau = {s_1, a_1, r_1, \dots, s_T, a_T, r_T} \sim \pi_\theta \ & \bullet \qquad \textbf{For } t = 1 \to T \textbf{ do}: \ & \bullet \qquad \qquad G_t \leftarrow \sum_{k=t}^T \gamma^{k-t} r_k \ & \bullet \qquad \qquad \theta \leftarrow \theta + \alpha \gamma^t G_t \nabla_\theta \log \pi_\theta(a_t|s_t) \ & \bullet \qquad \textbf{End For} \ & \bullet ; \textbf{End For} \end{aligned} $$

优缺点分析

优点：可以直接处理连续动作；学习到的随机策略可以探索；数学推导优美。
缺点：
- 方差极大：一局游戏的结果随机性很大，导致梯度估计不稳定。
- On-Policy：必须采集一条数据就更新一次，旧数据无法重复利用，效率低。
- 回合更新：必须等到游戏结束才能计算 $G_t$。

💡 思考：为了减小方差，我们通常会减去一个 基线 (Baseline) $b(s)$，比如状态价值 $V(s)$。这不会改变梯度的期望，但能显著降低方差。这就是 Actor-Critic 算法的雏形（下一章内容）。

RL笔记（8）：DQN

Wed, 17 Dec 2025 00:00:00 GMT

引言（Introduction）

在之前的 Q-Learning 算法中，我们使用一个矩阵（Q-Table）来记录每个状态动作对 $(s,a)$ 的价值。这种方法有两个致命局限：

内存限制：如果状态空间很大（例如围棋 $10^{170}$），表格根本存不下。这被称为维度灾难 (Curse of Dimensionality)。
泛化能力差：对于没见过的状态，表格无法给出估计，而在连续状态空间中，几乎很难遇到完全一样的状态。

为了解决这个问题，我们引入函数拟合 (Function Approximation)。深度Q网络 (Deep Q-Network, DQN) 使用一个神经网络 $Q_\omega(s, a)$ 来近似 $Q^*(s, a)$，输入状态 $s$，输出所有离散动作的 Q 值。

深度 Q 网络 (DQN)

核心定义

在 DQN 中，我们使用参数为 $\omega$ 的神经网络来拟合动作价值函数。

输入：状态 $s$（例如游戏的屏幕像素）。
输出：每个动作 $a \in \mathcal{A}$ 对应的价值 $Q(s,a)$。

损失函数

类似于 Q-Learning，我们希望神经网络的输出逼近 TD Target。对于一条数据 $(s_i, a_i, r_i, s_i^\prime)$，目标是最小化均方误差：

$$ J(\omega)=\frac{1}{2N}\sum_{i=1}^{N}\left[ \underbrace{Q_\omega(s_i,a_i)}{\text{预测值}} - \underbrace{\left(r_i+\gamma \max{a^\prime}Q_\omega(s_i^\prime,a^\prime)\right)}_{\text{TD Target}} \right]^2 $$

然而，直接这样训练是不稳定的。DQN 引入了两大“法宝”来解决这个问题。

创新一：经验回放 (Experience Replay)

在一般的监督学习中，我们假设训练数据是独立同分布 (i.i.d) 的。但在强化学习中，智能体采集的数据是序列相关的（现在的状态依赖于上一秒的状态）。

做法：维护一个回放缓冲区 (Replay Buffer) $\mathcal{R}$。

智能体与环境交互，将产生的数据 $(s_t, a_t, r_t, s_{t+1})$ 存入缓冲区。
训练时，从缓冲区中随机采样一个批次 (Batch) 的数据进行梯度下降。

作用：

打破相关性：随机采样消除了数据之间的时间相关性，满足独立同分布假设，稳定网络训练。
提高样本效率：一条经验数据可以被多次采样利用，而不是用完即弃。

创新二：目标网络 (Target Network)

在原版 Q-Learning 中，TD Target 的计算也依赖于当前网络参数 $\omega$：

$$ y_i = r_i + \gamma \max_{a'} Q_\omega(s'_i, a') $$

这就好比“在射箭的同时，靶子也在动”。更新 $\omega$ 会同时改变预测值和目标值，容易导致震荡发散。

做法：引入一个结构相同但参数独立的目标网络 (Target Network)，参数记为 $\omega^-$。计算目标值时使用 $\omega^-$，更新网络时优化 $\omega$。

$$ y_i = r_i + \gamma \max_{a'} Q_{\omega^-}(s'_i, a') $$

更新规则：

训练网络 $\omega$：每个 step 都进行梯度下降更新。
目标网络 $\omega^-$：每隔 $C$ 步（例如 1000 步），将 $\omega$ 的值复制给 $\omega^-$ ($\omega^- \leftarrow \omega$)。

💡 直觉：固定住靶子一会儿，让射手（训练网络）安心瞄准，等射手练好了，再把靶子挪到新的位置。

DQN 算法伪代码

$$ \begin{aligned} & \bullet ; \text{Initialize main network } Q_\omega \text{ and target network } Q_{\omega^-} \text{ with weights } \omega \ & \bullet ; \text{Initialize replay buffer } \mathcal{R} \ & \bullet ; \textbf{For } \text{episode } e = 1 \to E \textbf{ do}: \ & \bullet \qquad \text{Initialize state } s \ & \bullet \qquad \textbf{For } \text{step } t = 1 \to T \textbf{ do}: \ & \bullet \qquad \qquad \text{Select action } a \text{ using } \epsilon\text{-greedy based on } Q_\omega(s) \ & \bullet \qquad \qquad \text{Execute } a, \text{ observe } r, s' \ & \bullet \qquad \qquad \text{Store transition } (s, a, r, s') \text{ in } \mathcal{R} \ & \bullet \qquad \qquad \textbf{If } |\mathcal{R}| > \text{batch_size}: \ & \bullet \qquad \qquad \qquad \text{Sample batch } {(s_i, a_i, r_i, s'i)}{i=1}^N \text{ from } \mathcal{R} \ & \bullet \qquad \qquad \qquad \text{Calculate targets: } y_i = r_i + \gamma \max_{a'} Q_{\omega^-}(s'i, a') \ & \bullet \qquad \qquad \qquad \text{Update } \omega \text{ by minimizing } \frac{1}{N}\sum (Q\omega(s_i, a_i) - y_i)^2 \ & \bullet \qquad \qquad \qquad \textbf{Every } C \text{ steps: } \omega^- \leftarrow \omega \ & \bullet \qquad \qquad s \leftarrow s' \ & \bullet \qquad \textbf{End For} \ & \bullet ; \textbf{End For} \end{aligned} $$

进阶 1：Double DQN

问题：过高估计 (Overestimation)

DQN 在计算目标值时使用了 $\max$ 操作：$y_i = r + \gamma \max_{a'} Q(s', a')$。由于神经网络本身存在估计误差，$\max$ 操作倾向于选择那些被高估的值。这种最大化偏差 (Maximization Bias) 会导致 Q 值普遍偏大，影响策略学习。

解决方案

解耦选择与评估。

选择动作：使用当前网络 $Q_\omega$ 来决定哪个动作最好（即 argmax）。
评估价值：使用目标网络 $Q_{\omega^-}$ 来计算那个动作的价值。

Double DQN 目标公式：

$$ y_i = r_i + \gamma Q_{\omega^-}(s'i, \underset{a'}{\operatorname{argmax}} Q\omega(s'_i, a')) $$

进阶 2：Dueling DQN

核心思想

在很多状态下，状态本身的价值比选择什么动作更重要。例如：在赛车游戏中，如果前面是死胡同（状态差），无论你向左转还是向右转（动作），价值都很低。 Dueling DQN 改变了网络结构，将 Q 值分解为两部分：

状态价值函数 (Value Function) $V(s)$：仅与状态有关。
优势函数 (Advantage Function) $A(s,a)$：与动作有关，表示动作 $a$ 相比平均情况好多少。

$$ Q(s, a) = V(s) + A(s, a) $$

可辨识性问题 (Identifiability)

如果直接用 $V+A$，网络会出现唯一性问题（$V$ 加 10，$A$ 减 10，总和 $Q$ 不变）。为了让 $V$ 和 $A$ 能被唯一确定，我们需要强行约束 $A$ 的某种性质。

聚合公式 (Aggregation)：通常让优势函数 $A$ 对于某个状态的均值为 0，或者最大值为 0。

$$ Q(s,a;\theta,\alpha,\beta)=V(s;\theta,\beta) + \left( A(s,a;\theta,\alpha) - \frac{1}{|\mathcal{A}|}\sum_{a^\prime}A(s,a^\prime;\theta,\alpha) \right) $$

或者：

$$ Q(s,a;\theta,\alpha,\beta)=V(s;\theta,\beta) + \left( A(s,a;\theta,\alpha) - \max_{a^\prime}A(s,a^\prime;\theta,\alpha) \right) $$

优点：

在动作对环境影响不大的状态下，能更快地学习状态价值 $V$。
极大地提高了训练效率和稳定性。

RL笔记（7）：Dyna-Q

Tue, 16 Dec 2025 00:00:00 GMT

引言（Introduction）

在之前的 Q-Learning 和 SARSA 中，智能体只能通过真实地与环境交互（摔跟头、吃金币）来学习，这被称为 无模型强化学习 (Model-Free RL)。这种方式虽然稳健，但效率较低，因为真实交互往往昂贵且缓慢。

基于模型的强化学习 (Model-Based RL) 引入了一个新的思路：如果智能体能学会环境的运行规律（建立一个模型），它就可以在脑海中“推演”未来，从而减少对真实世界的依赖。

💡 直觉理解：

Model-Free (Q-Learning)：像是在练习投篮，必须每次真把球投出去才知道进没进。

Model-Based (Dyna-Q)：像是下棋高手，不仅在实战中学习，还在脑海中复盘和推演（Planning），“如果我走这一步，对手可能会那样走...”。

核心概念

什么是模型 (Model)？

在 RL 中，模型 $M$ 指的是对环境动态的模拟。给定状态 $s$ 和动作 $a$，模型能预测出下一个状态 $s'$ 和奖励 $r$：

$$ s', r \leftarrow M(s, a) $$

预知模型：如下棋，规则是完全已知的。
学习模型：如机器人走路，需要通过观测数据 $(s, a, r, s')$ 来拟合环境规律。

两个关键指标

收敛效果：算法收敛后能够获得的期望回报。
样本复杂度 (Sample Complexity)：达到同样的性能，需要在真实环境中交互多少次。
- Model-Based 的核心优势就是降低样本复杂度（少走弯路）。

学习与规划

Dyna-Q 架构将 RL 过程分为了两部分：

直接强化学习 (Direct RL)：利用真实经验更新价值函数（和 Q-Learning 一样）。
规划 (Planning)：利用模拟经验（模型生成的）更新价值函数。

Dyna-Q 算法

Dyna-Q 是将 Q-Learning 与规划结合的最简单范例。它维护一个简单的查表式模型 (Table-based Model)，记录在这个状态 $s$ 做动作 $a$ 曾经发生了什么。

算法流程

在每个时间步 $t$：

行动：在真实环境中执行动作，获得 $(s, a, r, s')$。
直接学习：用真实数据更新 $Q(s,a)$。
模型学习：把 $(s, a) \to (r, s')$ 记入模型（如果是确定性环境，直接覆盖；如果是随机环境，可能需要记录分布）。
规划 (Planning)：
- 重复 $N$ 次（比如 10 次）：
- 做梦：随机从记忆中挑选一个曾经去过的状态 $s_{sim}$ 和曾经做过的动作 $a_{sim}$。
- 推演：询问模型得到模拟结果 $r_{sim}, s'_{sim}$。
- 间接学习：用模拟数据更新 $Q(s_{sim}, a_{sim})$。

算法伪代码

$$ \begin{aligned} & \bullet ; \text{Initialize } Q(s,a), \text{Model } M(s,a) \ & \bullet ; \textbf{For } \text{episode } e = 1 \to E \textbf{ do}: \ & \bullet \qquad \text{Initialize state } s \ & \bullet \qquad \textbf{For } \text{step } t = 1 \to T \textbf{ do}: \ & \bullet \qquad \qquad \text{Choose action } a \text{ using } \epsilon\text{-greedy} \ & \bullet \qquad \qquad \text{Execute } a, \text{ observe } r, s' \ & \bullet \qquad \qquad \textbf{1. Direct RL (Q-Learning update):} \ & \bullet \qquad \qquad Q(s,a) \leftarrow Q(s,a) + \alpha [r + \gamma \max_{a'} Q(s', a') - Q(s,a)] \ & \bullet \qquad \qquad \textbf{2. Model Learning:} \ & \bullet \qquad \qquad M(s, a) \leftarrow (r, s') \ & \bullet \qquad \qquad \textbf{3. Planning (Loop N times):} \ & \bullet \qquad \qquad \textbf{For } n = 1 \to N \textbf{ do}: \ & \bullet \qquad \qquad \qquad \text{Randomly select } s_{sim} \text{ previously observed} \ & \bullet \qquad \qquad \qquad \text{Randomly select } a_{sim} \text{ previously taken in } s_{sim} \ & \bullet \qquad \qquad \qquad r_{sim}, s'{sim} \leftarrow M(s{sim}, a_{sim}) \ & \bullet \qquad \qquad \qquad Q(s_{sim}, a_{sim}) \leftarrow Q(s_{sim}, a_{sim}) + \alpha [r_{sim} + \gamma \max_{a'} Q(s'{sim}, a') - Q(s{sim}, a_{sim})] \ & \bullet \qquad \qquad \textbf{End For} \ & \bullet \qquad \qquad s \leftarrow s' \ & \bullet \qquad \textbf{End For} \ & \bullet ; \textbf{End For} \end{aligned} $$

优缺点分析

优势

样本效率极高：在每次与环境交互后，Dyna-Q 会进行 $N$ 次规划。这意味着一条真实经验被复用了 $N+1$ 次。对于真实交互很昂贵的场景（如机器人实验），这非常有用。

劣势

模型偏差 (Model Bias)：这是 Model-Based RL 的死穴。
- 如果模型学错了（比如现实中走这一步会掉坑里，模型却认为会飞过去），那么规划得越多，智能体就在错误的道路上越走越远。
- 解决方案通常涉及不确定性估计（如果对模型预测不自信，就不要信它）或探索奖励（Dyna-Q+，鼓励去验证模型不确定的地方）。

总结

Dyna-Q 完美展示了强化学习如何结合“行万里路”（真实交互）与“读万卷书”（模型规划）。在下一章，我们将正式告别“表格型 (Tabular)”强化学习，引入神经网络，进入 深度强化学习 (Deep Reinforcement Learning) 的时代。

RL笔记（6）：时序差分

Mon, 15 Dec 2025 00:00:00 GMT

引言（Introduction）

在大部分强化学习的现实场景中，MDP 中的状态转移概率 $\mathcal{P}$ 和奖励函数 $\mathcal{R}$ 通常是未知的。

因为没有模型，我们无法直接用动态规划 (DP) 来算出最优解。
智能体必须像蒙特卡洛 (MC) 那样，通过与环境交互、采样数据来学习。

这类方法统称为 无模型强化学习 (Model-Free RL)。本章将介绍其中最重要的一类方法：时序差分 (Temporal Difference, TD)。

时序差分方法 (Temporal Difference)

核心思想

时序差分 (TD) 结合了蒙特卡洛 (MC) 和动态规划 (DP) 的思想：

像 MC：直接从经验（采样数据）中学习，不需要环境模型。
像 DP：利用自举 (Bootstrapping) 的思想，用后继状态的估计值来更新当前状态的估计值，而不需要等到回合结束。

价值函数的更新

回顾蒙特卡洛 (MC) 的增量更新公式：

$$ V(s_t) \leftarrow V(s_t) + \alpha [G_t - V(s_t)] $$

其中 $G_t$ 是从 $t$ 时刻开始直到回合结束的真实回报。

TD 的改进： TD 不想等到回合结束。它利用贝尔曼方程的性质，用 $r_t + \gamma V(s_{t+1})$ 来替代 $G_t$：

$$ V(s_t) \leftarrow V(s_t) + \alpha [\underbrace{r_t + \gamma V(s_{t+1})}_{\text{TD Target}} - V(s_t)] $$

TD Target: $r_t + \gamma V(s_{t+1})$，这是我们对真实回报 $G_t$ 的一个有偏但方差更小的估计。
TD Error: $\delta_t = r_t + \gamma V(s_{t+1}) - V(s_t)$，表示“当下的惊喜”——实际发生的情况比预期的好了多少。

为什么可以替代？

根据 $V^\pi$ 的定义推导：

$$ \begin{align} V^\pi(s) &= \mathbb{E}\pi[G_t | S_t=s] \notag \ &= \mathbb{E}\pi [R_t + \gamma G_{t+1} | S_t=s] \notag \ &= \mathbb{E}\pi [R_t + \gamma V^\pi(S{t+1}) | S_t=s] \notag \end{align} $$

可见，$R_t + \gamma V(S_{t+1})$ 是 $V(s)$ 的无偏估计（假设 $V(S_{t+1})$ 准确）。随着迭代进行，最终 $V$ 会收敛到 $V^\pi$。

SARSA 算法

SARSA 是 State-Action-Reward-State-Action 的缩写，因为它利用五元组 $(s_t, a_t, r_t, s_{t+1}, a_{t+1})$ 进行更新。

从 V 到 Q

在 Model-Free 场景下，我们通常直接估计 动作价值函数 $Q(s,a)$，而不是 $V(s)$，以便直接选取动作。更新公式：

$$ Q(s_t,a_t) \leftarrow Q(s_t,a_t) + \alpha [r_t + \gamma Q(s_{t+1},a_{t+1}) - Q(s_t,a_t)] $$

探索与利用

SARSA 需要解决两个问题：

估计不准：在训练初期，Q 值是不准确的。
采样覆盖：如果一直贪婪地选动作，可能永远无法发现更好的策略。

因此，SARSA 使用 $\epsilon$-贪婪策略 ($\epsilon$-Greedy)：

以 $1-\epsilon$ 的概率选择 $\arg\max_a Q(s,a)$。
以 $\epsilon$ 的概率随机选择动作。

算法伪代码

$$ \begin{aligned} & \bullet ; \text{Initialize } Q(s,a) \ & \bullet ; \textbf{For } \text{episode } = 1 \to E \textbf{ do}: \ & \bullet \qquad \text{Initialize state } s \ & \bullet \qquad \text{Choose action } a \text{ from } s \text{ using } \epsilon\text{-greedy} \ & \bullet \qquad \textbf{For } \text{step } = 1 \to T \textbf{ do}: \ & \bullet \qquad \qquad \text{Take action } a, \text{ observe } r, s' \ & \bullet \qquad \qquad \text{Choose action } a' \text{ from } s' \text{ using } \epsilon\text{-greedy} \ & \bullet \qquad \qquad Q(s,a) \leftarrow Q(s,a) + \alpha [r + \gamma Q(s',a') - Q(s,a)] \ & \bullet \qquad \qquad s \leftarrow s', a \leftarrow a' \ & \bullet \qquad \textbf{End For} \ & \bullet ; \textbf{End For} \end{aligned} $$

多步 SARSA ($n$-step SARSA)

MC 是无偏但方差大（要等很久），TD(0) 是偏差大但方差小（看一步）。我们可以折中一下，看 $n$ 步。

单步 TD (SARSA): $$G_t^{(1)} = r_t + \gamma Q(s_{t+1}, a_{t+1})$$
$n$ 步 TD: $$G_t^{(n)} = r_t + \gamma r_{t+1} + \dots + \gamma^n Q(s_{t+n}, a_{t+n})$$

$n$ 步 SARSA 更新规则：

$$ Q(s_t,a_t) \leftarrow Q(s_t,a_t) + \alpha [G_t^{(n)} - Q(s_t,a_t)] $$

Q-Learning 算法

Q-Learning 是强化学习中最著名的算法之一，它与 SARSA 非常像，但有一个关键区别。

更新规则

$$ Q(s_t,a_t) \leftarrow Q(s_t,a_t) + \alpha [r_t + \gamma \max_{a'} Q(s_{t+1}, a') - Q(s_t,a_t)] $$

关键区别：

SARSA：使用 $Q(s_{t+1}, a_{t+1})$。这里的 $a_{t+1}$ 是智能体实际采取的动作（可能包含了 $\epsilon$ 的随机探索）。
Q-Learning：使用 $\max_{a'} Q(s_{t+1}, a')$。不管智能体下一步实际做了什么，我们在更新时都假设它会做最好的那个动作。

算法伪代码

$$ \begin{aligned} & \bullet ; \text{Initialize } Q(s,a) \ & \bullet ; \textbf{For } \text{episode } e = 1 \to E \textbf{ do}: \ & \bullet \qquad \text{Initialize state } s \ & \bullet \qquad \textbf{For } \text{step } t = 1 \to T \textbf{ do}: \ & \bullet \qquad \qquad \text{Choose action } a \text{ from } s \text{ using } \epsilon\text{-greedy} \ & \bullet \qquad \qquad \text{Take action } a, \text{ observe } r, s' \ & \bullet \qquad \qquad Q(s,a) \leftarrow Q(s,a) + \alpha [r + \gamma \max_{a'} Q(s', a') - Q(s,a)] \ & \bullet \qquad \qquad s \leftarrow s' \ & \bullet \qquad \textbf{End For} \ & \bullet ; \textbf{End For} \end{aligned} $$

核心对比：在线策略 vs. 离线策略

这是强化学习中最重要的分类之一。

行为策略 (Behavior Policy)：智能体与环境交互、产生数据时使用的策略（通常包含随机性，如 $\epsilon$-greedy）。
目标策略 (Target Policy)：我们想要学习和优化的策略（通常是贪婪策略，即最优策略）。

| 特性 | 在线策略 (On-Policy) | 离线策略 (Off-Policy) | | :----------- | :----------------------------------------------------------------------------------------------- | :------------------------------------------------------------------- | | 定义 | 行为策略 == 目标策略 | 行为策略 != 目标策略 | | 代表算法 | SARSA | Q-Learning | | 更新依据 | 使用实际执行的下一个动作 $a_{t+1}$ 的价值 | 使用理论上最优的动作 $\max Q$ 的价值 | | 优缺点 | 比较胆小。因为它知道自己下一步可能会乱走（随机探索），所以它会避开悬崖边缘（哪怕悬崖边有宝藏）。 | 比较大胆。它假设自己下一步一定会走最优路径，所以会勇敢地贴着悬崖走。 | | 数据效率 | 数据必须现采现用，不能使用旧策略产生的数据（Replay Buffer）。 | 可以使用过去的数据，或者别人玩的数据（适合结合 Experience Replay）。 |

💡 直觉理解：

SARSA 像是一个谨慎的学生：他在学习时会考虑到自己考试时可能会因为紧张（$\epsilon$ 随机性）而犯错，所以他平时练习时就尽量选容错率高的解法。

Q-Learning 像是一个理想主义者：他在学习时假设自己考试时绝对不会犯错（全选最优解 $\max Q$），所以他会学习那条理论上分数最高、但可能风险很大的路径。

RL笔记（5）：蒙特卡洛

Sun, 14 Dec 2025 00:00:00 GMT

引言（Introduction）

在上一章 动态规划 中，我们假设环境是已知的（即我们知道状态转移概率 $\mathcal{P}$ 和奖励函数 $\mathcal{R}$）。但在现实中，比如围棋或机器人在火星行走，我们往往无法预知“做了动作后具体会发生什么”。

蒙特卡洛方法 (Monte-Carlo methods, MC) 标志着我们进入了 无模型 (Model-Free) 强化学习的领域。

核心思想：不需要知道环境的动力学方程，只需要让智能体在环境中采样（玩游戏）。
大数定律：只要玩的次数够多，观测到的平均回报就会趋近于真实的期望回报。

注意：MC 方法仅适用于情节任务 (Episodic Tasks)，即任务必须有终止状态（如一盘棋下完、游戏通关或挂掉）。

蒙特卡洛预测 (Monte-Carlo Prediction)

我们的第一个目标是：给定一个策略 $\pi$，估算它的状态价值函数 $V^\pi(s)$。

回顾 $V$ 的定义：

$$ V^\pi(s)=\mathbb{E}_\pi[G_t|S_t=s] $$

在没有模型的情况下，我们无法通过贝尔曼方程的 $\sum P(s'|s)\dots$ 来计算期望。 MC 的做法是：直接用经验平均值来代替期望。

算法流程

使用策略 $\pi$ 采样 $N$ 条完整的轨迹（Episode）： $$s_0 \xrightarrow{a_0} r_0, s_1 \xrightarrow{a_1} r_1, \dots, s_{T-1} \xrightarrow{a_{T-1}} r_{T-1}, s_T$$
计算每条轨迹中，状态 $s$ 出现后的累积回报 $G_t$。
取平均值： $$V(s) \approx \frac{1}{N(s)} \sum_{i=1}^{N(s)} G_t^{(i)}$$

首次访问 vs. 每次访问

在一条轨迹中，状态 $s$ 可能会出现多次。如何计算回报？

首次访问 (First-visit MC)：只计算状态 $s$ 第一次出现时的回报 $G_t$。这是无偏估计。
每次访问 (Every-visit MC)：状态 $s$ 每次出现，都计算一次回报 $G_t$ 并纳入平均。这也是无偏估计（但收敛性证明略有不同）。

增量式更新 (Incremental Update)

在实际计算中，我们不需要要把几百万条轨迹的数据都存下来最后求平均，而是可以使用增量更新的方法（类似于第二章多臂老虎机中的更新）。

推导：假设 $V_{k-1}$ 是前 $k-1$ 次的平均值，$G_k$ 是第 $k$ 次观测到的回报：

$$ \begin{align} V_k &= \frac{1}{k} \sum_{i=1}^k G_i \notag \ &= \frac{1}{k} (G_k + \sum_{i=1}^{k-1} G_i) \notag \ &= \frac{1}{k} (G_k + (k-1)V_{k-1}) \notag \ &= V_{k-1} + \frac{1}{k} (G_k - V_{k-1}) \notag \end{align} $$

算法描述：对于每条采样出的轨迹，对其中的每个状态 $S_t$ 和回报 $G_t$：

计数器加一：$N(S_t) \leftarrow N(S_t) + 1$
更新价值： $$ V(S_t) \leftarrow V(S_t) + \frac{1}{N(S_t)} \underbrace{(G_t - V(S_t))}_{\text{误差 Error}} $$ 或者是使用固定的步长 $\alpha$（适用于非平稳问题）： $$ V(S_t) \leftarrow V(S_t) + \alpha (G_t - V(S_t)) $$

蒙特卡洛控制 (Monte-Carlo Control)

知道怎么评估价值还不够，我们的最终目标是找到最优策略 $\pi^*$。这就是 广义策略迭代 (Generalized Policy Iteration, GPI) 的思想：

评估：用 MC 方法估算当前策略的 $Q(s,a)$。
提升：根据估算的 $Q(s,a)$ 改进策略（通常是贪婪策略）。

为什么要用 $Q$ 而不是 $V$？

在 Model-Free 场景下，如果我们只知道 $V(s)$，却不知道状态转移 $P(s'|s,a)$，我们是无法推断出哪个动作 $a$ 导致了更好的 $s'$。因此，必须显式地估算 动作价值函数 $Q(s,a)$。

探索的必要性

如果我们在提升策略时使用完全贪婪策略（greedy）：$\pi(s) = \arg\max_a Q(s,a)$，智能体可能会因为过早收敛而错过最优解（没见过的动作永远不会去尝试）。

解决方案：$\epsilon$-Greedy 策略 保持持续的探索（Exploration）：

以 $1-\epsilon$ 的概率选择当前 $Q$ 值最大的动作。
以 $\epsilon$ 的概率随机选择动作。

GLIE (Greedy in the Limit with Infinite Exploration)：如果我们让 $\epsilon$ 随着时间推移逐渐趋近于 0（例如 $\epsilon_k = 1/k$），那么 MC 控制算法最终会收敛到最优策略。

总结与对比

蒙特卡洛方法是强化学习中第一种不需要了解环境模型的算法。

💡 思考： MC 必须等到游戏结束才能更新，这在像自动驾驶这样没有明确“终点”或者流程极长的任务中非常低效。有没有一种方法，既不需要模型（像 MC），又不需要等到结束就能更新（像 DP）呢？这就是下一章 时序差分 (Temporal Difference, TD) 要解决的问题。

RL笔记（4）：动态规划

Sat, 13 Dec 2025 00:00:00 GMT

引言（Introduction）

动态规划（DP）在强化学习中指的是在环境模型已知（即状态转移概率 $\mathcal{P}$ 和奖励函数 $\mathcal{R}$ 已知）的情况下，计算最优策略的一类算法。 DP 的核心思想是将复杂问题分解为子问题，通过求解子问题来求解原问题。在 MDP 中，这体现为利用贝尔曼方程进行迭代更新。

策略迭代 (Policy Iteration)

核心思想： “先以此为据，算个清楚；再择优而行。” 策略迭代将求解过程严格拆分为两个交替的步骤，直到策略不再改变。

步骤一：策略评估 (Policy Evaluation)：在当前策略 $\pi$ 固定不变的情况下，计算出该策略下精确的状态价值函数 $V^\pi$。这意味着在这个步骤里，我们通常需要多次迭代（或者解线性方程组）直到 $V^\pi$ 完全收敛。
步骤二：策略提升 (Policy Improvement)：基于刚刚算出来的精确 $V^\pi$，贪心地更新策略。即对于每个状态，选择那个能带来最大期望回报的动作 $\pi^\prime(s)=\arg\max_{a} Q^\pi(s,a)$。

特点：收敛所需的迭代步数少，但每一步内部的计算量大（因为策略评估需要很久）。

策略评估（Policy Evaluation）

策略评估的目标是求解给定策略 $\pi$ 的状态价值函数 $V^\pi$。对于策略 $\pi$，状态价值函数满足贝尔曼期望方程：

$$ V^\pi(s)=\sum_{a\in \mathcal{A}}\pi(a|s)(\mathcal{R}(s,a)+\gamma\sum_{s^\prime\in \mathcal{S}}\mathcal{P}(s^\prime|s,a)V^\pi(s^\prime)) $$

这构成了一个线性方程组，但在状态空间较大时直接求解困难，因此采用迭代法。

贝尔曼迭代（Bellman Iteration）

将当前时刻估计的价值函数 $V_k$ 代入贝尔曼方程右侧，计算下一轮的估计 $V_{k+1}$ ：

$$ V_{k+1}(s)\leftarrow\sum_{a\in\mathcal{A}}\pi(a|s)(\mathcal{R}(s,a)+\gamma\sum_{s^\prime\in\mathcal{S}}\mathcal{P}(s^\prime|s,a)V_{k}(s^\prime)) $$

随机选定初始值 $V_0$ ，当 $k\rightarrow\infin$ 时，序列 ${ V_k }$ 会收敛到 $V^\pi$ 。为了方便证明收敛性，定义贝尔曼算子为 $\mathcal{T}^\pi$：

$$ \mathcal{T}^\pi V_k = \sum_{a\in\mathcal{A}}\pi(a|s)(\mathcal{R}(s,a)+\gamma\sum_{s^\prime\in\mathcal{S}}\mathcal{P}(s^\prime|s,a)V_{k}(s^\prime)) $$

收敛性证明（Banach不动点定理）

为了证明序列 ${ V_k }$ 收敛于 $V^\pi$，我们将迭代过程看作算子 $\mathcal{T}^\pi$ 的应用：

$$ V_{k+1}=\mathcal{T}^\pi V_k $$

证明步骤如下：

定义范数：采用无穷范数 $\parallel V \parallel_\infty=\max_{s\in \mathcal{S}} | V(s)|$；
压缩映射性质：对于任意两个价值函数 $U, V$，有： $$ \begin{align} \parallel \mathcal{T}^\pi U - \mathcal{T}^\pi V \parallel_\infty &= \max_{s} | \gamma \sum_{a}\pi(a|s)\sum_{s^\prime}\mathcal{P}(s^\prime|s,a)(U(s^\prime)-V(s^\prime)) | \notag \ &\leqslant \gamma \max_{s} \sum_{a}\pi(a|s)\sum_{s^\prime}\mathcal{P}(s^\prime|s,a) |U(s^\prime)-V(s^\prime)| \notag \ &\leqslant \gamma \max_{s} \sum_{a}\pi(a|s)\sum_{s^\prime}\mathcal{P}(s^\prime|s,a) \parallel U - V \parallel_\infty \notag \ &= \gamma \parallel U - V \parallel_\infty \notag \end{align} $$
结论：只要折扣因子 satisfying $0 \le \gamma < 1$，算子 $\mathcal{T}^\pi$ 就是一个$\gamma$-压缩映射（Contraction Mapping）。根据 Banach 不动点定理，序列 ${V_k}$ 必收敛于唯一的固定点 $V^\pi$。

策略提升（Policy Improvement）

在计算出 $V^\pi$ 后，我们需要判断当前策略是否最优。如果不是，如何改进？

策略提升理论（Policy Improvement Theorem）

给定策略 $\pi$ 和其价值函数 $V^\pi$，构造新策略 $\pi^\prime$ 使得其在每个状态下都贪心地选择动作价值最大的动作：

$$ \pi^\prime(s) = \argmax_{a\in\mathcal{A}} Q^\pi(s,a) = \argmax_{a\in\mathcal{A}} \left( r(s,a)+\gamma\sum_{s^\prime \in\mathcal{S}}\mathcal{P}(s^\prime|s,a)V^\pi(s^\prime) \right) $$

定理保证：

$V^{\pi^\prime}(s) \geqslant V^\pi(s), \forall s \in \mathcal{S}$（策略单调递增）。
如果 $V^{\pi^\prime}(s) = V^\pi(s)$，则 $\pi$ 已经是与最优策略 $V^*$ 等价的策略。

理论证明（Theorem Proof）

证明：对于任何状态 $s$，满足$V^{\pi^\prime}(s)\geqslant V^\pi(s)$。证明思路：利用 $V^\pi(s) \leqslant \max_a Q^\pi(s,a) = Q^\pi(s, \pi^\prime(s))$，反复展开 $Q^\pi$ 即可证。

状态价值函数和动作价值函数之间的关系：

$$ V^\pi(s)=\sum_{a\in\mathcal{A}}\pi(a|s)Q^\pi(s,a) $$

经过推导，可以得出：

$$ \begin{align} V^\pi(s)&=\sum_{a\in\mathcal{A}}\pi(a|s)Q^\pi(s,a) \notag \ &\leqslant \max_{a\in\mathcal{A}} Q^\pi(s,a) \notag \ &=\max_{a\in\mathcal{A}} \left( r(s,a) + \gamma \sum_{s^\prime\in\mathcal{S}} \mathcal{P}(s^\prime|s,a) V^\pi(s^\prime)\right) \notag \ &= Q^\pi(s,\pi^\prime(s)) \notag \ \end{align} $$

有了 $V^\pi(s)\leqslant Q^\pi(s,\pi^\prime(s))$，可以进一步推导出：

$$ \begin{align} V^\pi(s) &\leqslant Q^\pi(s,\pi^\prime(s)) \notag \ &= \mathbb{E}{\pi^\prime}[R{t}+\gamma V^\pi(S_{t+1})|S_t=s] \notag \ &\leqslant \mathbb{E}{\pi^\prime}[R_t+\gamma Q^\pi(S{t+1},\pi^\prime(S_{t+1}))|S_t=s]\notag \ &= \mathbb{E}{\pi^\prime}[R_t+\gamma R{t+1}+\gamma^2V^\pi(S_{t+2})|S_t=s] \notag \ &\leqslant \mathbb{E}{\pi^\prime}[R_t+\gamma R{t+1}+\gamma^2 R_{t+2} + \gamma^3 V^\pi(S_{t+3})|S_t=s] \notag \ &\cdots \notag \ &\leqslant \mathbb{E}{\pi^\prime}[R_t+\gamma R{t+1}+\gamma^2 R_{t+2} + \gamma^3 R_{t+3} + \cdots|S_t=s] \notag \ &= V^{\pi^\prime}(s) \notag \end{align} $$

迭代算法（Iteration Algorithm）

策略迭代交替进行“策略评估”和“策略提升”，直到策略不再变化。

流程：

$$ \pi_0 \xrightarrow{E} V^{\pi_0} \xrightarrow{I} \pi_1 \xrightarrow{E} V^{\pi_1} \xrightarrow{I} \dots \xrightarrow{I} \pi_* \xrightarrow{E} V^* $$

算法伪代码：

初始化：$V(s) \in \mathbb{R}$，$\pi(s) \in \mathcal{A}$ 任意。
策略评估（循环直到收敛）：
- $\Delta \leftarrow 0$
- For each $s \in \mathcal{S}$:
  - $v \leftarrow V(s)$
  - $V(s) \leftarrow \sum_{s^\prime} \mathcal{P}(s^\prime|s,\pi(s))[\mathcal{R}(s,\pi(s)) + \gamma V(s^\prime)]$
  - $\Delta \leftarrow \max(\Delta, |v - V(s)|)$
- 若 $\Delta < \theta$，停止评估。
策略提升：
- $policy_stable \leftarrow true$
- For each $s \in \mathcal{S}$:
  - $old_action \leftarrow \pi(s)$
  - $\pi(s) \leftarrow \argmax_a \sum_{s^\prime} \mathcal{P}(s^\prime|s,a)[\mathcal{R}(s,a) + \gamma V(s^\prime)]$
  - If $old_action \neq \pi(s)$, then $policy_stable \leftarrow false$
- If $policy_stable$ is true，停止并返回 $V^, \pi^$；否则跳转至步骤 2。

注意：由于有限状态 MDP 的策略总数是有限的（$|\mathcal{A}|^{|\mathcal{S}|}$），且每次提升策略都严格（或非严格）变好，策略迭代保证在有限步内收敛。

价值迭代（Value Iteration）

策略迭代的缺点是每次“策略评估”都需要迭代很多次直到完全收敛。事实上，我们不需要等到 $V^\pi$ 完全收敛才进行策略提升。如果将策略评估的迭代次数缩减为 1次，并结合策略提升，就得到了价值迭代。

贝尔曼最优迭代（Bellman Optimal Iteration）

价值迭代直接迭代求解最优价值函数，基于贝尔曼最优方程进行迭代：

$$ V_{k+1}(s) \leftarrow \max_{a\in\mathcal{A}} \left{ \mathcal{R}(s,a) + \gamma \sum_{s^\prime \in \mathcal{S}} \mathcal{P}(s^\prime|s,a) V_k(s^\prime) \right} $$

随机选定初始值 $V_0$ ，当 $k\rightarrow\infin$ 时，序列 ${ V_k }$ 会收敛到 $V^$ 。为了方便证明收敛性，定义贝尔曼最优算子为 $\mathcal{T}^$：

$$ \mathcal{T}^* V_{k} = \max_{a\in\mathcal{A}} \left{ \mathcal{R}(s,a) + \gamma \sum_{s^\prime \in \mathcal{S}} \mathcal{P}(s^\prime|s,a) V_k(s^\prime) \right} $$

收敛性证明（Banach不动点定理）

为了证明序列 ${V_k}$ 收敛于 $V^$ ，将迭代过程看作算子 $\mathcal{T}^$ 的应用：

$$ V_{k+1} = \mathcal{T}^* V_k $$

证明步骤如下：

定义范数：采用无穷范数 $||V||{\infty}=\max{s\in\mathcal{S}}|V(s)|$；
压缩映射性质：对于 $\forall s\in\mathcal{S}$ 以及任意两个价值函数 $U,V$，有： $$ \begin{align} |\mathcal{T}^* U(s) - \mathcal{T}^* V(s)| &=\left|\max_{a\in\mathcal{A}}\left{\mathcal{R}(s,a)+\gamma\sum_{s^\prime\in\mathcal{S}}\mathcal{P}(s^\prime|s,a)U(s^\prime)\right}-\max_{a\in\mathcal{A}}\left{\mathcal{R}(s,a)+\gamma\sum_{s^\prime\in\mathcal{S}}\mathcal{P}(s^\prime|s,a)U(s^\prime)\right}\right| \notag \ &\leqslant \max_{a\in\mathcal{A}}\left|\gamma\sum_{s^\prime\in\mathcal{S}}\mathcal{P}(s^\prime|s,a)(U(s^\prime)-V(s^\prime))\right| \notag \ &= \gamma\max_{a\in\mathcal{A}}\sum_{s^\prime\in\mathcal{S}}\mathcal{P}(s^\prime|s,a)\left|U(s)-V(s)\right| \notag \ &\leqslant \gamma\max_{a\in\mathcal{A}}\sum_{s^\prime\in\mathcal{S}}\mathcal{P}(s^\prime|s,a)||U-V||{\infty} \notag \ &= \gamma ||U-V||{\infty} \notag \end{align} $$
对左式取最大值： $||\mathcal{T}^*U-\mathcal{T}^*V||{\infty}\leqslant\gamma ||U-V||{\infty}$
结论：只要折扣因子 satisfying $0 \le \gamma < 1$，算子 $\mathcal{T}^$ 就是一个$\gamma$-压缩映射（Contraction Mapping）。根据 Banach 不动点定理，序列 ${V_k}$ 必收敛于唯一的固定点 $V^$。

迭代算法（Iteration Algorithm）

初始化：$V(s)$ 任意。
迭代更新（Loop until $\Delta < \theta$）：
- $\Delta \leftarrow 0$
- For each $s \in \mathcal{S}$:
  - $v \leftarrow V(s)$
  - $V(s) \leftarrow \max_{a} \sum_{s^\prime\in\mathcal{S}} \mathcal{P}(s^\prime|s,a)[\mathcal{R}(s,a) + \gamma V(s^\prime)]$
  - $\Delta \leftarrow \max(\Delta, |v - V(s)|)$
输出策略：
- $\pi^*(s) = \argmax_{a} \sum_{s^\prime\in\mathcal{S}} \mathcal{P}(s^\prime|s,a)[\mathcal{R}(s,a) + \gamma V(s^\prime)]$

局限性（Limitation）

动态规划方法（如策略迭代和价值迭代）是强化学习的理论基石，其核心优势在于理论完备性，利用自举（Bootstrapping）机制能够保证在有限步内稳定收敛至全局最优策略。然而，其在实际应用中存在两大核心局限：一是强依赖完备的环境模型（Model-based），即必须预先知晓精确的状态转移概率和奖励函数，这在现实场景中往往难以满足；二是受困于维数灾难（Curse of Dimensionality），随着状态变量增加，状态空间呈指数级膨胀，导致遍历所有状态进行全宽更新（Full-width Backup）在计算资源和存储空间上变得不可行，因此无法直接应用于大规模或连续状态空间的复杂问题。

RL笔记（3）：马尔可夫决策过程

Fri, 12 Dec 2025 00:00:00 GMT

引言（Introduction）

在上一章《多臂老虎机》中，我们解决了一个简化版的强化学习问题：在一个只有一个不变状态的环境中，如何平衡探索与利用以获得最大收益。

然而，现实世界要复杂得多。下棋时，你走出的一步棋不仅决定了当下的局势，更改变了棋盘的格局，影响了你后续所有的选择。你的每一个动作（Action）不仅会带来即时的奖励（Reward），还会通过**状态转移（State Transition）**改变环境的状态（State）。

这就是**序列决策（Sequential Decision Making）**的核心难题：今天的选择，决定明天的处境。

为了描述这种“牵一发而动全身”的动态过程，我们需要引入强化学习的数学基石——马尔可夫决策过程（MDP）。本章将从最基础的马尔可夫过程出发，层层递进，最终推导出描述价值流转的贝尔曼方程（Bellman Equation）。这是理解后续所有 RL 算法（如 DQN, PPO, SAC）的绝对前提。

马尔可夫过程（Markov Process）

随机过程（Stochastic Process）

随机过程是研究随时间演变的随机现象。在随机过程中，随机现象在$$t$$时刻的取值为$S_t$，并且$S_t$通常会取决于之前的状态 $(S_1,...,S_{t-1})$。在已知 $(S_1,...,S_{t-1})$的情况下，下一个时刻 $t$的状态为 $S_t$的概率可以表示为$P(S_t | S_1,...,S_{t-1})$。

马尔可夫性质（Markov Property）

当且仅当某个时刻的状态只取决于上个时刻的状态时，这个随机过程满足马尔可夫性质，即$P(S_t | S_{t-1}) = P(S_t | S_1, ..., S_{t-1})$。

马尔可夫过程（Markov Process）

马尔可夫过程就是满足了马尔可夫性质的随机过程，也叫马尔可夫链（Markov Chain）。通常使用一个二元组 $<\mathcal{S}, \mathcal{P}>$ 来描述马尔可夫过程，其中 $\mathcal{S}$是有限数量的状态集合， $\mathcal{P}$是状态转移矩阵（State Transition Matrix）。假设 $|\mathcal{S}|=n$，那么有：

$$ \mathcal{P}=\begin{bmatrix} P(s_1|s_1) & \cdots & P(s_n|s_1) \cr \vdots & \ddots & \vdots \cr P(s_n|s_1) & \cdots & P(s_n|s_n) \end{bmatrix} $$

且对于任意 $i$行，满足 $\sum_{j=1}^{n} P(s_j|s_i)=1$。特别的，当一个状态 $s_t$ 满足 $P(s_t|s_t)=1$，那么称 $s_t$为终止状态（Terminal State）。给定马尔可夫过程，从某个状态 $S_1$ 出发，根据状态转移矩阵 $\mathcal{P}$ 得出一段状态序列 $S_1 S_2...S_T$（Episode），这个过程也叫做采样（Sampling）。

马尔可夫奖励过程（Markov Reward Process）

马尔可夫奖励过程基于马尔可夫过程加入了奖励函数 $\mathcal{R}$（Reward Function）与折扣因子 $$\gamma$$（Discount Factor），通常由四元组 $<\mathcal{S},\mathcal{P},\mathcal{R},\gamma>$ 构成：

$\mathcal{S}$ 是有限状态集；
$\mathcal{P}$ 是状态转移矩阵；
$\mathcal{R}$ 是奖励函数，$\mathcal{R}(s)$ 表示达到状态 $s$ 可以获得的奖励；
$\gamma$ 是折扣因子，取值为 $[0,1)$。 $\gamma$ 的越小，对于未来的利益折扣越大；

回报（Return）

在一个马尔可夫奖励过程中，在某个时刻 $t$，其回报 $G_t$ 的定义如下：

$$ G_t=R_t+\gamma R_{t+1}+\gamma^2 R_{t+2}+...=\sum_{k=0}^\infin \gamma^k R_{t+k} $$

其中， $R_t$ 表示 $t$ 时刻获得的奖励。

价值函数（Value Function）

某个状态 $s$的期望回报 $\mathbb{E}[G_t|S_t=s]$，被称为这个状态的价值（Value）。那么所有状态的价值组成了价值函数（Value Function），展开如下：

$$ \begin{align} V(s)&=\mathbb{E}[G_t|S_t=s] \notag \ &=\mathbb{E}[R_t+\gamma R_{t+1}+\gamma^2 R_{t+2}+...|S_t=s] \notag \ &=\mathbb{E}[R_t+\gamma(R_{t+1}+\gamma R_{t+2}+...)|S_t=s] \notag \ &=\mathbb{E}[R_t+\gamma G_{t+1}|S_t=s] \notag \ &= \mathbb{E}[R_t+\gamma V(S_{t+1})|S_t=s] \notag \ \end{align} $$

经过几步简单的推导，可以得出贝尔曼方程（Bellman Equation）：

$$ \begin{align} V(s)&= \mathbb{E}[R_t+\gamma V(S_{t+1})|S_t=s] \notag \ &= \mathbb{E}[R_t|S_t=s]+\gamma\mathbb{E}[V(S_{t+1})|S_t=s] \notag \ &= \mathcal{R}(s)+\gamma\sum_{s^\prime \in \mathcal{S}} P(s^\prime|s) V(s^\prime) \notag \end{align} $$

可以写成矩阵形式：

$$ \begin{align} \mathcal{V}&=\mathcal{R}+\gamma\mathcal{P}\mathcal{V} \notag \ (I-\gamma\mathcal{P})\mathcal{V}&=\mathcal{R} \notag \ \mathcal{V}&=(I-\gamma\mathcal{P})^{-1}\mathcal{R} \notag \end{align} $$

马尔可夫决策过程（Markov Decision Process）

在马尔可夫奖励过程的基础上，加入外界的刺激，即智能体（Agent）的动作（Action），就有了马尔可夫决策过程（Markov Decision Process）。马尔可夫决策由五元组 $<\mathcal{S},\mathcal{A},\mathcal{P},\mathcal{R},\gamma>$构成，分别是：

$\mathcal{S}$ 是有限状态集；
$\mathcal{A}$ 是动作的集合；
$\gamma$ 是折扣因子；
$\mathcal{R}(s,a)$ 是奖励函数；
$\mathcal{P}(s^\prime|s,a)$ 是状态转移函数；

策略（Policy）

策略的定义：智能体根据当前的状态 $S_t$，并从动作集合 $\mathcal{A}$中选取一个 $A_t$ 的函数，一般记为 $\pi$。 $\pi(a|s)=P(A_t=a|S_t=s)$ 表示状态 $s$ 下，选择动作 $a$ 的概率。

确定性策略（Deterministic Policy）

如果一个策略 $\pi$ ，对于每一个状态 $s\in\mathcal{S}$ ，有且仅有唯一动作 $a\in\mathcal{A}$ ，使得 $\pi(a|s)=1$ ，那么这个策略就是一个确定性策略。

随机性策略（Stochastic Policy）

随机性策略和确定性策略相反，它输出的各个动作的概率分布（Probability Distribution），每次采取动作时会从分布中进行采样。

状态价值函数（State-Value Function）

基于策略 $\pi$ 的状态价值函数被记为 $V^\pi(s)=\mathbb{E}_\pi[G_t|S_t=s]$ 。注意：若 $\pi \ne \pi^\prime$ ，则 $V^\pi \ne V^{\pi^\prime}$ 。

动作价值函数（Action-Value Function）

马尔可夫决策过程引入了动作，我们额外定义了一个动作价值函数（Action-Value Function）。基于策略 $\pi$ 的动作价值函数被记为 $Q^\pi(s,a)$ ，表达式为 $Q^\pi(s,a)=\mathbb{E}_{\pi}[G_t|S_t=s,A_t=a]$ 。经过简单的推导，可以得出如下公式：

$$ \begin{align} Q^\pi(s,a)&=\mathbb{E}\pi[G_t|S_t=s,A_t=a] \notag \ &=\mathbb{E}\pi[R_t+\gamma R_{t+1}+\gamma^2 R_{t+2}+...|S_t=s,A_t=a] \notag \ &= \mathbb{E}\pi[R_t+\gamma(R{t+1}+\gamma R_{t+2}+...)|S_t=s,A_t=a] \notag \ &= \mathbb{E}\pi[R_t+\gamma V(S{t+1})|S_t=s,A_t=a] \notag \ &= \mathbb{E}\pi[R_t]+\gamma \mathbb{E}\pi[V^\pi(S_{t+1})|S_t=s,A_t=a] \notag \ &= \mathcal{R}(s,a)+\gamma \sum_{s^\prime \in \mathcal{S}}\mathcal{P}(s^\prime|s,a)V^\pi(s^\prime) \notag \end{align} $$

状态价值函数和动作价值函数之间的关系：

$$ \begin{align} V^\pi(s)&= \mathbb{E}{a\sim \pi( \cdot | s)}[Q^\pi(s,a)] \notag \ &=\sum{a\in \mathcal{A}}\pi(a|s)Q^\pi(s,a) \notag \end{align} $$

注意：若 $\pi \ne \pi^\prime$ ，则 $Q^\pi \ne Q^{\pi^\prime}$ 。

贝尔曼期望方程（Bellman Expectation Equation）

对状态价值函数进行边缘化（Marginalization），可以得出 $V^\pi(s)$ 的贝尔曼期望方程：

$$ \begin{align} V^\pi(s)&=\mathbb{E}\pi[R_t+\gamma V^\pi(S{t+1})|S_t=s] \notag \ &=\mathcal{R}(s)+\gamma\sum_{s^\prime\in \mathcal{S}}\mathcal{P}(s^\prime|s)V^\pi(s^\prime) \notag \ &=\sum_{a\in \mathcal{A}}\pi(a|s)(\mathcal{R}(s,a)+\gamma\sum_{s^\prime\in \mathcal{S}}\mathcal{P}(s^\prime|s,a)V^\pi(s^\prime)) \notag \end{align} $$

将 $V^\pi(s)=\sum_{a\in\mathcal{A}}\pi(a|s)Q^\pi(s,a)$ 代入，可以得出 $Q^\pi(s,a)$ 的贝尔曼期望方程：

$$ \begin{align} Q^\pi(s,a)&=\mathbb{E}{\pi}[G_t|S_t=s,A_t=a] \notag \ &=\mathcal{R}(s,a) + \gamma \sum{s^\prime\in \mathcal{S}}\mathcal{P}(s^\prime|s,a)V^\pi(s^\prime) \notag \ &= \mathcal{R}(s,a)+\gamma\sum_{s\in\mathcal{S}}\mathcal{P}(s^\prime|s,a)\sum_{a^\prime\in\mathcal{A}}\pi(a^\prime|s^\prime)Q^\pi(s^\prime,a^\prime) \notag \end{align} $$

状态访问分布（State Visitation Distribution）

在同一个马尔可夫过程中，不同的策略，它们的价值函数是不一样的。因为在不同的策略，智能体能够访问的状态的概率分布是不同的。我们使用 $P_t^\pi(s)$ 来表示智能体使用策略 $\pi$ 在 $t$ 时刻访问状态 $s$ 的概率。策略 $\pi$ 的状态访问分布（State Visitation Distribution）定义如下：

$$ \nu^\pi(s)=(1-\gamma)\sum_{t=0}^{\infin}\gamma^t P_t^\pi(s) $$

$1-\gamma$ 是归一化因子，它保证 $\nu^\pi(s)$ 是一个有效的概率分布，即 $\sum_s \nu^\pi(s)=1$，推导如下：

$$ \begin{align} \sum_s \nu^\pi(s)&=\sum_s (1-\gamma) \sum_{t=0}^\infin \gamma^t P_t^\pi(s) \notag \ &= (1-\gamma)\sum_{t=0}^\infin \gamma^t \sum_s P_t^\pi(s) \notag \ \end{align} $$

在任意时刻 $t$，满足 $\sum_s P_t^\pi(s)=1$，可以推导出：

$$ \sum_s \nu^\pi(s)=(1-\gamma) \sum_{t=0}^\infin \gamma^t $$

这里有个几何级数，满足 $\sum_{t=0}^\infin\gamma^t=\frac{1}{1-\gamma}$，可以推导出：

$$ \sum_s \nu^\pi(s)=(1-\gamma) \frac{1}{1-\gamma}=1 $$

特别地，定义初始状态分布为 $\nu_0(s)$，且 $P_0^\pi(s)=\nu_0(s)$。

使用上述公式计算该分布涉及到了无穷步的交互，但是实际上的交互数量是有限的。同时，状态访问分布满足以下性质：

$$ \nu^\pi(s^\prime)=(1-\gamma)\nu_0(s^\prime)+\gamma \int \mathcal{P}(s^\prime|s,a)\pi(a|s)\nu^\pi(s) {\rm d} s {\rm d} a $$

占用度量（Occupancy Measure）

进一步，为了表示动作状态 $(s,a)$ 访问的分布，定义策略 $\pi$ 的占用度量（Occupancy Measure）如下：

$$ \rho^\pi(s,a)=(1-\gamma)\sum_{t=0}^\infin \gamma^t P_t^\pi(s)\pi(a|s) $$

两者存在以下关系：

$$ \rho^\pi(s,a)=\nu^\pi(s)\pi(a|s) $$

最终，可以推导出两个定理：

定理1：给定环境（MDP）的条件下，策略 $\pi_1$和策略 $\pi_2$ 得出的占用度量 $\rho^{\pi_1}$ 和 $\rho^{\pi_2}$ 满足：

$$ \pi_1 = \pi_2 \Longleftrightarrow \rho^{\pi_1} = \rho^{\pi_2} $$

定理2：给定一合法的占用度量 $\rho$，生成该占用度量的唯一策略是：

$$ \pi_\rho(a|s)=\frac{\rho(s,a)}{\sum_{a^\prime}\rho(s,a^\prime)} $$

最优策略（Optimal Policy）

强化学习的目标：找到一个策略，使得智能体从初始状态出发获取最大的累计奖励。首先定义策略之间的偏序关系：当且仅当对于任何状态 $s$ 都满足 $V^\pi(s) \ge V^{\pi^\prime}(s)$，则 $\pi > \pi^\prime$。最优策略（Optimal Policy）：在一个MDP中，至少存在一个策略优于其他策略或者至少存在一个策略不差于其他策略，这个策略就是最优策略。

最优策略都有相同的状态价值函数，被称为最优状态价值函数：

$$ V^*(s)=\max_\pi V^\pi(s),; \forall s \in \mathcal{S} $$

同理，定义最优动作价值函数：

$$ Q^*(s,a)=\max_\pi Q^\pi(s,a), ; \forall s\in\mathcal{S},a\in\mathcal{A} $$

最优状态价值函数和最优动作价值函数之间的关系：

$$ Q^(s,a)=\mathcal{R}(s,a)+\gamma\sum_{s^\prime\in\mathcal{S}} \mathcal{P}(s^\prime|s,a)V^(s^\prime) $$

$$ V^(s)=\max_{a\in\mathcal{A}}Q^(s,a) $$

贝尔曼最优方程（Bellman optimality equation）：

$$ V^(s)=\max_{a\in\mathcal{A}} { \mathcal{R}(s,a)+\gamma\sum_{s^\prime\in\mathcal{S}}\mathcal{P}(s^\prime|s,a)V^(s^\prime)} $$

$$ Q^(s,a)=\mathcal{R}(s,a)+\gamma\sum_{s^\prime\in\mathcal{S}}\mathcal{P}(s^\prime|s,a) \max_{a^\prime\in\mathcal{A}} Q^(s^\prime,a^\prime) $$

RL笔记（2）：多臂老虎机

Thu, 11 Dec 2025 00:00:00 GMT

引言（Introduction）

在上一章中，我们提到了 RL 的核心矛盾：探索与利用 (Exploration vs. Exploitation)。为了研究这个问题，我们先暂时把“状态转移”拿掉，看一个最简化的场景——多臂老虎机 (Multi-Armed Bandit, MAB)。

这个问题来源于赌场：假设你面前有 $K$ 台老虎机。每台老虎机吐钱的概率分布不一样（有的容易赢，有的容易输），但你事先不知道。你的目标是：在有限的操作次数 $T$ 内，获得最大的累积奖励。

这不仅是赌博问题，它在现实中无处不在：

推荐系统：把哪部电影推给用户？（探索新电影 vs 利用已知的高分电影）
临床试验：给病人用哪种药？（试新药 vs 用疗效确定的旧药）

问题定义

形式化描述

多臂老虎机问题是一个元组 $\langle \mathcal{A}, \mathcal{R} \rangle$：

$\mathcal{A}$：动作集合，即 $K$ 个拉杆，${a_1, \dots, a_K}$。
$\mathcal{R}$：奖励概率分布。对于每个动作 $a$，奖励 $r \sim \mathcal{R}(r|a)$。

累积懊悔 (Cumulative Regret)

怎么衡量一个算法好不好？我们引入懊悔 (Regret) 的概念。假设我们开了上帝视角，知道哪台机器最好，那台机器的期望奖励是 $Q^*$。如果我们选了差的机器，我们就会“后悔”。在 $T$ 步内的总懊悔定义为：

$$ R_T = \sum_{t=1}^T (Q^* - q_*(a_t)) $$

$Q^*$：全局最优拉杆的期望奖励。
$q_*(a_t)$：我们第 $t$ 步实际选的那个拉杆的期望奖励。

我们的目标：设计一个算法，让累积懊悔 $R_T$ 增长得越慢越好（最好是亚线性的，即 $\lim_{T \to \infty} \frac{R_T}{T} = 0$）。这意味着随着时间推移，我们几乎总是选中最好的那台机器。

基础：估计期望奖励

不论用什么算法，我们都需要估计每个拉杆的价值。最简单的方法是增量式蒙特卡洛更新。

假设第 $k$ 个拉杆被选中了 $n$ 次，每次的奖励是 $r_1, \dots, r_n$。当前的估计值 $Q_n$ 是平均值。当有新的奖励 $r_{n+1}$ 进来时，更新公式为：

$$ Q_{n+1} = Q_n + \frac{1}{n+1} (r_{n+1} - Q_n) $$

💡 直觉： $\text{新估计值} = \text{旧估计值} + \text{步长} \times \text{误差}$ 这个公式非常重要，它是后续所有强化学习价值更新的雏形。

算法 1：$\epsilon$-Greedy 算法

这是最直观的平衡策略。

规则

每次选择动作时，生成一个 $[0, 1]$ 的随机数：

以 $1-\epsilon$ 的概率（利用）：选择当前估计值 $Q(a)$ 最高的那个拉杆。
以 $\epsilon$ 的概率（探索）：随机选择任意一个拉杆。

衰减的 $\epsilon$

普通的 $\epsilon$-Greedy 有个缺点：即使已经玩了一万次，明明知道哪个最好，它还是会以固定的 $\epsilon$ 概率去乱选，导致懊悔线性增长。改进：让 $\epsilon$ 随时间减小，例如 $\epsilon_t = \frac{1}{t}$。

初期 $\epsilon$ 大：疯狂探索。
后期 $\epsilon$ 小：主要利用，趋近于最优策略。

算法 2：上置信界 (UCB)

$\epsilon$-Greedy 的探索是盲目的。UCB (Upper Confidence Bound) 提出了一种“面对不确定性保持乐观 (Optimism in the Face of Uncertainty)”的原则。

核心思想

我们给每个拉杆的价值算一个上界。

如果一个拉杆估计值高，上界就高。
如果一个拉杆被选的次数很少（不确定性大），它的波动范围就大，上界也会很高。我们每次都选上界最高的那个拉杆。

UCB 公式

在时刻 $t$，对于动作 $a$，我们计算它的 UCB 分数：

$$ \text{Score}_t(a) = \hat{Q}_t(a) + c \sqrt{\frac{\ln t}{N_t(a) + 1}} $$

$\hat{Q}_t(a)$：当前的平均收益（利用项）。
$\sqrt{\dots}$：不确定性红利（探索项）。
- $N_t(a)$ 是动作 $a$ 被选中的次数。分母越小（玩得少），这一项越大。
- $t$ 是总步数。随着时间推移，如果某个动作一直没被选，分子 $\ln t$ 变大，也会强行把它的分数拉高。
$c$：超参数，控制探索的权重。

💡 效果：那些“潜力股”（玩得少）和“绩优股”（均值高）都会被选中，而那些“玩了很多次且证明了很烂”的拉杆会被逐渐抛弃。

算法 3：汤普森采样 (Thompson Sampling)

汤普森采样 (Thompson Sampling)基于贝叶斯 (Bayesian) 思想，比 UCB 更具统计学美感。

核心思想

我们不维护一个具体的数值 $Q(a)$，而是维护每个拉杆奖励的概率分布。假设每台老虎机只有“赢”和“输”两种结果（伯努利分布）。我们可以用 Beta 分布 来描述这种不确定性。

流程

初始化：为每个拉杆 $k$ 维护两个数：$Win_k$（赢的次数）和 $Lose_k$（输的次数）。初始都为 1。
采样：在每一步，对于每个拉杆，从它的 Beta 分布中随机采样一个数： $$ \theta_k \sim \text{Beta}(Win_k + 1, Lose_k + 1) $$

注意：不是选 Beta 分布的均值，而是采样产生一个随机数。如果一个拉杆尝试少，Beta 分布很宽，采样出来的数可能很高也可能很低（探索）。如果尝试多且赢得多，Beta 分布很尖且靠右，采样出来的数大概率很高（利用）。
决策：选择采样值 $\theta_k$ 最大的那个拉杆 $a_t$。
更新：观察实际奖励 $r_t$，如果赢了则 $Win_{a_t} += 1$，输了则 $Lose_{a_t} += 1$。

优势

汤普森采样在很多实际应用中表现比 UCB 更好，因为它引入了随机性，能更平滑地处理探索与利用，而且对非平稳环境适应性较强。

总结

多臂老虎机是强化学习的“单状态”特例，它教会了我们处理 RL 核心难题的几种范式：

盲目探索：$\epsilon$-Greedy（简单粗暴，但有效）。
乐观探索：UCB（基于不确定性的确定性策略，数学理论完备）。
后验采样：Thompson Sampling（基于概率分布的随机策略，贝叶斯流派）。

解决了怎么选动作的问题，下一章我们将引入状态转移，去面对真正复杂的序列决策问题——马尔可夫决策过程 (MDP)。

RL笔记（1）：初入强化学习

Wed, 10 Dec 2025 00:00:00 GMT

引言（Introduction）

强化学习 (Reinforcement Learning, RL) 是机器学习中一个独特的领域，它关注的是智能体 (Agent) 如何在环境 (Environment) 中通过试错 (Trial-and-Error) 来学习最佳策略。

如果说监督学习是“老师手把手教你做题”（有标签），那么强化学习就是“把你扔进游戏里自己玩，赢了得分，输了扣分”。智能体必须通过与环境的交互，自己总结出怎么做才能获得最高的累积奖励。

核心直觉：就像训练小狗：小狗做动作（Action），你给它骨头或训斥（Reward）。小狗为了多吃骨头，逐渐学会了“听到口令坐下”这个策略（Policy）。

强化学习 vs. 其他机器学习

为了搞懂 RL，我们先看它和我们熟悉的监督学习有什么本质区别：

没有“正确答案” (No Ground Truth)：
- 监督学习：输入一张猫的图片，标签明确告诉你“这是猫”。
- RL：你走了一步棋，没人告诉你这一步是“对”还是“错”，你只知道这局棋最后是赢了还是输了。
反馈是延迟的 (Delayed Reward)：
- 你现在做的一个决定（比如买股票），可能要很久之后（卖出时）才知道好坏。这被称为信用分配问题 (Credit Assignment Problem)。
数据是动态分布的 (Non-i.i.d Data)：
- 你的策略变了，你看到的画面（状态）也就变了。智能体的动作会直接改变它未来接收到的数据。

核心组件：RL 的世界观

强化学习的一切都发生在一个循环交互中。我们需要掌握以下几个核心术语，它们是后续所有章节的基石。

1. 交互循环 (The Loop)

在每一个时刻 $t$：

观察：智能体看到环境的状态 $S_t$。
动作：智能体根据策略，选择一个动作 $A_t$。
反馈：环境受到动作影响，变成新状态 $S_{t+1}$，并给出一个即时奖励 $R_t$。

2. 状态 (State, $S$)

状态是对环境现状的描述。

例子：在玩《王者荣耀》时，屏幕上的所有画面（英雄位置、血量、小地图）就是状态。
全观测 vs. 部分观测：如果你能看到整个棋盘，这叫全观测；如果你在打扑克，你看不到对手的牌，这叫部分观测（POMDP）。

3. 动作 (Action, $A$)

智能体能做的事情。

离散动作：上下左右、跳跃、开火（如超级马里奥）。
连续动作：方向盘转动 30.5 度、油门踩 70%（如自动驾驶）。

4. 奖励 (Reward, $R$)

奖励是一个标量数值，是环境给智能体的唯一反馈信号。

奖励假设 (The Reward Hypothesis)：所有目标都可以被描述为“最大化累积奖励的期望”。
注意：奖励定义了“好坏”，但没告诉智能体“怎么做”。

5. 策略 (Policy, $\pi$)

策略是智能体的大脑，它定义了在某个状态下该采取什么动作。

确定性策略：看到 $s$，就做 $a$。即 $a = \pi(s)$。
随机性策略：看到 $s$，有 70% 概率做 $a_1$，30% 概率做 $a_2$。即 $\pi(a|s) = P(A_t=a|S_t=s)$。

6. 价值 (Value, $V$)

这是 RL 中最关键的概念之一（后续笔记会详细讲）。奖励是眼前的利益，价值是长远的目光。

例子：为了赢下棋局（高价值），你可能需要牺牲一个车（负的即时奖励）。
价值函数预测了：从当前状态出发，未来总共能拿多少分。

两个核心难题

在深入学习具体算法前，我们需要理解阻碍智能体变强的两大难题：

1. 序列决策 (Sequential Decision Making)

智能体的动作有长远影响。现在的选择决定了未来的状态，进而限制了未来的选择。

解决思路：我们需要引入 马尔可夫决策过程 (MDP) 来数学化描述这个过程（详见笔记 3），并通过 动态规划（笔记 5）或 时序差分（笔记 6）来求解未来的价值。

2. 探索与利用 (Exploration vs. Exploitation)

这是 RL 独有的矛盾。

利用 (Exploitation)：根据现有经验，做那个我认为最好的动作（拿确定的分数）。
探索 (Exploration)：尝试一个没做过的动作，虽然可能导致扣分，但也可能发现一条通往更高分的新捷径。
解决思路：就像去餐厅吃饭，是去吃那家确定的好吃的店（利用），还是去试一家新开的店（探索）？
这个问题在 多臂老虎机 (Multi-armed Bandit) 问题中最为纯粹（详见笔记 2）。

学习路线图 (Roadmap)

本系列笔记将按照以下逻辑逐步深入：

无状态的基础：从最简单的多臂老虎机（笔记 2）开始，只考虑动作选择，不考虑状态转移。
建立数学模型：引入马尔可夫决策过程 (MDP)（笔记 3），正式描述状态转移和序列决策。
求解 MDP：
- 如果你知道环境的一切规则（上帝视角），使用动态规划（笔记 5）。
- 如果你只能通过玩游戏来学习（蒙眼摸象），使用蒙特卡洛（笔记 4）和时序差分（笔记 6）。
进阶与深度强化学习：
- 当状态太多存不下表格时，我们引入神经网络，进入 Deep RL 时代（DQN, Policy Gradient, Actor-Critic 等）。
- 一直到最前沿的 SAC, PPO 等算法。

让我们开始这段旅程吧！

Slay the Spire: Silent Cards 评测

Tue, 14 Apr 2026 00:00:00 GMT

import { StsCardRating, StsSilentTierBoard } from '@/components/advanced'

Silent Cards Rank 表

个人情况：我在《杀戮尖塔》累计游玩约 2000h，最好成绩为 SL 179 连胜、NOSL 10 连胜。平时会在 B 站直播杀戮尖塔，主页：juhuahua233

说明：本 Rank 表按个人评测结果整理。评级解读时建议参考稀有度（Starter / Common / Uncommon / Rare）与成型阶段，不同稀有度的抓取机会与机会成本差异很大。

免责声明：该分级仅代表个人当前版本体验，不构成通用强度结论；不同路线、遗物、路径、事件、升级时机、Boss 都会显著改变卡牌价值。请结合你的局内状态灵活取舍。

起始卡 Starter Cards

防御 Defend

<StsCardRating name='Defend' rarity='Starter' type='Skill' cost='1' effect='Gain 5(8) Block.' score={5} image='https://pic.hana0721.top//Defend_G.8vni909zoh.webp'

猎人的防御价值会比较高，评分也会比其他角色的防御卡更高一些。首先，取决于猎人的毒系终端，毒会偏向于防杀。其次，猎人有一张轮椅卡——灵动，可以有效提高防御的数值。综上，猎人的防御是普遍比打击有价值的。

中和 Neutralize

<StsCardRating name='Neutralize' rarity='Starter' type='Attack' cost='0' effect='Deal 3(4) damage. Apply 1(2) Weak.' score={7.5} image='https://pic.hana0721.top//Neutralize.67y1yngycu.webp'

0费的1层虚弱，敲后2层。虚弱覆盖率是 Silent 在 NOSL 玩法中需要重点关注的。因此，一般在进入一层 boss 前会升级中和，若没有其他的虚弱卡。同时，轮椅遗物纸鹤的存在更加提高了虚弱的价值。

打击 Strike

<StsCardRating name='Strike' rarity='Starter' type='Attack' cost='1' effect='Deal 6(9) damage.' score={2} image='https://pic.hana0721.top//Strike_G.5trm7s8nhy.webp'

打击，不说了。但是在 Silent 套牌中，打击还真不是最垃圾的，原来还有高手。

生存者 Survivor

<StsCardRating name='Survivor' rarity='Starter' type='Skill' cost='1' effect='Gain 8(11) Block. Discard a card.' score={6} image='https://pic.hana0721.top//Survivor.6m4hpip987.webp'

Silent 的费防比最高的卡，特效是丢弃一张牌。在前期，丢弃是非常好的，因为你根本出不完手牌，还能听一些丢弃触发的卡牌。在后期，当你过牌很足时，丢弃也是一种很好的卸牌手段。针对保留，生存者可能时好时坏。在你有金字塔的情况下一般是好的，保留量大，可以卸牌。在你使用计划妥当的情况下，生存者可能会丢弃掉一些你想要保留的牌。

普通卡 Common Cards

杂技 Acrobatics

<StsCardRating name='Acrobatics' rarity='Common' type='Skill' cost='1' effect='Draw 3(4) cards. Discard 1 card.' score={0} image='https://pic.hana0721.top//Acrobatics.39lrv58oug.webp'