<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:media="http://search.yahoo.com/mrss/"><channel><title>Bless Blog</title><link>https://blog.hieros.me/zh/</link><description>Recent content on Bless Blog</description><generator>Hugo -- 0.166.0</generator><language>zh</language><lastBuildDate>Thu, 17 Sep 2026 23:00:00 +0800</lastBuildDate><atom:link href="https://blog.hieros.me/zh/index.xml" rel="self" type="application/rss+xml"/><item><title>Azure SRE 教程</title><link>https://blog.hieros.me/zh/posts/wsre/</link><pubDate>Thu, 17 Sep 2026 23:00:00 +0800</pubDate><author>BLESS</author><guid>https://blog.hieros.me/zh/posts/wsre/</guid><description>SRE学习</description><content type="text/html" mode="escaped"><![CDATA[<h1 id="sre简介">SRE简介<a href="#sre%e7%ae%80%e4%bb%8b" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h1>
<p>站点可靠性工程是一门工程专业，致力于持续帮助组织实现系统、服务和产品的可靠性级别。——本·特雷诺·斯洛斯</p>
<p>SRE 最核心的一词是“可靠性”，定义中说的不是“适当性能级别”、“适当效率级别”、“适当稳定性级别”或“达到适当收入级别”， 而是“适当可靠性级别”。如果应用程序没有正常运行（即如果它在客户需要访问它时无法运行或如果它不可靠），这对任何人都没有任何好处，尤其是对企业。缺少可靠性可能会（在信誉、经济、合同、士气等方面）对企业造成实际危害。</p>
<p>站点可靠性工程是一门工程专业，致力于持续帮助组织实现系统、服务和产品的可靠性级别。据 SRE 领域的重要观察，必须 100% 可靠的系统和服务寥寥无几。 值得注意的例外是，航空、医疗设备等生死攸关的行业。可靠性级别必须与业务需求保持一致，且切实可行。 例如，我们的客户可能通过不是 100% 可靠的网络连接到你（假设 90% 的时间都是）。 花费精力和金钱来确保服务 95% 的可靠性显然浪费时间和金钱。 建议实现系统、服务和产品的适当可靠性级别。</p>
<p>我们在继续之前需要重点强调的定义中的最后一个词是“持续”。 “持续”是指人员的角色。 创建可持续的操作实践至关重要。 人员生成可靠的系统、服务和产品。 <strong>如果我们不采取措施确保我们的工作是可持续的。 如果我们每天凌晨 3:00 把员工叫醒交付他们工作，不给他们和家人在一起的时间。 如果他们没有机会花时间照顾自己。 那么，他们就不可能构建可靠的系统。</strong> SRE 认为我们非常有必要实施一种长期可持续的操作实践，以便我们的员工能够在工作中发挥最大才能。</p>
<p>DevOps 可以理解为一种让开发和运维更紧密合作的软件交付方式。过去开发人员主要负责写代码，运维人员主要负责部署和维护系统，两边往往彼此独立。这样很容易出现“开发只管功能，运维只管稳定”的问题。DevOps 想解决的就是这种割裂，让开发、测试、部署和运维尽量形成一条连续的流程，并通过 CI/CD、自动化测试、自动部署等方式提高软件交付效率。</p>
<p>SRE，也就是站点可靠性工程，更关注系统上线之后如何长期稳定运行。它的核心思想是把传统运维中的问题当成工程问题来解决。例如，系统出现故障时，不只是依赖运维人员手动处理，而是考虑能不能通过监控、自动恢复、容量规划等方式提前发现和自动解决。SRE 还会用 SLI、SLO、Error Budget 等指标来明确“系统到底需要多可靠”。</p>
<p>两者最大的区别在于关注重点不同。DevOps 更关心“开发和运维怎么更好地协作，以及软件怎么更快、更顺利地上线”；SRE 更关心“系统上线之后怎么保持可靠，出了故障怎么快速恢复，以及怎么减少人工运维”。因此，DevOps 更像一种文化和工作方式，而 SRE 更像一套比较具体的工程方法。</p>
<p>不过两者并不是互相替代的关系。它们都强调自动化、监控、持续改进和减少人为失误，所以实际工作中经常会一起出现。一个已经实行 DevOps 的团队，通常也更容易进一步引入 SRE 的做法。<strong>DevOps 主要解决“怎么把软件交付好”，SRE 主要解决“怎么让软件运行好”。</strong></p>
<p>假设你正计划要将一项新服务投入生产，可能是已构造的服务，也可能是仍在计划过程当中的服务。 在此过程中，务必要对所需的可靠性做出一些决定。 如果不是所有代码都是你自己编写的，请与编写相应代码的开发人员共同做出这些决定（这一点至关重要）。</p>
<p>要做出的第一个决定是，应该用什么作为服务运行状况的指标（即“服务级别指标 (SLI)”）？ 这个问题的另一种问法是，“如何判断服务何时在运行且运行良好？”。 有很多方法可以跟踪 SLI，我们稍后会详细探讨一些方法。 但是，以下指标是很典型的：</p>
<ul>
<li>成功与失败度量标准： 服务是否在某个时间间隔内成功完成一定比例的操作？</li>
<li>计时度量值： 我们在某个时间阈值内是否返回答案？</li>
<li>吞吐量度量值： 我们处理了一定量的数据吗？</li>
</ul>
<p>SLO（Service Level Objective，服务级别目标）是团队根据服务运行指标设定的可靠性目标。例如，可以规定一天内的故障率不超过 20%。这里使用 20% 这样较大的数值，一方面便于理解和计算，另一方面也体现了 SRE 中对开发速度与运行稳定性之间平衡的考虑：在满足可靠性要求的同时，为持续交付、快速迭代和敏捷开发保留一定的调整空间。后续还可以进一步限定统计范围，例如哪些用户受到影响、错误率针对部分用户还是大多数用户等，从而使 SLO 的定义更加精确。</p>
<p>必须能够在监视系统中准确度量和表示 SLO。 这应该是一个客观且易于理解的服务可靠性目标。 多大的数字才够好呢？ 不得有下面这样的说辞：“好吧，我认为这项服务在过去一周左右的时间里一直没问题，但具体怎样很难说”。 服务要么实现 SLO，要么没有实现。 数据应该很明确。 如果服务没有实现 SLO（特别是在一段时间内反复这样），表示服务出现了问题，需要进行解决。</p>
<p>误差预算（Error Budget）是由 SLO 推导出来的“允许不可靠空间”。如果某项服务的 SLO 是 80% 可用性，那么理论上的误差预算就是 100% - 80% = 20%。这 20% 表示：只要整体可靠性仍然满足 SLO，服务可以在这部分范围内承担一定的故障、发布风险或升级带来的不稳定。</p>
<p>误差预算的意义在于，它为开发速度和系统稳定性之间提供了一个可以量化的平衡。例如，新版本上线后导致 10% 的额外故障时间，只要仍然没有超出 20% 的误差预算，就可以认为整体仍处于可接受范围内。因此，团队可以把一部分误差预算用于发布新功能、升级系统和快速迭代。</p>
<p>如果服务可靠性下降到 SLO 以下，例如目标是 80%，实际却只有 60%，就意味着误差预算已经耗尽甚至透支。此时团队通常会减少或暂停新的功能发布，把更多工程资源投入到稳定性、故障排查和可靠性改进中，直到服务重新恢复到目标水平。</p>
<p>因此，误差预算可以看作一种反馈机制：预算充足时，团队可以更积极地发布和迭代；预算接近耗尽时，就应更加保守；预算耗尽后，则优先修复可靠性问题。它把“到底该继续发版本，还是先解决稳定性问题”从主观争论转化成了基于 SLO 的工程判断。</p>
<p>事后调查（Postmortem）是对重大故障或异常事件进行回顾分析，目的是弄清楚故障为什么发生、哪些环节失效，以及今后如何避免类似问题再次出现。SRE 特别强调“无责备事后调查”，也就是分析重点放在系统、流程和信息设计上，而不是追究某个具体人员的责任。</p>
<p>无责备并不意味着忽视人的操作，而是进一步追问：为什么现有流程会允许一次操作演变成故障？当事人在当时缺少了什么信息？哪些提示或机制可能让他做出了错误判断？系统是否应该增加自动检查、权限限制、回滚机制或其他保护措施？核心目标是让系统本身变得更不容易出错。</p>
<p>这种做法背后的逻辑是，如果每次事故都优先寻找“谁犯了错”，员工以后就会更倾向于隐瞒问题、避免操作和拒绝尝试，从而让组织失去真正学习和改进的机会。相反，良好的事后调查会把故障转化为经验，通过持续改进流程和技术，让整个系统越来越可靠。</p>
<p>因此，SRE 把故障看作学习机会。每次事故都应该形成“发生故障—分析原因—改进系统—降低未来风险”的反馈循环，这也是 SRE 持续提升可靠性的核心机制之一。</p>
<p>Toil 是 SRE 中专门用来描述低价值重复性运维工作的概念。它通常具有手动、重复、可自动化、会随系统规模增长而增加等特点，而且完成这些工作并不会让系统得到长期改善。例如，反复重启进程、定期手动重置配置、人工创建账号或分配磁盘空间，都属于典型的 Toil。</p>
<p>Toil 的关键问题不在于工作本身是否困难，而在于它需要不断重复投入人力，却不会形成长期收益。即使这些工作通过工单系统被规范地记录和处理，只要最终仍然需要工程师一次次手动完成，它依然属于 Toil。</p>
<p>SRE 会尽可能减少或消除 Toil，其中最重要的手段之一就是自动化。通过把重复操作交给脚本、平台或自动化系统完成，可以让工程师把时间投入到架构改进、可靠性优化和工具建设等更有长期价值的工作中。不过，并不是所有 Toil 都必须立即消除，是否值得自动化仍要结合成本和优先级判断。</p>
<p>SRE 团队需要在“日常运维”和“长期工程改进”之间保持平衡。工程师不能把全部时间都用在处理告警、响应故障和清理工单上，还必须留出足够的时间编写代码、建设自动化工具、减少 Toil，并通过工程项目持续提高系统可靠性。</p>
<p>Google SRE 模型中常引用的原则是：<strong>操作性工作最好不要长期超过团队总时间的 50%</strong>。这里的 50% 并不是严格标准，而是一个经验性的上限，用来提醒团队必须为自动化和可靠性建设保留足够的工程时间。</p>
<p>在严重故障期间，SRE 团队短时间内把几乎全部精力投入救火是正常的；但如果这种状态长期持续，说明团队已经陷入被动运维：大量时间用于处理重复问题，却没有时间从根源上消除这些问题。这不仅容易造成工程师疲劳，也会使系统可靠性难以真正提高。</p>
<p>因此，SRE 强调形成一个正向循环：控制日常运维负担，把节省下来的时间投入自动化和可靠性改进，再进一步减少未来的运维负担。同时，也需要合理分配值班和告警压力，避免少数成员长期承担过重的响应任务。</p>
<h1 id="可靠性核心思路">可靠性核心思路<a href="#%e5%8f%af%e9%9d%a0%e6%80%a7%e6%a0%b8%e5%bf%83%e6%80%9d%e8%b7%af" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h1>
<p>可靠性（Reliability）是指系统在发生故障、异常或中断时，仍然能够持续提供预期功能的能力。一个可靠的系统通常需要同时具备韧性（Resiliency）、可恢复性（Recoverability）和可用性（Availability）。韧性强调系统在部分组件发生故障时仍能继续运行；可恢复性强调当故障超过系统的承受能力后，能够在约定时间内恢复服务；可用性则强调用户能否在承诺的时间范围内，以预期的质量访问服务。</p>
<p>在分布式系统中，故障几乎是不可避免的。某些组件可能发生故障，而其他组件仍然正常工作，因此系统设计不能建立在“不会出错”的假设上。真正需要考虑的是：系统能否提前发现问题、限制故障影响范围，并在必要时快速恢复，避免局部故障最终影响用户体验和业务目标。</p>
<p>可靠性不能只依赖某一个环节，而应同时体现在应用代码、基础设施和日常运维中。例如，应用本身需要具备异常处理和降级能力，基础设施需要考虑冗余和故障切换，运维则需要具备监控、告警和恢复机制。这些设计都应该服务于业务需求，而不能为了提高可靠性随意改变系统原本要实现的业务目标；如果必须做出取舍，就应该把它视为明确的架构权衡。</p>
<p>因此，可靠性设计应该贯穿整个开发生命周期，从设计阶段开始考虑系统可能出现的故障，并根据实际业务要求选择合适的方案。设计原则和可靠性检查清单的作用，就是帮助团队提前考虑这些问题，而不是等系统上线后出现事故再被动补救。对于普通系统，可靠性不足可能造成服务中断和经济损失；对于关键系统，严重的可靠性问题甚至可能影响安全。</p>
<h2 id="面向业务需求进行设计">面向业务需求进行设计<a href="#%e9%9d%a2%e5%90%91%e4%b8%9a%e5%8a%a1%e9%9c%80%e6%b1%82%e8%bf%9b%e8%a1%8c%e8%ae%be%e8%ae%a1" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>可靠性设计应从业务需求出发，而不是凭经验猜测。需要先明确系统范围、用户增长、服务承诺、可接受的用户体验以及成本和技术约束，再根据这些要求选择合适的可靠性方案。</p>
<table>
	<thead>
			<tr>
					<th>设计方法</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>明确解决方案的范围和深度，包括需要多高的韧性、恢复能力、可观测性和简洁性，并确定成本、合规、地域、延迟等约束</td>
					<td>先搞清楚“这个系统到底需要做到什么程度”，不要一开始就按最高标准设计</td>
					<td>明确“做到什么程度就足够”，避免目标模糊导致反复修改设计、浪费成本</td>
			</tr>
			<tr>
					<td>将业务目标转化为架构上的权衡，综合考虑成本、工程复杂度、安全和运维负担</td>
					<td>每提高一点可靠性，通常都要付出额外成本，所以必须权衡</td>
					<td>让业务方理解可靠性要求背后的代价，从而形成现实可行的目标</td>
			</tr>
			<tr>
					<td>优先针对关键用户流程定义可靠性目标，而不是只关注整体 uptime</td>
					<td>不要只看“网站有没有活着”，而要看用户最重要的操作能不能完成</td>
					<td>让可靠性直接对应真正有业务价值的功能</td>
			</tr>
			<tr>
					<td>按时间尺度考虑需求，例如上线时的用户量以及未来用户是线性、快速还是不确定增长</td>
					<td>不只考虑现在能不能跑，还要考虑未来规模扩大后是否还能稳定运行</td>
					<td>既满足当前需求，又避免未来因为增长而大规模重构</td>
			</tr>
			<tr>
					<td>考虑无法完全控制的外部依赖，例如统一基础设施、安全要求、网络策略和平台限制</td>
					<td>系统的可靠性不只取决于自己，还取决于外部平台和依赖服务</td>
					<td>确保 SLO、RTO、RPO 等目标现实可行，避免做出无法兑现的承诺</td>
			</tr>
	</tbody>
</table>
<p><em>关键词</em></p>
<ul>
<li><strong>关键用户流程（Critical User Flow）</strong>：用户完成核心业务目标所经过的一整条流程，例如“登录 → 选择商品 → 下单 → 支付”。</li>
<li><strong>Uptime</strong>：系统处于可用状态的时间比例。</li>
<li><strong>SLO</strong>：服务级别目标，用来规定系统应达到的可靠性水平。</li>
<li><strong>RTO</strong>：Recovery Time Objective，恢复时间目标，即故障后允许多长时间恢复服务。</li>
<li><strong>RPO</strong>：Recovery Point Objective，恢复点目标，即最多允许丢失多长时间范围内的数据。</li>
<li><strong>架构权衡（Trade-off）</strong>：为了获得某种好处，需要接受其他方面的代价，例如更高可靠性通常意味着更高成本和复杂度。</li>
</ul>
<hr>
<h2 id="面向韧性进行设计">面向韧性进行设计<a href="#%e9%9d%a2%e5%90%91%e9%9f%a7%e6%80%a7%e8%bf%9b%e8%a1%8c%e8%ae%be%e8%ae%a1" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>韧性（Resilience）强调：即使部分组件发生故障、平台中断、性能下降或资源不足，系统仍然能够以完整或降级形式继续提供服务。设计时应默认故障一定会发生。</p>
<table>
	<thead>
			<tr>
					<th>设计方法</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>区分关键路径组件和允许降级的非关键组件</td>
					<td>先判断哪些组件一坏整个业务就不行，哪些坏了只是体验差一点</td>
					<td>将可靠性资源集中到真正重要的组件上，避免过度设计</td>
			</tr>
			<tr>
					<td>找出潜在故障点，特别是关键组件，并分析对用户流程的影响</td>
					<td>提前想清楚“哪里可能坏、坏了会影响多大范围”</td>
					<td>可以评估故障类型、严重程度和影响范围，据此设计错误处理机制</td>
			</tr>
			<tr>
					<td>通过合理的设计模式、模块化和故障隔离建立系统自我保护能力</td>
					<td>一个模块出问题时，不要让问题继续传到其他模块</td>
					<td>防止故障向下游传播，缩小故障范围</td>
			</tr>
			<tr>
					<td>让关键组件具备横向扩展能力，并考虑不同区域的容量限制</td>
					<td>流量变大时，可以增加更多实例一起分担压力</td>
					<td>应对突发流量和容量变化，也能缓解单一区域资源不足</td>
			</tr>
			<tr>
					<td>在基础设施、数据、服务、运维和人员等多个层次建立冗余</td>
					<td>重要东西不要只有一份，避免一个点坏了整个系统就停</td>
					<td>减少单点故障，提高整体可用性</td>
			</tr>
			<tr>
					<td>适当进行资源超配，为系统保留额外容量</td>
					<td>平时不要把资源用到极限，要留一点余量应对突发情况</td>
					<td>在实例故障或资源异常增长时提供缓冲，为扩容和修复争取时间</td>
			</tr>
	</tbody>
</table>
<p><em>关键词</em></p>
<ul>
<li><strong>Resilience（韧性）</strong>：系统在发生部分故障时，仍然能够继续提供服务的能力。</li>
<li><strong>关键路径（Critical Path）</strong>：完成核心业务流程时必须经过的一组组件，其中任意关键组件失败都可能导致整个流程失败。</li>
<li><strong>Graceful Degradation（优雅降级）</strong>：部分功能失效时，系统主动降低功能或服务质量，但仍保持核心功能可用。</li>
<li><strong>Blast Radius</strong>：某个故障能够影响的范围。设计目标通常是尽量缩小故障影响范围。</li>
<li><strong>故障隔离（Fault Isolation）</strong>：通过架构设计阻止一个组件的故障扩散到其他组件。</li>
<li><strong>横向扩展（Scale Out）</strong>：通过增加更多服务器或实例来提高处理能力，而不是单纯增强单台机器性能。</li>
<li><strong>冗余（Redundancy）</strong>：为关键组件准备多个副本或替代路径，避免单点故障。</li>
<li><strong>单点故障（Single Point of Failure）</strong>：某个组件一旦失效，就会导致整个系统或核心功能停止。</li>
<li><strong>资源超配（Overprovisioning）</strong>：提前准备超过正常需求的计算、存储或网络资源，为故障和流量突增提供缓冲。</li>
</ul>
<hr>
<h2 id="面向恢复进行设计">面向恢复进行设计<a href="#%e9%9d%a2%e5%90%91%e6%81%a2%e5%a4%8d%e8%bf%9b%e8%a1%8c%e8%ae%be%e8%ae%a1" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>再强的韧性也无法处理所有故障。因此还必须考虑 Recovery：当故障已经超过系统自身的容错能力时，如何在规定的恢复目标内重新提供服务，并恢复正确的数据状态。</p>
<table>
	<thead>
			<tr>
					<th>设计方法</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>制定结构化、经过测试、有文档记录，并与恢复目标一致的恢复计划</td>
					<td>真出大故障时不能临时想怎么办，要提前把恢复步骤写清楚并测试</td>
					<td>在事故发生时能够快速、按流程恢复，减少业务和声誉损失</td>
			</tr>
			<tr>
					<td>定期进行组件、数据、故障切换和故障回切演练</td>
					<td>恢复方案不能只写在文档里，还要真正演练过</td>
					<td>验证恢复流程是否真的可用</td>
			</tr>
			<tr>
					<td>确保所有有状态组件的数据都能在恢复目标内修复</td>
					<td>服务重新启动还不够，数据库里的数据也必须能恢复</td>
					<td>利用可信恢复点和备份把系统恢复到正常状态</td>
			</tr>
			<tr>
					<td>使用不可变并保持事务一致性的备份</td>
					<td>备份本身也要可靠，不能恢复以后发现数据还是坏的</td>
					<td>防止备份被篡改，并保证恢复数据的一致性</td>
			</tr>
			<tr>
					<td>建立自动自愈能力</td>
					<td>一些常见故障可以让系统自己检测、自己恢复</td>
					<td>减少人工干预和人为错误，缩短恢复时间</td>
			</tr>
			<tr>
					<td>将无状态组件设计成不可变、可随时创建和销毁的临时单元</td>
					<td>与其在坏掉的机器上反复修，不如直接重新创建一个干净实例</td>
					<td>提高部署一致性和可重复性，并减少恢复过程中的中断</td>
			</tr>
	</tbody>
</table>
<p><em>关键词</em></p>
<ul>
<li><strong>Recovery（恢复能力）</strong>：当系统已经无法继续正常工作时，将服务恢复到可接受状态的能力。</li>
<li><strong>Stateful Component（有状态组件）</strong>：内部保存持久数据或状态的组件，例如数据库。</li>
<li><strong>Stateless Component（无状态组件）</strong>：自身不依赖本地持久状态，可以比较容易地被替换或重新创建。</li>
<li><strong>Failover（故障切换）</strong>：主系统故障后，将业务切换到备用系统。</li>
<li><strong>Failback（故障回切）</strong>：原系统恢复后，再把业务从备用系统切回。</li>
<li><strong>Immutable Backup（不可变备份）</strong>：创建后不能被随意修改或删除的备份。</li>
<li><strong>事务一致性（Transactional Consistency）</strong>：备份或恢复的数据保持完整的业务状态，不会出现部分操作成功、部分操作丢失的情况。</li>
<li><strong>Self-healing（自愈）</strong>：系统检测到故障后自动执行重启、替换、切换等恢复操作。</li>
<li><strong>Ephemeral Unit（临时单元）</strong>：可以随时创建和销毁的实例，例如容器实例。</li>
</ul>
<hr>
<h2 id="面向运维进行设计">面向运维进行设计<a href="#%e9%9d%a2%e5%90%91%e8%bf%90%e7%bb%b4%e8%bf%9b%e8%a1%8c%e8%ae%be%e8%ae%a1" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>可靠性工作应该尽量 Shift Left，即提前到开发和测试阶段，而不是等生产环境发生事故之后再处理。需要尽早测试故障，同时通过可观测性、诊断、告警和自动化支撑生产环境的可靠运行。</p>
<table>
	<thead>
			<tr>
					<th>设计方法</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>建立能够关联遥测数据的可观测系统</td>
					<td>系统出了问题后，要能看见发生了什么，而不是只能靠猜</td>
					<td>能确定哪里故障、何时发生、为什么发生，并观察完整用户流程</td>
			</tr>
			<tr>
					<td>预测潜在故障和异常行为，并建立有优先级、可操作的告警</td>
					<td>告警不是越多越好，而是要及时指出真正需要工程师处理的问题</td>
					<td>让 SRE 快速处理正在发生的事故，也可以提前处理潜在故障</td>
			</tr>
			<tr>
					<td>在预生产和生产环境中主动模拟故障</td>
					<td>主动制造故障，看看系统是否真的能按设计继续运行或恢复</td>
					<td>验证真实恢复能力、降级机制和可靠性阈值</td>
			</tr>
			<tr>
					<td>在设计阶段考虑自动化，并尽可能自动化测试、部署和运维</td>
					<td>重复、标准化的事情尽量交给机器完成</td>
					<td>减少人为错误，提高不同环境和操作之间的一致性</td>
			</tr>
			<tr>
					<td>评估日常操作对系统稳定性的影响，例如版本升级、安全审计、组件升级和备份</td>
					<td>很多故障不是机器自己坏了，而是正常维护时改坏的</td>
					<td>避免正常运维操作反而成为生产事故来源</td>
			</tr>
			<tr>
					<td>持续从真实生产事故中学习</td>
					<td>每次出事故都应该留下改进措施，而不是修好就算了</td>
					<td>找出设计和运维缺陷，并利用事故经验持续改进系统</td>
			</tr>
	</tbody>
</table>
<p><em>关键词</em></p>
<ul>
<li><strong>Shift Left</strong>：把测试、可靠性、安全等工作尽量提前到开发生命周期的前面阶段。</li>
<li><strong>Observability（可观测性）</strong>：根据系统产生的数据理解其内部运行状态的能力。</li>
<li><strong>Telemetry（遥测数据）</strong>：系统运行过程中自动采集的数据，例如日志、指标和调用链。</li>
<li><strong>Metrics（指标）</strong>：CPU 使用率、请求错误率、响应时间等数值数据。</li>
<li><strong>Logs（日志）</strong>：系统在运行过程中记录的事件和错误信息。</li>
<li><strong>Traces（链路追踪）</strong>：追踪一次请求在多个服务之间完整的调用过程。</li>
<li><strong>Alert（告警）</strong>：当系统达到某种异常条件时自动通知相关人员。</li>
<li><strong>Pre-production（预生产环境）</strong>：正式生产环境之前用于验证系统的环境，例如测试环境、预发布环境。</li>
<li><strong>Incident（生产事故）</strong>：已经对线上系统、用户或业务造成实际影响的故障事件。</li>
</ul>
<hr>
<h2 id="保持简单">保持简单<a href="#%e4%bf%9d%e6%8c%81%e7%ae%80%e5%8d%95" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>可靠性不意味着不断增加组件。系统越复杂，配置错误、组件交互和意外行为出现的可能性通常越高，因此应尽量减少没有必要的复杂性。不过也不能为了简单而形成新的单点故障，需要在简单与冗余之间保持平衡。</p>
<table>
	<thead>
			<tr>
					<th>设计方法</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>只有真正有助于实现业务目标时才添加新组件，并尽量保持关键路径精简</td>
					<td>不要为了让架构“看起来高级”就不断增加服务和组件</td>
					<td>减少关键故障点，同时让系统更容易实现、理解和管理</td>
			</tr>
			<tr>
					<td>为代码、部署和运维流程建立统一标准并形成文档，尽可能通过自动验证强制执行</td>
					<td>大家按同一套规则工作，减少因为个人习惯不同导致的问题</td>
					<td>提高一致性，减少人为错误，也方便故障排查</td>
			</tr>
			<tr>
					<td>判断理论上的设计方法是否真的适合实际业务场景</td>
					<td>理论上很先进的方案，不一定适合当前系统</td>
					<td>避免过度细粒度和过度复杂设计造成额外依赖和维护负担</td>
			</tr>
			<tr>
					<td>只编写足够满足需求的代码</td>
					<td>没必要为了可能永远不会发生的问题提前写大量复杂代码</td>
					<td>减少资源浪费、数据流问题和代码缺陷</td>
			</tr>
			<tr>
					<td>优先利用平台已经提供并经过验证的功能和现成能力</td>
					<td>能用成熟方案解决的事情，就不要重新造一套</td>
					<td>缩短开发时间，并复用已经验证过的可靠性实践</td>
			</tr>
	</tbody>
</table>
<p><em>关键词</em></p>
<ul>
<li><strong>Critical Path（关键路径）</strong>：完成核心业务所必须经过的组件和步骤。</li>
<li><strong>Overengineering（过度设计）</strong>：为了并不存在或不重要的问题，加入过多组件、机制和复杂性。</li>
<li><strong>Standardization（标准化）</strong>：为代码、部署、配置和运维制定统一规则。</li>
<li><strong>Automated Validation（自动验证）</strong>：使用工具自动检查代码、配置或流程是否符合标准。</li>
<li><strong>Platform-provided Feature（平台能力）</strong>：云平台、操作系统或基础设施已经提供的成熟功能，例如负载均衡、自动扩缩容、监控和备份。</li>
<li><strong>Technical Complexity（技术复杂度）</strong>：由于组件数量、依赖关系、配置和交互增加而带来的理解、维护和故障排查难度。</li>
</ul>
<h2 id="检查清单">检查清单<a href="#%e6%a3%80%e6%9f%a5%e6%b8%85%e5%8d%95" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>这份 Checklist 用来检查一个系统的架构是否真正考虑了<strong>可靠性、韧性和故障恢复能力</strong>。核心思路是：先根据业务需求确定可用性和恢复目标，再据此选择基础设施和应用设计方案。可靠性不能只在系统上线之后考虑，而应该贯穿<strong>设计、开发、测试和运维的整个生命周期</strong>。每个架构决策都可能影响系统的可靠性，因此需要明确其中的权衡，而不是单纯堆叠高可用技术。</p>
<hr>
<ol>
<li><strong>RE:01 保持简单和高效</strong></li>
</ol>
<p><strong>Focus your workload design on simplicity and efficiency.</strong></p>
<table>
	<thead>
			<tr>
					<th>设计建议</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>让系统设计尽量保持简单，同时满足业务需求</td>
					<td>不要为了“架构高级”加入大量实际上用不到的组件和技术</td>
					<td>降低系统复杂度，减少配置错误、依赖问题和潜在故障点</td>
			</tr>
			<tr>
					<td>使用实用而不是过度复杂的方案</td>
					<td>能简单解决的问题就不要使用复杂方案</td>
					<td>降低开发、维护和故障排查成本</td>
			</tr>
			<tr>
					<td>在满足业务目标的前提下提高效率</td>
					<td>简单并不意味着功能不足，而是在满足需求后不做多余设计</td>
					<td>避免 Overengineering，让架构更容易理解和维护</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Simplicity（简单性）</strong>：尽量减少不必要的组件、依赖和逻辑。</li>
<li><strong>Efficiency（效率）</strong>：在满足目标的同时减少不必要的资源和工程投入。</li>
<li><strong>Overengineering（过度设计）</strong>：使用远超实际需求的复杂架构或技术方案。</li>
</ul>
<hr>
<ol start="2">
<li><strong>RE:02 识别并评估用户流和系统流</strong></li>
</ol>
<p><strong>Identify and rate user and system flows.</strong></p>
<table>
	<thead>
			<tr>
					<th>设计建议</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>找出系统中的用户流程和系统内部流程</td>
					<td>不要只看“有哪些服务器”，还要看用户实际怎么使用系统</td>
					<td>从完整业务流程角度分析可靠性</td>
			</tr>
			<tr>
					<td>根据业务需求评估每条流程的重要程度</td>
					<td>不同流程的重要性不一样，例如付款比查看推荐更重要</td>
					<td>把可靠性资源优先投入真正重要的业务</td>
			</tr>
			<tr>
					<td>建立关键性等级</td>
					<td>给不同流程分级，例如关键、重要、普通</td>
					<td>为后续冗余、监控和恢复策略提供依据</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>User Flow（用户流）</strong>：用户完成一个业务目标时经过的一系列步骤。</li>
<li><strong>System Flow（系统流）</strong>：系统内部组件之间完成某项功能时的数据或调用流程。</li>
<li><strong>Criticality（关键性）</strong>：某个流程对业务的重要程度。</li>
<li><strong>Critical Flow（关键流程）</strong>：一旦失败就会严重影响核心业务的流程。</li>
</ul>
<p>例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>用户登录 → 搜索商品 → 加入购物车 → 下单 → 支付
</span></span></code></pre></div><p>这就是一条用户流程，其中：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>支付 &gt; 推荐商品
</span></span></code></pre></div><p>因为支付失败会直接影响业务目标，而推荐失败通常只影响体验。</p>
<hr>
<ol start="3">
<li><strong>RE:03 使用故障模式分析</strong></li>
</ol>
<p><strong>Use Failure Mode Analysis (FMA) to identify potential failures.</strong></p>
<table>
	<thead>
			<tr>
					<th>设计建议</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>找出系统可能发生的故障</td>
					<td>提前思考“什么东西可能坏”</td>
					<td>在事故发生前发现潜在风险</td>
			</tr>
			<tr>
					<td>识别组件之间的依赖关系</td>
					<td>一个组件坏了，可能会影响依赖它的其他组件</td>
					<td>防止局部故障扩大</td>
			</tr>
			<tr>
					<td>找出关键故障点</td>
					<td>分析哪些组件一旦故障会产生严重影响</td>
					<td>优先对高风险部分进行保护</td>
			</tr>
			<tr>
					<td>针对不同故障制定缓解方案</td>
					<td>不能只知道“会坏”，还要提前决定坏了怎么办</td>
					<td>提高系统应对故障的能力</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>FMA（Failure Mode Analysis，故障模式分析）</strong>：系统性分析“可能出现哪些故障，以及这些故障会产生什么影响”。</li>
<li><strong>Failure Mode（故障模式）</strong>：某个组件可能以什么方式失效。</li>
<li><strong>Failure Point（故障点）</strong>：系统中可能发生故障的位置。</li>
<li><strong>Dependency（依赖）</strong>：一个组件正常运行所依赖的其他组件或服务。</li>
<li><strong>Mitigation（缓解措施）</strong>：降低故障发生概率或影响程度的措施。</li>
</ul>
<p>可以简单理解为：</p>
<blockquote>
<p><strong>先假设每个东西都有可能坏，然后问：它坏了会怎样？我们准备怎么办？</strong></p>
</blockquote>
<hr>
<ol start="4">
<li><strong>RE:04 定义可靠性和恢复目标</strong></li>
</ol>
<p><strong>Define reliability and recovery targets.</strong></p>
<table>
	<thead>
			<tr>
					<th>设计建议</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>明确系统应该达到什么可靠性水平</td>
					<td>不要只说“系统要稳定”，而要给出具体数字</td>
					<td>让可靠性可以衡量</td>
			</tr>
			<tr>
					<td>明确故障后需要多快恢复</td>
					<td>系统挂了以后多久恢复才算可以接受</td>
					<td>指导灾难恢复方案设计</td>
			</tr>
			<tr>
					<td>根据这些目标设计系统架构</td>
					<td>先定目标，再决定要不要做冗余、备份、多区域等设计</td>
					<td>避免盲目堆高可用技术</td>
			</tr>
			<tr>
					<td>将可靠性指标作为系统健康模型的基础</td>
					<td>系统是否健康，要根据提前定义的指标判断</td>
					<td>让监控、告警和运维具有明确标准</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Reliability Target（可靠性目标）</strong>：系统需要达到的可靠性水平。</li>
<li><strong>Availability Target（可用性目标）</strong>：系统需要保持可用的时间比例。</li>
<li><strong>SLO</strong>：服务级别目标。</li>
<li><strong>RTO</strong>：Recovery Time Objective，允许的最大恢复时间。</li>
<li><strong>RPO</strong>：Recovery Point Objective，允许的数据损失范围。</li>
<li><strong>Health Model（健康模型）</strong>：通过一组指标判断系统当前是否处于正常状态的方法。</li>
</ul>
<p>例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>SLO：99.9% 可用性
</span></span><span style="display:flex;"><span>RTO：30 分钟
</span></span><span style="display:flex;"><span>RPO：5 分钟
</span></span></code></pre></div><p>表示：</p>
<blockquote>
<p>系统应该达到 99.9% 可用性；
真挂了以后最多 30 分钟恢复；
最多允许损失最近 5 分钟的数据。</p>
</blockquote>
<hr>
<ol start="5">
<li><strong>RE:05 建立不同层次的冗余</strong></li>
</ol>
<p><strong>Add redundancy at different levels, especially for critical flows.</strong></p>
<table>
	<thead>
			<tr>
					<th>设计建议</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>为关键流程增加冗余</td>
					<td>核心业务不要依赖唯一的一台机器或一个组件</td>
					<td>防止单点故障</td>
			</tr>
			<tr>
					<td>对计算资源进行冗余</td>
					<td>一台服务器坏了，还有其他实例接管</td>
					<td>保持服务继续运行</td>
			</tr>
			<tr>
					<td>对网络等基础设施进行冗余</td>
					<td>一条网络路径故障时，可以走其他路径</td>
					<td>减少基础设施故障造成的中断</td>
			</tr>
			<tr>
					<td>部署多个解决方案实例</td>
					<td>不让系统只有唯一实例</td>
					<td>提高整体可用性和容错能力</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Redundancy（冗余）</strong>：准备多个能够完成同一功能的资源。</li>
<li><strong>Single Point of Failure（单点故障）</strong>：某个组件一旦失效，就会导致整个系统无法工作的情况。</li>
<li><strong>Instance（实例）</strong>：某个应用或服务正在运行的一个副本。</li>
<li><strong>Critical Flow（关键流程）</strong>：直接影响核心业务的用户或系统流程。</li>
</ul>
<p>最简单的例子：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>只有一台服务器
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>服务器挂了
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>网站挂了
</span></span></code></pre></div><p>增加冗余后：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>服务器 A
</span></span><span style="display:flex;"><span>服务器 B
</span></span><span style="display:flex;"><span>服务器 C
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>A 挂了
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>B、C 继续服务
</span></span></code></pre></div><hr>
<ol start="6">
<li><strong>RE:06 建立可靠的扩缩容策略</strong></li>
</ol>
<p><strong>Implement a timely and reliable scaling strategy.</strong></p>
<table>
	<thead>
			<tr>
					<th>设计建议</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>在应用、数据和基础设施层面考虑扩缩容</td>
					<td>不只是服务器要能扩，数据库和应用本身也需要能扩</td>
					<td>避免某一层成为性能瓶颈</td>
			</tr>
			<tr>
					<td>根据真实或预测的使用量进行扩缩容</td>
					<td>用户变多时增加资源，用户变少时减少资源</td>
					<td>在可靠性和成本之间取得平衡</td>
			</tr>
			<tr>
					<td>尽量减少人工操作</td>
					<td>不要等工程师发现服务器不够了才手动加机器</td>
					<td>提高扩容速度并减少人为错误</td>
			</tr>
			<tr>
					<td>确保扩容能够及时发生</td>
					<td>扩容太慢的话，资源增加之前系统可能已经挂了</td>
					<td>应对突发流量</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Scaling（扩缩容）</strong>：根据负载增加或减少系统资源。</li>
<li><strong>Scale Out（横向扩展）</strong>：增加更多实例。</li>
<li><strong>Scale In（横向缩减）</strong>：减少实例。</li>
<li><strong>Autoscaling（自动扩缩容）</strong>：根据负载自动调整资源数量。</li>
<li><strong>Usage Pattern（使用模式）</strong>：用户访问量随时间变化的规律。</li>
</ul>
<p>例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>平时：5 台服务器
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>流量突然增加
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>自动扩容
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>20 台服务器
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>流量恢复正常
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>自动缩容
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>5 台服务器
</span></span></code></pre></div><hr>
<ol start="7">
<li><strong>RE:07 建立自我保护和自愈能力</strong></li>
</ol>
<p><strong>Implement self-preservation and self-healing measures.</strong></p>
<table>
	<thead>
			<tr>
					<th>设计建议</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>建立系统自我保护机制</td>
					<td>系统发现异常时先保护自己，不要继续恶化</td>
					<td>防止故障扩散</td>
			</tr>
			<tr>
					<td>建立自动自愈能力</td>
					<td>可以自动解决的问题就不要等待人工处理</td>
					<td>缩短故障恢复时间</td>
			</tr>
			<tr>
					<td>优先使用平台已有能力</td>
					<td>云平台已经提供自动重启、故障切换等能力时优先使用</td>
					<td>减少自己开发复杂机制的成本</td>
			</tr>
			<tr>
					<td>使用经过验证的云设计模式</td>
					<td>不要自己随便发明故障处理方式</td>
					<td>使用成熟经验提高可靠性</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Self-preservation（自我保护）</strong>：系统主动采取措施防止故障进一步扩大。</li>
<li><strong>Self-healing（自愈）</strong>：系统发现故障后自动恢复。</li>
<li><strong>Cloud Pattern（云设计模式）</strong>：经过大量实践验证的云架构设计方法。</li>
</ul>
<p>例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>某个服务实例异常
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>健康检查发现异常
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>停止向它发送请求
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>创建新的实例
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>新实例重新加入服务
</span></span></code></pre></div><p>整个过程可以不需要人工参与。</p>
<hr>
<ol start="8">
<li><strong>RE:08 使用混沌工程测试可靠性</strong></li>
</ol>
<p><strong>Test resiliency and availability by applying chaos engineering.</strong></p>
<table>
	<thead>
			<tr>
					<th>设计建议</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>主动制造故障进行测试</td>
					<td>不要等真实事故发生才第一次看到系统怎么反应</td>
					<td>验证系统是否真的具有韧性</td>
			</tr>
			<tr>
					<td>测试系统是否能够承受组件故障</td>
					<td>主动关掉服务器、网络或服务</td>
					<td>检查冗余和故障切换是否有效</td>
			</tr>
			<tr>
					<td>测试高负载情况下是否可以扩容</td>
					<td>人为制造流量高峰</td>
					<td>验证扩缩容策略</td>
			</tr>
			<tr>
					<td>测试系统是否可以在目标时间内恢复</td>
					<td>故意制造中断，再观察恢复时间</td>
					<td>验证 RTO、RPO 等目标是否真的能达到</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Chaos Engineering（混沌工程）</strong>：主动向系统注入故障，验证系统面对真实异常时的行为。</li>
<li><strong>Fault Injection（故障注入）</strong>：人为制造服务器、网络、磁盘、服务等故障。</li>
<li><strong>Reliability Testing（可靠性测试）</strong>：验证系统是否满足既定可靠性目标。</li>
<li><strong>Resilience Testing（韧性测试）</strong>：验证系统部分组件故障时是否仍能继续运行。</li>
</ul>
<p>例如：</p>
<blockquote>
<p>主动杀掉一台生产服务器，然后观察流量是否自动切换到其他服务器。</p>
</blockquote>
<p>重点不是“故意把系统搞坏”，而是：</p>
<blockquote>
<p><strong>提前证明系统真的扛得住故障。</strong></p>
</blockquote>
<hr>
<ol start="9">
<li><strong>RE:09 建立灾难恢复计划</strong></li>
</ol>
<p><strong>Implement structured, tested, and documented disaster recovery plans.</strong></p>
<table>
	<thead>
			<tr>
					<th>设计建议</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>建立结构化的灾难恢复方案</td>
					<td>大规模故障发生以后，要有完整恢复流程</td>
					<td>避免事故发生后临时决定怎么办</td>
			</tr>
			<tr>
					<td>恢复方案必须经过测试</td>
					<td>文档上写“可以恢复”不等于真的能恢复</td>
					<td>验证实际恢复能力</td>
			</tr>
			<tr>
					<td>将恢复方案形成正式文档</td>
					<td>谁负责、怎么恢复、恢复顺序都应该写清楚</td>
					<td>减少事故期间的混乱</td>
			</tr>
			<tr>
					<td>恢复方案应满足既定恢复目标</td>
					<td>恢复速度和数据损失必须符合 RTO、RPO</td>
					<td>保证灾难恢复能力满足业务要求</td>
			</tr>
			<tr>
					<td>既考虑单个组件，也考虑整个系统</td>
					<td>不能只知道如何恢复一台服务器</td>
					<td>应对区域级、平台级等大规模事故</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>DR（Disaster Recovery，灾难恢复）</strong>：面对严重系统中断或灾难时恢复业务的完整方案。</li>
<li><strong>Disaster Recovery Plan（灾难恢复计划）</strong>：描述事故发生后如何恢复系统、数据和业务的正式流程。</li>
<li><strong>Failover（故障切换）</strong>：从故障系统切换到备用系统。</li>
<li><strong>Failback（故障回切）</strong>：原系统恢复后重新切回。</li>
<li><strong>Recovery Drill（恢复演练）</strong>：定期模拟灾难并实际执行恢复流程。</li>
</ul>
<p>普通故障可能是：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>一台服务器挂了
</span></span></code></pre></div><p>而 Disaster Recovery 更关注：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>整个机房故障
</span></span><span style="display:flex;"><span>整个区域故障
</span></span><span style="display:flex;"><span>严重数据损坏
</span></span><span style="display:flex;"><span>大规模网络中断
</span></span></code></pre></div><hr>
<ol start="10">
<li><strong>RE:10 持续监控系统健康状态</strong></li>
</ol>
<p><strong>Continuously measure and track system health.</strong></p>
<table>
	<thead>
			<tr>
					<th>设计建议</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>持续监控系统健康状态</td>
					<td>不能等用户告诉你“网站挂了”才发现问题</td>
					<td>尽早发现异常</td>
			</tr>
			<tr>
					<td>监控各组件和关键流程</td>
					<td>不只看单台服务器，还要看用户的完整业务流程</td>
					<td>判断故障是否真正影响用户</td>
			</tr>
			<tr>
					<td>使用 uptime 和可靠性指标</td>
					<td>用数据判断系统是否满足可靠性目标</td>
					<td>衡量 SLO 等目标是否实现</td>
			</tr>
			<tr>
					<td>保存历史监控数据</td>
					<td>监控数据不能看完就丢</td>
					<td>支持趋势分析和事故调查</td>
			</tr>
			<tr>
					<td>确保监控数据可以快速访问</td>
					<td>出事故后要马上能找到相关数据</td>
					<td>帮助故障响应和根因分析</td>
			</tr>
			<tr>
					<td>利用监控数据进行事故后分析</td>
					<td>事故结束后回看当时系统发生了什么</td>
					<td>支持 Postmortem 和持续改进</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>System Health（系统健康状态）</strong>：系统当前是否正常完成预期功能的整体状态。</li>
<li><strong>Reliability Indicator（可靠性指标）</strong>：衡量系统可靠性的指标，例如可用率、错误率和延迟。</li>
<li><strong>Uptime</strong>：系统正常可用的时间比例。</li>
<li><strong>Monitoring（监控）</strong>：持续收集和观察系统运行状态。</li>
<li><strong>Post-incident Analysis（事故后分析）</strong>：故障结束后根据监控、日志等数据分析事故原因。</li>
<li><strong>Retention（数据保留）</strong>：保存历史监控数据，供之后查询和分析。</li>
</ul>
<hr>
<h2 id="整体理解">整体理解<a href="#%e6%95%b4%e4%bd%93%e7%90%86%e8%a7%a3" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>这 10 条其实可以压缩成一个完整的可靠性设计流程：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>RE:01 先保持设计简单
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>RE:02 找出哪些业务流程最重要
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>RE:03 分析这些流程可能怎么坏
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>RE:04 定义到底需要多可靠、多久恢复
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>RE:05 给关键部分增加冗余
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>RE:06 确保流量增加时能够及时扩容
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>RE:07 让系统能够自我保护和自动恢复
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>RE:08 主动制造故障，验证这些设计真的有效
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>RE:09 如果发生严重灾难，要有完整恢复方案
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>RE:10 持续监控，确认系统实际是否达到目标
</span></span></code></pre></div><p>也就是说，这份 Checklist 并不是 10 个彼此独立的要求，而是从：</p>
<blockquote>
<p><strong>明确业务 → 找出关键流程 → 分析故障 → 定目标 → 做冗余和扩容 → 自动恢复 → 主动测试 → 灾难恢复 → 持续监控</strong></p>
</blockquote>
<p>构成了一套完整的可靠性设计思路。</p>
<h1 id="azure">Azure<a href="#azure" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h1>
<h2 id="云计算基础">云计算基础<a href="#%e4%ba%91%e8%ae%a1%e7%ae%97%e5%9f%ba%e7%a1%80" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>云计算（Cloud Computing）是通过互联网按需提供计算服务的模式，它把原本需要自行购买和维护的 IT 资源变成随用随取的服务。这里的计算服务既包括虚拟机、存储、数据库和网络等传统基础设施，也包括物联网（IoT）、机器学习（ML）和人工智能（AI）等能力。</p>
<h3 id="云计算提供什么">云计算提供什么<a href="#%e4%ba%91%e8%ae%a1%e7%ae%97%e6%8f%90%e4%be%9b%e4%bb%80%e4%b9%88" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<table>
	<thead>
			<tr>
					<th>服务类型</th>
					<th>通俗解释</th>
					<th>例子</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Virtual Machines</td>
					<td>在云里运行一台虚拟电脑</td>
					<td>Windows / Linux 虚拟机</td>
			</tr>
			<tr>
					<td>Storage</td>
					<td>在云里保存数据</td>
					<td>文件、对象、备份</td>
			</tr>
			<tr>
					<td>Databases</td>
					<td>使用云端数据库</td>
					<td>SQL、NoSQL</td>
			</tr>
			<tr>
					<td>Networking</td>
					<td>提供网络连接和流量管理</td>
					<td>虚拟网络、负载均衡</td>
			</tr>
			<tr>
					<td>IoT</td>
					<td>连接和管理物联网设备</td>
					<td>传感器、工业设备</td>
			</tr>
			<tr>
					<td>ML</td>
					<td>提供机器学习能力</td>
					<td>模型训练、预测</td>
			</tr>
			<tr>
					<td>AI</td>
					<td>提供人工智能能力</td>
					<td>语音、视觉、生成式 AI</td>
			</tr>
	</tbody>
</table>
<h3 id="为什么云计算和传统数据中心不同">为什么云计算和传统数据中心不同<a href="#%e4%b8%ba%e4%bb%80%e4%b9%88%e4%ba%91%e8%ae%a1%e7%ae%97%e5%92%8c%e4%bc%a0%e7%bb%9f%e6%95%b0%e6%8d%ae%e4%b8%ad%e5%bf%83%e4%b8%8d%e5%90%8c" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>传统数据中心受物理基础设施限制较大。企业突然需要更多计算资源时，通常要经历以下过程：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>评估需求
</span></span><span style="display:flex;"><span>→ 购买服务器
</span></span><span style="display:flex;"><span>→ 等待运输
</span></span><span style="display:flex;"><span>→ 安装服务器
</span></span><span style="display:flex;"><span>→ 配置网络
</span></span><span style="display:flex;"><span>→ 部署系统
</span></span></code></pre></div><p>采购、运输、安装和配置可能耗时很久，而云计算允许企业通过平台直接申请资源：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>需要更多资源
</span></span><span style="display:flex;"><span>→ 在云平台申请
</span></span><span style="display:flex;"><span>→ 几分钟内获得资源
</span></span></code></pre></div><p>两种方式的差别在于，基础设施从“提前购买”变成了“按需获取”。</p>
<h3 id="实际例子">实际例子<a href="#%e5%ae%9e%e9%99%85%e4%be%8b%e5%ad%90" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>假设一家零售公司准备进行大型季节性促销，预计活动期间访问量会突然增加。传统方式可能需要提前几个月购买额外服务器：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>购买服务器
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>安装和配置
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>促销期间使用
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>促销结束
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>大量服务器闲置
</span></span></code></pre></div><p>使用云计算时，企业可以根据活动进度调整资源：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>促销开始
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>临时增加云计算资源
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>处理高峰流量
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>促销结束
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>减少资源
</span></span></code></pre></div><p>这种做法既能更快应对流量变化，也能让成本更接近实际需求。</p>
<h3 id="云计算带来的几个变化">云计算带来的几个变化<a href="#%e4%ba%91%e8%ae%a1%e7%ae%97%e5%b8%a6%e6%9d%a5%e7%9a%84%e5%87%a0%e4%b8%aa%e5%8f%98%e5%8c%96" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<table>
	<thead>
			<tr>
					<th>变化</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>On-demand Provisioning</td>
					<td>需要资源时再创建</td>
					<td>不必提前几个月购买服务器</td>
			</tr>
			<tr>
					<td>Rapid Scaling</td>
					<td>可以快速增加或减少资源</td>
					<td>更容易应对流量变化</td>
			</tr>
			<tr>
					<td>Faster Testing</td>
					<td>可以快速创建测试环境</td>
					<td>开发和测试速度更快</td>
			</tr>
			<tr>
					<td>Faster Recovery</td>
					<td>故障后可以快速重新创建或切换资源</td>
					<td>提高恢复能力</td>
			</tr>
			<tr>
					<td>Global Reach</td>
					<td>可以在世界不同地区部署服务</td>
					<td>让服务更靠近用户</td>
			</tr>
			<tr>
					<td>Regional Resilience</td>
					<td>可以跨区域设计系统</td>
					<td>一个区域出问题时，可以由其他区域继续提供服务</td>
			</tr>
	</tbody>
</table>
<h3 id="关键词">关键词<a href="#%e5%85%b3%e9%94%ae%e8%af%8d" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<ul>
<li><strong>Cloud Computing（云计算）</strong>：通过互联网按需提供计算资源和服务。</li>
<li><strong>IT Infrastructure（IT 基础设施）</strong>：运行信息系统所需要的计算、存储、网络等基础资源。</li>
<li><strong>Virtual Machine，VM（虚拟机）</strong>：通过软件模拟出来的一台完整计算机。</li>
<li><strong>Storage（存储）</strong>：用于保存文件和数据的资源。</li>
<li><strong>Database（数据库）</strong>：用于组织、保存和查询数据的系统。</li>
<li><strong>Networking（网络）</strong>：负责不同计算资源之间的通信。</li>
<li><strong>IoT（Internet of Things，物联网）</strong>：让各种物理设备连接到网络并交换数据。</li>
<li><strong>ML（Machine Learning，机器学习）</strong>：让计算机通过数据学习规律并进行预测或判断。</li>
<li><strong>AI（Artificial Intelligence，人工智能）</strong>：让计算机完成通常需要人类智能才能完成的任务。</li>
<li><strong>Provisioning（资源预配）</strong>：创建并准备计算资源，使其可以使用。</li>
<li><strong>On-demand（按需）</strong>：需要时再申请资源，而不是提前准备。</li>
<li><strong>Scaling（扩缩容）</strong>：根据负载增加或减少资源。</li>
<li><strong>Global Reach（全球覆盖）</strong>：利用云平台在多个国家和地区部署服务。</li>
<li><strong>Regional Resilience（区域韧性）</strong>：通过跨区域部署降低单一区域故障带来的影响。</li>
</ul>
<h3 id="本节总结">本节总结<a href="#%e6%9c%ac%e8%8a%82%e6%80%bb%e7%bb%93" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>传统 IT 的资源准备流程是：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>传统 IT
</span></span><span style="display:flex;"><span>先买资源
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>安装和配置
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>再使用
</span></span></code></pre></div><p>云计算则把流程改为：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>云计算
</span></span><span style="display:flex;"><span>需要资源
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>立即创建
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>按需使用
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>不用时释放
</span></span></code></pre></div><p>因此，云计算把 IT 基础设施从长期采购、固定容量的资产，变成了可以按需获取、快速扩展和及时释放的服务。</p>
<h2 id="云计算共享责任模型shared-responsibility-model">云计算共享责任模型（Shared Responsibility Model）<a href="#%e4%ba%91%e8%ae%a1%e7%ae%97%e5%85%b1%e4%ba%ab%e8%b4%a3%e4%bb%bb%e6%a8%a1%e5%9e%8bshared-responsibility-model" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>共享责任模型说明了云服务商与客户各自负责什么。传统本地数据中心的机房、服务器、网络、操作系统、应用和数据几乎都由企业管理；迁移到云之后，云服务商接管底层基础设施，客户仍要管理自己的数据和访问权限，操作系统、平台与应用等中间层则取决于使用的是 IaaS、PaaS 还是 SaaS。</p>
<hr>
<h3 id="1-本地数据中心中的责任">1. 本地数据中心中的责任<a href="#1-%e6%9c%ac%e5%9c%b0%e6%95%b0%e6%8d%ae%e4%b8%ad%e5%bf%83%e4%b8%ad%e7%9a%84%e8%b4%a3%e4%bb%bb" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>在传统本地数据中心（On-Premises）中，企业需要负责几乎整个 IT 环境：</p>
<table>
	<thead>
			<tr>
					<th>责任内容</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>维护物理空间</td>
					<td>机房、门禁、消防等都需要企业自己管理</td>
					<td>保证服务器所在环境安全</td>
			</tr>
			<tr>
					<td>负责电力和冷却</td>
					<td>服务器供电、UPS、空调散热都要自己维护</td>
					<td>保证硬件能够持续运行</td>
			</tr>
			<tr>
					<td>维护物理服务器</td>
					<td>服务器坏了需要自己维修或更换</td>
					<td>保证计算资源可用</td>
			</tr>
			<tr>
					<td>维护网络</td>
					<td>交换机、路由器、线路等都由自己管理</td>
					<td>保证设备之间能够通信</td>
			</tr>
			<tr>
					<td>管理操作系统和软件</td>
					<td>系统安装、版本升级和补丁都需要自己完成</td>
					<td>保证软件环境正常和安全</td>
			</tr>
			<tr>
					<td>管理应用、账号和数据</td>
					<td>应用部署、用户权限和数据保护都由企业负责</td>
					<td>保证业务系统和数据安全</td>
			</tr>
	</tbody>
</table>
<p>因此，On-Premises 基本意味着所有责任都由企业自己承担。</p>
<hr>
<h3 id="2-上云以后责任开始分开">2. 上云以后，责任开始分开<a href="#2-%e4%b8%8a%e4%ba%91%e4%bb%a5%e5%90%8e%e8%b4%a3%e4%bb%bb%e5%bc%80%e5%a7%8b%e5%88%86%e5%bc%80" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>使用云计算后，客户无法直接接触的数据中心、供电、冷却、物理网络和服务器等底层设施会转由云服务商负责：</p>
<table>
	<thead>
			<tr>
					<th>云服务商负责</th>
					<th>通俗解释</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Physical Security</td>
					<td>数据中心的门禁、安保等物理安全</td>
			</tr>
			<tr>
					<td>Power</td>
					<td>数据中心和服务器供电</td>
			</tr>
			<tr>
					<td>Cooling</td>
					<td>服务器散热和机房温度控制</td>
			</tr>
			<tr>
					<td>Network Connectivity</td>
					<td>底层数据中心网络连接</td>
			</tr>
			<tr>
					<td>Physical Hardware</td>
					<td>真正的物理服务器及相关设备</td>
			</tr>
	</tbody>
</table>
<p>与此同时，客户仍然必须管理自己的数据、账号、身份和访问控制：</p>
<table>
	<thead>
			<tr>
					<th>客户负责</th>
					<th>通俗解释</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Data</td>
					<td>自己上传、创建和保存的数据</td>
			</tr>
			<tr>
					<td>Information</td>
					<td>企业自己的业务信息</td>
			</tr>
			<tr>
					<td>Access Security</td>
					<td>谁能够访问系统和数据</td>
			</tr>
			<tr>
					<td>Accounts</td>
					<td>用户和服务账号</td>
			</tr>
			<tr>
					<td>Identities</td>
					<td>用户、服务和设备的身份</td>
			</tr>
	</tbody>
</table>
<p>Microsoft 可以替客户维护服务器，却不能替客户决定“张三是否应该看到公司的财务数据”。</p>
<hr>
<h3 id="3-有些责任取决于使用方式">3. 有些责任取决于使用方式<a href="#3-%e6%9c%89%e4%ba%9b%e8%b4%a3%e4%bb%bb%e5%8f%96%e5%86%b3%e4%ba%8e%e4%bd%bf%e7%94%a8%e6%96%b9%e5%bc%8f" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>部分责任会随云服务模式变化。以 SQL 数据库为例：</p>
<p><strong>使用云端托管 SQL 数据库</strong></p>
<p>如果直接使用云服务商提供的数据库服务：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>云服务商：
</span></span><span style="display:flex;"><span>维护数据库平台
</span></span><span style="display:flex;"><span>安装数据库补丁
</span></span><span style="display:flex;"><span>维护底层服务器
</span></span><span style="display:flex;"><span>维护操作系统
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>客户：
</span></span><span style="display:flex;"><span>管理数据库中的数据
</span></span><span style="display:flex;"><span>配置用户和权限
</span></span><span style="display:flex;"><span>决定数据如何使用
</span></span></code></pre></div><p>这种情况下，数据库平台本身主要由云服务商维护。</p>
<p><strong>在虚拟机中自己安装 SQL Server</strong></p>
<p>如果先创建一台虚拟机，再自己安装 SQL Server：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>云服务商：
</span></span><span style="display:flex;"><span>维护物理服务器
</span></span><span style="display:flex;"><span>维护数据中心
</span></span><span style="display:flex;"><span>维护底层物理网络
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>客户：
</span></span><span style="display:flex;"><span>维护虚拟机操作系统
</span></span><span style="display:flex;"><span>安装和更新 SQL Server
</span></span><span style="display:flex;"><span>安装数据库补丁
</span></span><span style="display:flex;"><span>配置数据库
</span></span><span style="display:flex;"><span>维护数据库中的数据
</span></span></code></pre></div><p>同样是 SQL 数据库，采用不同的服务模式，责任划分也会完全不同。</p>
<hr>
<h3 id="4-共享责任与-iaaspaassaas">4. 共享责任与 IaaS、PaaS、SaaS<a href="#4-%e5%85%b1%e4%ba%ab%e8%b4%a3%e4%bb%bb%e4%b8%8e-iaaspaassaas" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>共享责任模型与云服务模式直接相关，总体规律是：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>On-Premises → IaaS → PaaS → SaaS
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>客户负责的内容越来越少
</span></span><span style="display:flex;"><span>云服务商负责的内容越来越多
</span></span></code></pre></div><table>
	<thead>
			<tr>
					<th>服务模式</th>
					<th>客户责任</th>
					<th>云服务商责任</th>
					<th>通俗理解</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>On-Premises</td>
					<td>几乎全部</td>
					<td>几乎没有</td>
					<td>什么都自己管</td>
			</tr>
			<tr>
					<td>IaaS</td>
					<td>较多</td>
					<td>主要负责底层物理基础设施</td>
					<td>云厂商给你基础设施，上面的东西大多自己管</td>
			</tr>
			<tr>
					<td>PaaS</td>
					<td>中等</td>
					<td>基础设施和平台主要由厂商负责</td>
					<td>云厂商连运行平台都帮你维护</td>
			</tr>
			<tr>
					<td>SaaS</td>
					<td>较少</td>
					<td>大部分系统由厂商负责</td>
					<td>直接使用厂商已经运行好的软件</td>
			</tr>
	</tbody>
</table>
<p>越靠近 IaaS，客户越像在自行运维；越靠近 SaaS，客户越接近直接使用现成服务。</p>
<hr>
<h3 id="5-iaas-中的责任">5. IaaS 中的责任<a href="#5-iaas-%e4%b8%ad%e7%9a%84%e8%b4%a3%e4%bb%bb" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>IaaS（Infrastructure as a Service）主要把底层物理基础设施交给云服务商。</p>
<table>
	<thead>
			<tr>
					<th>云服务商负责</th>
					<th>客户通常负责</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>数据中心</td>
					<td>操作系统</td>
			</tr>
			<tr>
					<td>物理服务器</td>
					<td>操作系统补丁</td>
			</tr>
			<tr>
					<td>电力与冷却</td>
					<td>应用程序</td>
			</tr>
			<tr>
					<td>物理网络</td>
					<td>数据</td>
			</tr>
			<tr>
					<td>底层基础设施</td>
					<td>用户与权限</td>
			</tr>
	</tbody>
</table>
<p>IaaS 可以理解为云厂商提供一台“云里的电脑”，但系统里安装什么、如何配置和维护，主要仍由客户负责。</p>
<hr>
<h3 id="6-paas-中的责任">6. PaaS 中的责任<a href="#6-paas-%e4%b8%ad%e7%9a%84%e8%b4%a3%e4%bb%bb" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>PaaS（Platform as a Service）进一步把操作系统和运行平台交给云服务商维护，客户主要关注：</p>
<ul>
<li>应用代码</li>
<li>业务逻辑</li>
<li>数据</li>
<li>用户</li>
<li>权限</li>
</ul>
<p>云服务商主要负责：</p>
<ul>
<li>物理基础设施</li>
<li>操作系统</li>
<li>平台运行环境</li>
<li>平台维护和补丁</li>
</ul>
<p>PaaS 不只提供机器，还准备好应用运行的平台，因此开发人员可以少关注服务器和系统维护，把更多精力放在应用本身。</p>
<hr>
<h3 id="7-saas-中的责任">7. SaaS 中的责任<a href="#7-saas-%e4%b8%ad%e7%9a%84%e8%b4%a3%e4%bb%bb" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>SaaS（Software as a Service）中，云服务商负责的内容最多。客户直接使用已经运行好的软件，不需要自己维护：</p>
<ul>
<li>软件安装</li>
<li>操作系统</li>
<li>服务器</li>
<li>数据库基础设施</li>
<li>软件补丁</li>
<li>平台升级</li>
</ul>
<p>客户仍然需要管理自己的数据和使用方式，包括：</p>
<ul>
<li>自己的数据</li>
<li>用户账号</li>
<li>角色</li>
<li>权限</li>
<li>接入设备</li>
</ul>
<p>SaaS 的软件已经由服务商运行，客户主要负责如何使用它。</p>
<hr>
<h3 id="8-无论使用哪种云服务始终由客户负责的内容">8. 无论使用哪种云服务，始终由客户负责的内容<a href="#8-%e6%97%a0%e8%ae%ba%e4%bd%bf%e7%94%a8%e5%93%aa%e7%a7%8d%e4%ba%91%e6%9c%8d%e5%8a%a1%e5%a7%8b%e7%bb%88%e7%94%b1%e5%ae%a2%e6%88%b7%e8%b4%9f%e8%b4%a3%e7%9a%84%e5%86%85%e5%ae%b9" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>无论采用哪种云服务，信息与数据、终端设备、账号与身份始终由客户负责：</p>
<table>
	<thead>
			<tr>
					<th>内容</th>
					<th>通俗解释</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Information and Data</td>
					<td>自己存储在云中的信息和数据</td>
			</tr>
			<tr>
					<td>Devices / Endpoints</td>
					<td>允许连接到云环境的电脑、手机等设备</td>
			</tr>
			<tr>
					<td>Accounts and Identities</td>
					<td>用户、服务和设备的账号及身份</td>
			</tr>
	</tbody>
</table>
<p>上云不会把数据、账号、身份和终端设备的责任转交给云服务商。</p>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Information and Data（信息和数据）</strong>：企业在云中创建、存储和处理的业务信息。</li>
<li><strong>Endpoint（终端）</strong>：连接云环境的电脑、手机等设备。</li>
<li><strong>Identity（身份）</strong>：用户、服务或设备在系统中的身份。</li>
<li><strong>Account（账号）</strong>：用来登录和访问系统的账户。</li>
</ul>
<hr>
<h3 id="9-无论使用哪种云服务始终由云服务商负责的内容">9. 无论使用哪种云服务，始终由云服务商负责的内容<a href="#9-%e6%97%a0%e8%ae%ba%e4%bd%bf%e7%94%a8%e5%93%aa%e7%a7%8d%e4%ba%91%e6%9c%8d%e5%8a%a1%e5%a7%8b%e7%bb%88%e7%94%b1%e4%ba%91%e6%9c%8d%e5%8a%a1%e5%95%86%e8%b4%9f%e8%b4%a3%e7%9a%84%e5%86%85%e5%ae%b9" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>云服务商始终负责客户无法直接接触的物理云基础设施：</p>
<table>
	<thead>
			<tr>
					<th>内容</th>
					<th>通俗解释</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Physical Datacenter</td>
					<td>真正的数据中心和机房</td>
			</tr>
			<tr>
					<td>Physical Network</td>
					<td>数据中心中的实体网络设备和线路</td>
			</tr>
			<tr>
					<td>Physical Hosts</td>
					<td>真正运行云服务的物理服务器</td>
			</tr>
	</tbody>
</table>
<p>资源进入云环境后，真正的机房、物理服务器和物理网络便不再由客户维护。</p>
<hr>
<h3 id="10-根据服务类型决定的责任">10. 根据服务类型决定的责任<a href="#10-%e6%a0%b9%e6%8d%ae%e6%9c%8d%e5%8a%a1%e7%b1%bb%e5%9e%8b%e5%86%b3%e5%ae%9a%e7%9a%84%e8%b4%a3%e4%bb%bb" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>下面这些责任会随着 IaaS、PaaS、SaaS 的不同而变化：</p>
<table>
	<thead>
			<tr>
					<th>责任</th>
					<th>为什么会变化</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Operating Systems</td>
					<td>IaaS 通常由客户维护，PaaS / SaaS 更多由厂商维护</td>
			</tr>
			<tr>
					<td>Network Controls</td>
					<td>不同服务模式允许客户控制的网络层级不同</td>
			</tr>
			<tr>
					<td>Applications</td>
					<td>IaaS / PaaS 中更多由客户负责，SaaS 中更多由厂商负责</td>
			</tr>
			<tr>
					<td>Identity and Access</td>
					<td>客户和厂商通常共同承担</td>
			</tr>
			<tr>
					<td>Infrastructure</td>
					<td>上云之后逐渐转移给云服务商</td>
			</tr>
	</tbody>
</table>
<p><strong>Identity and Access 为什么是共享责任</strong></p>
<p>以 PaaS 或 SaaS 中的身份与访问为例，云服务商负责：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>运行认证平台
</span></span><span style="display:flex;"><span>维护认证服务
</span></span><span style="display:flex;"><span>维护底层身份基础设施
</span></span></code></pre></div><p>客户则负责：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>创建哪些用户
</span></span><span style="display:flex;"><span>给用户什么角色
</span></span><span style="display:flex;"><span>配置什么权限
</span></span><span style="display:flex;"><span>制定什么访问策略
</span></span></code></pre></div><p>在 Microsoft Entra ID 中，Microsoft 负责身份平台的运行，企业负责决定谁能登录以及登录后可以执行哪些操作。</p>
<hr>
<h3 id="关键词-1">关键词<a href="#%e5%85%b3%e9%94%ae%e8%af%8d-1" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<ul>
<li><strong>Shared Responsibility Model（共享责任模型）</strong>：云服务商与客户共同承担云环境中的管理、安全和运维责任。</li>
<li><strong>On-Premises（本地部署）</strong>：服务器和基础设施由企业自己拥有和维护。</li>
<li><strong>Cloud Provider（云服务商）</strong>：提供云基础设施和服务的厂商，例如 Microsoft Azure。</li>
<li><strong>Consumer / Customer（客户）</strong>：使用云服务的组织或个人。</li>
<li><strong>IaaS（Infrastructure as a Service）</strong>：基础设施即服务。</li>
<li><strong>PaaS（Platform as a Service）</strong>：平台即服务。</li>
<li><strong>SaaS（Software as a Service）</strong>：软件即服务。</li>
<li><strong>Identity and Access Management，IAM（身份与访问管理）</strong>：管理用户身份以及用户能够访问哪些资源。</li>
<li><strong>Authentication（认证）</strong>：确认“你是谁”。</li>
<li><strong>Authorization（授权）</strong>：确认“你能够做什么”。</li>
<li><strong>Role（角色）</strong>：一组预先定义好的权限。</li>
<li><strong>Policy（策略）</strong>：用于规定访问和使用规则的配置。</li>
<li><strong>Patch（补丁）</strong>：修复软件漏洞、Bug 或安全问题的软件更新。</li>
</ul>
<hr>
<h3 id="本节总结-1">本节总结<a href="#%e6%9c%ac%e8%8a%82%e6%80%bb%e7%bb%93-1" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>共享责任会随着服务模式变化：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>On-Premises
</span></span><span style="display:flex;"><span>客户几乎什么都负责
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>IaaS
</span></span><span style="display:flex;"><span>云服务商接管物理基础设施
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>PaaS
</span></span><span style="display:flex;"><span>云服务商进一步接管操作系统和平台
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>SaaS
</span></span><span style="display:flex;"><span>云服务商连应用本身也主要负责
</span></span></code></pre></div><p>客户承担的责任依次减少：</p>
<table>
	<thead>
			<tr>
					<th>模式</th>
					<th>客户责任</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>On-Premises</td>
					<td>最多</td>
			</tr>
			<tr>
					<td>IaaS</td>
					<td>较多</td>
			</tr>
			<tr>
					<td>PaaS</td>
					<td>较少</td>
			</tr>
			<tr>
					<td>SaaS</td>
					<td>最少</td>
			</tr>
	</tbody>
</table>
<p>无论采用哪种模式，客户始终负责数据、身份、账号和终端设备，云服务商始终负责物理数据中心、物理网络和物理服务器。共享责任模型并不表示责任消失，而是随着 On-Premises → IaaS → PaaS → SaaS，越来越多底层责任从客户转移到云服务商。</p>
<h2 id="云计算部署模型cloud-models">云计算部署模型（Cloud Models）<a href="#%e4%ba%91%e8%ae%a1%e7%ae%97%e9%83%a8%e7%bd%b2%e6%a8%a1%e5%9e%8bcloud-models" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>云模型说明云资源以什么方式部署、由谁使用以及资源属于谁，主要分为三种：</p>
<ul>
<li>Private Cloud（私有云）</li>
<li>Public Cloud（公有云）</li>
<li>Hybrid Cloud（混合云）</li>
</ul>
<p>Multicloud（多云）也很常见，但它描述的是同时采用多个公有云平台，与三种基本部署模型不是同一个分类维度。公有云向多个客户开放，私有云只供一个组织使用，混合云则把公有云和私有云连接起来。</p>
<hr>
<h3 id="1-private-cloud私有云">1. Private Cloud（私有云）<a href="#1-private-cloud%e7%a7%81%e6%9c%89%e4%ba%91" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>私有云是只供一个组织使用的云环境，可以看作传统数据中心云化后的形态。它仍然服务于单一组织，但资源管理方式更接近云计算，可以部署在企业自己的数据中心、其他专用数据中心，也可以交给第三方托管：</p>
<ul>
<li>建在企业自己的本地数据中心</li>
<li>建在其他专用数据中心</li>
<li>甚至由第三方帮企业托管</li>
</ul>
<table>
	<thead>
			<tr>
					<th>特点</th>
					<th>通俗解释</th>
					<th>影响</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>资源只属于一个组织</td>
					<td>不和其他客户共享核心资源</td>
					<td>控制能力更强</td>
			</tr>
			<tr>
					<td>企业对资源和安全拥有完整控制权</td>
					<td>网络、安全策略、硬件配置等都可以自己决定</td>
					<td>更容易满足特殊安全要求</td>
			</tr>
			<tr>
					<td>数据不会和其他租户放在同一个共享环境中</td>
					<td>更容易进行严格的数据隔离</td>
					<td>适合部分高安全、高合规场景</td>
			</tr>
			<tr>
					<td>需要自己购买硬件</td>
					<td>服务器等基础设施不能直接按需从公共云获取</td>
					<td>初始投入通常更高</td>
			</tr>
			<tr>
					<td>企业负责硬件维护和升级</td>
					<td>服务器坏了、需要升级都要自己处理</td>
					<td>运维负担更重</td>
			</tr>
			<tr>
					<td>公有云的一些优势会减少</td>
					<td>扩容速度、按需使用等能力可能不如公有云</td>
					<td>灵活性通常较低</td>
			</tr>
	</tbody>
</table>
<p>私有云就是公司专用的一套云。例如，一家银行可能因为安全、监管或数据要求，不希望核心系统运行在共享公有云中，因此建立自己的私有云。</p>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Private Cloud（私有云）</strong>：只供单一组织使用的云环境。</li>
<li><strong>Dedicated Resources（专用资源）</strong>：资源专门分配给某个组织，而不是和其他客户共同使用。</li>
<li><strong>Tenant（租户）</strong>：使用云平台资源的一个独立客户或组织。</li>
<li><strong>On-site / On-premises（本地）</strong>：资源部署在企业自己的场地或数据中心。</li>
<li><strong>Control（控制权）</strong>：企业能够直接决定硬件、网络、安全和配置方式的程度。</li>
</ul>
<hr>
<h3 id="2-public-cloud公有云">2. Public Cloud（公有云）<a href="#2-public-cloud%e5%85%ac%e6%9c%89%e4%ba%91" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>公有云由第三方云服务商建设、运营和维护，个人或组织通常都可以购买和使用，其中 Microsoft Azure 就是公有云平台。</p>
<table>
	<thead>
			<tr>
					<th>特点</th>
					<th>通俗解释</th>
					<th>影响</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>云平台由第三方服务商建设和管理</td>
					<td>客户不用自己建设数据中心</td>
					<td>大幅减少基础设施维护工作</td>
			</tr>
			<tr>
					<td>大量客户共同使用云平台</td>
					<td>云厂商把庞大的基础设施提供给很多客户使用</td>
					<td>可以形成规模效应</td>
			</tr>
			<tr>
					<td>不需要为了扩容提前购买硬件</td>
					<td>需要更多资源时直接申请</td>
					<td>扩容速度快</td>
			</tr>
			<tr>
					<td>应用可以快速创建和删除</td>
					<td>需要时开，不需要时关</td>
					<td>非常灵活</td>
			</tr>
			<tr>
					<td>按实际使用量付费</td>
					<td>用多少资源通常付多少费用</td>
					<td>避免大量闲置基础设施</td>
			</tr>
			<tr>
					<td>客户不能完全控制底层资源和物理安全</td>
					<td>机房、物理服务器等由云厂商管理</td>
					<td>控制权比私有云低</td>
			</tr>
	</tbody>
</table>
<p>云厂商建设和维护大型平台，再把资源按需提供给大量客户。企业需要 100 台服务器时，可以直接在 Azure 上创建虚拟机，不必自行采购 100 台实体服务器。</p>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Public Cloud（公有云）</strong>：由第三方云服务商运营，并向多个客户提供服务的云环境。</li>
<li><strong>Cloud Provider（云服务商）</strong>：建设和运营公有云的企业。</li>
<li><strong>Provisioning（资源预配）</strong>：创建并准备云资源。</li>
<li><strong>Deprovisioning（资源释放）</strong>：删除或停止不再需要的云资源。</li>
<li><strong>Capital Expenditure，CapEx（资本支出）</strong>：提前购买服务器、机房等长期资产所需要的大额投入。</li>
<li><strong>Pay-as-you-go（按使用付费）</strong>：根据实际资源使用量支付费用。</li>
</ul>
<hr>
<h3 id="3-hybrid-cloud混合云">3. Hybrid Cloud（混合云）<a href="#3-hybrid-cloud%e6%b7%b7%e5%90%88%e4%ba%91" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>混合云把公有云和私有云连接起来共同使用。企业不必在两者之间二选一，可以根据业务、安全、成本和合规要求决定各个系统的运行位置。</p>
<table>
	<thead>
			<tr>
					<th>特点</th>
					<th>通俗解释</th>
					<th>影响</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>同时使用公有云和私有云</td>
					<td>一部分系统放自己这里，一部分放公共云</td>
					<td>灵活性最高</td>
			</tr>
			<tr>
					<td>企业可以决定每个应用运行在哪里</td>
					<td>不同业务根据需求选择最适合的环境</td>
					<td>可以兼顾成本、安全和性能</td>
			</tr>
			<tr>
					<td>私有云资源不足时，可以借用公有云资源</td>
					<td>临时高峰不需要提前购买大量硬件</td>
					<td>更容易应对短期流量增长</td>
			</tr>
			<tr>
					<td>敏感服务可以保留在私有云</td>
					<td>不适合上公有云的数据仍然留在企业内部</td>
					<td>更容易满足安全或法律要求</td>
			</tr>
			<tr>
					<td>普通服务可以使用公有云</td>
					<td>对安全要求较低的系统可以利用公有云优势</td>
					<td>降低成本并提高扩展能力</td>
			</tr>
	</tbody>
</table>
<p>例如，企业可以按以下方式分配工作负载：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>核心客户数据库
</span></span><span style="display:flex;"><span>→ 私有云
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>公开网站
</span></span><span style="display:flex;"><span>→ Azure 公有云
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>流量突然增加
</span></span><span style="display:flex;"><span>→ 临时增加 Azure 资源
</span></span></code></pre></div><p>这样企业既能保留核心系统的控制权，又能利用公有云的快速扩展能力。</p>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Hybrid Cloud（混合云）</strong>：将公有云和私有云连接并共同使用的云环境。</li>
<li><strong>Cloud Bursting</strong>：私有云资源不足时，临时使用公有云资源处理额外负载。</li>
<li><strong>Compliance（合规）</strong>：满足法律、行业标准或组织内部规定。</li>
<li><strong>Flexibility（灵活性）</strong>：可以根据实际需求自由选择资源运行位置。</li>
</ul>
<hr>
<h3 id="4-三种云模型的比较">4. 三种云模型的比较<a href="#4-%e4%b8%89%e7%a7%8d%e4%ba%91%e6%a8%a1%e5%9e%8b%e7%9a%84%e6%af%94%e8%be%83" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<table>
	<thead>
			<tr>
					<th>对比项</th>
					<th>Public Cloud</th>
					<th>Private Cloud</th>
					<th>Hybrid Cloud</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>谁可以使用</td>
					<td>多个客户</td>
					<td>单一组织</td>
					<td>公有云 + 单一组织私有云</td>
			</tr>
			<tr>
					<td>基础设施投入</td>
					<td>通常不需要提前购买大量硬件</td>
					<td>通常需要购买和维护硬件</td>
					<td>根据私有云规模决定</td>
			</tr>
			<tr>
					<td>扩容速度</td>
					<td>很快</td>
					<td>通常较慢</td>
					<td>可以借助公有云快速扩容</td>
			</tr>
			<tr>
					<td>控制权</td>
					<td>较低</td>
					<td>最高</td>
					<td>可以按业务分别控制</td>
			</tr>
			<tr>
					<td>运维负担</td>
					<td>较低</td>
					<td>较高</td>
					<td>中等到较高</td>
			</tr>
			<tr>
					<td>按需使用能力</td>
					<td>强</td>
					<td>相对较弱</td>
					<td>较强</td>
			</tr>
			<tr>
					<td>安全和合规控制</td>
					<td>受云平台能力限制</td>
					<td>可以完全自行控制</td>
					<td>可以按需求选择部署位置</td>
			</tr>
			<tr>
					<td>灵活性</td>
					<td>高</td>
					<td>相对较低</td>
					<td>最高</td>
			</tr>
	</tbody>
</table>
<p>三种模型的差异可以概括为：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Public Cloud
</span></span><span style="display:flex;"><span>便宜、灵活、扩展快
</span></span><span style="display:flex;"><span>但控制权相对少
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Private Cloud
</span></span><span style="display:flex;"><span>控制权强
</span></span><span style="display:flex;"><span>但成本和维护负担高
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Hybrid Cloud
</span></span><span style="display:flex;"><span>两者结合
</span></span><span style="display:flex;"><span>可以按需求选择
</span></span></code></pre></div><hr>
<h3 id="5-multicloud多云">5. Multicloud（多云）<a href="#5-multicloud%e5%a4%9a%e4%ba%91" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Multicloud 是同时使用两个或更多公有云服务商，例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Microsoft Azure
</span></span><span style="display:flex;"><span>+
</span></span><span style="display:flex;"><span>Amazon Web Services
</span></span><span style="display:flex;"><span>+
</span></span><span style="display:flex;"><span>Google Cloud
</span></span></code></pre></div><p>企业采用多云的原因包括平台能力差异、迁移需要、降低供应商依赖，以及不同团队各自选择了不同平台：</p>
<table>
	<thead>
			<tr>
					<th>原因</th>
					<th>通俗解释</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>不同云平台各有优势</td>
					<td>某个平台的 AI 更合适，另一个平台的数据库更适合</td>
			</tr>
			<tr>
					<td>正在进行云迁移</td>
					<td>原来使用一个云厂商，现在正在逐步迁移到另一个</td>
			</tr>
			<tr>
					<td>避免完全依赖单一供应商</td>
					<td>不把所有业务完全绑定在一个云平台</td>
			</tr>
			<tr>
					<td>不同团队使用不同平台</td>
					<td>不同业务部门可能选择不同云服务商</td>
			</tr>
	</tbody>
</table>
<p>多云环境也增加了管理负担，因为团队需要同时维护多个平台中的资源、安全策略和配置。</p>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Multicloud（多云）</strong>：同时使用多个公有云服务商。</li>
<li><strong>Cloud Provider（云服务商）</strong>：例如 Microsoft、AWS、Google。</li>
<li><strong>Vendor Lock-in（供应商锁定）</strong>：系统高度依赖某个厂商，导致未来很难迁移到其他平台。</li>
</ul>
<hr>
<h3 id="6-azure-arc">6. Azure Arc<a href="#6-azure-arc" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Azure Arc 是微软提供的一组管理技术，帮助企业通过 Azure 管理不同位置和平台上的资源，范围包括：</p>
<ul>
<li>Azure 公有云</li>
<li>企业自己的私有云</li>
<li>混合云</li>
<li>多云环境</li>
</ul>
<p>管理关系可以表示为：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Azure
</span></span><span style="display:flex;"><span>      \
</span></span><span style="display:flex;"><span>本地服务器
</span></span><span style="display:flex;"><span>       \
</span></span><span style="display:flex;"><span>AWS ------ Azure Arc
</span></span><span style="display:flex;"><span>       /
</span></span><span style="display:flex;"><span>其他云
</span></span></code></pre></div><p>Azure Arc 提供统一的管理入口，让分散在不同环境中的资源能够采用较为一致的管理方式。</p>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Azure Arc</strong>：用于统一管理 Azure、本地、私有云和其他云资源的一组 Azure 技术。</li>
<li><strong>Hybrid Management（混合环境管理）</strong>：使用统一工具管理本地和云端资源。</li>
<li><strong>Multicloud Management（多云管理）</strong>：统一管理不同云服务商中的资源。</li>
</ul>
<hr>
<h3 id="7-azure-vmware-solution">7. Azure VMware Solution<a href="#7-azure-vmware-solution" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>已经使用 VMware 构建私有云的企业迁移到 Azure 时，需要处理原有工作负载。Azure VMware Solution 允许这些工作负载直接在 Azure 中运行，让企业保留现有 VMware 技术体系，同时逐步使用 Azure 的公有云和扩展能力。</p>
<p><strong>通俗理解</strong></p>
<p>原本：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>企业数据中心
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>VMware
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>大量虚拟机
</span></span></code></pre></div><p>想迁移到 Azure 时，不一定需要立即：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>全部重写
</span></span><span style="display:flex;"><span>全部重新部署
</span></span><span style="display:flex;"><span>全部改变架构
</span></span></code></pre></div><p>而可以：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>现有 VMware 工作负载
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Azure VMware Solution
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>在 Azure 中继续运行
</span></span></code></pre></div><p><strong>关键词</strong></p>
<ul>
<li><strong>VMware</strong>：常见的企业虚拟化平台。</li>
<li><strong>Workload（工作负载）</strong>：为了完成某项业务而运行的一组应用、服务和资源。</li>
<li><strong>Azure VMware Solution</strong>：允许 VMware 工作负载在 Azure 中运行的服务。</li>
<li><strong>Migration（迁移）</strong>：将应用、数据或工作负载从一个环境移动到另一个环境。</li>
</ul>
<hr>
<h3 id="本节总结-2">本节总结<a href="#%e6%9c%ac%e8%8a%82%e6%80%bb%e7%bb%93-2" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>云部署模型主要回答资源部署在哪里以及由谁使用。三种基本模型如下：</p>
<table>
	<thead>
			<tr>
					<th>模型</th>
					<th>一句话理解</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Public Cloud</td>
					<td><strong>使用云厂商向大量客户开放的云平台</strong></td>
			</tr>
			<tr>
					<td>Private Cloud</td>
					<td><strong>整个云环境只服务一个组织</strong></td>
			</tr>
			<tr>
					<td>Hybrid Cloud</td>
					<td><strong>公有云和私有云连接起来一起使用</strong></td>
			</tr>
	</tbody>
</table>
<p>Multicloud 则表示同时使用多个公有云厂商。三种部署模型之间的关系可以整理为：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Private Cloud
</span></span><span style="display:flex;"><span>自己的专用云
</span></span><span style="display:flex;"><span>      ↓
</span></span><span style="display:flex;"><span>Hybrid Cloud
</span></span><span style="display:flex;"><span>自己的云 + 公有云
</span></span><span style="display:flex;"><span>      ↓
</span></span><span style="display:flex;"><span>Public Cloud
</span></span><span style="display:flex;"><span>云厂商提供的公共云
</span></span></code></pre></div><p>Multicloud 属于另一个维度：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Azure + AWS + Google Cloud + ...
</span></span></code></pre></div><p>私有云侧重控制，公有云侧重灵活和按需使用，混合云结合两者，多云则表示同时使用多个公有云平台。</p>
<h2 id="云计算消费模型consumption-based-model">云计算消费模型（Consumption-based Model）<a href="#%e4%ba%91%e8%ae%a1%e7%ae%97%e6%b6%88%e8%b4%b9%e6%a8%a1%e5%9e%8bconsumption-based-model" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>云计算通常采用 Consumption-based Model（基于使用量的消费模型）：需要多少 IT 资源就使用多少，并按实际用量付费，不再需要时再释放。传统 IT 往往要提前购买服务器、网络设备和机房空间，而云计算更接近租用资源，区别可以概括为“传统 IT 先买再用，云计算按需租用”。</p>
<hr>
<h3 id="1-capex-与-opex">1. CapEx 与 OpEx<a href="#1-capex-%e4%b8%8e-opex" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>传统 IT 预算通常区分 CapEx 和 OpEx：</p>
<table>
	<thead>
			<tr>
					<th>概念</th>
					<th>通俗解释</th>
					<th>例子</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>CapEx</td>
					<td>提前花一大笔钱购买长期使用的资产</td>
					<td>购买服务器、交换机、机房设备</td>
			</tr>
			<tr>
					<td>OpEx</td>
					<td>随着使用过程持续产生的运营费用</td>
					<td>每月支付云服务费用</td>
			</tr>
	</tbody>
</table>
<p>云计算通常归入 OpEx，因为资源不是一次性买下，而是根据使用情况持续付费。传统数据中心的支出过程如下：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>传统数据中心：
</span></span><span style="display:flex;"><span>先花钱买服务器
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>服务器买下来以后长期使用
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>属于 CapEx
</span></span></code></pre></div><p>云计算的支出则随资源用量变化：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>这个月用了 10 台虚拟机
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>支付对应费用
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>下个月只需要 3 台
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>只支付 3 台的费用
</span></span></code></pre></div><p>因此，这类费用属于 OpEx。</p>
<p><strong>关键词</strong></p>
<ul>
<li><strong>CapEx（Capital Expenditure，资本支出）</strong>：提前投入资金购买服务器、网络设备、机房等长期资产。</li>
<li><strong>OpEx（Operational Expenditure，运营支出）</strong>：随着业务运行持续产生的费用。</li>
<li><strong>Consumption-based Model（基于使用量的消费模型）</strong>：根据实际使用的资源量计费。</li>
<li><strong>Cloud Resource（云资源）</strong>：云平台提供的虚拟机、存储、数据库等资源。</li>
</ul>
<hr>
<h3 id="2-基于使用量模型的优势">2. 基于使用量模型的优势<a href="#2-%e5%9f%ba%e4%ba%8e%e4%bd%bf%e7%94%a8%e9%87%8f%e6%a8%a1%e5%9e%8b%e7%9a%84%e4%bc%98%e5%8a%bf" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<table>
	<thead>
			<tr>
					<th>优势</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>不需要提前购买硬件和数据中心基础设施</td>
					<td>不用先花大量资金采购服务器</td>
					<td>降低初始投入</td>
			</tr>
			<tr>
					<td>不需要提前购买可能用不上的容量</td>
					<td>不必为了预测未来需求而买一堆闲置服务器</td>
					<td>减少资源浪费</td>
			</tr>
			<tr>
					<td>需求增加时可以增加资源</td>
					<td>流量突然变大时，可以快速加机器</td>
					<td>应对业务增长和流量高峰</td>
			</tr>
			<tr>
					<td>需求下降时可以释放资源</td>
					<td>高峰结束后，把不用的资源删掉</td>
					<td>避免继续为空闲资源付费</td>
			</tr>
	</tbody>
</table>
<p>这种模式的核心是让资源投入尽可能贴近真实业务需求。</p>
<hr>
<h3 id="3-传统数据中心中的容量规划">3. 传统数据中心中的容量规划<a href="#3-%e4%bc%a0%e7%bb%9f%e6%95%b0%e6%8d%ae%e4%b8%ad%e5%bf%83%e4%b8%ad%e7%9a%84%e5%ae%b9%e9%87%8f%e8%a7%84%e5%88%92" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>传统数据中心需要提前预测未来的资源需求。例如，预计未来一年需要 20 台服务器时，可能要完成以下流程：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>预测需求
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>采购服务器
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>运输
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>安装
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>配置电力和网络
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>部署应用
</span></span></code></pre></div><p>容量预测很难完全准确，过高或过低都会带来问题：</p>
<table>
	<thead>
			<tr>
					<th>情况</th>
					<th>结果</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>高估需求</td>
					<td>买了太多服务器，大量资源长期闲置</td>
			</tr>
			<tr>
					<td>低估需求</td>
					<td>服务器不够，应用性能下降甚至无法提供服务</td>
			</tr>
	</tbody>
</table>
<p>如果容量不足，企业也无法立即补充资源，还要重新采购、安装和配置硬件。</p>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Capacity Planning（容量规划）</strong>：提前预测未来需要多少计算、存储和网络资源。</li>
<li><strong>Underutilized（利用不足）</strong>：买来的资源没有得到充分使用。</li>
<li><strong>Degraded Performance（性能下降）</strong>：因为资源不足，系统响应变慢或处理能力下降。</li>
<li><strong>Provisioning（预配）</strong>：准备并配置资源，使其能够投入使用。</li>
</ul>
<hr>
<h3 id="4-云计算中的容量规划">4. 云计算中的容量规划<a href="#4-%e4%ba%91%e8%ae%a1%e7%ae%97%e4%b8%ad%e7%9a%84%e5%ae%b9%e9%87%8f%e8%a7%84%e5%88%92" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>云计算不必完全依赖长期预测，可以根据实际需求调整资源。例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>平时：
</span></span><span style="display:flex;"><span>5 台虚拟机
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>促销活动开始：
</span></span><span style="display:flex;"><span>流量增加
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>增加到 20 台虚拟机
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>活动结束：
</span></span><span style="display:flex;"><span>流量下降
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>减少回 5 台
</span></span></code></pre></div><p>这样可以使资源容量更接近实际业务需求。</p>
<table>
	<thead>
			<tr>
					<th>云中的做法</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>需求增加时添加资源</td>
					<td>忙的时候多开机器</td>
					<td>防止容量不足</td>
			</tr>
			<tr>
					<td>需求下降时删除资源</td>
					<td>闲的时候把多余机器关掉</td>
					<td>减少浪费</td>
			</tr>
			<tr>
					<td>按实际使用量计费</td>
					<td>不需要为空闲资源持续付费</td>
					<td>提高成本效率</td>
			</tr>
			<tr>
					<td>根据流量动态调整</td>
					<td>容量可以跟着业务变化</td>
					<td>提高灵活性</td>
			</tr>
	</tbody>
</table>
<hr>
<h3 id="5-scale-out-与-scale-in">5. Scale Out 与 Scale In<a href="#5-scale-out-%e4%b8%8e-scale-in" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p><strong>Scale Out</strong></p>
<p>Scale Out 是增加更多资源或实例，例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>5 台服务器
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>流量上涨
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>增加到 20 台服务器
</span></span></code></pre></div><p><strong>Scale In</strong></p>
<p>Scale In 是在需求降低后减少资源或实例，例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>20 台服务器
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>流量下降
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>减少到 5 台服务器
</span></span></code></pre></div><p>两者与需求变化的关系如下：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>需求增加
</span></span><span style="display:flex;"><span>→ Scale Out
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>需求下降
</span></span><span style="display:flex;"><span>→ Scale In
</span></span></code></pre></div><p><strong>关键词</strong></p>
<ul>
<li><strong>Scale Out（横向扩展）</strong>：增加更多服务器或实例。</li>
<li><strong>Scale In（横向缩减）</strong>：减少服务器或实例。</li>
<li><strong>Scaling（扩缩容）</strong>：根据业务负载增加或减少系统资源。</li>
<li><strong>Capacity（容量）</strong>：系统能够处理的最大工作负载。</li>
</ul>
<hr>
<h3 id="6-pay-as-you-go-定价">6. Pay-as-you-go 定价<a href="#6-pay-as-you-go-%e5%ae%9a%e4%bb%b7" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>云服务商通常采用 Pay-as-you-go（按使用付费）的定价模式，也就是用了多少资源就支付多少费用。这与传统方式先购买一批服务器、之后无论是否充分使用都已经产生支出有明显区别。</p>
<table>
	<thead>
			<tr>
					<th>Pay-as-you-go 带来的好处</th>
					<th>通俗解释</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>更容易管理运营成本</td>
					<td>费用更直接地跟实际资源使用情况关联</td>
			</tr>
			<tr>
					<td>提高基础设施利用率</td>
					<td>减少大量长期闲置资源</td>
			</tr>
			<tr>
					<td>可以根据负载调整成本</td>
					<td>业务增长时多花钱，业务下降时减少支出</td>
			</tr>
			<tr>
					<td>不必自己维护底层基础设施</td>
					<td>电力、冷却、硬件、物理网络由云服务商负责</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Pay-as-you-go（按使用付费）</strong>：根据实际使用的云资源计费。</li>
<li><strong>Idle Capacity（闲置容量）</strong>：已经购买或分配，但当前没有实际使用的资源。</li>
<li><strong>Operating Cost（运营成本）</strong>：系统持续运行过程中产生的费用。</li>
</ul>
<hr>
<h3 id="7-为什么云计算能做到这种模式">7. 为什么云计算能做到这种模式<a href="#7-%e4%b8%ba%e4%bb%80%e4%b9%88%e4%ba%91%e8%ae%a1%e7%ae%97%e8%83%bd%e5%81%9a%e5%88%b0%e8%bf%99%e7%a7%8d%e6%a8%a1%e5%bc%8f" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>云服务商维护底层的大规模基础设施，包括：</p>
<ul>
<li>电力</li>
<li>冷却</li>
<li>物理服务器</li>
<li>物理网络</li>
</ul>
<p>客户不需要自行购买这些基础设施，而是使用云服务商已经建好的资源池：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>云服务商
</span></span><span style="display:flex;"><span>提前建设大量基础设施
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>形成巨大的资源池
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>客户需要资源时申请
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>不用时释放
</span></span></code></pre></div><p>客户因此可以把更多精力放在业务问题和应用功能上，而不是购买、安装和维护硬件。</p>
<hr>
<h3 id="本节总结-3">本节总结<a href="#%e6%9c%ac%e8%8a%82%e6%80%bb%e7%bb%93-3" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>基于使用量的消费模型改变了资源规划方式。传统 IT 的流程是：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>传统 IT：
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>预测未来需求
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>提前买硬件
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>固定容量
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>高估 = 浪费
</span></span><span style="display:flex;"><span>低估 = 性能不足
</span></span></code></pre></div><p>云计算的流程则是：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>云计算：
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>实际需求增加
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>增加资源
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>实际需求下降
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>释放资源
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>按实际使用量付费
</span></span></code></pre></div><p>三个概念的关系如下：</p>
<table>
	<thead>
			<tr>
					<th>概念</th>
					<th>一句话理解</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>CapEx</td>
					<td><strong>先买资产，再慢慢用</strong></td>
			</tr>
			<tr>
					<td>OpEx</td>
					<td><strong>随着使用持续付费</strong></td>
			</tr>
			<tr>
					<td>Consumption-based Model</td>
					<td><strong>用多少资源，付多少钱</strong></td>
			</tr>
	</tbody>
</table>
<p>云计算在容量规划上的主要优势，是不再要求企业准确预测未来所需的全部基础设施，而是允许资源随着实际需求扩缩。</p>
<h2 id="azure-物理基础架构">Azure 物理基础架构<a href="#azure-%e7%89%a9%e7%90%86%e5%9f%ba%e7%a1%80%e6%9e%b6%e6%9e%84" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>Azure 的核心架构组件分为两类：</p>
<ul>
<li><strong>Physical Infrastructure（物理基础架构）</strong></li>
<li><strong>Management Infrastructure（管理基础架构）</strong></li>
</ul>
<p>这一部分讨论物理基础架构。Azure 不让用户直接管理某台物理服务器，而是通过 Datacenter、Region、Availability Zone 和 Region Pair 组织全球资源，使工作负载能够在更高层次上部署，并获得故障隔离、可靠性和韧性。</p>
<hr>
<h3 id="1-datacenter数据中心">1. Datacenter（数据中心）<a href="#1-datacenter%e6%95%b0%e6%8d%ae%e4%b8%ad%e5%bf%83" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Azure 的物理基础从 Datacenter 开始。它与传统企业数据中心类似，包含：</p>
<ul>
<li>服务器</li>
<li>机架</li>
<li>电力系统</li>
<li>冷却系统</li>
<li>网络设备</li>
</ul>
<p>主要区别在于规模，Azure 在世界各地拥有大量数据中心。用户通常不会选择某个具体 Datacenter，而是通过更高层次的 Region 和 Availability Zone 部署资源。</p>
<table>
	<thead>
			<tr>
					<th>设计概念</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Datacenter 是 Azure 最底层的物理设施</td>
					<td>真正的服务器、网络、电力、冷却都在这里</td>
					<td>为 Azure 云服务提供实际硬件基础</td>
			</tr>
			<tr>
					<td>用户通常不直接操作具体 Datacenter</td>
					<td>你不会选择“把 VM 放到第几栋机房”</td>
					<td>Azure 可以自行管理底层资源</td>
			</tr>
			<tr>
					<td>Datacenter 会被进一步组织成 Region 和 Availability Zone</td>
					<td>把大量物理机房抽象成更容易使用的逻辑结构</td>
					<td>提供更好的可靠性和故障隔离</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Datacenter（数据中心）</strong>：容纳服务器、网络、电力和冷却设施的物理场所。</li>
<li><strong>Rack（机架）</strong>：用于安装服务器和网络设备的物理机柜。</li>
<li><strong>Physical Infrastructure（物理基础架构）</strong>：真正的机房、服务器、电力、网络等硬件设施。</li>
</ul>
<hr>
<h3 id="2-region区域">2. Region（区域）<a href="#2-region%e5%8c%ba%e5%9f%9f" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Azure Region 是包含一个或多个邻近数据中心的地理区域，这些数据中心通过低延迟网络连接。创建 Azure 资源时，通常需要从以下这类 Region 中选择部署位置：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Japan East
</span></span><span style="display:flex;"><span>West Europe
</span></span><span style="display:flex;"><span>East US
</span></span><span style="display:flex;"><span>Southeast Asia
</span></span></code></pre></div><table>
	<thead>
			<tr>
					<th>设计概念</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>一个 Region 包含一个或多个邻近 Datacenter</td>
					<td>Region 不是一个机房，而是一组地理位置接近的数据中心</td>
					<td>把底层数据中心组织成可管理的部署区域</td>
			</tr>
			<tr>
					<td>Region 内部使用低延迟网络连接</td>
					<td>同一区域内的数据中心之间通信速度较快</td>
					<td>适合组成一个完整的区域级云环境</td>
			</tr>
			<tr>
					<td>创建 Azure 资源时通常需要选择 Region</td>
					<td>决定 VM、数据库等资源主要部署在哪里</td>
					<td>影响延迟、合规、服务可用性和成本</td>
			</tr>
			<tr>
					<td>Azure 会在 Region 内管理资源分配和负载</td>
					<td>用户不需要自己指定某台实体服务器</td>
					<td>Azure 自动管理底层资源</td>
			</tr>
	</tbody>
</table>
<p>Region 可以理解为 Azure 在某个地理范围内建立的一整套云基础设施。例如，在日本部署服务时可以选择 Japan East，使服务更接近日本用户。</p>
<hr>
<h3 id="3-region-并不是所有服务都一样">3. Region 并不是所有服务都一样<a href="#3-region-%e5%b9%b6%e4%b8%8d%e6%98%af%e6%89%80%e6%9c%89%e6%9c%8d%e5%8a%a1%e9%83%bd%e4%b8%80%e6%a0%b7" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>并非所有 Azure 服务和功能都在每个 Region 中提供，常见差异包括：</p>
<ul>
<li>某些 VM Size 只在部分 Region 可用</li>
<li>某些 Storage 类型只在部分 Region 可用</li>
<li>某些特殊服务只部署在指定 Region</li>
</ul>
<p>因此，选择部署位置时既要考虑与用户的距离，也要确认目标 Region 是否提供所需服务。Microsoft Entra ID、Azure Traffic Manager 和 Azure DNS 等 Global Service 则不要求选择具体 Region：</p>
<ul>
<li>Microsoft Entra ID</li>
<li>Azure Traffic Manager</li>
<li>Azure DNS</li>
</ul>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Region（区域）</strong>：由一个或多个邻近数据中心组成的 Azure 地理部署范围。</li>
<li><strong>Low-latency Network（低延迟网络）</strong>：具有较低通信延迟的高速网络。</li>
<li><strong>Global Service（全球服务）</strong>：不要求用户选择特定 Azure Region 的服务。</li>
<li><strong>VM Size</strong>：Azure VM 不同的 CPU、内存和硬件规格组合。</li>
</ul>
<hr>
<h3 id="4-availability-zone可用区">4. Availability Zone（可用区）<a href="#4-availability-zone%e5%8f%af%e7%94%a8%e5%8c%ba" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Availability Zone 是同一个 Azure Region 内彼此物理分离的数据中心区域，每个 Zone 都有独立的：</p>
<ul>
<li>电力</li>
<li>冷却</li>
<li>网络</li>
</ul>
<p>一个 Zone 出现故障时，其他 Zone 仍可继续运行；各 Zone 之间则通过高速私有光纤网络连接，以支持跨 Zone 通信和复制。</p>
<table>
	<thead>
			<tr>
					<th>设计概念</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Availability Zone 在物理上彼此分离</td>
					<td>虽然都属于同一个 Region，但不是共用同一个机房环境</td>
					<td>减少单一机房故障造成的影响</td>
			</tr>
			<tr>
					<td>每个 Zone 有独立电力、冷却和网络</td>
					<td>一个 Zone 的供电或网络故障不会必然拖垮其他 Zone</td>
					<td>提供故障隔离</td>
			</tr>
			<tr>
					<td>Zone 之间通过高速私有网络连接</td>
					<td>不同 Zone 仍然可以快速通信</td>
					<td>支持跨 Zone 冗余和复制</td>
			</tr>
			<tr>
					<td>一个 Zone 可以包含一个或多个 Datacenter</td>
					<td>Availability Zone 是比单一机房更高一层的故障隔离单位</td>
					<td>提供更稳定的可用性边界</td>
			</tr>
	</tbody>
</table>
<p>假设一个 Region 有三个 Availability Zone：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Azure Region
</span></span><span style="display:flex;"><span>├── Zone 1
</span></span><span style="display:flex;"><span>├── Zone 2
</span></span><span style="display:flex;"><span>└── Zone 3
</span></span></code></pre></div><p>如果 Zone 1 因为电力问题完全故障：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Zone 1 ✕
</span></span><span style="display:flex;"><span>Zone 2 ✓
</span></span><span style="display:flex;"><span>Zone 3 ✓
</span></span></code></pre></div><p>只要服务跨多个 Zone 部署，Zone 1 的电力故障就不会必然中断整个服务。因此，Availability Zone 主要解决同一个 Region 内的机房级故障。</p>
<hr>
<h3 id="5-availability-zone-是故障隔离边界">5. Availability Zone 是故障隔离边界<a href="#5-availability-zone-%e6%98%af%e6%95%85%e9%9a%9c%e9%9a%94%e7%a6%bb%e8%be%b9%e7%95%8c" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Azure 把 Availability Zone 设计成 Isolation Boundary（隔离边界），目标是把故障限制在单个 Zone 内，避免影响其他 Zone。这与前文的 Fault Isolation 思路一致：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Zone 1
</span></span><span style="display:flex;"><span>电力故障
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>Zone 1 服务停止
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Zone 2 / Zone 3
</span></span><span style="display:flex;"><span>独立供电
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>继续运行
</span></span></code></pre></div><p>对于支持 Availability Zone 的 Region，Azure 至少提供三个独立 Zone。</p>
<p>不过，并非所有 Azure Region 都支持 Availability Zone。</p>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Availability Zone（可用区）</strong>：Region 内物理隔离的基础设施区域。</li>
<li><strong>Isolation Boundary（隔离边界）</strong>：一个故障尽量被限制在该范围内，不继续向外扩散。</li>
<li><strong>Fault Isolation（故障隔离）</strong>：阻止局部故障影响其他资源的设计方式。</li>
</ul>
<hr>
<h3 id="6-如何利用-availability-zone-提高可靠性">6. 如何利用 Availability Zone 提高可靠性<a href="#6-%e5%a6%82%e4%bd%95%e5%88%a9%e7%94%a8-availability-zone-%e6%8f%90%e9%ab%98%e5%8f%af%e9%9d%a0%e6%80%a7" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>传统本地数据中心通常要购买两套或多套硬件才能实现冗余，而 Azure 可以把资源直接部署到不同 Availability Zone，例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Zone 1
</span></span><span style="display:flex;"><span>VM A
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Zone 2
</span></span><span style="display:flex;"><span>VM B
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Zone 3
</span></span><span style="display:flex;"><span>VM C
</span></span></code></pre></div><p>某个 Zone 出现故障后，其他 Zone 中的资源仍然存在。可以跨 Zone 部署的资源包括：</p>
<ul>
<li>VM</li>
<li>Storage</li>
<li>Database</li>
<li>其他支持 Availability Zone 的 Azure 服务</li>
</ul>
<p>跨 Zone 冗余也会增加成本，例如：</p>
<ul>
<li>创建更多资源副本</li>
<li>跨 Zone 传输数据</li>
<li>保存更多数据副本</li>
</ul>
<p>因此，设计时仍需权衡可靠性与成本。</p>
<hr>
<h3 id="7-availability-zone-服务的三种类型">7. Availability Zone 服务的三种类型<a href="#7-availability-zone-%e6%9c%8d%e5%8a%a1%e7%9a%84%e4%b8%89%e7%a7%8d%e7%b1%bb%e5%9e%8b" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>支持 Availability Zone 的 Azure 服务大致分为三类：</p>
<table>
	<thead>
			<tr>
					<th>类型</th>
					<th>通俗解释</th>
					<th>例子</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Zonal Service</td>
					<td>你自己指定资源放在哪个 Zone</td>
					<td>VM、Managed Disk、IP Address</td>
			</tr>
			<tr>
					<td>Zone-redundant Service</td>
					<td>Azure 自动在多个 Zone 之间复制</td>
					<td>Zone-redundant Storage、SQL Database</td>
			</tr>
			<tr>
					<td>Non-regional Service</td>
					<td>服务本身不依赖某一个单独 Region</td>
					<td>一些全球性 Azure 服务</td>
			</tr>
	</tbody>
</table>
<p><strong>Zonal Service</strong></p>
<p>使用 Zonal Service 时，用户明确指定资源所在的 Zone：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>VM A → Zone 1
</span></span><span style="display:flex;"><span>VM B → Zone 2
</span></span></code></pre></div><p>跨 Zone 冗余需要由用户设计。</p>
<p><strong>Zone-redundant Service</strong></p>
<p>使用 Zone-redundant Service 时，用户只需创建服务，Azure 平台会在多个 Zone 中部署副本：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Zone 1
</span></span><span style="display:flex;"><span>Zone 2
</span></span><span style="display:flex;"><span>Zone 3
</span></span></code></pre></div><p>多 Zone 复制由平台自动完成。</p>
<p><strong>Non-regional Service</strong></p>
<p>Non-regional Service 不绑定单个 Region，因此可以抵御：</p>
<ul>
<li>Zone 级故障</li>
<li>Region 级故障</li>
</ul>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Zonal Service</strong>：绑定到某一个特定 Availability Zone 的资源。</li>
<li><strong>Zone-redundant Service</strong>：Azure 自动将服务复制到多个 Zone。</li>
<li><strong>Non-regional Service</strong>：不依赖单一区域的服务。</li>
<li><strong>Managed Disk</strong>：Azure 管理的 VM 磁盘。</li>
<li><strong>Zone-redundant Storage，ZRS</strong>：自动在同一个 Region 的多个 Availability Zone 之间复制数据的存储方式。</li>
</ul>
<hr>
<h3 id="8-为什么有-availability-zone-还需要-region-pair">8. 为什么有 Availability Zone 还需要 Region Pair<a href="#8-%e4%b8%ba%e4%bb%80%e4%b9%88%e6%9c%89-availability-zone-%e8%bf%98%e9%9c%80%e8%a6%81-region-pair" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Availability Zone 可以应对单个 Zone 故障，但大规模自然灾害、区域级电力或网络中断、社会事件以及整个 Region 的基础设施问题，可能同时影响同一区域内的多个 Zone：</p>
<ul>
<li>大规模自然灾害</li>
<li>区域级电力中断</li>
<li>大规模网络故障</li>
<li>社会事件</li>
<li>整个 Region 的基础设施问题</li>
</ul>
<p>为了应对这类 Region 级故障，Azure 提供了 Region Pair（区域对）。</p>
<hr>
<h3 id="9-region-pair区域对">9. Region Pair（区域对）<a href="#9-region-pair%e5%8c%ba%e5%9f%9f%e5%af%b9" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>大多数 Azure Region 会与同一 Geography 中的另一个 Region 配对。两个 Region 通常至少相距约 300 英里，以降低同一场区域性灾难同时影响两边的可能性，例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>West US ↔ East US
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Southeast Asia ↔ East Asia
</span></span></code></pre></div><table>
	<thead>
			<tr>
					<th>设计概念</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>两个 Region 组成 Region Pair</td>
					<td>一个区域还有另一个远距离区域作为恢复选择</td>
					<td>提高 Region 级灾难的恢复能力</td>
			</tr>
			<tr>
					<td>两个 Region 距离较远</td>
					<td>避免同一次区域灾难同时破坏两个 Region</td>
					<td>降低相关性故障风险</td>
			</tr>
			<tr>
					<td>可以跨 Region 复制资源或数据</td>
					<td>一个 Region 故障后可以使用另一个 Region</td>
					<td>提供更高级别的灾难恢复</td>
			</tr>
			<tr>
					<td>Region Pair 通常位于同一 Geography</td>
					<td>数据通常不会跨出所要求的地理范围</td>
					<td>有利于数据驻留和合规</td>
			</tr>
	</tbody>
</table>
<p>Availability Zone 类似一个城市里的多个独立机房，Region Pair 则相当于在远处的另一个城市准备一套恢复环境。</p>
<hr>
<h3 id="10-region-pair-并不等于自动灾备">10. Region Pair 并不等于自动灾备<a href="#10-region-pair-%e5%b9%b6%e4%b8%8d%e7%ad%89%e4%ba%8e%e8%87%aa%e5%8a%a8%e7%81%be%e5%a4%87" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Region Pair 只提供跨区域恢复的基础条件，并不表示 Azure 会自动复制所有数据和服务。事实上，并非所有服务都会：</p>
<ul>
<li>自动跨 Region 复制</li>
<li>自动 Failover</li>
<li>自动 Failback</li>
</ul>
<p>很多情况下，客户仍需自行配置：</p>
<ul>
<li>数据复制</li>
<li>备用 Region</li>
<li>Failover</li>
<li>Disaster Recovery</li>
</ul>
<p>是否进行跨 Region 复制和恢复，最终取决于服务本身的能力和客户配置。</p>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Region Pair（区域对）</strong>：两个相距较远、用于增强区域级灾难恢复能力的 Azure Region。</li>
<li><strong>Cross-region Replication（跨区域复制）</strong>：把数据或资源复制到另一个 Region。</li>
<li><strong>Failover（故障切换）</strong>：主 Region 故障后切换到备用 Region。</li>
<li><strong>Failback（故障回切）</strong>：主 Region 恢复后再切回。</li>
<li><strong>Disaster Recovery，DR（灾难恢复）</strong>：发生大规模严重故障后恢复业务的整体能力。</li>
</ul>
<hr>
<h3 id="11-region-pair-的额外优势">11. Region Pair 的额外优势<a href="#11-region-pair-%e7%9a%84%e9%a2%9d%e5%a4%96%e4%bc%98%e5%8a%bf" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>除跨区域复制外，Region Pair 还有以下作用：</p>
<table>
	<thead>
			<tr>
					<th>优势</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>大规模 Azure 故障时，会优先恢复每对 Region 中至少一个</td>
					<td>微软会尽量保证一对 Region 不会长期一起不可用</td>
					<td>提高恢复概率</td>
			</tr>
			<tr>
					<td>Azure 计划更新通常不会同时更新两个配对 Region</td>
					<td>一个更新时，另一个暂时保持不变</td>
					<td>降低更新导致同时故障的风险</td>
			</tr>
			<tr>
					<td>数据通常保持在同一个 Geography 内</td>
					<td>数据不会随意跨出某个国家或地理范围</td>
					<td>满足数据驻留和合规需求</td>
			</tr>
	</tbody>
</table>
<hr>
<h3 id="12-region-pair-的特殊情况">12. Region Pair 的特殊情况<a href="#12-region-pair-%e7%9a%84%e7%89%b9%e6%ae%8a%e6%83%85%e5%86%b5" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>大多数 Region Pair 是双向的：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Region A ↔ Region B
</span></span></code></pre></div><p>这表示 A 和 B 互为备份选择，但并非所有 Region 都采用这种方式。Brazil South 就是一个特殊案例：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Brazil South
</span></span><span style="display:flex;"><span>→ South Central US
</span></span></code></pre></div><p>这种配对并不完全对称，还有一些 Region 没有传统 Region Pair，例如：</p>
<ul>
<li>Italy North</li>
<li>Poland Central</li>
<li>Israel Central</li>
</ul>
<p>这些 Region 更多依赖以下机制实现韧性：</p>
<ul>
<li>Availability Zone</li>
<li>Geo-redundant Storage</li>
</ul>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Bidirectional Pairing（双向配对）</strong>：两个 Region 互相作为配对区域。</li>
<li><strong>One-direction Pairing（单向配对）</strong>：Region A 使用 Region B 作为配对，但反过来并不成立。</li>
<li><strong>Geo-redundant Storage（地理冗余存储）</strong>：把数据复制到较远的另一个地理区域，以应对 Region 级故障。</li>
</ul>
<hr>
<h3 id="13-geography">13. Geography<a href="#13-geography" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Geography 是比 Region 更大的地理边界，例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>United States
</span></span><span style="display:flex;"><span>Europe
</span></span><span style="display:flex;"><span>Asia
</span></span></code></pre></div><p>一个 Geography 可以包含多个 Region，整体层级如下：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Geography
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Region
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Availability Zone
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Datacenter
</span></span></code></pre></div><p>Geography 的范围最大，Datacenter 则是最具体的物理层级。</p>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Geography（地理区域）</strong>：Azure 用来组织多个 Region 的更大地理范围，通常与数据驻留和合规要求相关。</li>
<li><strong>Data Residency（数据驻留）</strong>：规定数据应存储在哪个国家或地理范围内。</li>
</ul>
<hr>
<h3 id="14-sovereign-region主权区域">14. Sovereign Region（主权区域）<a href="#14-sovereign-region%e4%b8%bb%e6%9d%83%e5%8c%ba%e5%9f%9f" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>除普通 Azure Region 外，还有 Sovereign Region（主权区域）。它们与 Azure 的全球基础设施在物理和逻辑上隔离，主要用于满足：</p>
<ul>
<li>政府要求</li>
<li>法律要求</li>
<li>合规要求</li>
<li>数据主权要求</li>
</ul>
<table>
	<thead>
			<tr>
					<th>类型</th>
					<th>通俗解释</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>US Government Regions</td>
					<td>专门为美国政府机构和合作伙伴提供的隔离 Azure 环境</td>
			</tr>
			<tr>
					<td>China Regions</td>
					<td>中国地区独立运营的 Azure 环境</td>
			</tr>
	</tbody>
</table>
<p><strong>美国政府区域</strong></p>
<p>美国政府区域包括：</p>
<ul>
<li>US DoD Central</li>
<li>US Gov Virginia</li>
<li>US Gov Arizona</li>
</ul>
<p>这些环境具有以下特点：</p>
<ul>
<li>与普通 Azure 网络隔离</li>
<li>面向美国政府机构及合作伙伴</li>
<li>由经过审查的美国人员运营</li>
<li>具备额外合规认证</li>
</ul>
<p><strong>中国区域</strong></p>
<p>中国区域包括：</p>
<ul>
<li>China East</li>
<li>China North</li>
</ul>
<p>中国 Azure 由 Microsoft 与 21Vianet 合作提供，Microsoft 不直接维护这些数据中心。</p>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Sovereign Region（主权区域）</strong>：与普通全球 Azure 环境隔离、用于满足特殊法律和合规要求的云区域。</li>
<li><strong>Logical Isolation（逻辑隔离）</strong>：虽然都是 Azure 技术体系，但网络、账号或管理体系彼此独立。</li>
<li><strong>Compliance Certification（合规认证）</strong>：证明云环境符合特定政府、行业或法律标准的认证。</li>
<li><strong>21Vianet（世纪互联）</strong>：在中国运营相关 Azure 云服务的合作伙伴。</li>
</ul>
<hr>
<h3 id="总结">总结<a href="#%e6%80%bb%e7%bb%93" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Azure 的物理架构层级如下：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Geography
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Region
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Availability Zone
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Datacenter
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Physical Servers
</span></span></code></pre></div><p>每个层级解决的问题不同：</p>
<table>
	<thead>
			<tr>
					<th>层级</th>
					<th>主要解决什么问题</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Datacenter</td>
					<td>真正在哪里运行服务器</td>
			</tr>
			<tr>
					<td>Availability Zone</td>
					<td>一个机房级故障时怎么办</td>
			</tr>
			<tr>
					<td>Region</td>
					<td>资源主要部署在哪个地理区域</td>
			</tr>
			<tr>
					<td>Region Pair</td>
					<td>整个 Region 出现严重故障时怎么办</td>
			</tr>
			<tr>
					<td>Geography</td>
					<td>数据和资源属于哪个大的地理、合规范围</td>
			</tr>
			<tr>
					<td>Sovereign Region</td>
					<td>特殊政府、法律和数据主权要求</td>
			</tr>
	</tbody>
</table>
<p>其中最容易混淆的是 Availability Zone 与 Region Pair：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Availability Zone
</span></span><span style="display:flex;"><span>同一个 Region 内的故障隔离
</span></span></code></pre></div><p>相比之下：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Region Pair
</span></span><span style="display:flex;"><span>不同 Region 之间的灾难恢复
</span></span></code></pre></div><p>简而言之，Zone 处理机房级故障，Region Pair 处理区域级灾难。Azure 的物理可靠性设计通过以下层级逐步扩大故障隔离范围：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>一台服务器坏了
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>Datacenter 内处理
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>一个机房 / Zone 坏了
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>其他 Availability Zone 继续运行
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>整个 Region 坏了
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>另一个 Region / Region Pair 提供恢复能力
</span></span></code></pre></div><p>Azure 通过 Datacenter → Availability Zone → Region → Region Pair 的多层结构，把故障隔离和冗余能力从单个数据中心扩展到整个地理区域。</p>
<h2 id="azure-管理基础架构">Azure 管理基础架构<a href="#azure-%e7%ae%a1%e7%90%86%e5%9f%ba%e7%a1%80%e6%9e%b6%e6%9e%84" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>Azure 的管理基础架构主要包括：</p>
<ul>
<li><strong>Resources（资源）</strong></li>
<li><strong>Resource Groups（资源组）</strong></li>
<li><strong>Subscriptions（订阅）</strong></li>
<li><strong>Management Groups（管理组）</strong></li>
<li><strong>Accounts / Microsoft Entra Tenant（账户 / 租户）</strong></li>
</ul>
<p>这些层级共同决定资源如何组织、权限如何控制以及费用如何管理，完整关系如下：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Tenant Root Group
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Management Groups
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Subscriptions
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Resource Groups
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Resources
</span></span></code></pre></div><hr>
<h3 id="1-azure-resource资源">1. Azure Resource（资源）<a href="#1-azure-resource%e8%b5%84%e6%ba%90" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Resource 是 Azure 中最基本的管理对象。在 Azure 中创建、预配或部署的服务实例通常都属于 Resource，例如：</p>
<ul>
<li>Virtual Machine</li>
<li>Virtual Network</li>
<li>Database</li>
<li>Storage Account</li>
<li>Azure AI Service</li>
</ul>
<table>
	<thead>
			<tr>
					<th>概念</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Resource 是 Azure 最基本的构建单元</td>
					<td>你实际创建出来并使用的 Azure 服务，就是资源</td>
					<td>所有部署、权限、监控和计费最终都会落到具体资源上</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Resource（资源）</strong>：Azure 中实际创建出来的服务实例。</li>
<li><strong>Provision（预配）</strong>：创建并准备资源，使其能够使用。</li>
<li><strong>Deploy（部署）</strong>：把资源、应用或配置真正放到环境中运行。</li>
</ul>
<hr>
<h3 id="2-resource-group资源组">2. Resource Group（资源组）<a href="#2-resource-group%e8%b5%84%e6%ba%90%e7%bb%84" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Resource Group 是一组 Azure Resources 的逻辑集合，每个 Resource 必须且只能同时属于一个 Resource Group。例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Resource Group: Web-App-Prod
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>├── VM
</span></span><span style="display:flex;"><span>├── Virtual Network
</span></span><span style="display:flex;"><span>├── SQL Database
</span></span><span style="display:flex;"><span>└── Storage Account
</span></span></code></pre></div><p>资源组不是物理位置，而是组织相关资源的逻辑容器。</p>
<table>
	<thead>
			<tr>
					<th>设计规则</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>每个 Resource 必须属于一个 Resource Group</td>
					<td>Azure 不允许资源完全“散着放”</td>
					<td>让所有资源都有明确管理归属</td>
			</tr>
			<tr>
					<td>一个 Resource 同一时间只能属于一个 Resource Group</td>
					<td>一台 VM 不能同时放进两个资源组</td>
					<td>避免管理边界混乱</td>
			</tr>
			<tr>
					<td>某些 Resource 可以在 Resource Group 之间移动</td>
					<td>如果分组方式发生变化，可以把部分资源重新归类</td>
					<td>提高组织灵活性</td>
			</tr>
			<tr>
					<td>Resource Group 不能嵌套</td>
					<td>不能在一个资源组里面再建另一个资源组</td>
					<td>保持层级简单</td>
			</tr>
			<tr>
					<td>Resource Group 创建后不能重命名</td>
					<td>名字要在一开始就规划好</td>
					<td>避免后期命名混乱</td>
			</tr>
			<tr>
					<td>对 Resource Group 执行某些操作，会影响里面所有 Resource</td>
					<td>管理动作可以批量向下作用</td>
					<td>方便统一管理</td>
			</tr>
	</tbody>
</table>
<p><strong>为什么 Resource Group 很重要</strong></p>
<p>Resource Group 不只是用于分类的“文件夹”，在其范围内执行的删除或权限配置等操作可能作用于组内资源。</p>
<p><strong>删除 Resource Group</strong></p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Delete Resource Group
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>里面所有 Resources 一起删除
</span></span></code></pre></div><p>所以，如果你建立一个临时开发环境：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Dev-Test Resource Group
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>├── VM
</span></span><span style="display:flex;"><span>├── Database
</span></span><span style="display:flex;"><span>├── Storage
</span></span><span style="display:flex;"><span>└── Network
</span></span></code></pre></div><p>测试结束后可以直接删除整个 Resource Group，不必逐个清理资源。</p>
<p><strong>权限控制</strong></p>
<p>如果给某个用户授予 Resource Group 的访问权限：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>User
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>获得 Resource Group 权限
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>可以访问组内相应 Resources
</span></span></code></pre></div><p>因此，Resource Group 也是常用的权限管理范围。</p>
<p><strong>如何划分 Resource Group</strong></p>
<p>Azure 没有规定资源组的唯一划分方式，组织可以根据实际需求按项目划分：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Project A Resource Group
</span></span><span style="display:flex;"><span>Project B Resource Group
</span></span><span style="display:flex;"><span>Project C Resource Group
</span></span></code></pre></div><p>也可以按环境划分：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Dev Resource Group
</span></span><span style="display:flex;"><span>Test Resource Group
</span></span><span style="display:flex;"><span>Prod Resource Group
</span></span></code></pre></div><p>另一种方式是把生命周期相同的应用资源放在一起。划分时应优先考虑生命周期、权限和管理方式是否相近，例如临时测试环境中的 VM、数据库和网络通常一起创建和删除，适合放在同一个 Resource Group。</p>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Resource Group（资源组）</strong>：用于组织和统一管理 Azure Resources 的逻辑容器。</li>
<li><strong>Lifecycle（生命周期）</strong>：资源从创建、运行到删除的整个过程。</li>
<li><strong>Naming Convention（命名规范）</strong>：统一规定资源和资源组如何命名。</li>
<li><strong>Access Control（访问控制）</strong>：规定谁能够访问和操作哪些资源。</li>
</ul>
<hr>
<h3 id="3-azure-subscription订阅">3. Azure Subscription（订阅）<a href="#3-azure-subscription%e8%ae%a2%e9%98%85" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Subscription 是 Azure 的资源组织、访问控制和费用管理边界，Resource Group 位于 Subscription 之下：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Subscription
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Resource Groups
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Resources
</span></span></code></pre></div><p>一个 Azure Account 可以拥有多个 Subscription，但至少需要一个 Subscription 才能使用 Azure 服务。</p>
<table>
	<thead>
			<tr>
					<th>Subscription 的作用</th>
					<th>通俗解释</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Management Unit</td>
					<td>用来组织一批 Resource Groups 和 Resources</td>
			</tr>
			<tr>
					<td>Billing Unit</td>
					<td>Azure 可以按照不同 Subscription 分别统计费用</td>
			</tr>
			<tr>
					<td>Access Boundary</td>
					<td>不同 Subscription 可以配置不同权限和访问策略</td>
			</tr>
			<tr>
					<td>Scale Boundary</td>
					<td>可以通过多个 Subscription 扩大和分隔资源管理范围</td>
			</tr>
	</tbody>
</table>
<p><strong>计费边界</strong></p>
<p>Subscription 可以作为独立的计费边界。例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Azure Account
</span></span><span style="display:flex;"><span>├── Dev Subscription
</span></span><span style="display:flex;"><span>├── Test Subscription
</span></span><span style="display:flex;"><span>└── Production Subscription
</span></span></code></pre></div><p>Azure 可以分别产生：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Dev → 一份费用报告
</span></span><span style="display:flex;"><span>Test → 一份费用报告
</span></span><span style="display:flex;"><span>Production → 一份费用报告
</span></span></code></pre></div><p>分开统计后，组织可以清楚地看到各项目、团队或环境产生的费用。</p>
<table>
	<thead>
			<tr>
					<th>做法</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>为不同业务创建不同 Subscription</td>
					<td>把费用拆开统计</td>
					<td>方便成本追踪</td>
			</tr>
			<tr>
					<td>为生产和开发环境使用不同 Subscription</td>
					<td>生产成本不会和测试成本混在一起</td>
					<td>提高财务可见性</td>
			</tr>
			<tr>
					<td>为不同团队创建 Subscription</td>
					<td>每个团队单独计算云资源成本</td>
					<td>方便预算管理</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Billing Boundary（计费边界）</strong>：费用统计和账单划分的范围。</li>
<li><strong>Billing Report（费用报告）</strong>：记录某个 Subscription 使用了多少 Azure 服务以及产生多少费用。</li>
<li><strong>Cost Tracking（成本追踪）</strong>：分析云费用来自哪些项目、团队或资源。</li>
</ul>
<p><strong>访问控制边界</strong></p>
<p>Subscription 同时也是权限控制边界，不同环境可以采用不同的权限配置：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Development Subscription
</span></span><span style="display:flex;"><span>开发人员拥有较高权限
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Production Subscription
</span></span><span style="display:flex;"><span>只有少数运维人员能够修改
</span></span></code></pre></div><p>这种隔离可以降低开发人员测试代码时误操作生产资源的风险。各 Subscription 还可以分别设置 Access Policy、Budget / Cost Alert 和 Resource Permission。只有 Free Trial、Visual Studio 等带额度的订阅才可能具有 Spending Limit，按使用付费的订阅通常通过预算和告警监控成本。</p>
<table>
	<thead>
			<tr>
					<th>做法</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Dev 和 Prod 使用不同 Subscription</td>
					<td>把开发环境和生产环境隔离</td>
					<td>减少误操作风险</td>
			</tr>
			<tr>
					<td>不同 Subscription 配置不同权限</td>
					<td>不同团队只能操作自己的资源</td>
					<td>加强安全性</td>
			</tr>
			<tr>
					<td>不同 Subscription 设置预算和成本告警</td>
					<td>分别监控各环境的支出</td>
					<td>控制成本风险</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Access Control Boundary（访问控制边界）</strong>：权限规则可以独立配置的一层管理范围。</li>
<li><strong>Budget / Cost Alert（预算 / 成本告警）</strong>：跟踪费用并在达到阈值时通知相关人员，但不会自动停止资源。</li>
<li><strong>Access Policy（访问策略）</strong>：规定谁可以执行哪些操作。</li>
</ul>
<p><strong>为什么创建多个 Subscription</strong></p>
<p>随着 Azure 环境扩大，单个 Subscription 往往难以同时满足环境隔离、团队授权和成本核算需求，常见拆分方式有三类。</p>
<p><strong>按环境拆分</strong></p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Sandbox
</span></span><span style="display:flex;"><span>Development
</span></span><span style="display:flex;"><span>Test
</span></span><span style="display:flex;"><span>Production
</span></span></code></pre></div><p>这样可以隔离生命周期不同的环境。</p>
<p><strong>按团队或工作负载拆分</strong></p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Team A Subscription
</span></span><span style="display:flex;"><span>Team B Subscription
</span></span><span style="display:flex;"><span>Project C Subscription
</span></span></code></pre></div><p>这样更容易分别管理权限和费用。</p>
<p><strong>按计费需求拆分</strong></p>
<p>按计费需求拆分时，可以采用以下结构：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Production Subscription
</span></span><span style="display:flex;"><span>Development &amp; Test Subscription
</span></span></code></pre></div><p>这样财务部门可以清楚区分正式业务成本与开发测试成本。</p>
<hr>
<h3 id="4-azure-management-group管理组">4. Azure Management Group（管理组）<a href="#4-azure-management-group%e7%ae%a1%e7%90%86%e7%bb%84" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>少量 Subscription 可以逐个管理，但大型企业可能拥有：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>几十个
</span></span><span style="display:flex;"><span>几百个
</span></span><span style="display:flex;"><span>甚至几千个 Subscription
</span></span></code></pre></div><p>逐个配置这些 Subscription 的权限和策略会产生大量重复工作，因此 Azure 在 Subscription 之上提供了 Management Group：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Management Group
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Subscriptions
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Resource Groups
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Resources
</span></span></code></pre></div><p>Management Group 用于统一管理多个 Subscription。</p>
<p><strong>策略继承</strong></p>
<p>Management Group 支持 Policy 和 Access 向下继承。例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Production Management Group
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Policy:
</span></span><span style="display:flex;"><span>VM 只能部署到 West US
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Subscription A
</span></span><span style="display:flex;"><span>Subscription B
</span></span><span style="display:flex;"><span>Subscription C
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>所有 Resource Groups
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>所有 Resources
</span></span></code></pre></div><p>下层所有 Subscription 都会受到该规则约束，不需要逐个重复配置。</p>
<table>
	<thead>
			<tr>
					<th>Management Group 能做什么</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>对多个 Subscription 设置统一 Policy</td>
					<td>一条规则管很多订阅</td>
					<td>提高治理效率</td>
			</tr>
			<tr>
					<td>统一配置 Access</td>
					<td>给用户一次授权，就可以作用到下面多个 Subscription</td>
					<td>减少重复权限配置</td>
			</tr>
			<tr>
					<td>建立多层组织结构</td>
					<td>可以按照部门、区域、业务等组织 Subscription</td>
					<td>模拟真实企业组织结构</td>
			</tr>
			<tr>
					<td>向下继承配置</td>
					<td>子层级自动获得上层规则</td>
					<td>保持管理一致性</td>
			</tr>
	</tbody>
</table>
<p><strong>Policy 继承示例</strong></p>
<p>假设公司要求 Production 环境的 VM 只能运行在 West US，可以按以下方式配置：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Production Management Group
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Policy:
</span></span><span style="display:flex;"><span>Allowed Region = West US
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>├── Production Subscription A
</span></span><span style="display:flex;"><span>├── Production Subscription B
</span></span><span style="display:flex;"><span>└── Production Subscription C
</span></span></code></pre></div><p>在此结构中，下层 VM 都受到同一策略约束：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>所有下面的 VM
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>只能部署到 West US
</span></span></code></pre></div><p>继承的上层治理策略不能由 Subscription Owner 直接绕过，因此企业可以把统一规则应用到大量 Subscription。</p>
<p><strong>Azure RBAC 与 Management Group</strong></p>
<p>Management Group 也能统一分配权限。假设某个管理员需要读取多个 Subscription，没有 Management Group 时必须逐个配置：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Subscription A → 配一次权限
</span></span><span style="display:flex;"><span>Subscription B → 再配一次
</span></span><span style="display:flex;"><span>Subscription C → 再配一次
</span></span><span style="display:flex;"><span>Subscription D → 再配一次
</span></span></code></pre></div><p>使用 Management Group 后：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Management Group
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>配置一次 Azure RBAC
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>下面所有 Subscription 自动继承
</span></span></code></pre></div><p>权限还可以继续向下继承：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Management Group
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Sub-management Group
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Subscription
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Resource Group
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Resource
</span></span></code></pre></div><p><strong>关键词</strong></p>
<ul>
<li><strong>Azure RBAC（Role-Based Access Control）</strong>：基于角色的访问控制，用角色决定用户能够对 Azure 资源执行什么操作。</li>
<li><strong>Role Assignment（角色分配）</strong>：把某个 Azure Role 分配给某个用户、组或身份。</li>
<li><strong>Inheritance（继承）</strong>：下层资源自动获得上层定义的权限或策略。</li>
<li><strong>Governance（治理）</strong>：通过规则、权限和策略统一管理云资源。</li>
<li><strong>Policy（策略）</strong>：用于限制或规范 Azure 资源配置的规则。</li>
</ul>
<p><strong>Management Group 嵌套</strong></p>
<p>Resource Group 不能嵌套，Management Group 则可以形成多层结构。例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Tenant Root Group
</span></span><span style="display:flex;"><span>│
</span></span><span style="display:flex;"><span>├── Production
</span></span><span style="display:flex;"><span>│   ├── Europe
</span></span><span style="display:flex;"><span>│   │   ├── Subscription A
</span></span><span style="display:flex;"><span>│   │   └── Subscription B
</span></span><span style="display:flex;"><span>│   │
</span></span><span style="display:flex;"><span>│   └── Asia
</span></span><span style="display:flex;"><span>│       ├── Subscription C
</span></span><span style="display:flex;"><span>│       └── Subscription D
</span></span><span style="display:flex;"><span>│
</span></span><span style="display:flex;"><span>└── Development
</span></span><span style="display:flex;"><span>    ├── Subscription E
</span></span><span style="display:flex;"><span>    └── Subscription F
</span></span></code></pre></div><p>企业可以按照部门、国家或地区、开发环境、项目和业务类型建立管理层级。Management Group 最多可以嵌套 6 层，这一限制不计算：</p>
<ul>
<li>Tenant Root Group</li>
<li>Subscription 层</li>
</ul>
<p><strong>Management Group 的限制</strong></p>
<p>Management Group 还受以下数量和层级规则限制：</p>
<table>
	<thead>
			<tr>
					<th>规则</th>
					<th>含义</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>一个 Directory 最多支持 10,000 个 Management Groups</td>
					<td>Azure 对管理组数量有上限</td>
			</tr>
			<tr>
					<td>Management Group 可以嵌套最多 6 层</td>
					<td>可以建立较复杂的组织层级</td>
			</tr>
			<tr>
					<td>每个 Management Group 只能有一个 Parent</td>
					<td>一个管理组不能同时属于两个上级</td>
			</tr>
			<tr>
					<td>每个 Subscription 只能有一个 Parent</td>
					<td>一个 Subscription 同时只能处于一个 Management Group 分支中</td>
			</tr>
	</tbody>
</table>
<p>这与 Resource Group 的组织原则相似，每个对象在层级中都有明确的父级。</p>
<hr>
<h3 id="5-tenant-root-group">5. Tenant Root Group<a href="#5-tenant-root-group" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>每个 Microsoft Entra Tenant 都有一个 Tenant Root Group，它是 Management Group 层级的根节点，所有 Management Groups 和 Subscriptions 最终都位于其下。结构如下：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Tenant Root Group
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Management Groups
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Subscriptions
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Resource Groups
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Resources
</span></span></code></pre></div><p>在 Tenant Root Group 上应用的 Policy 或角色分配会沿层级继承，因此可能影响整个 Tenant 下的 Azure 环境。</p>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Microsoft Entra Tenant（Entra 租户）</strong>：一个组织在 Microsoft Entra ID 中的独立身份和目录边界。</li>
<li><strong>Tenant Root Group</strong>：Management Group 层级最顶层的根管理组。</li>
<li><strong>Directory（目录）</strong>：保存组织用户、组、身份等信息的身份管理环境。</li>
</ul>
<hr>
<h3 id="关键词总览">关键词总览<a href="#%e5%85%b3%e9%94%ae%e8%af%8d%e6%80%bb%e8%a7%88" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<ul>
<li><strong>Azure Resource</strong>：Azure 中实际创建和使用的服务实例。</li>
<li><strong>Resource Group</strong>：把相关 Resources 放在一起管理的逻辑容器。</li>
<li><strong>Subscription</strong>：Azure 中用于资源组织、权限控制和费用管理的边界。</li>
<li><strong>Management Group</strong>：用于统一管理多个 Subscription 的上层管理结构。</li>
<li><strong>Tenant Root Group</strong>：整个 Management Group 层级的根节点。</li>
<li><strong>Microsoft Entra Tenant</strong>：组织在 Microsoft Entra ID 中的独立身份目录。</li>
<li><strong>Billing Boundary</strong>：费用独立统计的管理边界。</li>
<li><strong>Access Control Boundary</strong>：权限可以独立配置的管理边界。</li>
<li><strong>Azure RBAC</strong>：基于角色控制用户能够访问和操作哪些 Azure 资源。</li>
<li><strong>Azure Policy</strong>：用于规定 Azure Resource 必须满足哪些配置和合规要求。</li>
<li><strong>Inheritance（继承）</strong>：上层的 Policy 或 Access 设置自动作用到下层。</li>
</ul>
<hr>
<h3 id="总结-1">总结<a href="#%e6%80%bb%e7%bb%93-1" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Azure 管理基础架构的核心是以下层级：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Tenant Root Group
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Management Group
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Subscription
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Resource Group
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Resource
</span></span></code></pre></div><p>可以用公司的组织结构作类比：</p>
<table>
	<thead>
			<tr>
					<th>Azure 概念</th>
					<th>类比</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Tenant Root Group</td>
					<td>整个公司</td>
			</tr>
			<tr>
					<td>Management Group</td>
					<td>事业部 / 部门</td>
			</tr>
			<tr>
					<td>Subscription</td>
					<td>某个项目或独立预算单位</td>
			</tr>
			<tr>
					<td>Resource Group</td>
					<td>项目中的某一组相关资源</td>
			</tr>
			<tr>
					<td>Resource</td>
					<td>真正的 VM、数据库、网络等</td>
			</tr>
	</tbody>
</table>
<p>各层承担不同职责：</p>
<table>
	<thead>
			<tr>
					<th>层级</th>
					<th>核心作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Resource</td>
					<td>真正提供功能</td>
			</tr>
			<tr>
					<td>Resource Group</td>
					<td>管理一组相关资源</td>
			</tr>
			<tr>
					<td>Subscription</td>
					<td>隔离权限、费用和环境</td>
			</tr>
			<tr>
					<td>Management Group</td>
					<td>统一管理大量 Subscription</td>
			</tr>
			<tr>
					<td>Tenant Root Group</td>
					<td>对整个组织进行最高层治理</td>
			</tr>
	</tbody>
</table>
<p>Policy 和 Access 的继承关系如下：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>上层 Policy / Access
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Management Group
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Subscription
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Resource Group
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Resource
</span></span></code></pre></div><p>Resource 是实际服务，Resource Group 管理一组资源，Subscription 负责资源组织、权限和费用边界，Management Group 统一管理多个 Subscription，Tenant Root Group 则位于整个 Azure 管理层级的顶层。</p>
<h2 id="azure-monitor">Azure Monitor<a href="#azure-monitor" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<h3 id="azure-monitor-中的-sli">Azure Monitor 中的 SLI<a href="#azure-monitor-%e4%b8%ad%e7%9a%84-sli" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>SLI（Service Level Indicator，服务级别指标）用于衡量服务的实际可靠性或性能。Azure Monitor 会把实际观测到的服务表现，与预先设定的目标进行比较，从而判断服务是否达到预期。一个完整的 SLI 不只是一个指标，而是由服务范围、SLI 类型、评估方式、信号设计、SLO 目标和统计周期等共同组成。</p>
<p><strong>1. SLI 的基本组成</strong></p>
<table>
	<thead>
			<tr>
					<th>组成部分</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Service Group</td>
					<td>这个 SLI 到底是在衡量哪个应用或工作负载</td>
					<td>明确测量范围</td>
			</tr>
			<tr>
					<td>SLI Type</td>
					<td>你到底想测“能不能用”，还是“够不够快”</td>
					<td>决定可靠性问题的类型</td>
			</tr>
			<tr>
					<td>Evaluation Method</td>
					<td>按每一次请求统计，还是按一段段时间窗口统计</td>
					<td>决定 SLI 的计算方式</td>
			</tr>
			<tr>
					<td>Signal Design</td>
					<td>用哪些指标、过滤条件、聚合方式和公式来判断好坏</td>
					<td>定义什么算成功、什么算失败</td>
			</tr>
			<tr>
					<td>Baseline Target</td>
					<td>实际指标需要达到的目标值，也就是 SLO</td>
					<td>判断服务是否达标</td>
			</tr>
			<tr>
					<td>Compliance Period</td>
					<td>在多长时间范围内判断是否达标</td>
					<td>明确统计周期</td>
			</tr>
	</tbody>
</table>
<p><em>关键词</em></p>
<ul>
<li><strong>SLI</strong>：实际测量出来的服务表现。</li>
<li><strong>SLO</strong>：SLI 应该达到的目标。</li>
<li><strong>Compliance Period</strong>：判断 SLO 是否达标的统计时间范围，例如 7 天、30 天。</li>
<li><strong>Signal</strong>：用于计算 SLI 的原始监控数据和条件。</li>
</ul>
<hr>
<p><strong>2. SLI 的两种主要类型</strong></p>
<p>Azure Monitor 主要支持 Availability 和 Latency 两类 SLI：</p>
<table>
	<thead>
			<tr>
					<th>类型</th>
					<th>通俗解释</th>
					<th>例子</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Availability</td>
					<td>服务到底有没有正常工作</td>
					<td>99.99% 的读写请求成功</td>
			</tr>
			<tr>
					<td>Latency</td>
					<td>服务响应得够不够快</td>
					<td>95% 的请求在 300 ms 内完成</td>
			</tr>
	</tbody>
</table>
<p><em>关键词</em></p>
<ul>
<li><strong>Availability（可用性）</strong>：服务是否成功完成用户请求。</li>
<li><strong>Latency（延迟）</strong>：从请求发出到得到响应所需要的时间。</li>
</ul>
<p>Availability 衡量请求是否成功，Latency 衡量响应是否足够快。</p>
<hr>
<p><strong>3. 两种评估方式</strong></p>
<p>Azure Monitor 可以按 Request-based 或 Window-based 两种方式计算 SLI：</p>
<table>
	<thead>
			<tr>
					<th>评估方式</th>
					<th>通俗解释</th>
					<th>适合场景</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Request-based</td>
					<td>每个请求都算一次，然后看成功请求占总请求多少</td>
					<td>最适合衡量接口请求成功率，是最常见方式</td>
			</tr>
			<tr>
					<td>Window-based</td>
					<td>把时间切成一段一段，每一段判断“好还是坏”</td>
					<td>适合不希望短时间抖动对整体结果影响太大的场景</td>
			</tr>
	</tbody>
</table>
<p><strong>Request-based</strong></p>
<p>Request-based SLI 的核心公式是：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>SLI = Good Requests / Total Requests
</span></span></code></pre></div><p>以下示例中，成功请求数为 9900，总请求数为 10000：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>成功请求：9900
</span></span><span style="display:flex;"><span>总请求：10000
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>SLI = 9900 / 10000 = 99%
</span></span></code></pre></div><p>其中，Good Signal 是分子，表示符合成功条件的请求；Total Signal 是分母，表示所有参与统计的请求。例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Good Signal：
</span></span><span style="display:flex;"><span>HTTP 状态码 = 200 的请求
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Total Signal：
</span></span><span style="display:flex;"><span>所有 HTTP 请求
</span></span></code></pre></div><p>相应的 Availability SLI 为：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Availability SLI
</span></span><span style="display:flex;"><span>= HTTP 200 请求数 / 总请求数
</span></span></code></pre></div><p><strong>Window-based</strong></p>
<p>Window-based 不直接统计成功请求占比，而是先把时间划分为多个窗口，例如每 5 分钟一个窗口：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>每 5 分钟作为一个窗口
</span></span></code></pre></div><p>然后逐个判断窗口是否合格：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>错误率 &lt; 1%
</span></span><span style="display:flex;"><span>→ Good Window
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>错误率 &gt;= 1%
</span></span><span style="display:flex;"><span>→ Bad Window
</span></span></code></pre></div><p>最终按合格窗口占比计算 SLI：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>SLI = Good Windows / Total Windows
</span></span></code></pre></div><p>这种方法能降低短暂流量尖峰对整体 SLI 的影响。</p>
<p><em>关键词</em></p>
<ul>
<li><strong>Good Signal</strong>：满足成功条件的数据。</li>
<li><strong>Total Signal</strong>：参与统计的全部数据。</li>
<li><strong>Request-based</strong>：以请求为基本统计单位。</li>
<li><strong>Window-based</strong>：以时间窗口为基本统计单位。</li>
<li><strong>Threshold（阈值）</strong>：用于判断结果是否合格的界限值。</li>
</ul>
<hr>
<p><strong>4. Signal 如何定义</strong></p>
<p>真正创建 SLI 时，需要指定 Azure Monitor 应该使用哪些 Metrics，并通过过滤、聚合和公式定义成功条件。</p>
<table>
	<thead>
			<tr>
					<th>方法</th>
					<th>通俗解释</th>
					<th>例子</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Metric</td>
					<td>选择真正要统计的数据</td>
					<td>请求数、错误数、响应时间</td>
			</tr>
			<tr>
					<td>Filter</td>
					<td>只保留符合条件的数据</td>
					<td>只统计 HTTP 200</td>
			</tr>
			<tr>
					<td>Temporal Aggregation</td>
					<td>把一段时间内的数据进行汇总</td>
					<td>Average、Maximum、Count</td>
			</tr>
			<tr>
					<td>Spatial Aggregation</td>
					<td>把多个时间序列进一步合并</td>
					<td>把多个实例的数据汇总成服务整体</td>
			</tr>
			<tr>
					<td>Formula</td>
					<td>用多个指标计算出新信号</td>
					<td>成功请求数 ÷ 总请求数</td>
			</tr>
	</tbody>
</table>
<p><em>关键词</em></p>
<ul>
<li><strong>Metric（指标）</strong>：系统持续产生的数值，例如请求数、CPU、延迟。</li>
<li><strong>Filter（过滤）</strong>：从所有数据中筛选出需要的数据。</li>
<li><strong>Temporal Aggregation（时间聚合）</strong>：对一段时间内的数据进行平均、求最大值或计数。</li>
<li><strong>Spatial Aggregation（空间聚合）</strong>：把来自多个实例、区域或时间序列的数据合并。</li>
<li><strong>Formula（公式）</strong>：通过一个或多个指标计算出最终信号。</li>
</ul>
<hr>
<p><strong>5. SLI 与 SLO 的关系</strong></p>
<p>SLI 是实际测量值，Baseline Target 是 SLI 应达到的目标，也就是 SLO。例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>SLI：
</span></span><span style="display:flex;"><span>过去 30 天请求成功率 = 99.92%
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>SLO：
</span></span><span style="display:flex;"><span>请求成功率 &gt;= 99.9%
</span></span></code></pre></div><p>此时实际值高于目标：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>99.92% &gt; 99.9%
</span></span><span style="display:flex;"><span>→ 达到 SLO
</span></span></code></pre></div><p>如果实际值低于目标：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>SLI = 99.7%
</span></span><span style="display:flex;"><span>SLO = 99.9%
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>→ 未达到 SLO
</span></span></code></pre></div><p>可以把 SLI 理解为实际成绩，把 SLO 理解为目标分数。</p>
<hr>
<p><strong>6. Error Budget</strong></p>
<p>Azure Monitor 根据 SLO 计算 Error Budget，公式为：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Error Budget = 100% - SLO
</span></span></code></pre></div><p>SLO 为 99.9% 时：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>SLO = 99.9%
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Error Budget
</span></span><span style="display:flex;"><span>= 100% - 99.9%
</span></span><span style="display:flex;"><span>= 0.1%
</span></span></code></pre></div><p>这表示服务在当前统计周期内最多可以承受 0.1% 的不可靠性。</p>
<table>
	<thead>
			<tr>
					<th>概念</th>
					<th>通俗解释</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>SLO</td>
					<td>你要求系统达到的可靠性</td>
			</tr>
			<tr>
					<td>Error Budget</td>
					<td>在不违反 SLO 的前提下，还允许出多少问题</td>
			</tr>
	</tbody>
</table>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>SLO：99.9%
</span></span><span style="display:flex;"><span>允许失败：0.1%
</span></span></code></pre></div><p>当 SLO 为 99.9% 时，剩余的 0.1% 就是可以被故障、发布风险或其他异常消耗的预算。</p>
<hr>
<p><strong>7. Burn Rate</strong></p>
<p>Burn Rate 表示 Error Budget 的消耗速度。Azure Monitor 不只关心预算还剩多少，也会判断当前消耗速度是否会使预算很快耗尽。例如，初始 Error Budget 为 0.1%：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Error Budget = 0.1%
</span></span></code></pre></div><p>如果统计刚开始不久就出现以下情况：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>已经消耗 0.08%
</span></span></code></pre></div><p>即使服务暂时没有违反 SLO，预算也消耗得过快，Burn Rate 可以提前反映这种风险。</p>
<p><strong>Fast Burn</strong></p>
<p>Fast Burn 指 Error Budget 在短时间内快速消耗，通常意味着突然发生严重故障或版本回退，例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>刚发布新版本
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>大量 500 错误
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>10 分钟消耗掉大量 Error Budget
</span></span></code></pre></div><p><strong>Slow Burn</strong></p>
<p>Slow Burn 的消耗速度较慢，但持续时间很长，例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>每天都有少量请求失败
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>问题持续几个星期
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>最终仍然可能耗尽 Error Budget
</span></span></code></pre></div><p><em>关键词</em></p>
<ul>
<li><strong>Error Budget</strong>：允许的不可靠性额度。</li>
<li><strong>Burn Rate</strong>：Error Budget 的消耗速度。</li>
<li><strong>Fast Burn</strong>：短时间内快速消耗预算。</li>
<li><strong>Slow Burn</strong>：长期持续消耗预算。</li>
</ul>
<p>Error Budget 反映还剩多少容错空间，Burn Rate 反映这部分空间消耗得有多快。</p>
<hr>
<p><strong>8. Alert</strong></p>
<p>Azure Monitor 可以针对 SLI 配置不同类型的告警：</p>
<table>
	<thead>
			<tr>
					<th>告警类型</th>
					<th>通俗解释</th>
					<th>用途</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Baseline Alert</td>
					<td>SLI 已经低于 SLO</td>
					<td>告诉你服务已经不达标</td>
			</tr>
			<tr>
					<td>Fast Burn Rate Alert</td>
					<td>Error Budget 正在被快速消耗</td>
					<td>提前发现突然恶化的问题</td>
			</tr>
			<tr>
					<td>Slow Burn Rate Alert</td>
					<td>Error Budget 长时间持续被消耗</td>
					<td>发现长期的小问题</td>
			</tr>
	</tbody>
</table>
<p>三类告警关注的阶段不同：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Baseline Alert：
</span></span><span style="display:flex;"><span>“你已经不及格了。”
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Fast Burn：
</span></span><span style="display:flex;"><span>“照这个速度下去，很快就会不及格。”
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Slow Burn：
</span></span><span style="display:flex;"><span>“问题虽然不严重，但一直这样迟早会不及格。”
</span></span></code></pre></div><p>Burn Rate 告警能够在 SLO 真正被突破前发出预警，因此比只等待基线告警更早暴露风险。</p>
<hr>
<h3 id="整体流程">整体流程<a href="#%e6%95%b4%e4%bd%93%e6%b5%81%e7%a8%8b" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Azure Monitor 中创建和使用 SLI 的流程如下：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>确定要监控哪个服务
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>选择 SLI 类型
</span></span><span style="display:flex;"><span>Availability / Latency
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>选择评估方式
</span></span><span style="display:flex;"><span>Request-based / Window-based
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>选择 Metrics
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>通过 Filter / Aggregation / Formula
</span></span><span style="display:flex;"><span>定义什么算 Good
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>计算 SLI
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>设置 SLO
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>计算 Error Budget
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>持续观察 Burn Rate
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>配置告警
</span></span></code></pre></div><p>各概念之间的关系如下：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>SLI
</span></span><span style="display:flex;"><span>实际表现
</span></span><span style="display:flex;"><span>   ↓
</span></span><span style="display:flex;"><span>与 SLO 比较
</span></span><span style="display:flex;"><span>   ↓
</span></span><span style="display:flex;"><span>SLO
</span></span><span style="display:flex;"><span>目标表现
</span></span><span style="display:flex;"><span>   ↓
</span></span><span style="display:flex;"><span>100% - SLO
</span></span><span style="display:flex;"><span>   ↓
</span></span><span style="display:flex;"><span>Error Budget
</span></span><span style="display:flex;"><span>允许失败多少
</span></span><span style="display:flex;"><span>   ↓
</span></span><span style="display:flex;"><span>Burn Rate
</span></span><span style="display:flex;"><span>失败额度消耗多快
</span></span></code></pre></div><p>SLI 描述系统的实际表现，SLO 规定目标水平，Error Budget 表示还能容忍多少失败，Burn Rate 则反映这部分额度的消耗速度。</p>
]]></content></item><item><title>School of SRE</title><link>https://blog.hieros.me/zh/posts/sre/</link><pubDate>Thu, 17 Sep 2026 23:00:00 +0800</pubDate><author>BLESS</author><guid>https://blog.hieros.me/zh/posts/sre/</guid><description>SRE学习与翻译</description><content type="text/html" mode="escaped"><![CDATA[<p>最近在准备工作相关的，感觉 SRE 是个重要方向，所以开始看 Linkedin 的 SRE 教程，纯英，看的有点吃力，所以一边看一边写笔记缓解一下。这份笔记是我的个人评论和部分原文的 GPT5.6 sol翻译的结合，主要融入了一些我查阅的关于教程中我不理解的地方的信息，当否供参考。Linkedin 的 SRE 教程原链接 <a href="https://linkedin.github.io/school-of-sre/" target="_blank" >https://linkedin.github.io/school-of-sre/</a>，此份文档遵循CC BY-NC-SA 4.0 协议。</p>
<h1 id="school-of-sre">School of SRE<a href="#school-of-sre" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h1>
<p>站点可靠性工程师（Site Reliability Engineer，SRE）处于软件工程与系统工程的交叉领域。虽然基础设施和软件组件的组合方式几乎是无限的，不同组件可以通过各种排列组合来实现特定目标，但只要掌握扎实的基础技能，SRE 就能够应对复杂的系统和软件，不必过分依赖具体技术环境——无论这些系统是企业自研的、第三方提供的、开放式系统，还是运行在云端或本地基础设施上。关键是要深入理解系统与基础设施中各个领域之间是如何相互关联、相互作用的。兼具软件工程和系统工程能力的人才相对少见，这类能力通常需要经过较长时间的积累，并通过接触各种不同类型的基础设施、系统和软件逐渐形成。</p>
<p>SRE 会将工程化实践引入系统运维工作，以确保网站和服务能够持续稳定运行。每一个分布式系统本质上都是由大量组件组合而成的。SRE 需要验证业务需求，并将这些需求转化为针对分布式系统各个组成部分的服务等级协议（Service Level Agreement，SLA）；持续监控和衡量系统是否满足这些 SLA。当系统存在违反 SLA 的风险时，SRE 会通过重新设计系统架构、横向扩展等方式进行缓解或避免。与此同时，SRE 还会把这些实践中获得的经验反馈到新的系统或项目中，从而减少日常运维中重复、繁琐的人工工作（operational toil）。因此，在系统设计之初（day 0），SRE 就发挥着非常重要的作用。</p>
<p>我们相信，持续学习能够帮助大家获得更深入的知识和能力，从而不断扩展自己的技能体系。因此，每个模块中都加入了相关参考资料，可作为进一步学习的指南。我们希望，通过学习这些模块，大家能够逐步具备一名 SRE 所必需的核心技能。</p>
<h1 id="level-101">Level 101<a href="#level-101" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h1>
<blockquote>
<p>101 是美国大学课程编号里的习惯用法，通常代表某领域的基础课，201 301 401依次进阶。后文的 102 通常是 101 下一门课的编号。</p>
</blockquote>
<p><strong>什么是 Linux 操作系统</strong></p>
<p>我们大多数人都比较熟悉 Windows 操作系统。在个人电脑中，Windows 的使用比例超过 75%。Windows 操作系统基于 Windows NT 内核。</p>
<p>所谓<strong>内核（kernel）</strong>，是操作系统中最重要的组成部分。它负责执行很多核心功能，例如进程管理、内存管理、文件系统管理等。</p>
<p>Linux 操作系统则基于 Linux 内核。一个基于 Linux 的操作系统通常包括 Linux 内核、GUI/CLI、系统库以及系统工具。Linux 内核最初由 Linus Torvalds 独立开发并发布。Linux 内核是自由且开源的软件。</p>
<p>Linux 本身严格来说只是一个<strong>内核</strong>，并不是一个完整的操作系统。Linux 内核通常会与 GNU 系统结合，组成一个完整的操作系统。因此，基于 Linux 的操作系统也常被称为 <strong>GNU/Linux 系统</strong>。</p>
<p>GNU 是一个非常庞大的自由软件集合，其中包括编译器、调试器、C 语言库等工具和组件。</p>
<p>关于 Linux 与 GNU 系统之间的关系，可以参考：
<a href="https://www.gnu.org/gnu/linux-and-gnu.en.html" target="_blank" >Linux and the GNU System</a></p>
<p>关于 Linux 的发展历史，可以参考：
<a href="https://en.wikipedia.org/wiki/History_of_Linux" target="_blank" >History of Linux</a></p>
<p><strong>什么是常见的 Linux 发行版</strong></p>
<p>Linux 发行版（Linux distribution，简称 <strong>distro</strong>）是基于 Linux 内核，并配套了一套软件包管理系统的操作系统。</p>
<p>所谓<strong>软件包管理系统（package management system）</strong>，是由一组用于安装、升级、配置和卸载操作系统中软件的工具组成的。</p>
<p>软件通常需要针对不同的 Linux 发行版进行适配，并被打包成该发行版所采用的特定格式。这些软件包一般会存放在对应发行版的软件仓库（repository）中。</p>
<p>在操作系统中，用户通过**软件包管理器（package manager）**来安装和管理这些软件包。</p>
<p>常见的 Linux 发行版包括：</p>
<ul>
<li>Fedora</li>
<li>Ubuntu</li>
<li>Debian</li>
<li>CentOS</li>
<li>Red Hat Enterprise Linux（RHEL）</li>
<li>SUSE</li>
<li>Arch Linux</li>
</ul>
<p>不同发行版通常采用不同的软件包格式和软件包管理器：</p>
<table>
	<thead>
			<tr>
					<th>软件包体系</th>
					<th>常见发行版</th>
					<th>软件包管理器</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Debian 系（<code>.deb</code>）</td>
					<td>Debian、Ubuntu</td>
					<td>APT</td>
			</tr>
			<tr>
					<td>Red Hat 系（<code>.rpm</code>）</td>
					<td>Fedora、CentOS、Red Hat Enterprise Linux</td>
					<td>YUM</td>
			</tr>
	</tbody>
</table>
<blockquote>
<p>以上内容已经老了，2019 年 YUM 底层就彻底被 DNF 替代了，近几年 Nix 也火了：</p>
<table>
	<thead>
			<tr>
					<th>软件包体系</th>
					<th>常见发行版</th>
					<th>软件包管理器</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Debian 系（<code>.deb</code>）</td>
					<td>Debian、Ubuntu</td>
					<td>APT</td>
			</tr>
			<tr>
					<td>Red Hat 系（<code>.rpm</code>）</td>
					<td>Fedora、CentOS Stream、Red Hat Enterprise Linux</td>
					<td>DNF</td>
			</tr>
			<tr>
					<td>SUSE 系（<code>.rpm</code>）</td>
					<td>openSUSE、SUSE Linux Enterprise</td>
					<td>Zypper</td>
			</tr>
			<tr>
					<td>Arch 系（<code>.pkg.tar.zst</code>）</td>
					<td>Arch Linux、Manjaro</td>
					<td>Pacman</td>
			</tr>
			<tr>
					<td>Nix 系</td>
					<td>NixOS</td>
					<td>Nix</td>
			</tr>
	</tbody>
</table>
</blockquote>
<p><strong>Linux 架构</strong></p>
<img src="../../SRE/linux_arch.png" alt="Linux 架构" style="width:60%">
<blockquote>
<p>图中用户空间运行普通程序，例如 ls。大多数应用程序都运行在这一层，它们通常会依赖 glibc 或其他用户态库提供的接口。程序需要内核服务时，会通过系统调用接口发起请求，此时 CPU 从用户态切换到内核态，由内核中的不同子系统处理相应功能。进程管理负责进程的创建、调度和结束；内存管理负责虚拟内存、内存分配和页表等；虚拟文件系统 VFS 负责统一抽象不同文件系统；网络子系统负责 TCP/IP、socket 等网络功能；进程间通信 IPC 负责不同进程之间的数据交换。设备驱动则负责内核与具体硬件之间的通信，最终完成硬件操作。</p>
</blockquote>
<ul>
<li>Linux 内核本质上采用**宏内核（Monolithic Kernel）**架构。</li>
</ul>
<blockquote>
<p>宏内核是指大多数核心功能（文件系统、驱动等）都直接放到内核里运行的架构，区别于微内核——只保留核心功能。</p>
</blockquote>
<ul>
<li>内核代码只能在<strong>内核态（Kernel Mode）<strong>下执行；非内核代码通常运行在</strong>用户态（User Mode）</strong>。</li>
</ul>
<blockquote>
<p>用户态是供普通程序运行的低权限 CPU 执行模式，不能直接访问内核内存和随意操作硬件，内核态则是高权限 CPU 执行模式，可以访问系统全部内存和硬件资源。这里的权限指的是执行时 CPU 有多高的硬件权限，和操作系统的访问控制规则不同层级。</p>
</blockquote>
<ul>
<li>用户空间程序通过**系统调用（System Call）**与 Linux 内核空间进行交互。</li>
</ul>
<blockquote>
<p>系统调用运行在用户态的程序，为了请求操作系统内核提供某项受保护的服务，而通过规定接口主动切换到内核态执行的一种机制。用户态的程序像读写文件，建立网络连接都得请求内核服务，发生从用户态-&gt;内核态-&gt;用户态的切换。</p>
</blockquote>
<ul>
<li>**设备驱动（Device Driver）**用于与硬件设备进行通信。</li>
</ul>
<p><strong>Linux 操作系统的用途</strong></p>
<p>基于 Linux 内核的操作系统被广泛应用于：个人电脑，服务器，手机：Android 基于 Linux 内核；嵌入式设备：如手表、电视、交通信号灯等；卫星，网络设备：如路由器、交换机等。</p>
<p><strong>图形用户界面（GUI）与命令行界面（CLI）</strong></p>
<p>用户借助用户界面（User Interface）与计算机进行交互。用户界面可以是 GUI（Graph User Interface），也可以是 CLI（Command Line Interface）。</p>
<p>GUI 允许用户通过图标、图像等图形元素与计算机进行交互。当用户点击某个图标来打开计算机上的应用程序时，实际上就是在使用 GUI。使用 GUI 执行任务通常比较容易。</p>
<p>CLI 允许用户通过命令与计算机进行交互。用户在终端中输入命令，系统负责执行这些命令。对于习惯使用 GUI 的新用户来说，CLI 可能会比较难，因为用户需要知道执行某项具体操作所对应的命令。</p>
<p><strong>Shell 与终端</strong></p>
<p>Shell 是一种程序，它接收用户输入的命令，并将这些命令交给操作系统处理。Shell 是 CLI 的一种实现。Bash 是 Linux 服务器上最常见的 Shell 程序之一。其他常见的 Shell 程序还有 zsh、ksh、tcsh、fish、dash、nushell等等。</p>
<p>终端（Terminal）是一种程序，它会打开一个窗口，并允许你与 Shell 进行交互。常见的终端程序包括 GNOME Terminal、xterm、Konsole、Kitty等。</p>
<p>Linux 用户经常会将 shell、终端、命令提示符、控制台等术语混用。简单来说，这些术语都可以用来指代一种接收用户命令的方式。</p>
<h4 id="命令行基础">命令行基础<a href="#%e5%91%bd%e4%bb%a4%e8%a1%8c%e5%9f%ba%e7%a1%80" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h4>
<p><strong>命令是什么</strong></p>
<p>命令（command）是一个告诉操作系统执行某项特定工作的程序。在 Linux 中，程序以文件的形式存储。因此，一个命令本质上也是一个存放在磁盘某处的文件。</p>
<blockquote>
<p>大多数常见 Linux 命令，本质上都是用户空间程序（还有一些 Shell 内置命令），并不是 Linux 内核的一部分，因此理论上可以不安装。下面这些命令只是大多数发行版通常会预装的工具。</p>
</blockquote>
<p>命令还可以接收用户提供的额外参数作为输入，这些参数称为命令行参数（command-line arguments）。</p>
<p>了解如何使用命令很重要，而 Linux 提供了很多获取帮助的方法，尤其是针对各种命令。几乎每个命令都会提供某种形式的文档。大多数命令都支持 -h 或 &ndash;help 这样的命令行参数，用来显示一定量的帮助信息。</p>
<p>不过，Linux 中最常用的文档系统是 man pages，也就是 manual pages（手册页） 的简称。</p>
<p><strong>文件系统组织方式</strong></p>
<p>Linux 文件系统采用树状结构，其最高层级的目录称为根目录（root directory），用 <code>/</code> 表示。根目录下包含多个目录，用于存放与系统相关的文件。这些目录中又可以继续存放系统文件、应用程序文件或与用户相关的文件。</p>
<img src="../../SRE/file_org.png" alt="file_org" style="width: 80%">
<div class="info-table-wrap directory-table-wrap">
  <table class="info-table directory-table">
    <thead>
      <tr>
        <th scope="col">目录</th>
        <th scope="col">英文来源</th>
        <th scope="col">说明</th>
      </tr>
    </thead>
    <tbody>
      <tr><td><code>/bin</code></td><td>binary</td><td>存放最常用命令的可执行程序</td></tr>
      <tr><td><code>/dev</code></td><td>device</td><td>存放与系统设备相关的文件</td></tr>
      <tr><td><code>/etc</code></td><td>et cetera</td><td>存放系统配置文件</td></tr>
      <tr><td><code>/home</code></td><td>home</td><td>存放普通用户的文件和目录</td></tr>
      <tr><td><code>/lib</code></td><td>library</td><td>存放系统所需的库文件</td></tr>
      <tr><td><code>/mnt</code></td><td>mount</td><td>通常用于挂载设备或文件系统</td></tr>
      <tr><td><code>/proc</code></td><td>process</td><td>存放与当前运行进程和内核状态相关的虚拟文件</td></tr>
      <tr><td><code>/root</code></td><td>root</td><td>root 用户的主目录</td></tr>
      <tr><td><code>/sbin</code></td><td>system binary</td><td>存放系统管理相关的程序</td></tr>
      <tr><td><code>/tmp</code></td><td>temporary</td><td>存放临时文件</td></tr>
      <tr><td><code>/usr</code></td><td>user（历史名称）</td><td>存放大量用户空间程序、库和相关文件</td></tr>
    </tbody>
  </table>
</div>
<p><strong>用于查看文件的命令</strong></p>
<p>有五个经常用于查看文件内容的基本命令：cat、head、tail、more、less</p>
<p>我们将创建一个名为 <code>numbers.txt</code> 的新文件，并在这个文件中写入从 1 到 100 的数字。每个数字单独占一行。</p>
<img src="../../SRE/seq1.png" alt="seq1">
<p>现在不必担心上面的命令。它是一个用于生成数字的高级命令。之后，我们又使用了一个重定向操作符，将这些数字写入文件中。我们将在后面的章节中讨论 I/O 重定向。</p>
<p><em>cat</em>(concatenate)</p>
<p><code>cat</code> 命令最简单的用途，是将文件内容打印到输出屏幕上。这个命令非常有用，还可以用于许多其他用途。我们会在后面学习它的其他用法。</p>
<img src="../../SRE/cat.png" alt="cat">
<p>你可以尝试运行上面的命令，你会看到从 1 到 100 的数字被打印到屏幕上。你需要向上滚动，才能查看所有数字。</p>
<p><em>head</em></p>
<p><code>head</code> 命令默认显示文件的前 10 行。我们可以加入额外参数，以显示从文件开头算起的任意行数。</p>
<p>在这个例子中，当我们使用 <code>head</code> 命令时，只能看到文件的前 10 行。</p>
<img src="../../SRE/head1.png" alt="head1">
<p>默认情况下，<code>head</code> 命令只会显示前 10 行。如果我们想指定从文件开头查看多少行，可以使用 <code>-n</code> 参数来提供这个数值。</p>
<img src="../../SRE/head2.png" alt="head2">
<p><em>tail</em></p>
<p><code>tail</code> 命令默认显示文件的最后 10 行。我们可以加入额外参数，以显示从文件末尾算起的任意行数。</p>
<img src="../../SRE/tail1.png" alt="tail1">
<p>默认情况下，<code>tail</code> 命令只会显示最后 10 行。如果我们想指定从文件末尾查看多少行，可以使用 <code>-n</code> 参数来提供这个数值。</p>
<img src="../../SRE/tail2.png" alt="tail2">
<p>在这个例子中，当我们显式使用 <code>-n</code> 选项配合 <code>tail</code> 命令时，只能看到文件的最后 5 行。</p>
<p><em>more</em></p>
<p><code>more</code> 命令用于显示文件内容或命令输出。当文件很大时，例如日志文件，它会一次显示一个屏幕的内容。它也支持向前导航，以及有限的向后导航。</p>
<blockquote>
<p><code>more</code> 就是前面提到的分页显示工具的一种</p>
</blockquote>
<img src="../../SRE/more.png" alt="more">
<p><code>more</code> 命令会显示当前屏幕能够容纳的尽可能多的内容，然后等待用户输入以继续。可以按 <code>Enter</code> 键向前移动一行，也可以按 <code>Space</code> 键向前移动一个屏幕。</p>
<p><em>less</em></p>
<p><code>less</code> 命令是 <code>more</code> 的改进版本。它用于显示文件内容或命令输出，并且一次显示一页。</p>
<p>它既支持向后导航，也支持向前导航，还提供搜索功能。我们可以使用方向键每次向前或向后移动一行。要向前移动一页，可以按 <code>Space</code>；要向后移动一页，可以按键盘上的 <code>b</code>。</p>
<p>你还可以立即跳转到文件的开头或结尾。</p>
<p><strong>文本处理命令</strong></p>
<p>在上一节中，我们学习了如何查看文件内容。在很多情况下，我们会希望执行以下操作：</p>
<ul>
<li>只打印包含某个特定单词的行</li>
<li>将文件中的某个特定单词替换为另一个单词</li>
<li>按照特定顺序对各行进行排序</li>
</ul>
<p>有三个经常用于处理文本的基本命令：<code>grep</code>，<code>sed</code>，<code>sort</code></p>
<p>我们将创建一个名为 <code>numbers.txt</code> 的新文件，并在该文件中写入从 1 到 10 的数字。每个数字单独占一行。</p>
<img src="../../SRE/seq2.png" alt="seq2">
<p><em>grep</em>(global regular expression print)</p>
<p><code>grep</code> 命令最简单的用途，是在文本文件中搜索特定单词。它会显示文件中所有包含特定输入内容的行。</p>
<p>我们想要搜索的单词会作为输入提供给 <code>grep</code> 命令。</p>
<p>使用 <code>grep</code> 命令的一般语法：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-shell" data-lang="shell"><span style="display:flex;"><span>grep &lt;word_to_search&gt; &lt;file_name&gt;
</span></span></code></pre></div><p>在这个例子中，我们尝试在这个文件中搜索字符串 <code>&quot;1&quot;</code>。<code>grep</code> 命令会输出找到这个字符串的那些行。</p>
<img src="../../SRE/grep.png" alt="grep">
<p><em>sed</em>(stream editor)</p>
<p><code>sed</code> 命令最简单的用途，是替换文件中的文本。</p>
<p>使用 <code>sed</code> 命令进行替换的一般语法：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-shell" data-lang="shell"><span style="display:flex;"><span>sed <span style="color:#e6db74">&#39;s/&lt;text_to_replace&gt;/&lt;replacement_text&gt;/&#39;</span> &lt;file_name&gt;
</span></span></code></pre></div><p>下面我们尝试使用 <code>sed</code> 命令，将文件中每次出现的 <code>&quot;1&quot;</code> 替换为 <code>&quot;3&quot;</code>。</p>
<img src="../../SRE/sed.png" alt="sed">
<p>在上面的例子中，文件本身的内容不会发生改变。</p>
<p>如果要让修改直接写回文件，我们必须额外使用 <code>-i</code> 参数，这样修改才会反映到原文件中。</p>
<p><em>sort</em></p>
<p><code>sort</code> 命令可以对作为参数提供给它的输入进行排序。默认情况下，它会按照升序进行排序。</p>
<p>在尝试排序之前，我们先查看一下文件内容。</p>
<img src="../../SRE/sort1.png" alt="sort1">
<p>现在，我们将尝试使用 <code>sort</code> 命令对文件进行排序。<code>sort</code> 命令按照字典序进行排序。</p>
<blockquote>
<p><code>sort</code> 默认进行的是“字符串排序”，不是“数学上的数字升序排序”。默认认为每行都是字符串然后依次比较每个字符的大小按ASCII码的顺序。</p>
</blockquote>
<img src="../../SRE/sort2.png" alt="sort2">
<p>在上面的例子中，文件本身的内容不会发生改变。</p>
<p><strong>I/O 重定向</strong></p>
<p>每个打开的文件都会被分配一个文件描述符（file descriptor）。文件描述符是系统中用于标识打开文件的唯一标识符。系统始终默认打开三个文件：</p>
<blockquote>
<p>程序每打开一个文件或输入输出通道，系统都会给它一个数字编号。这个数字编号叫文件描述符。程序启动时，默认已经有 0、1、2 三个文件描述符。</p>
</blockquote>
<ul>
<li><code>stdin</code> — standard input，标准输入，这里通常指键盘</li>
<li><code>stdout</code> — standard output，标准输出，这里通常指屏幕</li>
<li><code>stderr</code> — standard error，标准错误，即输出到屏幕上的错误信息</li>
</ul>
<p>这些文件都可以被重定向。</p>
<p>Linux 中“一切皆文件”（Everything is a file）：</p>
<p><a href="https://unix.stackexchange.com/questions/225537/everything-is-a-file" target="_blank" >https://unix.stackexchange.com/questions/225537/everything-is-a-file</a></p>
<blockquote>
<p>Linux 将普通文件、目录、设备、终端、管道等资源统一抽象为“文件”，程序可以通过类似的读写接口访问它们。很多操作都可以被抽象成对广义文件的<code>open</code>，<code>read</code>，<code>write</code>，<code>close</code>。前文的<code>stdin</code>，<code>stdout</code>，<code>stderr</code>就被抽象为文件。</p>
</blockquote>
<p>到目前为止，我们一直把所有输出显示在屏幕上，而屏幕就是标准输出。我们可以使用一些特殊操作符，将命令的输出重定向到文件中，甚至将其重定向成其他命令的输入。I/O 重定向是一项非常强大的功能。</p>
<p>在下面的例子中，我们使用 <code>&gt;</code> 操作符，将 <code>ls</code> 命令的输出重定向到 <code>output.txt</code> 文件中。</p>
<img src="../../SRE/io1.png" alt="io1">
<p>在下面的例子中，我们将 <code>echo</code> 命令的输出重定向到了一个文件中。</p>
<img src="../../SRE/io2.png" alt="io2">
<p>我们也可以将一个命令的输出重定向为另一个命令的输入。</p>
<p>这可以借助管道（pipe）来实现。</p>
<p>在下面的例子中，我们使用管道操作符 <code>|</code>，把 <code>cat</code> 命令的输出作为输入传递给 <code>grep</code> 命令。</p>
<img src="../../SRE/io3.png" alt="io3">
<p><em>uniq</em>(unique)</p>
<p>在下面的例子中，我们使用管道操作符 <code>|</code>，把 <code>sort</code> 命令的输出作为输入传递给 <code>uniq</code> 命令。</p>
<p><code>uniq</code> 命令只会打印输入中的唯一数字。</p>
<img src="../../SRE/io4.png" alt="io4">
<p>I/O 重定向： <a href="https://tldp.org/LDP/abs/html/io-redirection.html" target="_blank" >https://tldp.org/LDP/abs/html/io-redirection.html</a></p>
<h4 id="linux-服务器管理">Linux 服务器管理<a href="#linux-%e6%9c%8d%e5%8a%a1%e5%99%a8%e7%ae%a1%e7%90%86" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h4>
<p><strong>多用户操作系统</strong></p>
<p>如果一个操作系统允许多个用户使用同一台计算机，并且不会相互影响彼此的文件和个人设置，那么这个操作系统就可以被称为多用户操作系统。</p>
<p>基于 Linux 的操作系统本质上就是多用户操作系统，因为它允许多个用户同时访问系统。一台典型的计算机通常只有一个键盘和一台显示器，但如果计算机连接到了网络，多个用户就可以通过 SSH 登录到这台计算机。我们会在后面进一步介绍 SSH。</p>
<p>作为服务器管理员，我们大多数时候需要管理的 Linux 服务器，在物理位置上都距离我们非常远。我们可以借助 SSH 这类远程登录方式连接到这些服务器。</p>
<p>由于 Linux 支持多个用户，因此我们需要一种机制来让不同用户彼此隔离并受到保护。一个用户不应该能够访问或修改其他用户的文件。</p>
<p><strong>用户/用户组管理</strong></p>
<p>Linux 中的每个用户都有一个与之关联的用户 ID，称为 UID（User ID，用户标识符）。每个用户还会关联一个主目录（home directory）和一个登录 Shell（login shell）。**用户组（group）**是一个或多个用户的集合。通过用户组，可以更方便地为一组用户共享和管理权限。每个用户组都有一个与之关联的组 ID，称为 GID（Group ID，组标识符）。</p>
<p><em>id</em></p>
<p>id 命令可以用来查看与某个用户关联的 UID 和 GID。它还会列出该用户所属的用户组。</p>
<p>与 root 用户关联的 UID 和 GID 都是 0。</p>
<p>在 Linux 中，查看当前用户是谁，一个很方便的方法是使用 whoami 命令。</p>
<p>root 用户，也称为超级用户（superuser），是系统中权限最高的用户，可以不受限制地访问系统中的所有资源。它的 UID 为 0。</p>
<p><strong>与用户/用户组相关的重要文件</strong></p>
<div class="info-table-wrap account-files-table-wrap">
  <table class="info-table account-files-table">
    <thead>
      <tr>
        <th scope="col">文件</th>
        <th scope="col">作用</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><code>/etc/passwd</code></td>
        <td>记录用户名、<code>UID</code>、<code>GID</code>、主目录和登录 Shell 等账户信息</td>
      </tr>
      <tr>
        <td><code>/etc/shadow</code></td>
        <td>存储用户密码的哈希值及密码有效期等安全信息</td>
      </tr>
      <tr>
        <td><code>/etc/group</code></td>
        <td>记录用户组名称、<code>GID</code>及组成员信息</td>
      </tr>
    </tbody>
  </table>
</div>
<p>进一步理解 linux 的权限机制可以参考下面的链接：</p>
<p><a href="https://tldp.org/LDP/lame/LAME/linux-admin-made-easy/shadow-file-formats.html" target="_blank" >https://tldp.org/LDP/lame/LAME/linux-admin-made-easy/shadow-file-formats.html</a>
<a href="https://tldp.org/HOWTO/User-Authentication-HOWTO/x71.html" target="_blank" >https://tldp.org/HOWTO/User-Authentication-HOWTO/x71.html</a></p>
<p><strong>管理用户的重要命令</strong></p>
<p>Linux 中经常用于管理用户/用户组的一些命令如下：</p>
<ul>
<li><code>useradd</code> — <strong>user add</strong>，创建一个新用户</li>
<li><code>passwd</code> — <strong>password</strong>，为用户添加或修改密码</li>
<li><code>usermod</code> — <strong>user modify</strong>，修改用户属性</li>
<li><code>userdel</code> — <strong>user delete</strong>，删除用户</li>
</ul>
<p><em>useradd</em>(user add)</p>
<p><code>useradd</code> 命令用于在 Linux 中添加一个新用户。</p>
<p>我们将创建一个新用户 <code>shivam</code>。然后通过查看 <code>/etc/passwd</code> 文件的末尾内容，验证该用户是否已经成功创建。</p>
<p>新创建用户的 <code>UID</code> 和 <code>GID</code> 都是 <code>1000</code>。分配给该用户的主目录（home directory）是 <code>/home/shivam</code>，登录 Shell（login shell）是 <code>/bin/bash</code>。</p>
<p>需要注意的是，用户的主目录和登录 Shell 之后都可以修改。</p>
<img src="../../SRE/useradd1.png" alt="useradd1">
<p>如果我们没有为主目录或登录 Shell 等属性指定任何值，系统就会为用户分配默认值。</p>
<p>在创建新用户时，我们也可以覆盖这些默认值，手动指定相应属性。</p>
<img src="../../SRE/useradd2.png" alt="useradd2">
<p><em>passwd</em>(password)</p>
<p><code>passwd</code> 命令用于为用户创建或修改密码。</p>
<p>在上面的例子中，我们创建用户 <code>shivam</code> 和 <code>amit</code> 时，都没有为他们设置密码。</p>
<p>在 <code>/etc/shadow</code> 中，如果一个账户对应的字段中出现 <code>!!</code>，表示该用户账户已经创建，但尚未设置密码。</p>
<img src="../../SRE/passwd1.png" alt="passwd1">
<p>现在我们尝试为用户 <code>shivam</code> 创建一个密码。</p>
<img src="../../SRE/passwd2.png" alt="passwd2">
<p>请记住这个密码，因为在后面的示例中我们还会用到它。</p>
<p>另外，现在我们也来修改 <code>root</code> 用户的密码。</p>
<p>当我们从普通用户切换到 <code>root</code> 用户时，系统会要求输入密码。同样，当你直接使用 <code>root</code> 用户登录时，也会要求输入密码。</p>
<img src="../../SRE/passwd3.png" alt="passwd3">
<blockquote>
<p>图上密码强度检验工具的字典不存在所以报错，正常情况下不会报这种错。</p>
</blockquote>
<p><em>usermod</em>(user modify)</p>
<p><code>usermod</code> 命令用于修改用户的属性，例如主目录或 Shell。</p>
<p>下面我们尝试把用户 <code>amit</code> 的登录 Shell 修改为 <code>/bin/bash</code>。</p>
<img src="../../SRE/usermod.png" alt="usermod">
<p>类似地，你还可以修改用户的许多其他属性。</p>
<p>可以运行：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-shell" data-lang="shell"><span style="display:flex;"><span>usermod -h
</span></span></code></pre></div><p>查看可以修改的属性列表。</p>
<p><em>userdel</em>(user delete)</p>
<p><code>userdel</code> 命令用于删除 Linux 中的用户。</p>
<p>删除一个用户后，与该用户相关的信息也会被删除。</p>
<p>下面我们尝试删除用户 <code>amit</code>。删除之后，你将无法再在 <code>/etc/passwd</code> 或 <code>/etc/shadow</code> 文件中找到该用户对应的条目。</p>
<img src="../../SRE/userdel.png" alt="userdel">
<p><strong>管理用户组的重要命令</strong></p>
<p>用于管理用户组的命令，与用于管理用户的命令非常相似。由于这些命令的用法比较接近，这里不再逐一详细解释。你可以尝试在自己的系统上运行这些命令。</p>
<table>
	<thead>
			<tr>
					<th>命令</th>
					<th>说明</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td><code>groupadd &lt;group_name&gt;</code></td>
					<td><strong>group add</strong>，创建一个新用户组</td>
			</tr>
			<tr>
					<td><code>groupmod &lt;group_name&gt;</code></td>
					<td><strong>group modify</strong>，修改用户组的属性</td>
			</tr>
			<tr>
					<td><code>groupdel &lt;group_name&gt;</code></td>
					<td><strong>group delete</strong>，删除一个用户组</td>
			</tr>
			<tr>
					<td><code>gpasswd &lt;group_name&gt;</code></td>
					<td><strong>group password</strong>，修改用户组密码</td>
			</tr>
	</tbody>
</table>
<blockquote>
<p><code>groupmod</code> 一般用于改用户组名和 GID
用户组密码用的很少了，有<code>newgrp</code>命令可以临时将用户添加入该组，此时需要输入组密码。</p>
</blockquote>
<img src="../../SRE/groupadd.png" alt="groupadd">
<p>现在，我们将尝试把用户 <code>shivam</code> 添加到上面创建的用户组中。</p>
<img src="../../SRE/groups.png" alt="groups">
<p><strong>成为超级用户</strong></p>
<p><strong>在运行下面这些命令之前，请确保你已经按照上一节介绍的方法，使用 <code>passwd</code> 命令为用户 <code>shivam</code> 和用户 <code>root</code> 设置了密码。</strong></p>
<p><code>su</code>(switch user) 命令可以用于在 Linux 中切换用户。现在我们尝试切换到用户 <code>shivam</code>。</p>
<img src="../../SRE/su1.png" alt="su1">
<p>现在我们尝试打开 <code>/etc/shadow</code> 文件。</p>
<img src="../../SRE/su2.png" alt="su2">
<p>操作系统不允许用户 <code>shivam</code> 读取 <code>/etc/shadow</code> 文件的内容。这个文件在 Linux 中非常重要，用于存储用户密码相关的信息。只有 <code>root</code> 用户或具有超级用户权限的用户才能访问这个文件。</p>
<p><strong><code>sudo</code> 命令允许用户以 <code>root</code> 用户的安全权限来运行命令。</strong></p>
<p>请记住，<code>root</code> 用户拥有系统上的全部权限。</p>
<p>我们也可以使用 <code>su</code> 命令切换到 <code>root</code> 用户，然后再打开上面的文件，但这样做需要输入 <code>root</code> 用户的密码。</p>
<p>在大多数现代操作系统中，更常见也更推荐的另一种方式，是使用 <code>sudo</code>(superuser do/substitute user do) 命令来获得超级用户权限。采用这种方式时，用户通常需要输入自己的密码，并且需要属于拥有 <code>sudo</code> 权限的用户组。</p>
<p><strong>如何给其他用户提供超级用户权限？</strong></p>
<p>我们先使用 <code>su</code> 命令切换到 <code>root</code> 用户。需要注意的是，执行下面的命令时需要输入 <code>root</code> 用户的密码。</p>
<img src="../../SRE/su3.png" alt="su3">
<p>如果你忘了给 <code>root</code> 用户设置密码，可以输入<code>exit</code></p>
<p>这样你就会返回之前的 <code>root</code> 用户环境。然后使用 <code>passwd</code> 命令设置密码。</p>
<p><strong><code>/etc/sudoers</code> 文件用于保存哪些用户可以调用 <code>sudo</code>，以及相关的权限规则。</strong></p>
<p>在 Red Hat 系列操作系统中，这个文件所依赖的 <code>sudo</code> 工具在某些精简环境里可能默认没有安装，因此需要先安装 <code>sudo</code>。</p>
<p>尝试打开系统中的 <code>/etc/sudoers</code> 文件。这个文件包含很多信息，用来保存用户运行 <code>sudo</code> 命令时必须遵循的规则。</p>
<p>例如，<code>root</code> 用户被允许在任何地方运行任何命令。</p>
<img src="../../SRE/root.png" alt="root">
<p>一种比较简单的给用户提供 <code>root</code> 权限的方法，是把用户加入一个被允许执行所有命令的用户组。</p>
<p>在 Red Hat Linux 中，<code>wheel</code> 就是这样一个常见的特权用户组。</p>
<img src="../../SRE/wheel.png" alt="wheel">
<blockquote>
<p>这里的 <code>%wheel ALL=(ALL) ALL</code> 的意思是 <code>wheel</code> 这个组中的用户可以使用 <code>sudo</code> 命令临时用任何用户身份做任何事。所以 <code>sudo</code> 也可以被理解成 substitute user do —— 用另一个用户身份代替当前用户去执行命令。不加 <code>-u</code> 参数时，默认使用 <code>root</code> 用户。</p>
</blockquote>
<p>现在我们把用户 <code>shivam</code> 加入这个组，这样它也可以获得 <code>sudo</code> 权限。</p>
<img src="../../SRE/sudo.png" alt="sudo">
<p>现在我们切换回用户 <code>shivam</code>，再次尝试访问 <code>/etc/shadow</code> 文件。</p>
<img src="../../SRE/sudo2.png" alt="sudo2">
<p>由于这个文件只能由具有相应高权限的用户访问，因此我们需要在命令前加上 <code>sudo</code>。</p>
<p>我们之前已经把用户 <code>shivam</code> 加入了 <code>wheel</code> 组，因此它已经获得了使用 <code>sudo</code> 的权限。</p>
<blockquote>
<p><code>sudo</code> 的验证逻辑是先判断当前用户是不是本人，然后再按照权限组规则开发对应替代用户的权限，所以 <code>sudo</code> 时输入的是当前用户的密码。而 <code>su</code> 则是输入目标用户的密码。</p>
</blockquote>
]]></content></item><item><title>Windows 软件管理方案分享</title><link>https://blog.hieros.me/zh/posts/package-managers/</link><pubDate>Wed, 03 Jun 2026 12:00:00 +0800</pubDate><author>BLESS</author><guid>https://blog.hieros.me/zh/posts/package-managers/</guid><description>聊聊本机的 Windows 软件管理思路，八个包管理器各司其职，再加上游戏平台和兜底目录</description><content type="text/html" mode="escaped"><![CDATA[<h1 id="windows-软件管理方案分享">Windows 软件管理方案分享<a href="#windows-%e8%bd%af%e4%bb%b6%e7%ae%a1%e7%90%86%e6%96%b9%e6%a1%88%e5%88%86%e4%ba%ab" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h1>
<p>最近整理了一下 <code>updateall.ps1</code>，发现本机跑着八个包管理器，趁机把整体的软件管理思路梳理一下，不只是开发工具，也包括游戏和其他日常软件，免得以后搞混了装到错地方。</p>
<hr>
<h2 id="系统级">系统级<a href="#%e7%b3%bb%e7%bb%9f%e7%ba%a7" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<h3 id="scoop">Scoop<a href="#scoop" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>用了很久，体验最好的 Windows 包管理器，主要覆盖跨平台的命令行工具和开发工具链。最满意的地方是软件源的质量，很多在 Linux 上用惯的工具在 Scoop 里都能直接装到，比如 helix、yazi、git、btop、fzf、ripgrep、eza、zoxide、fd、jq……现在本机装了七十多个包，日常用到的命令行工具基本都在这里。</p>
<p>所有东西装在 <code>~/scoop/apps/</code>，完全不需要管理员权限，用 shims 挂到 PATH，卸载也干净，不会留下注册表残留。<code>nerd-fonts</code> bucket 管字体也很方便，FiraCode NF 和 Sarasa Gothic 都是从这里装的。</p>
<p>另外 winget 在 Windows 10 的低版本上可能没有预装，这时候可以直接用 Scoop 来装或者更新 winget 本身，算是 Scoop 作为基础设施的一个体现。</p>
<p>因为很多工具本身也是通过 Scoop 装的，所以更新脚本里 Scoop 必须单独跑在最前面，等它完成之后再并行更新其他东西。</p>
<h3 id="winget">winget<a href="#winget" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>微软官方出的，侧重于专供 Windows 的桌面应用和商业软件，这类东西在 Scoop 里基本找不到。包库来自 winget-pkgs 社区仓库，走官方渠道相对可信。</p>
<p><code>winget upgrade --all</code> 是我觉得最实用的功能，系统里装的软件一条命令全部更新，比手动挨个去官网下安装包省心太多。还有 <code>winget export</code> 可以导出当前安装的所有软件列表，换新机的时候 <code>winget import</code> 一次性恢复，算是一个不错的迁移方案。</p>
<p>分工上比较清晰：命令行开发工具走 Scoop，Windows 桌面应用走 winget，两者重叠的情况不多。</p>
<h3 id="chocolatey">Chocolatey<a href="#chocolatey" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>本机的 Chocolatey 是通过 winget 装的，包库是三个里最大的，但维护质量参差不齐，而且基本都需要管理员权限。目前实际只用它装了一个东西：MSVC，Scoop 和 winget 都没收录，choco 的 <code>visualstudio2022buildtools</code> 包正好能覆盖这个需求。说白了就是为了这一个用途存在的。</p>
<h3 id="msys2">MSYS2<a href="#msys2" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>性质上和上面三个不太一样，MSYS2 提供的是一套完整的类 Unix 环境，内置 pacman 包管理器。在 Windows 上编译 C/C++ 项目或者需要 gcc、make、cmake 这类 GNU 工具的时候，MSYS2 是绕不开的选择。Git for Windows 底层用的也是这套环境。</p>
<p>更新时有个小细节，pacman 需要跑两遍：第一遍 <code>-Syyu</code> 强制刷新数据库同时升级 pacman 自身，第二遍 <code>-Syu</code> 才升级其余包。跑一遍有时候会漏掉东西，这个是 pacman 的设计，不是 bug。</p>
<p>MSYS2 提供了 MSYS2、MinGW-w64、UCRT64 几套不同的子系统，底层 ABI 不一样，和 Windows 原生工具链的互操作性也有区别，具体选哪个看项目需求，一般来说现代项目推荐 UCRT64。</p>
<h3 id="游戏平台">游戏平台<a href="#%e6%b8%b8%e6%88%8f%e5%b9%b3%e5%8f%b0" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>游戏统一交给官方平台管理：Steam、Epic、GOG、Battle.net，各家自己维护更新，不走任何包管理器。这类软件本来就是平台强绑定的，没必要强行纳入 Scoop 或 winget 管理，官方渠道反而最省心。</p>
<h3 id="兜底固定安装目录">兜底：固定安装目录<a href="#%e5%85%9c%e5%ba%95%e5%9b%ba%e5%ae%9a%e5%ae%89%e8%a3%85%e7%9b%ae%e5%bd%95" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>不在以上任何包管理器覆盖范围内的软件，统一安装到一个固定目录。这样不管过了多久，想找某个软件装在哪直接去那个目录翻，不用靠记忆，也不会在 C 盘到处散落。</p>
<hr>
<h2 id="python">Python<a href="#python" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<h3 id="uv">uv<a href="#uv" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Rust 写的，速度比 pip 快 10-100 倍，本机所有 Python 项目现在全走 uv 管理。之前同时在用 pip、venv、pyenv、pipx，现在一个 uv 全替代了，少维护好几套工具。</p>
<p><code>uv run</code> 是我觉得体验提升最大的地方，不需要先 <code>source .venv/bin/activate</code> 激活虚拟环境，直接 <code>uv run python script.py</code> 就能在正确的环境里运行，少了很多上下文切换的心智负担。</p>
<p><code>uv tool</code> 这个子命令值得单独说一下。有一类 Python 工具，官方文档推荐的安装方式是 <code>pip install</code>，但它们又不属于某个具体项目的依赖，需要全局可用——Scoop 里能找到的（比如 ruff）还是走 Scoop，但 Scoop 没有收录的就用 <code>uv tool install</code> 来管。</p>
<p>每个工具装在各自独立的虚拟环境里，入口暴露到 PATH，依赖完全隔离，不会互相污染，也不会搅乱项目环境。这和直接 <code>pip install --user</code> 装到全局 site-packages 的区别很大，后者各工具依赖混在一起，迟早出冲突。</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>uv tool install &lt;package&gt;     <span style="color:#75715e"># 安装</span>
</span></span><span style="display:flex;"><span>uv tool upgrade --all         <span style="color:#75715e"># 一次性升级所有工具</span>
</span></span><span style="display:flex;"><span>uv tool list                  <span style="color:#75715e"># 查看已安装的工具</span>
</span></span></code></pre></div><hr>
<h2 id="多语言运行时">多语言运行时<a href="#%e5%a4%9a%e8%af%ad%e8%a8%80%e8%bf%90%e8%a1%8c%e6%97%b6" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<h3 id="mise">mise<a href="#mise" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>mise 是运行时版本管理器，asdf 的 Rust 重写，原来叫 rtx。理论上能管很多语言的运行时，但本机实际上只用它做一件事：管理 Node.js 版本和全局 npm 包。Python 那边完全交给 uv，不需要 mise 插手。</p>
<p>最省心的地方是 shell hook，进入项目目录会自动读 <code>.mise.toml</code> 切换到对应 Node.js 版本，不需要手动激活。全局 npm 包（比如一些前端 CLI 工具）也通过 mise 统一管理，<code>mise upgrade</code> 一起更新。</p>
<hr>
<h2 id="latex">LaTeX<a href="#latex" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<h3 id="miktex">MiKTeX<a href="#miktex" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>MiKTeX 是 Windows 上最常用的 LaTeX 发行版，包管理走内置的 <code>mpm</code>（MiKTeX Package Manager）。它的按需安装设计我挺喜欢：第一次编译遇到缺失宏包会自动下载，不需要提前把几个 GB 的包全装上，初装体积小很多。</p>
<p>批量更新用 <code>miktex packages update</code>，也有 MiKTeX Console 这个 GUI 工具，但我基本只在命令行里操作。</p>
<hr>
<h2 id="rust-工具链">Rust 工具链<a href="#rust-%e5%b7%a5%e5%85%b7%e9%93%be" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<h3 id="rustup">rustup<a href="#rustup" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Rust 官方的工具链管理器，安装和更新 Rust 本身就靠它，没有替代品。<code>rustup update</code> 把所有已安装的 toolchain 更新到最新，非常简单。</p>
<p>rustup 还管 stable/beta/nightly 多版本并存，通过项目根目录的 <code>rust-toolchain.toml</code> 可以声明这个项目用哪个 channel，进去就自动切换，和 mise 的设计思路类似。跨平台编译也靠 <code>rustup target add</code> 来管理 target。</p>
<hr>
<h2 id="小结">小结<a href="#%e5%b0%8f%e7%bb%93" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>八个工具，一张表理清楚：</p>
<table>
	<thead>
			<tr>
					<th>包管理器</th>
					<th>覆盖范围</th>
					<th>更新命令</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Scoop</td>
					<td>Windows CLI 工具</td>
					<td><code>scoop update *</code></td>
			</tr>
			<tr>
					<td>winget</td>
					<td>Windows 桌面软件</td>
					<td><code>winget upgrade --all</code></td>
			</tr>
			<tr>
					<td>Chocolatey</td>
					<td>老旧/企业 Windows 软件</td>
					<td><code>sudo choco upgrade all -y</code></td>
			</tr>
			<tr>
					<td>MSYS2 / pacman</td>
					<td>Unix 工具链、MinGW 编译器</td>
					<td><code>pacman -Syyu &amp;&amp; pacman -Syu</code></td>
			</tr>
			<tr>
					<td>uv</td>
					<td>Python 项目/工具/解释器</td>
					<td><code>uv tool upgrade --all</code></td>
			</tr>
			<tr>
					<td>mise</td>
					<td>Node.js 版本 + 全局 npm 包</td>
					<td><code>mise upgrade</code></td>
			</tr>
			<tr>
					<td>MiKTeX / mpm</td>
					<td>LaTeX 宏包</td>
					<td><code>miktex packages update</code></td>
			</tr>
			<tr>
					<td>rustup</td>
					<td>Rust 工具链</td>
					<td><code>rustup update</code></td>
			</tr>
	</tbody>
</table>
<p><code>updateall.ps1</code> 里 Scoop 单独串行跑完，其余七个并行，整体更新一次大概几分钟，比以前挨个手动执行省了不少时间。</p>
]]></content></item><item><title>RAD2阅读</title><link>https://blog.hieros.me/zh/posts/rad2/</link><pubDate>Fri, 01 May 2026 21:00:00 +0800</pubDate><author>BLESS</author><guid>https://blog.hieros.me/zh/posts/rad2/</guid><description>自驾相关的新颖RL算法阅读</description><content type="text/html" mode="escaped"><![CDATA[<h1 id="rad2阅读">RAD2阅读<a href="#rad2%e9%98%85%e8%af%bb" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h1>
<p><strong>RAD (Reinforcement Learning for Autonomous Driving)</strong> 系列工作聚焦于自动驾驶中的运动规划，目标是解决强化学习在闭环驾驶中的两大痛点：一是因果混淆，即模型无法确定哪些动作导致了好的结果；二是开环差距，即训练是开环的，不考虑动作执行后的环境反馈，而实际部署是闭环的，导致分布偏移和累计误差。RAD 选择直接构建大规模的 3DGS 闭环仿真环境，用强化学习训练端到端驾驶策略（实际训练时先用模仿学习预训练，再用 RL 精调）。首个用 3DGS 环境的端对端自动驾驶策略训练算法，吃到了 3DGS 的红利。</p>
<p>而2026年4月，华中科大和地平线机器人合作，推出了RAD-2，主要想法是将扩散模型和强化学习结合，而且做了实际场景验证，可以说是又一重大提升，思路值得学习，本文选择转述原文。</p>
<p>原论文： <a href="https://arxiv.org/abs/2604.15308" target="_blank" >https://arxiv.org/abs/2604.15308</a></p>
<p>原项目： <a href="https://hgao-cv.github.io/RAD-2" target="_blank" >https://hgao-cv.github.io/RAD-2</a></p>
<h2 id="介绍">介绍<a href="#%e4%bb%8b%e7%bb%8d" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>现有的轨迹规划器，包括基于回归的（神经网络直接输出一条轨迹，这条轨迹往往是可能轨迹的平均值，抹平了多模态行为，安全性较差），基于选择的（预生成多条候选轨迹，然后打分排序选择一个最优的，能力取决于候选集的质量，能力有限）等等，总的来说存在多模态表征能力差的局限，而扩散模型作为生成式模型，基于模仿学习训练的扩散模型能很好的对多模态连续轨迹进行建模。</p>
<p>但是真实数据集包含噪声，分布不均匀，导致扩散模型偶尔输出低质量不稳定的轨迹，安全性较差，并且由于轨迹是高维数据，学习难度也很高。而模仿学习本身无法提供负反馈抑制不切实际的行为，由于 IL 的缺陷，模型学到的是状态与动作之间的相关性，而不是真正的因果关系，导致出现捷径行为。同时，开环训练范式与实际驾驶的闭环特性不匹配。</p>
<p>现有的将RL与IL结合的思路（直接用RL信号优化扩散模型）存在严重信用分配问题，结果不稳定。仿真选择也存在诸多局限，不真实，价格高，长时域多视角表现差等等。</p>
<p>所以为了解决这些问题，作者提出了一种统一架构扩展RL训练规模，将生成器-判别器设计与可扩展的仿真环境结合，生成器-判别器设计可以认为是分割了任务，扩散模型只要输出多样化的轨迹即可，而判别器则只选择最优的，这减轻了优化扩散模型的负担，降低了学习难度，增强了学习效率。</p>
<p>为了在线时能同时优化生成器和判别器，作者提出了同策略生成器优化算法，对于判别器提供的反馈，生成器仅针对纵向分量（车速、油门、刹车等）进行优化，这部分优化难度更低，不会把生成器学崩，而判别器则全优化，这样的设计能在RL训练时生成器与判别器同时学习进一步提高了效率，只要调整生成器生成的轨迹个数即可鼓励判别器进一步寻优，不是固定参数，可以在不同场景选择不同的性能，不需要重训练。</p>
<p>自动驾驶任务是典型的稀疏奖励任务，为了解决稀疏奖励任务中严重的信用分配问题，作者还提出了时间一致性的采样与优化方式，轨迹采集时锁存执行，强制固定周期内复用选定的轨迹，确保行为的连贯性，然后候选轨迹就可以在持久的行为背景下评估，有效去噪。</p>
<h2 id="方法">方法<a href="#%e6%96%b9%e6%b3%95" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<h3 id="生成器-判别器架构">生成器-判别器架构<a href="#%e7%94%9f%e6%88%90%e5%99%a8-%e5%88%a4%e5%88%ab%e5%99%a8%e6%9e%b6%e6%9e%84" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>作者将轨迹规划解耦为两个组件：一个基于扩散模型的<strong>生成器</strong>，负责生成多样化的候选轨迹集合；以及一个<strong>判别器</strong>，负责对候选轨迹进行评估和重排序。二者共同定义了一个结构化的策略，使得生成与评估能够联合优化。</p>
<h4 id="基于扩散模型的生成器">基于扩散模型的生成器<a href="#%e5%9f%ba%e4%ba%8e%e6%89%a9%e6%95%a3%e6%a8%a1%e5%9e%8b%e7%9a%84%e7%94%9f%e6%88%90%e5%99%a8" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h4>
<p>生成器建模未来轨迹的多模态分布，根据当前观测 \(o_t\) 生成一组候选轨迹，形式化表示为 \(G_\theta(\tau | o_t)\)。</p>
<p><strong>场景编码：</strong> 观测 \(o_t\) 首先被编码为BEV特征 \(T_b\)，以捕获场景的空间布局。从该表征中提取静态场景元素（如车道几何、道路边界及其他地图结构）和动态智能体（如周围车辆和行人及其运动状态），实现对环境的全面感知。令 \(X_{\text{map}}\)、\(X_{\text{agent}}\) 和 \(X_{\text{nav}}\) 分别表示预测的静态地图元素、动态智能体以及给定的导航输入（如航路点或参考路径）。随后通过轻量级编码器获得token嵌入：</p>
$$
T_m = E_m(X_{\text{map}}), \quad T_a = E_a(X_{\text{agent}}), \quad T_n = E_n(X_{\text{nav}}).
$$<p>这些嵌入通过可学习模块 \(F(\cdot)\) 与 \(T_b\) 融合，得到统一的场景嵌入：</p>
$$
E_{\text{scene}} = F(T_b, T_m, T_a, T_n),
$$<p>该场景嵌入通过交叉注意力机制为基于DiT的轨迹生成器提供条件输入。</p>
<p><strong>轨迹生成。</strong> 对于 \(M\) 个独立的模式，初始噪声轨迹 \(\tau^{(0,m)} \sim \mathcal{N}(0, I)\) 经过 \(K\) 步迭代去噪：</p>
$$
\tau^{(k,m)} = G\!\left(\tau^{(k-1,m)}, E_{\text{scene}}, k\right), \quad k = 1, \ldots, K,
$$<p>其中 \(G\) 表示条件去噪网络，根据当前噪声样本 \(\tau^{(k-1,m)}\)、场景嵌入 \(E_{\text{scene}}\) 以及当前步数 \(k\) 进行去噪，逐步将噪声轨迹推向更清晰的轨迹分布。最终的候选轨迹集合为：</p>
$$
\mathcal{T}_b = \left\{\hat{\tau}^m_{t:t+H}\right\}_{m=1}^{M}, \quad \hat{\tau}^m_{t:t+H} = \tau^{(K,m)} \sim G_\theta(\tau | o_t), 
$$<p>其中 \(\hat{\tau}^m_{t:t+H}\) 是规划时域 \(H\) 内的连续 \((x, y)\) 轨迹。这些轨迹构成了策略的候选集，并传递给判别器进行评估与选择。</p>
<h4 id="基于rl的判别器">基于RL的判别器<a href="#%e5%9f%ba%e4%ba%8erl%e7%9a%84%e5%88%a4%e5%88%ab%e5%99%a8" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h4>
<p>判别器依据当前场景对候选轨迹的预期效果进行评估，在候选集中产生偏好排序。</p>
<p><strong>轨迹编码：</strong> 轨迹中的每个点通过共享MLP进行嵌入，得到嵌入序列 \(\{e_i\}_{i=1}^{H}\)。在该序列前拼接一个可学习的 [CLS] token，然后送入 Transformer 编码器。[CLS] 的输出聚合了整条轨迹的信息，作为轨迹级查询 \(Q_\tau\)。</p>
<p><strong>场景条件化：</strong> 判别器使用与生成器相同的输入 \(X_{\text{map}}\) 和 \(X_{\text{agent}}\) 构建场景表征，判别器只需关注安全性，因此未引入导航点。其静态和动态编码器 \(E_m^*\) 和 \(E_a^*\) 与生成器对应的编码器 \(E_m\) 和 \(E_a\) 共享相同架构，但维护独立的参数：</p>
$$
T_m^* = E_m^*(X_{\text{map}}), \quad T_a^* = E_a^*(X_{\text{agent}}). 
$$<p><strong>轨迹-场景交互。</strong> 轨迹查询 \(Q_\tau\) 通过交叉注意力 \(\Psi(Q, KV)\) 聚合多源场景上下文：</p>
$$
O_m = \Psi(Q_\tau, T_m^*), \quad O_b = \Psi(Q_\tau, T_b), \quad O_a = \Psi(Q_\tau, T_a^*),
$$<p>
</p>
$$
T_{a \cap m} = \Psi(T_a^*, T_m^*), \quad O_{a \cap m} = \Psi(Q_\tau, T_{a \cap m}). 
$$<p>上述嵌入经拼接后过MLP，得到融合表征：</p>
$$
E_{\text{fusion}} = \Phi([O_m; O_b; O_a; O_{a \cap m}]), 
$$<p>其中 \(\Phi(\cdot)\) 表示拼接后接一个MLP，\(O_m\) 表示生成轨迹与预测静态地图嵌入交互，\(O_b\) 表示生成轨迹与实际观测嵌入交互，\(O_a\) 表示与预测动态智能体嵌入交互，\(T_{a \cap m}\) 表示预测静态地图与动态智能体之间的交互，刻画二者间的潜在关系并表征可能的未来冲突，\(O_{a \cap m}\) 表示生成轨迹与 \( T_{a \cap m} \) 的交互。各分支嵌入最终融合为统一的轨迹-场景交互表征。</p>
<p><strong>轨迹打分与重排序。</strong> 对于每个候选轨迹 \(\hat{\tau}_{t:t+H} \in \mathcal{T}_b\)，判别器通过sigmoid激活函数 \(\sigma\) 作用于融合表征，产生一个标量分数：</p>
$$
s(\hat{\tau}_{t:t+H}) = \sigma(E_{\text{fusion}}) \in [0, 1]. 
$$<p>理论上可对候选集上的分数做归一化，得到轨迹上的概率分布以供重排序；实际实现中直接以sigmoid输出作为优先级排序依据。</p>
<h3 id="闭环仿真环境与控制器">闭环仿真环境与控制器<a href="#%e9%97%ad%e7%8e%af%e4%bb%bf%e7%9c%9f%e7%8e%af%e5%a2%83%e4%b8%8e%e6%8e%a7%e5%88%b6%e5%99%a8" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>所提出的策略在高效的BEV-Warp环境中进行评估——通过对BEV特征进行变换实现高通量交互。此外，在基于3D高斯泼溅（3DGS）构建的环境中也进行了验证，以检验策略在不同场景表征下的泛化能力。</p>
<p><strong>BEV-Warp环境。</strong> BEV-Warp通过直接在时间维度上操控BEV特征来构建仿真环境，绕过了冗余的图像级渲染。仿真从记录的真实世界序列初始化，包括多视角观测、自车轨迹和场景上下文。</p>
<p>对于每个仿真步 \(t\)，系统提取BEV特征 \(B_t^{\text{ref}}\) 并加载记录的位姿 \(P_t \in SE(2)\) 作为状态。规划器生成候选轨迹 \(\mathcal{T}_b\)，从中选择最优轨迹 \(\hat{\tau}^*\) 并进行跟踪，以更新智能体的仿真位姿 \(P_{t+1}\)。</p>
<p>如图3所示，为了将记录的环境与仿真自车状态重新对齐，我们推导出一个变换矩阵 \(M_{t+1} = (P_{t+1})^{-1} P_{t+1}^{\text{ref}} \in \mathbb{R}^{3 \times 3}\)。假设高度恒定且忽略旋转（即俯仰和翻滚），下一时间步的合成特征通过以下方式获得：</p>
$$
B_{t+1} = \mathcal{W}(B_{t+1}^{\text{ref}}, M_{t+1}), 
$$<p>其中 \(\mathcal{W}(\cdot)\) 通过双线性插值实现。该合成表征与 \(P_{t+1}\) 一起，为闭环评估提供了连续的交互。具体地，闭环仿真在每个时刻 \(t\) 按如下流程驱动：首先，系统根据当前自车位姿 \(P_t\) 获取环境表征 \(B_t\)；随后规划器基于该表征生成候选轨迹集合 \(\mathcal{T}_b\)；判别器从中选出最优轨迹 \(\hat{\tau}^*\)；控制器跟踪该轨迹，产生油门、转向等控制指令，并将自车位姿更新至 \(P_{t+1}\)；最后，系统以 \(P_{t+1}\) 重新生成对应视角下的环境表征，进入下一时刻。整个过程以固定的频率循环迭代，构成闭环。</p>
<p><strong>3DGS环境。</strong> 为了确保不同场景表征下性能的一致性，策略还在通过3D高斯泼溅构建的逼真仿真世界中进行进一步验证。与特征级变换不同，这种方法根据智能体当前位姿 \(P_t\) 从场景 \(\mathcal{G}\) 直接渲染原始多视角观测 \(o_t\)：\(o_t = \mathcal{R}(\mathcal{G}, P_t)\)，其中 \(\mathcal{R}(\cdot)\) 是可微分渲染算子。这构成了一组显式图像级渲染下的测试，用以验证策略的鲁棒性。</p>
<p><strong>基于轨迹的控制器。</strong> 两个环境均采用基于iLQR的控制器来跟踪规划轨迹 \(\hat{\tau}^*\)。给定非线性车辆动力学，\(x_{k+1} = f(x_k, u_k)\)（如运动学自行车模型），控制器在时域 \(H\) 上最小化二次代价函数：</p>
$$
u_{t:t+H}^* = \arg\min \sum_{k=t}^{t+H} \|x_k - \hat{x}_k^{\text{ref}}\|_Q^2 + \|u_k\|_R^2, 
$$<p>其中 \(\hat{x}_k^{\text{ref}}\) 是由 \(\hat{\tau}^*\) 导出的参考状态。iLQR算法通过对 \(f(\cdot)\) 的局部线性化和代价的二次近似来迭代优化控制序列。其中，第一个最优控制指令 \(u_t^*\) 被施加以更新车辆状态，产生新的自车位姿 \(P_{t+1}\) 用于后续仿真步。</p>
<h3 id="联合策略优化">联合策略优化<a href="#%e8%81%94%e5%90%88%e7%ad%96%e7%95%a5%e4%bc%98%e5%8c%96" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>为了在BEV-Warp环境中优化策略，我们提出了一种联合优化框架，通过结构化迭代流程将扩散生成器 \(G_\theta\) 与RL训练的判别器 \(D_\phi\) 协同起来。全局目标是最小化混合策略（生成器-判别器策略网络） \(\Pi_{\theta,\phi}\) 与理想的、风险中性且高效率的分布 \(\Pi^*\) 之间的KL散度：</p>
$$
\min_{\theta,\phi} D_{\text{KL}}\left(\Pi_{\theta,\phi}(\tau | o) \| \Pi^*(\tau | o)\right). 
$$<p>该目标通过三阶段迭代过程实现：（i）时间一致性的轨迹采集（Sec. 3.3.1），收集稳定的闭环交互数据以锚定探索行为；（ii）判别器优化（Sec. 3.3.2），通过轨迹级RL优化 \(\phi\)，使其习得稀疏奖励规律并提供精确的排序反馈；（iii）生成器优化（Sec. 3.3.3），采用同策略生成器优化（On-policy Generator Optimization）将 \(G_\theta\) 的输出密度向高奖励区域集中——即让生成器更多地产生回报高的轨迹。</p>
<h4 id="时间一致性的轨迹采集">时间一致性的轨迹采集<a href="#%e6%97%b6%e9%97%b4%e4%b8%80%e8%87%b4%e6%80%a7%e7%9a%84%e8%bd%a8%e8%bf%b9%e9%87%87%e9%9b%86" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h4>
<p>规划器在每个时间步可生成多模态轨迹假设，但如果以高频率在不同模式之间频繁切换，将破坏运动意图的连续性，割裂策略决策与长期驾驶结果之间的关联，导致信用分配低效和策略更新不稳定。</p>
<p>为缓解这一问题，作者引入了轨迹复用机制以维持短期行为一致性。一旦在时刻 \(t\) 选定最优轨迹 \(\hat{\tau}_t^*\)，便按照式(10)的iLQR优化将其转化为控制序列 \(u_{t:t+H}^*\)。策略不在下一步立即重新规划，而是在固定的执行时域 \(H_{\text{reuse}} < H\) 内依次复用这些预计算的控制指令 \(u_{t+h}^*\)，使车辆状态沿所承诺的轨迹一致演化。\(H_{\text{reuse}}\) 作为固定超参数控制复用长度，同时该机制原生支持在安全约束被违反时异步终止，不影响智能体对动态环境的应急响应能力。通过稳定探索方向，该机制使累积奖励更准确地反映所选轨迹 \(\hat{\tau}_t^*\) 的质量，从而提升策略梯度的有效性。</p>
<h4 id="通过rl优化判别器">通过RL优化判别器<a href="#%e9%80%9a%e8%bf%87rl%e4%bc%98%e5%8c%96%e5%88%a4%e5%88%ab%e5%99%a8" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h4>
<p>为了引导判别器捕获长时域驾驶语义，我们建立了多目标奖励函数评估闭环结果，并通过时间一致性的分组相对策略优化（TC-GRPO）框架来优化策略。</p>
<p><strong>奖励建模。</strong> 强化学习环境建立在一系列长时长片段之上。在每个片段内，策略 \(\Pi_{\theta,\phi}\) 以闭环方式与环境交互，生成多条轨迹采集结果（rollout）。每条rollout代表一个完整的决策链，我们定义两个互补的奖励来刻画安全性和效率：</p>
<p>（i）<strong>安全性奖励</strong>（\(r_{\text{coll}}\)）：我们通过反事实插值来量化碰撞风险。具体地，在每个仿真步 \(t\)，碰撞时间（Time-To-Collision）\(T_t\) 定义为自车投影占据区域与环境真值状态发生交集的最早时刻：</p>
$$
T_t = \inf\{k \in [0, T_{\max}] \mid B_{\text{ego}}(k; t) \cap V_{\text{env}}(t+k) \neq \emptyset\}, 
$$<p>其中 \(T_{\max}\) 是安全检测阈值，\(B_{\text{ego}}(k; t)\) 表示从步 \(t\) 向前投影 \(k\) 步后自车的占据区域，\(V_{\text{env}}(t+k)\) 表示绝对时间 \(t+k\) 时环境的集体真值占据。如果未检测到交集，\(T_t\) 默认为 \(T_{\max}\)。直白说是从现在开始，最早多少步之后会发生碰撞。序列级奖励则定义为最差时间裕度：</p>
$$
r_{\text{coll}} = \min_{1 \leq t \leq L} (T_t - T_{\max}), 
$$<p>其中 \(L\) 是rollout时域。这种瓶颈式设计确保rollout内任何时刻的安全违规都决定序列级奖励，从而倾向于保守的驾驶策略。</p>
<p>（ii）<strong>导航效率奖励</strong>（\(r_{\text{eff}}\)）：为了同步行驶节奏与专家示范，我们在每条rollout结束时评估序列级自车进度（Ego Progress, EP），记为 \(\rho\)。奖励 \(r_{\text{eff}}\) 被设计为一个稳定性窗口惩罚，将车辆进度锚定在目标效率区间 \([\rho_{\text{low}}, \rho_{\text{high}}]\) 内：</p>
$$
r_{\text{eff}} = \min(\rho - \rho_{\text{low}}, 0) + \min(\rho_{\text{high}} - \rho, 0) + 1, 
$$<p>其中 \(\rho_{\text{low}} = 1.05\) 和 \(\rho_{\text{high}} = 1.10\) 定义了相对于裁剪后专家轨迹的归一化进度边界。该设计将导航效率视为有界同步任务，同时惩罚迟缓的低效表现和过于激进的偏离，以强制执行类人的行驶节奏。</p>
<p>二者共同平衡了闭环驾驶中的安全性和驾驶效率。</p>
<p><strong>优化目标。</strong> 为了解决连续驾驶空间中的信用分配问题，我们提出了时间一致性的分组相对策略优化（TC-GRPO）。该框架针对运动规划的时间依赖性设计了结构化的轨迹采集和奖励分配机制——采样的轨迹假设在短时域内持续执行以确保行为一致性。通过将稀疏环境奖励直接归属于在每个持续执行区间内所维持的特定轨迹假设，该方法防止了强化信号被不同运动意图之间的高频切换所稀释。这种时间对齐有效地去噪了策略梯度，并稳定了生成器-判别器系统的迭代优化。</p>
<p>对于具有序列级奖励 \(r_i\) 的rollout \(\mathcal{O}_i\)，标准化优势 \(A_i\) 相对于从同一初始状态生成的组 \(\{\mathcal{O}_i\}_{i=1}^{G}\) 计算：</p>
$$
A_i = \frac{r_i - \text{mean}(\{r_1, \ldots, r_G\})}{\text{std}(\{r_1, \ldots, r_G\})}. 
$$<p>令 \(K_i\) 为rollout \(\mathcal{O}_i\) 中采样新轨迹 \(\hat{\tau}_{i,t}^*\) 以开始锁存执行区间的时间步集合。这些稀疏决策点上的裁剪目标定义为：</p>
$$
\mathcal{L}_{i,t \in K_i} = \min\left(\rho_{i,t} A_i, \text{clip}(\rho_{i,t}, 1-\varepsilon, 1+\varepsilon) A_i\right), 
$$<p>其中 \(\rho_{i,t} = \frac{D_\phi(\hat{\tau}_{i,t}^* | o_{i,t})}{D_{\phi_{\text{old}}}(\hat{\tau}_{i,t}^* | o_{i,t})}\) 是重要性采样比率。该设计确保优势信号强化的是连贯的轨迹假设，而非缺乏时间一致性的独立动作样本。</p>
<p>为防止过早收敛和sigmoid饱和，引入了基于温度控制的自适应熵正则化机制。具体而言，令 \(H_{i,t}\) 表示第 \(i\) 条rollout在时间步 \(t\) 的策略熵，\(\bar{H}\) 表示其批次平均值。自适应正则化权重基于平均熵计算：</p>
$$
\beta = \exp(\lambda) \cdot \mathbb{1}[\bar{H} < \bar{H}_{\text{target}}], 
$$<p>其中 \(\lambda\) 是可学习的温度参数，\(\bar{H}_{\text{target}}\) 表示目标熵水平。该设计仅在平均熵低于目标时激活熵正则化。温度参数 \(\lambda\) 仅在此类不足条件下通过梯度下降自适应调整。</p>
<p>判别器的RL目标定义为：</p>
$$
\mathcal{J}_{\text{RL}}(\phi) = \mathbb{E}\left[\frac{1}{\sum_{i=1}^{G} |K_i|} \sum_{i=1}^{G} \sum_{t=1}^{|K_i|} \mathcal{L}_{i,t} + \beta H_{i,t}\right]. 
$$<p>通过将自适应熵正则化与 \(\mathcal{L}_{i,t}\) 相结合，判别器确保了在不损害策略稳定性的情况下进行稳定探索。</p>
<p>和GRPO区别不大只是更新仅在下次决策开始前学习一次。</p>
<h4 id="同策略生成器优化">同策略生成器优化<a href="#%e5%90%8c%e7%ad%96%e7%95%a5%e7%94%9f%e6%88%90%e5%99%a8%e4%bc%98%e5%8c%96" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h4>
<p>混合策略 \(\Pi_{\theta,\phi}\) 由生成器 \(G_\theta\) 和判别器 \(D_\phi\) 的组合定义。虽然第3.3.2节优化了 \(D_\phi\) 以进行候选选择，但 \(G_\theta\) 的模式覆盖范围限制了可探索的策略空间。为了扩展这一边界，我们通过同策略生成器优化来优化 \(G_\theta\)，将闭环反馈转化为结构化的纵向优化信号，把生成器的概率质量重新定位到具有有利长期结果的区域。</p>
<p><strong>奖励引导的纵向优化。</strong> 在每个闭环时间步 \(t\)，获得原始的前瞻轨迹片段 \(\tau_t^{\text{raw}} = \{(x_{t+h}, y_{t+h}, v_{t+h}, a_{t+h})\}_{h=0}^{H}\)，覆盖时域 \(H\)。基于闭环反馈，识别潜在的碰撞风险或不足的进度，并相应地优化纵向分量。该过程通过向原始值施加常量偏移（带符号感知处理）并重新积分来调整加速度曲线，产生优化轨迹 \(\tau_t^{\text{opt}}\)，在保持 \(\tau_t^{\text{raw}}\) 空间路径的同时优化其时间推进，以更好地对齐奖励信号。</p>
<p>（i）<strong>安全性驱动的减速：</strong> 当前时间步的碰撞时间 \(T_t\) 低于阈值 \(\gamma_{\text{safe}}\) 时，将时域 \(H\) 内的行驶距离按固定比例 \(\rho \in (0, 1)\) 缩减以施加时间压缩。</p>
<p>（ii）<strong>效率驱动的加速：</strong> 自车落后于参考轨迹（表明进度不足）且瞬时碰撞时间 \(T_t\) 超过安全阈值（即无碰撞风险）时，将时域 \(H\) 内的行驶距离按固定比例 \(\rho' > 1\) 增加以施加时间扩展。</p>
<p>通过将闭环奖励信号转化为结构化优化，该机制使生成器能迭代地将其输出分布转向更安全、更高效的行为。</p>
<p><strong>同策略分布迁移。</strong> 优化后的轨迹片段 \(\tau_t^{\text{opt}}\) 被聚合为同策略数据集 \(\mathcal{D}^{\text{opt}} = \{\tau_t^{\text{opt}}\}\)，通过在预测时域 \(H\) 上的均方误差损失为微调生成器 \(G_\theta\) 提供结构化监督：</p>
$$
\mathcal{L}_{\text{op}}(\theta) = \mathbb{E}_{\tau^{\text{opt}} \sim \mathcal{D}^{\text{opt}}} \left[\sum_{k=0}^{H} \|\hat{\tau}_{t+k} - \tau_{t+k}^{\text{opt}}\|_2^2\right]. 
$$<p>这种分布迁移本质上是渐进且稳定的，因为 \(\mathcal{D}^{\text{opt}}\) 中的目标轨迹是通过同策略交互和维度特定优化构建的。</p>
<p>直说就是，碰撞时间小于阈值时缩短轨迹距离长度（每个轨迹周期总是固定的）以减速避免碰撞；碰撞时间安全时，自车落后于参考轨迹时拉长轨迹距离长度以加速。使用修改后的轨迹作为监督信号训练生成器，所以是纵向的，只加减速，且使用了判别器学习时算出的碰撞时间和参考轨迹等信息。</p>
<h2 id="后续">后续<a href="#%e5%90%8e%e7%bb%ad" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>实验不看，除了原理性思路剩下的就是扒代码了。 <a href="https://hgao-cv.github.io/RAD-2" target="_blank" >https://hgao-cv.github.io/RAD-2</a></p>
]]></content></item><item><title>DiscoRL</title><link>https://blog.hieros.me/zh/posts/discovering/</link><pubDate>Mon, 08 Dec 2025 17:25:00 +0800</pubDate><author>BLESS</author><guid>https://blog.hieros.me/zh/posts/discovering/</guid><description>25年10月15日Nature接受的DeepMind新作</description><content type="text/html" mode="escaped"><![CDATA[<h1 id="discorl">DiscoRL<a href="#discorl" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h1>
<p>DeepMind 最新力作，10月15日 Nature 预印版。</p>
<p>论文地址： <a href="https://www.nature.com/articles/s41586-025-09761-x" target="_blank" >https://www.nature.com/articles/s41586-025-09761-x</a></p>
<h2 id="介绍">介绍<a href="#%e4%bb%8b%e7%bb%8d" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>DeepMind 证明，通过在大量复杂环境中，对智能体的累积经验直接进行元学习，机器能够自己发现一种超越人工设计规则的先进的强化学习算法，这种算法是一个更新智能体策略与预测的强化学习规则，DeepMind 又在 Atari 测试中刷榜了，所以他们认为实现先进人工智能需要的强化学习算法可能很快不依赖于人工设计而是智能体自己发现。总的来说这个看法和 Sutton 的思想一致，可能元强化学习是一个实现先进人工智能的途径。</p>
<p>这种自主发现强化学习规则的方法，依赖于两个重要改进：搜索范围扩大到规则潜空间；在复杂多样的环境进行大规模的学习。</p>
<p>规则潜空间，作者认为强化学习算法的核心是规则，规则向着目标更新一个或者多个预测值或者策略本身，而目标可能是未来奖励，未来预测值等等。在不同目标下的规则有 TD（ \(r+\gamma V(s')\) ），Q-learning（ \(r+\gamma \max_a Q(s',a)\) ），PPO（\(r + \gamma V(s') - V(s)\)），辅助任务（监督学习辅助强化学习训练，但是不直接在更新中，譬如学一个世界模型来预测下个状态等），后继特征（ \(\phi(s_{t+1})+\gamma \Psi(s_{t+1},\pi(s_{t+1}))\) 其中 \(\Psi(s_{t+1},\pi(s_{t+1}))\) 称为后继特征，就是状态特征的累计折扣），分布强化学习（ \(r+\gamma Z(s',a')\) 其中 \(Z(s',a')\) 是回报分布），目标的选择决定了这些目标是价值函数、模型还是后继特征。</p>
<p>在作者的框架中，强化学习规则用一个元网络表示，这个网络直接决定了预测和策略的更新方向，这样系统能够在无需定义目标是什么的情况下自动发现有效的预测机制（选择什么目标）和使用方式（怎么用这个目标更新策略）。理论上这个框架可以发现现有的强化学习规则，但是这样灵活的形式也能让智能体创造出一些全新的强化学习规则，在一些特定环境里这些规则可能会更优秀。</p>
<p>在发现阶段，作者创建了一群智能体，这些智能体在各自独立的环境中进行并行训练，探索哪些强化学习规则更好，环境从多样化且有挑战性的任务集合（环境的差别在于任务不同，初始条件不同，任务参数不同，奖励函数不同）中随机抽取，每个智能体都按照自己的强化学习规则（不同的算法，不同的目标，不同的超参）更新，这些超参数和目标被参数化为一个可微分的强化学习规则，用一个向量表示，使用元梯度逐步改进这个强化学习规则本身。这样就能进化出一个更好的通用强化学习算法。</p>
<p>DeepMind的大规模测试表明，他们用这个元强化学习算法，学出来的称为DiscoRL的强化学习规则，再次在Atari刷榜，而且在没训练过的任务上也有不错的效率和泛化性，如果在发现阶段，再用一些更复杂多样的环境，DiscoRL的性能和泛化水平会进一步提高。</p>
<h2 id="发现方法">发现方法<a href="#%e5%8f%91%e7%8e%b0%e6%96%b9%e6%b3%95" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>发现方法，分为两类优化：智能体优化与元优化。智能体参数通过将其策略和预测更新至强化学习规则生成的目标来优化，强化学习规则的元参数通过更新其目标以最大化智能体的累计奖励来优化。</p>
<h2 id="智能体网络">智能体网络<a href="#%e6%99%ba%e8%83%bd%e4%bd%93%e7%bd%91%e7%bb%9c" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>作者没有人工设计这些更新方式（例如策略梯度）、损失（例如TD误差）、预测（例如价值估计）等等，定义了一个有丰富表达能力的预测空间，这个空间的各个参数的表征义也是由元网络指定的，以元学习的方式让智能体自主优化所需目标，这方法能保持对现有强化学习核心思想的表征能力，也能支持广阔的强化学习规则探索。</p>
<p>由 \(\theta\) 参数化的网络除了输出策略 \(\pi\) 外还输出两类预测：</p>
<ul>
<li>
<p>观测条件向量预测 \(y(s) \in \mathbb{R}^n\)，一个依赖于 \(s\) 的输出用于表征类似于，预测类：例如值函数估计的TD预测和蒙特卡洛预测的输出。（在 Atari 这种图像任务中对原始状态-图像进行特征提取很重要，所以默认提取，提取后的特征向量，认为是一般意义上的状态用 \(s\) 表示，而原始状态命名为观测用 \(o\) 表示）</p>
</li>
<li>
<p>动作条件向量预测 \(z(s,a) \in \mathbb{R}^m\)，一个依赖于 \(s,a\) 的输出用于表征类似于，控制类：例如动作值函数估计的TD控制和蒙特卡洛控制的输出。</p>
</li>
</ul>
<p>后继特征等等也都是依赖于 \(s\) 或者 \(s,a\) 所以这两个向量有极强的普适性。</p>
<p>除了这两种预测，作者还是给智能体加上了一些预定义好的预测减小搜索空间，一个是动作值函数的预测 \(Q(s,a)\)，一个是动作条件辅助策略预测 \(P(s,a)\)（这个预测输出一个概率分布，智能体在 \(s\) 执行了动作 \(a\) 后的未来策略的动作分布 \(P(s,a) \approx \pi(a' \mid s')\)）。</p>
<h2 id="元网络">元网络<a href="#%e5%85%83%e7%bd%91%e7%bb%9c" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>多数现代强化学习都是用前向视角，算法接受从时间步 \(t\) 到 \(t+n\) 未来 \(n\) 步的轨迹信息，利用这些信息更新智能体的预测或者策略，一般是使用自举的目标更新，是对未来预测的目标（例如TD）</p>
<p>作者的强化学习规则，使用一个元网络去决定智能体应该把预测和策略如何移动，在时刻 \(t\) 生成这一次更新的目标，元网络的输入包括：</p>
<ul>
<li>
<p>从 \(t\) 到 \(t+n\) 智能体预测和策略的轨迹</p>
</li>
<li>
<p>从 \(t\) 到 \(t+n\) 的奖励和 episode 结束标志</p>
</li>
</ul>
<p>使用一个标准的 LSTM 网络去处理输入，也可以使用别的架构。</p>
<p>所以元网络和智能体网络不是同步学习的，在智能体网络给出预测后的 \(n\) 步，元网络才收集轨迹进行训练。</p>
<p>这种输入输出的选择保留了强化学习规则的优良特性：</p>
<ul>
<li>
<p>元网络能够处理任意观测值和任意规模的离散动作空间，因为元网络直接以预测信息作为输入从预测中间接获取信息。通过跨动作维度共享的权重处理动作特定的输入与输出（使用特定的头去处理不同动作的输入与输出，隐层不变），能够泛化到完全不同的环境（从极少的动作到极多的动作都可以）。</p>
</li>
<li>
<p>元网络对智能体网络的设计是无感的，因为他只接受智能体的输出，只要智能体网络能生成所需形式的输出 \(\pi, y, z\)，元网络所发现的强化学习规则就可以泛化到任意的智能体架构或者规模。（元网络不挑智能体网络，是什么都行）</p>
</li>
<li>
<p>元网络定义的搜索空间包含了自举法（能学到TD等方法）这一重要的算法思想，因为它的输入是一个未来的轨迹。</p>
</li>
<li>
<p>由于元网络同时处理策略与预测值，他不仅能元学习辅助任务，还能直接利用预测值更新策略（譬如使用优势）</p>
</li>
<li>
<p>输出目标值在表达能力上严格优于输出标量损失函数，因为它将 Q-learning 等半梯度方法也纳入了搜索空间。（由于神经网络的表达能力优势，搜索空间不止包含标量的损失函数，损失函数一定是可导的–标准梯度，也包括半梯度的方法，例如 Q-leaning \(Q_{\text{target}}=r+\gamma \max_a Q(s',a')\) 这样损失不可导的半梯度方法）</p>
</li>
</ul>
<p>在继承了标准强化学习算法的这些特性的基础上，参数丰富的神经网络使所发现的规则能够实现效率更高，情景适应性更强的算法。</p>
<h2 id="智能体优化">智能体优化<a href="#%e6%99%ba%e8%83%bd%e4%bd%93%e4%bc%98%e5%8c%96" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>智能体参数 \(\theta\) 通过最小化预测与策略和元网络生成的目标之间的距离来更新，损失函数可以表示为：</p>
$$\mathcal{L}(\theta) = \mathbb{E}_{s,a,s' \sim \pi_\theta} \big[ D(\hat{\pi}, \pi_\theta(s)) + D(\hat{y}, y_\theta(s)) + D(\hat{z}, z_\theta(s,a)) + \mathcal{L}_{aux} \big]$$<p>其中，\(D(p,q)\) 表示 \(p\) 与 \(q\) 之间的距离函数，作者选择了 KL 散度作为距离函数，具有足够的普适性，且DeepMind团队此前的工作已经证明了 KL 散度是最合适的，相比交叉熵，L2，JS散度而言。算距离前使用 softmax 函数对每个向量进行了归一化处理。</p>
<p>辅助损失 \(\mathcal{L}_{aux}\) 是预定义语义的预测的损失，</p>
$$\mathcal{L}_{aux} = D(\hat{q}, q_\theta(s,a)) + D(\hat{p}, p_\theta(s,a))$$<p>\(\hat{q}\) 是 Retrace 算法的动作值目标，再使用 two-hot 变成类似于 C51 的离散分布，方便计算 KL 散度，\(\hat{p}\) 是单步未来策略，这里的距离也是用 KL 散度。</p>
<hr>
<p>这个 Retrace 是 Q-target 估计器里的 GAE，在 off-policy 的情况下算一个稳健，低方差，几乎无偏的 Q-target</p>
$$\delta_k = r_k + \gamma(1 - d_{k+1}) V(s_{k+1}) - Q(s_k, a_k)$$$$c_k = \lambda \cdot \min\left(1, \frac{\pi(a_k \mid s_k)}{\mu(a_k \mid s_k)}\right) \cdot c_{k+1}$$$$q_k^{ret} = V(s_k) + c_k \big[ Q(s_k, a_k) - V(s_k) + \delta_k \big]$$<p>\(k\) 是时间步，\(\delta_k\) 是 \(V\) 的单步 TD 误差，\(r_k+\gamma(1-d_{k+1})V(s_{k+1})\) 是 \(Q\) 的自举估计值，令 \(Q(s_k,a_k)\) 逼近于目标回报的自举估计。\(d_{k+1}\) 是终止指示器，终止状态没有下一个状态了所以直接用奖励。</p>
<p>\(c_k\) 是截断重要性权重，一个后向递归，将 \(\lambda\) 和截断 IS 权重乘积累计起来，相当于 \(\lambda\) 折扣和裁剪的重要性采样权重，对该步的信任程度考虑后续轨迹。</p>
<p>\(q_k^{ret}\) 是 Retrace 动作值目标，其中 \(V\) 是平均动作 \(Q\) 值，当学习目标不可靠时，\(V\) 值提供一个稳定的基准。\(Q(s_k,a_k)-V(s_k)\) 是优势项，当前动作比平均动作差时减小目标 \(Q\) 值，防止高估；好时防止低估。\(\delta_k\) 就是标准的更新信号，当 \(c_k=1\) 退化成标准的目标 \(Q\) 值。</p>
<h2 id="元优化">元优化<a href="#%e5%85%83%e4%bc%98%e5%8c%96" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>目标是发现一个有元网络和元参数 \(\eta\) 表示的强化学习规则，让智能体最大化在不同训练环境中的奖励，元参数的性能指标和它的梯度可以表示如下：</p>
$$J(\eta) = \mathbb{E}_\varepsilon \mathbb{E}_\theta [J(\theta)]$$$$\nabla_\eta J(\eta) = \mathbb{E}_\varepsilon \mathbb{E}_\theta [\nabla_\eta \theta \nabla_\theta J(\theta)]$$<p>其中 \(\varepsilon\) 表示从环境分布中采样的环境，\(\theta\) 代表由初始参数分布及其在强化学习规则作用下随学习过程演化所生成的智能体参数。\(J(\theta) = \mathbb{E}[\sum_t \gamma^t r_t]\) 是期望累计折扣奖励。元参数使用上述方差通过梯度上升法进行优化。</p>
<p>为了估计元梯度，作者实例化了一组智能体群体，这些智能体在一系列采样环境中依据元网络进行学习。为确保此采样估计的元梯度近似值接近目标元梯度真实分布，采用了来自高难度基准测试的大量复杂环境。探索过程呈现出多样化的强化学习挑战，例如奖励稀疏性、任务时间跨度、环境的部分可观测性或随机性。</p>
<p>为促使更新规则在有限智能体生命周期内快速学习，各智能体的参数会被周期性重置。元梯度项 \(\nabla_\eta J(\eta)\) 可通过链式法则分解为两个梯度项：\(\nabla_\eta \theta\) 与 \(\nabla_\theta J(\theta)\)。第一项可理解为智能体更新过程的梯度，而第二项是标准强化学习目标的梯度。为估计第一项，对智能体进行多次迭代更新，沿整个更新过程反向传播。由于智能体数量过多，作者使用滑动窗口只对最近的20次智能体更新进行反向传播。为估计第二项，使用 A2C 方法，再训练一个元价值函数网络，估计优势从而计算策略梯度，这个元价值函数只用于发现阶段，不是元学习规则的一部分。</p>
<h2 id="实验">实验<a href="#%e5%ae%9e%e9%aa%8c" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>测试了 Atari 57，再次刷榜，从未进行训练的环境也进行了测试，依然有不错的泛化性，通篇都在说很厉害。</p>
<h2 id="分析">分析<a href="#%e5%88%86%e6%9e%90" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>作者对在雅达利57个游戏上训练的强化学习规则进行了仔细分析。</p>
<h3 id="定性分析">定性分析<a href="#%e5%ae%9a%e6%80%a7%e5%88%86%e6%9e%90" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>从定性角度看，所发现的预测信号在关键事件（如获得奖励或策略熵值变化）发生前会呈现显著峰值。进一步通过测量观测数据各部分的梯度范数，探究了观测值中哪些特征会引发元学习预测的强烈响应。结果表明，元学习预测倾向于关注未来可能相关的对象（观测中未来可能会变得极为关键的东西，譬如游戏中一个可能会刷怪的位置，几秒后就刷怪了），这与策略函数和价值函数的关注点（短视，只能看到现在存在的东西）存在明显差异。这些发现表明，DiscoRL已学会识别并预测适度时间范围内的关键事件，从而对策略函数和价值函数等现有概念形成了有效补充。</p>
<h3 id="信息分析">信息分析<a href="#%e4%bf%a1%e6%81%af%e5%88%86%e6%9e%90" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>为验证定性分析结论，作者进一步探究了预测结果所包含的信息。首先收集 DiscoRL 智能体在 10 款雅达利游戏中的运行数据，并训练神经网络分别从发现的预测结果、策略函数或价值函数中预测目标变量。结果显示，相较于策略函数与价值函数，发现的预测结果对即将到来的高额奖励及未来策略熵值具有更强的信息表征能力。这表明发现的预测可能捕获了任务相关的独特信息，而这些信息未被策略函数和价值函数充分提取。</p>
<h3 id="自举机制的涌现">自举机制的涌现<a href="#%e8%87%aa%e4%b8%be%e6%9c%ba%e5%88%b6%e7%9a%84%e6%b6%8c%e7%8e%b0" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>作者还发现了证据表明 DiscoRL 采用了自举机制。当给元网络对未来时间步的预测输入 \(z_{t+k}\) 扰动时，会显著影响当前目标预测值 \(\hat{z}_t\)。这意味着未来预测结果被用于构建当前预测的目标值。这种自举机制与发现的预测被证实对算法性能至关重要。若在计算目标值 \(\hat{y}\) 和 \(\hat{z}\) 时将元网络的 \(y\) 和 \(z\) 输入置零（从而禁用自举机制），算法性能将大幅下降。若在计算包括策略目标在内的所有目标值时将 \(y\) 和 \(z\) 输入置零，性能衰退更为显著。这表明发现的预测深度参与策略更新过程，而非仅作为辅助任务存在。（这说明存在一个尚未被发现的目标有远超现有任何目标的合理性）</p>
<h2 id="方法">方法<a href="#%e6%96%b9%e6%b3%95" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>实现细节就不仔细看了，这里贴上翻译</p>
<h3 id="元网络-1">元网络<a href="#%e5%85%83%e7%bd%91%e7%bb%9c-1" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>元网络将智能体输出的轨迹以及环境中的相关量映射为目标值：</p>
$$m_\eta: f_\theta(s_t), f_{\theta^-}(s_t), a_t, r_t, b_t, \ldots, f_\theta(s_{t+n}), f_{\theta^-}(s_{t+n}), a_{t+n}, r_{t+n}, b_{t+n} \mapsto \hat{\pi}, \hat{y}, \hat{z}$$<p>其中，\(\eta\) 代表元参数，而 \(f_\theta = [\pi_\theta(s), y_\theta(s), z_\theta(s), q_\theta(s)]\) 是参数为 \(\theta\) 的智能体输出。\(a, r, b\) 分别是智能体采取的动作、获得的奖励和回合终止指示器。\(\theta^-\) 是参数 \(\theta\) 的指数移动平均。这种函数形式允许元网络搜索的规则空间严格大于元学习一个标量损失函数所能搜索的空间。这将在补充信息中进一步讨论。元网络通过在时间上反向展开一个 LSTM 来处理输入。这使得它能够考虑 \(n\) 步的未来信息来生成目标，类似于 \(\text{TD}(\lambda)\) 等多步 RL 方法。我们发现，这种架构在计算上比 Transformer 等替代方案更有效率，同时取得了相似的性能。元网络使用共享权重跨动作维度处理动作特定的输入与输出，并通过对其进行平均来计算一个中间嵌入向量。这使得元网络能够处理任意数量的动作。更多细节可在补充信息中找到。为了使元网络能够发现更广泛的算法类别（例如奖励归一化等需要维护智能体生命周期统计信息的算法），我们添加了一个额外的循环神经网络。这个 &ldquo;Meta-RNN&rdquo; 是沿着智能体更新（从 \(\theta_i\) 到 \(\theta_{i+1}\)）正向展开，而不是沿着回合中的时间步展开。Meta-RNN 的核心是另一个 LSTM 模块。对于每一次智能体更新，一整个批次的轨迹被嵌入为一个单一向量，并传递给这个 LSTM。Meta-RNN 能够潜在地捕获智能体整个生命周期中的学习动态，生成适应特定智能体和环境的目标。Meta-RNN 略微提高了总体性能。更多细节在补充信息中描述。</p>
<h3 id="元优化稳定性">元优化稳定性<a href="#%e5%85%83%e4%bc%98%e5%8c%96%e7%a8%b3%e5%ae%9a%e6%80%a7" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>大规模进行发现时，会出现一些挑战，主要是因为来自不同环境的智能体带来的不平衡梯度信号（unbalanced gradient signals）以及由智能体较长生命周期引起的短视梯度（myopic gradients）。我们引入了几种方法来缓解这些问题。稳定方法 1：优势项归一化首先，在 A2C 中估计优势项（advantage term）以估计元梯度中的 \(\nabla_\theta J(\theta)\) 时，我们对优势项进行如下归一化：</p>
$$\bar{A} = \frac{A - \mu}{\sigma}$$<p>其中 \(\bar{A}\) 是归一化的
优势，\(\mu\) 和 \(\sigma\) 分别是在智能体生命周期内累积的优势的指数移动平均和标准差。我们发现这使得优势项的规模在不同环境之间保持平衡。稳定方法 2：聚合元梯度时的个体 Adam 优化器此外，在聚合来自智能体群体的元梯度时，我们在对每个智能体计算出的元梯度应用一个单独的 Adam 优化器之后，取所有智能体元梯度的平均值：</p>
$$\eta \leftarrow \eta + \frac{1}{n} \sum_{i=1}^{n} \text{ADAM}(g_i)$$<p>其中 \(g_i\) 是来自群体中第 \(i\) 个智能体的元梯度估计。我们发现这有助于归一化每个智能体元梯度的量级。稳定方法 3：元正则化损失（Meta-Regularisation Losses）我们在元目标 \(J(\eta)\) 中添加了两个元正则化损失（\(\mathcal{L}_{ent}\) 和 \(\mathcal{L}_{kl}\)），如下所示：</p>
$$\mathbb{E}_\theta \big[ J(\theta) - \mathcal{L}_{ent}(\theta) - \mathcal{L}_{kl}(\theta) \big]$$<p>\(\mathcal{L}_{ent}(\theta)\):</p>
$$\mathcal{L}_{ent}(\theta) = -\mathbb{E}_{s,a} \big[ H(y_\theta(s)) + H(z_\theta(s,a)) \big]$$<p>这是对预测 \(y\) 和 \(z\) 的熵正则化，其中 \(H(\cdot)\) 是给定分类分布的熵。我们发现这有助于防止预测过早收敛。\(\mathcal{L}_{kl}(\theta)\):</p>
$$\mathcal{L}_{kl}(\theta) = D_{KL}(\pi_{\theta^-} \| \hat{\pi})$$<p>这是使用智能体参数的指数移动平均 \(\theta^-\) 的目标网络策略与元网络策略目标 \(\hat{\pi}\) 之间的 KL 散度。这防止了元网络提出过于激进的更新，这些更新可能导致性能崩溃。</p>
<h3 id="补充细节">补充细节<a href="#%e8%a1%a5%e5%85%85%e7%bb%86%e8%8a%82" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>我们开发了一个基于 JAX 的框架，该框架借鉴了 Podracer 架构，将计算分布在 TPU 上。在这个框架中，每个智能体都是独立模拟的，所有智能体的元梯度都是并行计算的。通过聚合所有智能体的元梯度，元参数被同步更新。我们使用了 MixFlow-MG 来最小化运行的计算成本。对于 Disco57，我们通过以词典顺序循环遍历 57 个 Atari 环境，实例化了 128 个智能体。对于 Disco103，我们实例化了 206 个智能体，包含了来自 Atari、ProcGen 和 DMLab-30 的每个环境的两份拷贝。Disco57 使用 1024 个 TPUv3 核心发现了 64 小时，Disco103 使用 2048 个 TPUv3 核心发现了 60 小时。用于计算元梯度的元价值函数使用 V-Trace 进行更新，折扣因子为 0.997，\(\text{TD}(\lambda)\) 系数为 0.95。元价值函数和智能体网络使用 Adam 优化器进行优化，学习率为 0.0003。对于元参数更新，我们使用学习率为 0.001 且梯度裁剪为 1.0 的 Adam 优化器。每个智能体基于一个包含 96 条轨迹的批次进行更新，每条轨迹包含 29 个时间步。在每个批次中，在策略（on-policy）轨迹和从重放缓冲区（replay buffer）采样的轨迹被混合，其中重放轨迹占每个批次的 90%。在每个元步骤中，生成 48 条轨迹用于计算元梯度和更新元价值函数。智能体参数重置机制每个智能体的参数在其消耗完分配的经验预算后会被重置。重置时，新的经验预算从类别 (200M, 100M, 50M, 20M) 中采样，其权重与预算成反比，这样每个类别采样的总经验量是相同的。这是基于我们观察到大部分学习发生在生命周期的早期，并且在我们初步的小规模调查中显示出边际改进。</p>
<h3 id="超参和评估">超参和评估<a href="#%e8%b6%85%e5%8f%82%e5%92%8c%e8%af%84%e4%bc%b0" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>对于在保留基准（held-out benchmarks）上的评估，我们仅调优了学习率，其范围为 \(\{0.0001, 0.0003, 0.0005\}\)。其余的超参数是根据文献中基线算法选取的。对 Atari 游戏的评估（如图 2a和扩展数据表 1所示）使用了 IMPALA34 网络的修改版本，其参数数量有所增加，以匹配 MuZero2 使用的智能体网络大小。具体来说，我们使用了具有四个卷积残差块（过滤器数量分别为 256, 384, 384, 256）、一个 768 维度共享全连接最终层，以及一个基于 LSTM 的动作条件预测组件的网络。该组件由一个隐藏状态维度为 1024 的 LSTM 和一个1024 维度的全连接层组成。DMLab-30 评估（图 2c和扩展数据表 3）使用了与 IMPALA 中使用的相同的动作空间离散化和智能体网络架构。有关超参数列表，请参见扩展数据表 6。为了验证我们评估的统计显著性，我们对 Atari、ProcGen 和 DMLab 中的每个环境使用了两个随机种子进行初始化；对 Crafter 和 Nethack 使用了三个种子；对 Sokoban 使用了五个种子。</p>
]]></content></item><item><title>MARL综述阅读</title><link>https://blog.hieros.me/zh/posts/marl_theory/</link><pubDate>Sat, 06 Dec 2025 17:00:00 +0800</pubDate><author>BLESS</author><guid>https://blog.hieros.me/zh/posts/marl_theory/</guid><description>偏理论的MARL综述阅读</description><content type="text/html" mode="escaped"><![CDATA[<h1 id="多智能体强化学习理论与算法选讲">多智能体强化学习：理论与算法选讲<a href="#%e5%a4%9a%e6%99%ba%e8%83%bd%e4%bd%93%e5%bc%ba%e5%8c%96%e5%ad%a6%e4%b9%a0%e7%90%86%e8%ae%ba%e4%b8%8e%e7%ae%97%e6%b3%95%e9%80%89%e8%ae%b2" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h1>
<p>这篇是Arxiv上的一篇综述论文，主要介绍了多智能体强化学习的理论与算法，因为在看了几篇MARL新的文章之后发现根基不稳，需要补一些理论基础和其他算法的知识，所以挑了一篇比较经典的。看着挺难读，正文就有47页，引用文献数量达383，写的很不错可惜有点早了2021年的。
注意部分内容是我补充上去的，部分内容也有所修改，虽然严谨性可能大打折扣，但是至少比原文好读，方便自己之后查阅。
论文地址： <a href="https://arxiv.org/abs/1911.10635" target="_blank" >https://arxiv.org/abs/1911.10635</a>
这里贴上作者的github页面，确实是行业内的专家，譬如这篇论文被引就达2k
<a href="https://kzhang66.github.io/" target="_blank" >https://kzhang66.github.io/</a>
有一点很重要，笔记的定义为是半翻译半讲述，其中有相关专业术语翻译不一定准确的会标出英文原文。
对于 distributed 翻译为分布式，decentralized 翻译为去中心，fully decentralized 翻译为分散式</p>
<h2 id="摘要">摘要<a href="#%e6%91%98%e8%a6%81" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>MARL 的理论在上世纪就提出来了，但是直到单智能体有所突破才重新焕发生机，现在的 MARL 虽然验证效果不错，但是理论相对薄弱，作者强调他们只是选择性讲了一些理论：重点聚焦有理论支撑的算法体系。把任务分为三类，分别是完全合作任务、完全竞争任务和混合任务。问题建模框架主要选择讲马尔可夫/随机博弈和扩展形式博弈（Extensive-Form Games）。涉及一些新颖的视角和分类体系例如：扩展式博弈中的学习、网络化智能体的去中心（Decentralized）学习、平均场（Mean Field）框架下的多智能体学习、博弈学习中策略梯度方法。</p>
<h2 id="介绍">介绍<a href="#%e4%bb%8b%e7%bb%8d" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>MARL 致力于解决多个自主智能体在共同环境中的序贯决策（Sequential Decision-Making）问题——每个智能体都通过与环境及其他智能体的交互，来优化自身长期回报。
总得来说，MARL 根据应用场景分为三类：完全合作任务——智能体协作优化共同的长期回报；竞争场景——智能体的回报通常为零和或常和；混合任务——智能体的回报通常为一般和（就是除去前两种和的类型之外的最一般的回报类型），对 MARL 问题建模需要 “优化理论，动态规划，博弈论，去中心控制” 等多种理论工具，但是不同理论在建模中遇到的问题是有共性的，譬如：学习目标多维，即不同智能体间目标不一定一致，很难处理均衡点（是指均衡点的多重性等问题）；优化结果外的其他性能也不好衡量，例如通信效率或者说协调效率，对潜在的对抗性智能体的鲁棒性；由于每个智能体都根据自身利益同步优化策略，导致对于单个智能体而言环境呈现非平稳性，（平稳性和非平稳性简单地可以理解为，如果时序数据，其主要统计量与时间无关即为平稳的，若与时间有关则为非平稳的）这打破了单智能体的理论框架；联合动作空间会随智能体数量增加呈现指数级增长，可能引发扩展性问题，称为 <strong>MARL 的组合复杂性</strong>；MARL中的信息结构（即智能体间的信息分布）更为复杂，由于每个智能体对其他智能体观测信息的获取受限，可能导致局部决策规则陷入次优困境。
研究者们致力于解决上述挑战，结合深度学习、运筹学和多智能体系统等领域的最新进展，涌现出诸多创新性研究成果。然而，这些成果普遍缺乏坚实的理论基础——单智能体深度强化学习的理论体系尚未成熟，多智能体场景的复杂性又进一步加剧了理论分析的难度。为此，作者系统梳理了具有理论保证的 MARL 算法，撰写此综述以明确当前研究的边界，并为该领域的未来发展提供方向性指引。
作者选择重点阐述离散时间框架下的两类代表性建模范式：扩展形式博弈和马尔科夫或者说随机博弈。也总结到现有的新视角与新的分类体系：基于作者的早期研究的智能体网络化分布式 MARL ；引入均值场博弈体系作为超大规模智能体群体的解决方案；优化理论新突破对策略梯度类方法收敛性（特别是零和博弈场景）的理论启示。作者甚至评述了部分观测场景下的 MARL 研究（未采用深度强化学习作为启发式解决方案）。</p>
<h2 id="背景">背景<a href="#%e8%83%8c%e6%99%af" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<h3 id="单智能体">单智能体<a href="#%e5%8d%95%e6%99%ba%e8%83%bd%e4%bd%93" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>RL 中，智能体通过与环境交互进行序贯决策，环境通常被建模为无限时域折扣马尔可夫决策过程。
定义： 马尔可夫决策过程（MDP）由一个五元组 \((\mathcal{S}, \mathcal{A}, P, R, \gamma)\) 定义，其中 \(\mathcal{S}\) 与 \(\mathcal{A}\) 分别表示状态空间与动作空间；\(P: \mathcal{S} \times \mathcal{A} \to \Delta(\mathcal{S})\) 表示在动作 \(a \in \mathcal{A}\) 作用下，从任意状态 \(s \in \mathcal{S}\) 转移到任意状态 \(s' \in \mathcal{S}\) 的转移概率；\(R: \mathcal{S} \times \mathcal{A} \times \mathcal{S} \to \mathbb{R}\) 为奖励函数，决定智能体在从 \((s, a)\) 转移到 \(s'\) 时获得的即时奖励；\(\gamma \in [0, 1)\) 为折扣因子，用于权衡即时与未来奖励。
作为标准模型，MDP 被广泛用于刻画在完全可观测系统状态 \(s\) 下的单智能体决策过程。每个时刻 \(t\)，智能体面对系统状态 \(s_t\) 选择动作 \(a_t\)，使系统转移到 \(s_{t+1} \sim P(\cdot \mid s_t, a_t)\)，同时获得即时奖励 \(R(s_t, a_t, s_{t+1})\)。求解 MDP 的目标是找到一个策略 \(\pi: \mathcal{S} \to \Delta(\mathcal{A})\)，即将状态空间映射到动作空间的分布，使得 \(a_t \sim \pi(\cdot \mid s_t)\)，并最大化如下折扣累计奖励：</p>
$$
\mathbb{E}\!\left[ \sum_{t \ge 0} \gamma^{t} R(s_t, a_t, s_{t+1}) \,\middle|\, a_t \sim \pi(\cdot \mid s_t),\, s_0 \right].
$$<p>因此，可定义策略 \( \pi \) 下的动作价值函数（ Q 函数）与状态价值函数（ V 函数）为</p>
$$
Q_\pi(s, a) = \mathbb{E}\!\left[ \sum_{t \ge 0} \gamma^{t} R(s_t, a_t, s_{t+1}) \,\middle|\, a_t \sim \pi(\cdot \mid s_t), a_t = a, s_0 = s \right],
$$<p>
</p>
$$
V_\pi(s) = \mathbb{E}\!\left[ \sum_{t \ge 0} \gamma^{t} R(s_t, a_t, s_{t+1}) \,\middle|\, a_t \sim \pi(\cdot \mid s_t), s_0 = s \right].
$$<p>对任意 \(s \in \mathcal{S}\) 与 \(a \in \mathcal{A}\)，上述两个量分别表示从 \((s_0, a_0) = (s, a)\) 与 \(s_0 = s\) 出发的折扣累计回报（从当前状态 \( s \) ，采取动作 \( a \) 之后的折扣累计回报是 Q 函数，衡量状态动作对的预期回报，从当前状态 \( s \) 之后的折扣累计回报是 V 函数，衡量状态的预期回报，两者均由贝尔曼方程导出）。对应于最优策略 \(\pi^*\) 的两者通常分别称为最优动作价值函数与最优状态价值函数。
利用马尔可夫性质，最优策略可以通过动态规划或者说向后归纳的方法，例如价值迭代与策略迭代算法，获得。这类方法需要已知模型信息，即转移概率以及奖励函数的形式。而强化学习旨在在未知模型的条件下找到这样的最优策略，智能体可以通过与环境交互收集的经验来学习策略。
总的来说，RL 算法大致可以分为两大类：基于价值的方法与基于策略的方法。</p>
<h3 id="基于价值的方法">基于价值的方法<a href="#%e5%9f%ba%e4%ba%8e%e4%bb%b7%e5%80%bc%e7%9a%84%e6%96%b9%e6%b3%95" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>基于价值的强化学习方法旨在求得状态动作价值函数的良好估计，即最优 \(Q\) 函数 \(Q_{\pi^*}\)。随后可以通过对该 \(Q\) 函数估计采取贪心动作来提取（近似）最优策略。
最常见的价值类算法是 Q-learning ，其中智能体维护对 \(Q\) 值函数的一个估计 \(\hat Q(s, a)\)。当从状态-动作对 \((s, a)\) 转移到下一状态 \(s'\) 时，智能体获得回报 \(r\)，并按如下规则更新 Q 函数：
</p>
$$
\hat Q(s, a) \leftarrow (1 - \alpha)\hat Q(s, a) + \alpha\big[r + \gamma \max_{a'} \hat Q(s', a')\big],
$$<p>基于最优贝尔曼方程。其中 \(\alpha > 0\) 是步长或称学习率，\( \gamma \) 乘的是下一状态所有可能动作中 \(Q\) 值最大的动作（对应“最优动作”假设）。在满足 Robbins–Monro 步长条件、每个状态-动作对被无限访问、回报有界且 \(\gamma < 1\) 的前提下，Q-learning 在有限状态与动作空间中几乎必然收敛到最优 \(Q\) 值函数。因此与深度神经网络结合就有了 DQN、DDQN、Dueling DQN、Rainbow DQN，在雅达利游戏中的测试表现良好。
还有 SARSA ，与 Q-learning 更新方式略有不同：
</p>
$$
\hat Q(s, a) \leftarrow (1 - \alpha)\hat Q(s, a) + \alpha\big[r + \gamma \hat Q(s', a')\big],
$$<p>基于策略贝尔曼方程，优化当前策略 \(\pi\) 下的动作价值函数 \(Q_\pi(s, a)\)，其中 Q-learning 的最大化项被换成下一个状态和动作的 \(Q\) 值（\(a'\) 由当前策略选出）。其收敛性通常要求 GLIE（Greedy in the Limit with Infinite Exploration）：在保证每个状态-动作对被无限访问的同时，探索强度随时间递减并最终趋于贪心；再配合 Robbins–Monro 步长条件与有界回报，即可在有限空间下收敛。SARSA 相比 DQN 系列更稳健，因为它为同策略学习，不使用“最乐观”的最大化估计，降低了过估计风险。
还有 MCTS（蒙特卡洛树搜索），通过蒙特卡洛模拟构建搜索树来进行近似规划；树策略用于在搜索中平衡探索与利用。常见做法是将 UCB1 应用于树的每个节点（UCT），或采用带先验的 PUCT。MCTS 本身不必使用 DNN，但在 AlphaGo/AlphaZero 等方法中，MCTS 与策略和价值网络结合以提升搜索质量。
强化学习中与 \(Q\) 函数相关的还有策略评估任务：给定策略 \(\pi\)，评估其好坏，本质上是估计其值函数（\(V_\pi(s)\) 或 \(Q_\pi(s, a)\)）。可以使用 TD 学习（例如 TD(0)）：
</p>
$$
V(s) \leftarrow V(s) + \alpha\big[r + \gamma V(s') - V(s)\big],
$$<p>
对于表格或线性函数的值函数，满足适当的步长条件与平稳马尔可夫过程假设时，TD(0) 收敛到投影贝尔曼固定点；但在非线性函数逼近下一般不保证收敛，因此需额外的正则化或算法设计（如目标网络、经验回放等）。</p>
<h3 id="基于策略的方法">基于策略的方法<a href="#%e5%9f%ba%e4%ba%8e%e7%ad%96%e7%95%a5%e7%9a%84%e6%96%b9%e6%b3%95" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>另一类强化学习算法直接在策略空间上进行搜索，策略通常由参数化的函数逼近器（如神经网络）估计，逼近器目标是近似 \(\pi(\cdot \mid s) \approx \pi_\theta(\cdot \mid s)\)。因此，最直接的思路是沿长期回报的梯度方向更新参数，这一思想由策略梯度（PG）方法实现。其关键前提是 PG 的闭式表达式：
</p>
$$
\nabla J(\theta)
= \mathbb{E}_{\,a\sim \pi_\theta(\cdot \mid s),\, s \sim \eta_{\pi_\theta}} \big[\, Q_{\pi_\theta}(s, a)\, \nabla \log \pi_\theta(a \mid s) \,\big],
$$<p>其中 \(J(\theta)\) 与 \(Q_{\pi_\theta}\) 分别是策略 \(\pi_\theta\) 下的期望回报与 \(Q\) 函数；\(\nabla \log \pi_\theta(a \mid s)\) 是策略的得分函数（对数概率的梯度），即把“在状态 \(s\) 选择动作 \(a\)”这件事的概率往更大/更小推的方向；\(\eta_{\pi_\theta}\) 是策略 \(\pi_\theta\) 下的状态占用测度，可以认为是状态在策略下的概率分布，区别在于如果状态占用测度没有折扣，那么它就是状态在策略下出现的概率分布，与初始状态无关，只考虑长期来看，每个状态在策略下出现的概率分布，如果状态占用测度是折扣形式，那么它会和初始状态相关，并且其概率会随乘时间步的折扣，这会使概率分布具有时间偏见性。
有策略参数的更新规则：
</p>
$$
\theta \leftarrow \theta + \alpha \nabla J(\theta),
$$<p>其中 \(\alpha > 0\) 是步长/学习率。
根据 PG 的计算方式不同可划分为两类：随机 PG 与确定 PG。
对于随机 PG：REINFORCE 用蒙特卡洛的似然比或者得分函数来估计梯度，常配合基线降低方差；GAE 从 GPOMDP 获得灵感通过 \(\lambda\) 加权的优势时序差分在偏差和方差间折中；Actor–Critic 由 Critic 估值 \(V\) 或者 \(Q\)，Actor 按优势 \(A\) 更新，依靠 TD bootstrap 做到低方差的在线训练；TRPO 以 KL 约束的置信域更新保证步长稳定、近似单调改进；PPO 用剪裁的替代目标近似 TRPO，同时引入GAE，结构更简洁、效果稳健。SAC 基于最大熵强化学习框架，将策略熵 \(\mathcal{H}(\pi(\cdot\mid s))\) 纳入目标函数（鼓励策略输出的多样化），采用重参数化技巧实现随机策略的稳定更新（将动作表示为状态和独立噪声的确定性函数：\(a_t = f_\phi(\epsilon_t; s_t)\)，其中 \(\epsilon_t \sim \mathcal{N}(0, I)\)，使得梯度可以通过整个计算图反向传播，显著降低策略梯度的方差），配合&quot;双重 \(Q\) 网络&quot;（同时学两个独立的 Q 网络，取最小值以减少过估计）与 \(\alpha\) 自动调节机制，表现稳定、样本效率好。
对于确定 PG，动作不再是概率分布，而是确定动作，其 PG 形式为：
</p>
$$
\nabla J(\theta)
= \mathbb{E}_{\,s \sim \eta_{\pi_\theta}} \Big[\, \nabla_\theta \pi_\theta(s)\; \nabla_a Q_{\pi_\theta}(s, a)\Big|_{a=\pi_\theta(s)} \,\Big].
$$<p>这表示：用链式法则将”动作对参数的敏感度”与”价值对动作的敏感度”相乘，并在 \(a=\pi_\theta(s)\) 处取值；不再出现 \(\nabla \log \pi_\theta(a\mid s)\) 的得分函数项（那是随机策略的形式）。
确定 PG 的开山之作为 DPG：首次提出了确定性策略梯度原理，方差更低且支持 off-policy；DDPG 把 DPG 做成 Actor–Critic，用 DNN 逼近策略和价值，并借助经验回放、目标网络与 OU 噪声提升稳定性与探索；TD3 针对 DDPG 的过估计问题，引入三个关键改进：双重 Critic 网络（取两个 \(Q\) 网络的最小值以减少过估计）、延迟策略更新（Actor 更新频率低于 Critic，增强稳定性）和目标策略平滑化（在目标动作上添加噪声以提高鲁棒性）。</p>
<h3 id="多智能体">多智能体<a href="#%e5%a4%9a%e6%99%ba%e8%83%bd%e4%bd%93" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>多智能体与单智能体相比，首先是系统状态的演变过程受到所有智能体联合行动的影响；最重要的问题是，每个智能体所要优化的自己的长期奖励函数也会收到所有其他智能体策略的影响。
MARL 可以由两种不同的框架建模，马尔可夫/随机博弈和扩展形式博弈，（虽然不能用来建模，但是认知科学和神经科学的研究也对MARL有重要影响）</p>
<h4 id="马尔可夫随机博弈">马尔可夫/随机博弈<a href="#%e9%a9%ac%e5%b0%94%e5%8f%af%e5%a4%ab%e9%9a%8f%e6%9c%ba%e5%8d%9a%e5%bc%88" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h4>
<p>在多智能体交互设定下，直接的思路是，把马尔可夫决策过程推广为马尔可夫博弈，或称随机博弈（应该说随机博弈定义更加宽泛，马尔可夫博弈要求随机博弈必须满足马尔可夫性质，但是实际建模中随机博弈通常被建模为马尔可夫博弈）。
马尔可夫博弈定义：马尔可夫博弈由一个元组 \((N, S, \{A_i\}_{i\in N}, P, \{R_i\}_{i\in N}, \gamma)\) 所定义。其中，\(N = \{1, \cdots, N\}\) 表示 \(N > 1\) 个智能体的集合；\(S\) 为所有智能体共同观察到的状态空间；\(A_i\) 为第 \(i\) 个智能体的动作空间。令 \(A := A_1 \times \cdots \times A_N\)，则 \(P: S \times A \to \Delta(S)\) 表示在任一联合动作 \(a \in A\) 下，从任一状态 \(s \in S\) 转移到任一状态 \(s' \in S\) 的转移概率；\(R_i: S \times A \times S \to \mathbb{R}\) 为奖励函数，决定了从 \((s, a)\) 转移到 \(s'\) 时智能体 \(i\) 获得的即时奖励；\(\gamma \in [0, 1)\) 为折扣因子。
在时间 \(t\)，每个智能体 \(i \in N\) 会根据系统状态 \(s_t\) 执行动作 \(a_i^t\)（所有智能体同时执行动作）。随后系统转移到状态 \(s_{t+1}\)，并依据 \(R_i(s_t, a_t, s_{t+1})\) 对每个智能体 \(i\) 给予奖励，其中联合动作 \(a_t \in A\)。智能体 \(i\) 的目标是寻找策略 \(\pi_i: S \to \Delta(A_i)\) 且 \(a_i^t \sim \pi_i(\cdot \mid s_t)\)，使自身的长期回报最大，\( \Delta \) 表示概率单纯形即所有状态上动作的概率分布的集合。
此时，智能体 \(i\) 的状态价值函数 \(V_i: S \to \mathbb{R}\) 成为联合策略的函数。假设每个智能体在动作选择上是独立的，即智能体间策略是独立的，联合策略 \(\pi: S \to \Delta(A)\) 定义为
</p>
$$
\pi(a \mid s) := \prod_{i\in N} \pi_i(a_i \mid s).
$$<p>特别地，对于任一联合策略 \(\pi\) 与状态 \(s \in S\)，定义智能体 \(i\) 在状态 \(s\) 下的状态价值函数为：
</p>
$$
V_i^{\pi_i,\pi_{-i}}(s)
:= \mathbb{E}\Big[ \sum_{t \ge 0} \gamma^t\, R_i(s_t, a_t, s_{t+1}) \,\Big|\, a_i^t \sim \pi_i(\cdot \mid s_t),\; s_0 = s \Big],
$$<p>其中 \(-i\) 表示除智能体 \(i\) 外的所有智能体的索引集合，该公式定义了当智能体 \(i\) 在状态 \(s\) 下遵循策略 \(\pi_i\)，而其他智能体（用下标 \(-i\) 表示）遵循策略 \(\pi_{-i}\) 时，智能体 \(i\) 的期望累计折扣回报。
由此可见，马尔可夫博弈的解概念有别于马尔可夫决策过程：某个智能体的最优表现不仅受其自身策略影响，也受到其他玩家选择的共同作用。最常见的解概念是纳什均衡简称 NE ，其定义如下：
纳什均衡定义：对于马尔可夫博弈 \((N, S, \{A_i\}_{i\in N}, P, \{R_i\}_{i\in N}, \gamma)\)，一个联合策略 \(\pi^* = (\pi_1^*, \cdots, \pi_N^*)\) 若满足对任意 \(s \in S\) 与任意 \(i \in N\)，
</p>
$$
V_i^{\pi_i^*,\,\pi_{-i}^*}(s) \;\ge\; V_i^{\pi_i,\,\pi_{-i}^*}(s), \quad \forall\, \pi_i,
$$<p>则称 \(\pi^*\) 为该博弈的纳什均衡。纳什均衡刻画了一个无人有激励单边偏离的平衡点：对任意智能体 \(i \in N\)，\(\pi_i^*\) 是对 \(\pi_{-i}^*\) 的最优响应（任何智能体都无法只改变自己的策略获得更优的利益，所有智能体都没有动机改变自己的策略）。作为 MARL 的标准学习目标，NE 在有限状态/动作空间、无限时域且折扣的 MG 中总是存在，但一般不保证唯一。大多数 MARL 算法的目标是当 NE 存在时收敛到这样的平衡点。马尔可夫博弈框架足够通用，可以统一覆盖多种 MARL 设定。</p>
<p><strong>完全合作设定下：</strong></p>
<p>在完全合作的设定下，所有智能体通常共享同一个奖励函数，即 \(R_1 = R_2 = \cdots = R_N = R\)。该模型在 AI 社区被称为多智能体 MDP（MMDPs），在控制或者博弈论社区则被称为马尔可夫团队或者马尔可夫团队博弈（ Markov teams/team Markov games）。此外，从博弈论视角看，这一合作设定也可视为马尔可夫势博弈（ Markov potential games ）的特殊情形，其中势函数为共享的累计回报。
在此设定下，各智能体的 \( V \) 函数与 \(Q\) 函数相同；若所有智能体能够被协调为“单一决策者”，则可直接应用单智能体强化学习算法。合作设定的全局最优解是马尔可夫博弈的一个纳什均衡。
除共享奖励模型外，另一类更一般的合作 MARL 模型则考虑团队平均奖励，智能体可以拥有不同（且可保持私有）的奖励函数，而合作的目标是优化与平均奖励对应的长期回报，其中平均奖励定义为
</p>
$$
\bar{R}(s,a,s') := \frac{1}{N}\sum_{i\in N} R_i(s,a,s'), \quad (s,a,s') \in S \times A \times S.
$$<p>平均奖励模型不仅支持更强的智能体异构性，还能保护智能体间的隐私，促进了去中心化MARL算法的发展。这种异构性特征进一步强化了将通信协议整合到多智能体强化学习中的必要性，推动了通信高效MARL算法的研究。</p>
<p><strong>完全竞争设定下：</strong></p>
<p>在完全竞争设定下，MARL 通常建模为零和马尔可夫博弈，即对任意 \((s,a,s')\)，都有 \(\sum_{i\in N} R_i(s,a,s') = 0\)。为便于算法分析与计算可行性，大多数文献聚焦于两个相互对抗的智能体，此时一方的奖励即为另一方的损失。除了直接用于博弈类应用外，零和博弈亦常用作鲁棒学习的模型：学习中的不确定性可视作始终与智能体对立的“虚拟对手”，此时，纳什均衡对应的策略在最坏情形的长期回报意义下是鲁棒的，即假设对手（即环境）总是会以最凶险的方式对付你的前提下，所能保证的最坏设定下的最好结果。</p>
<p><strong>混合合作竞争设定下：</strong></p>
<p>混合设定亦称一般和（general-sum）博弈，对智能体的目标与关系不作限制。每个智能体是自利的，其奖励可能与他者冲突。博弈论中的均衡解概念（如纳什均衡）对该设定下算法的发展影响最为显著。此外，同时包含完全合作与完全竞争的设定——例如两个零和竞争团队，且每个团队内智能体合作——也可视为混合设定的实例。</p>
<h4 id="扩展形式博弈extensive-form-games">扩展形式博弈（Extensive-Form Games）<a href="#%e6%89%a9%e5%b1%95%e5%bd%a2%e5%bc%8f%e5%8d%9a%e5%bc%88extensive-form-games" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h4>
<p>尽管马尔可夫博弈是 MARL 的经典形式，但它只能处理完全可观测情形，即智能体在时刻 \(t\) 对系统状态 \(s_t\) 与已执行的联合动作 \(a_t\) 拥有完备信息。与此同时，诸多 MARL 应用涉及仅部分可观测的智能体，即不完备信息的博弈。虽然将马尔可夫博弈扩展到部分可观测情形（Dec-POMDP）但即使是在完全合作的情况下求解难度也极大。
相较而言，扩展形式博弈能够更自然地刻画不完备信息的多智能体决策；该框架源于计算博弈论，并在温和条件（某些不是很严格的条件下）下可用多项式时间（时间复杂度是多项式）算法求解。
扩展形式博弈定义：一个扩展形式博弈由 \((N \cup \{c\}, H, Z, A, \{R_i\}_{i\in N}, \tau, \pi_c, S)\) 定义，其中 \(N = \{1, \ldots, N\}\) 表示 \(N>1\) 个智能体的集合，\(c\) 是称为“机会/自然”的特殊智能体，其固定的随机策略 \(\pi_c\) 代表环境中的随机性。\(A\) 是所有可能动作的集合，\(H\) 是所有可能的历史集合，每个历史是自博弈开始以来的动作序列。记 \(A(h) = \{\, a \mid ha \in H \,\}\) 为非终止历史 \(h\) 之后可用的动作集合。若一个智能体在历史 \(h \in H\) 下采取动作 \(a \in A(h)\)，则到达新历史 \(ha \in H\)。在所有历史中，\(Z \subseteq H\) 是终止历史的子集，表示博弈结束；每个智能体 \(i \in N\) 在终止历史上的回报由 \(R_i: Z \to \mathbb{R}\) 给出（注意扩展博弈没有单步回报，其效用只在终止历史上给定）。并且 \(\tau: H \to N \cup \{c\}\) 是识别函数，指定每个历史上由谁执行动作：若 \(\tau(h) = c\)，则机会智能体按其策略选择 \(a \sim \pi_c(\cdot \mid h)\)。此外，\(S\) 将 \(H\) 划分为不相交的子集，使得对任意 \(s \in S\) 以及其中任意 \(h, h' \in s\)，都有 \(\tau(h) = \tau(h')\) 且 \(A(h) = A(h')\)。换言之，属于同一分区的历史对即将行动的智能体而言不可区分（扑克牌，出牌者手里的牌一致的设定下，对方的牌可能是任何一种设定，这表明历史不同，但是对于出牌者而言，不知道对手的牌具体是哪种设定）；\(S\) 的元素 \( s \) 称为信息状态。
直观地说，不完备信息体现在智能体无法区分同一信息状态中的不同历史。为简化记号，对任意 \(s \in S\) 与其中任意 \(h \in s\)（任意一个分区的任意一段历史），记 \(A(s) := A(h)\)、\(\tau(s) := \tau(h)\)（智能体无法判定自己处于哪段历史，只能判定自己处于哪个信息状态，所以它对于一个历史的动作可以认为是对这个信息状态的动作，对于该由谁行动也可以基于信息状态判定），并定义映射 \(I: H \to S\)，满足当且仅当 \(h \in s\) 时 \(I(h) = s\)。仅考虑 \(H\) 与 \(A\) 为有限集的情形。对任意两个历史 \(h, h' \in H\)，若从 \(h\) 经过一串动作可到达 \(h'\)，则称 \(h\) 是 \(h'\) 的前缀，记为 \(h \sqsubseteq h'\)；同时称 \(h'\) 是 \(h\) 的后缀。另外假设博弈满足完美回忆，即每个智能体记得导致其当前信息状态的历史中的信息状态-动作序列。由著名的 Kuhn 定理（在满足 “完美回忆” 的有限扩展形式博弈中，对于任何一个智能体，其任何混合策略都存在一个收益等价（即对所有其他智能体都产生相同期望回报）的行为策略）可知，在完美回忆下，只需在行为策略中寻找纳什均衡；行为策略把每个信息状态 \(s \in S\) 映射为其可行动作集合上的概率分布（意思是只需要按照当前的信息状态执行策略就可以囊括所有可能的复杂策略，大大减少了策略的搜索范围）。
对任意 \(i \in N\)，令 \(S_i := \{\, s \in S : \tau(s) = i \,\}\) 为智能体 \(i\) 的信息状态集合。联合策略记为 \(\pi = (\pi_1, \ldots, \pi_N)\)，其中 \(\pi_i : S_i \to \Delta(A(s))\) 是智能体 \(i\) 的策略。对任意历史 \(h\) 及联合策略 \(\pi\)，定义在 \(\pi\) 下到达历史 \(h\) 的到达概率为
</p>
$$
\eta_\pi(h)
= \prod_{\,h':\, h'a \sqsubseteq h} \pi^{\tau(h')}\!\big(a \,\big|\, I(h')\big)
= \prod_{\,i \in N \cup \{c\}} \;\prod_{\substack{h':\, h'a \sqsubseteq h \\ \tau(h') = i}} \pi^i\!\big(a \,\big|\, I(h')\big)
$$<p>它刻画在所有智能体遵循 \(\pi\) 时生成历史 \(h\) 的概率。类似地，信息状态 \(s\) 的到达概率记为 \(\eta_\pi(s) = \sum_{h \in s} \eta_\pi(h)\)。智能体 \(i\) 的期望回报为
</p>
$$
R_i(\pi) = \sum_{z \in Z} \eta_\pi(z) \cdot R_i(z).
$$<p>现在给出扩展形式博弈的解概念，即 \(\varepsilon\)-纳什均衡：
\(\varepsilon\)-纳什均衡定义：对于由 \((N \cup \{c\}, H, Z, A, \{R_i\}_{i\in N}, \tau, \pi_c, S)\) 表示的扩展形式博弈，若存在联合策略 \(\pi^* = (\pi_1^*, \cdots, \pi_N^*)\)，使得对任意 \(i \in N\) 与任意策略 \(\pi_i\)，</p>
$$
R_i(\pi_i^*, \pi_{-i}^*) \;\ge\; R_i(\pi_i, \pi_{-i}^*) - \varepsilon,
$$<p>则称 \(\pi^*\) 为一个 \(\varepsilon\)-纳什均衡。这里 \(\pi_{-i}\) 表示集合 \(N\setminus \{i\}\) 中各智能体的联合策略（其中 \(j \in N\setminus\{i\}\) 的策略为 \(\pi_j\)）。若 \(\varepsilon = 0\)，则 \(\pi^*\) 构成一个纳什均衡。由于 \(\varepsilon\)-纳什均衡相对纳什均衡更加宽松，因此，\(\varepsilon\)-纳什均衡通常被视为一种解概念。
多种设定：
扩展形式博弈通常用于刻画非合作设定。具体地，若效用满足零和或者常和，即 \(\sum_{i\in N} R_i = k\)（其中 \(k\) 为常数），则对应完全竞争设定；一般和的效用则对应混合设定。主要是，不同的信息结构都可以可用扩展形式博弈来描述：完备信息博弈指每个信息集都是单点集，即对任意 \(s \in S\)，\(|s| = 1\)；不完备信息博弈指存在 \(s \in S\) 使得 \(|s| > 1\)。换言之，在不完备信息下，用于决策的信息状态 \(s\) 代表多个可能的历史，智能体无法区分它们。众多设定中，零和的不完备信息设定一直是连接 MARL 与广义形式博弈的理论研究重点，并催生了颠覆性的竞争场景算法，如 Poker AI 打德扑的 AI 好像挺强的，也挺吃算力的。
与马尔可夫博弈的联系：
更直观地说，扩展形式博弈与马尔可夫博弈在“到达概率”的建模上是可以互相映射的：在“同时行动”的马尔可夫博弈里，某个智能体在该时间步看不到其他智能体到底选了什么动作，因此对它而言，同一时刻可能发生的多种联合动作序列其实是“不可区分”的，这些不同的历史会被合并为同一个信息状态 \(s\)。在这种视角下，历史就是从起点到当前的一串联合动作，而“到达概率”就是“所有参与者按各自策略一路走到某个历史/信息状态的概率”（分别记为 \(\eta_\pi(h)\) 和 \(\eta_\pi(s)\)）。反过来，如果在某个信息状态 \(s\) 上只允许当前行动者选择动作，把其他参与者的动作集置空（对所有 \(j \neq \tau(s)\) 设 \(A_j = \varnothing\)），那么这个扩展形式博弈就会退化为一个具有随状态变化的动作空间的马尔可夫博弈。简言之：扩展形式用信息集 \(s\) 表达“在该时间步对他人动作的不完全信息”，而马尔可夫博弈用联合动作与折扣累计回报刻画序列决策；两者以不同层次描述同一条轨迹的概率。</p>
<h4 id="其他-marl-框架">其他 MARL 框架<a href="#%e5%85%b6%e4%bb%96-marl-%e6%a1%86%e6%9e%b6" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h4>
<p>还存在其他 MARL 的理论框架，例如规范形博弈或者说重复博弈，以及部分可观测马尔可夫博弈。前者可视为马尔可夫的一个特例（状态为单点集，即只有一种状态，状态只会转移回这个状态），局限于小规模问题；部分可观测马尔可夫博弈由于更具挑战性，因此相关理论相对稀缺。</p>
<h2 id="marl-理论的挑战">MARL 理论的挑战<a href="#marl-%e7%90%86%e8%ae%ba%e7%9a%84%e6%8c%91%e6%88%98" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<h3 id="非唯一学习目标">非唯一学习目标<a href="#%e9%9d%9e%e5%94%af%e4%b8%80%e5%ad%a6%e4%b9%a0%e7%9b%ae%e6%a0%87" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>与单智能体强化学习中智能体以高效最大化长期回报为目标不同，多智能体强化学习的学习目标更为复杂且常常不唯一。早期 MARL 的一个主要缺陷在于研究目标界定不清。
在 MARL 算法设计与分析中，最常见的目标是收敛到纳什均衡。纳什均衡的含义是：一旦达到该均衡点，任何智能体都没有动机单方面偏离。该目标依赖严格的理想化假设：智能体完全理性、具备完全推理能力、并拥有无限的相互建模能力。在此假设下，纳什均衡是一个合理的解概念。
然而，纳什均衡作为学习目标存在明显局限：它可能全局次优、计算代价高昂，且现实中智能体只能进行有限次的相互建模。因此，单纯追求纳什均衡收敛的学习方法在实际 MARL 中往往缺乏合理性。
基于上述反思，研究者提出了两类目标框架：
均衡议程（equilibrium agenda）：继续以某种均衡概念为收敛目标，强调系统层面的稳定性。 人工智能议程（AI agenda）：在其他智能体属于固定类别（其策略集合有限，可视作环境的一部分）的前提下，为给定智能体设计最优学习策略，强调个体性能优化。 与此同时，将“收敛至均衡点”作为主要评估标准也引发争议。有研究指出，在一般和（general-sum）马尔可夫博弈中，部分基于值的 MARL 算法可能无法保证收敛到静态纳什均衡，这促生了“循环均衡”的新概念：智能体在一组静态策略之间呈现严格的周期性切换，而非收敛到任何纳什策略。
另一条评估思路将学习目标拆分为“稳定性”与“理性”：稳定性指在预定义的对手算法类别下算法的收敛性；理性则要求当其他智能体策略保持不变时，算法能收敛到最优反应。若所有智能体兼具稳定性与理性，则在该框架下系统自然收敛至纳什均衡。此外，遗憾值也为刻画智能体理性提供了另一视角：它衡量算法相对“事后可知的最佳静态策略”的性能差异。当平均遗憾渐近为零 \( \lim_{T \to \infty} \frac{1}{T}\sum_{t=1}^{T} \mathrm{regret}_t = 0 \)，无遗憾学习在一定监控或者说信息反馈条件下可保证收敛至特定博弈的相关均衡；其本质是确保长期来看智能体不被他人策略所利用（即长期来看无论其他智能体行为如何智能体的策略总不会差于事后可知的最佳静态策略）。
除了优化回报的目标外，多智能体系统特有的其他目标也日益受到关注。例如，通信学习以便智能体更好地协调，这种对通信协议的关注自然推动了通信高效的 MARL 研究。其他重要目标包括如何学习而不过度拟合特定智能体，以及如何在存在恶意、对抗性或失效或失调的学习智能体的设定下进行鲁棒学习。</p>
<h3 id="非平稳性">非平稳性<a href="#%e9%9d%9e%e5%b9%b3%e7%a8%b3%e6%80%a7" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>另一个关键挑战在于多智能体通常同时学习，导致每个个体面对的环境是非平稳的。具体而言，一个智能体的动作会影响其他对手的奖励与系统状态的演化；因此，学习者必须考虑其他智能体的行为，并据此适应联合行为。这直接破坏了单智能体RL建立收敛性的平稳性假设（环境满足平稳的马尔可夫性质，即个体奖励与当前状态仅依赖于前一状态和所采取的动作）。由此也就无法直接套用单智能体RL的数学分析工具到 MARL 上。理论上，如果智能体忽略这一问题并在假定环境平稳的前提下优化自身策略（通常称为独立学习者-IRL），算法可能出现不收敛的情况，除非在若干特殊设定下（例如智能体共享一个团队回报函数，智能体局部行动但是有全局观测）。而在经验上， IRL 有时也能取得尚可的表现（例如IPPO）。作为MARL中最为人熟知的问题之一，非平稳性在文献中早已被广泛讨论；可以参见这篇综述，<a href="https://arxiv.org/abs/1906.04737" target="_blank" >https://arxiv.org/abs/1906.04737</a></p>
<h3 id="可拓展性问题">可拓展性问题<a href="#%e5%8f%af%e6%8b%93%e5%b1%95%e6%80%a7%e9%97%ae%e9%a2%98" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>为应对非平稳性，个体智能体通常需要考虑联合动作空间，而其维度会随智能体数量指数级增长，这也被称为 MARL 的组合爆炸特性。大量智能体的存在显著增加了理论分析的复杂度，尤其是收敛性分析；这也从侧面反映在现有理论进展上：关于二人零和的MARL理论明显更为完备，而对于多于两人的一般和的设定则相对落后。一种可能的缓解思路是进一步假设价值函数或奖励函数在动作依赖上的分解（因子化）结构：例如 VDN ，QMIX 这类算法（虽然他们的理论证明薄弱）。严格理论分析参见 <a href="https://ieeexplore.ieee.org/document/9029635" target="_blank" >https://ieeexplore.ieee.org/document/9029635</a> ：在一种特殊的依赖结构下，提出了可证明收敛的基于模型的算法。与此同时，还有一类与可扩展性相互独立但被其进一步加剧的理论挑战：建立“深度”多智能体强化学习（deep MARL）的系统理论。由于可扩展性，MARL 往往需要使用函数逼近，尤其是深度神经网络；尽管在经验上颇为成功，但深度 MARL 的理论分析几乎仍是一片空白，因为当前对深度学习理论的理解尚且有限，更遑论深度 RL 理论。这也是未来的研究方向之一。</p>
<h3 id="多样的信息结构">多样的信息结构<a href="#%e5%a4%9a%e6%a0%b7%e7%9a%84%e4%bf%a1%e6%81%af%e7%bb%93%e6%9e%84" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>与单智能体相比，MARL 的信息结构（即在训练与执行阶段“谁知道什么”）更为复杂。以马尔可夫博弈为例，只需观测瞬时状态 \(s_t\) 即可使每个智能体作出决策，因为局部策略 \(\pi_i: S \to \Delta(A_i)\) 能表达均衡策略。而在扩展形式博弈中，在常见的“完美回忆”假设下，每个智能体可能需要回忆过去的决策历史。
此外，作为自利的智能体，每个智能体通常难以直接获取对手的策略或奖励，最多只能观测其采取的动作。这种部分信息会加剧非平稳性问题：样本难以准确恢复对手策略的真实行为，从而增加个体智能体所感知的非平稳性。其极端情形是前述的 IRL ，它仅假设可观测本地动作与奖励，通常不收敛。
不同信息结构下的学习方案会带来不同层次的理论分析难度。为缓解上述部分信息问题，许多工作假设存在一个中央控制器，能够收集联合动作、联合奖励与联合观测，甚至为所有智能体设计策略。这一结构催生了“集中式训练—分散式执行”（CTDE）的流行范式，其源自对部分可观测设定的规划研究，即 Dec-POMDPs，并被近年来的深度 MARL 工作广泛采用。在合作设定中，这一范式能显著简化分析，可以借用单智能体 RL 的工具；但在非合作且异构智能体的设定中，由于各方学习目标不一致，该范式并不能简化问题。
需要指出的是，在许多应用中通常并不存在这样的中央控制器，除非能方便地访问仿真环境（如电子游戏、机器人）。因此，往往更偏好分散式（fully decentralized）的学习方案，其中 IRL 是一个特例。为缓解 IRL 的不收敛问题，智能体通常允许通过通信网络与邻居交换或共享本地信息；我们将这种设定称为“带网络的去中心结构”。在该设定下，可以开展收敛性的理论分析，其难度介于单智能体 RL 与一般 MARL 算法之间。</p>
<h2 id="具备理论支撑的-marl-算法">具备理论支撑的 MARL 算法<a href="#%e5%85%b7%e5%a4%87%e7%90%86%e8%ae%ba%e6%94%af%e6%92%91%e7%9a%84-marl-%e7%ae%97%e6%b3%95" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<h3 id="完全合作设定">完全合作设定<a href="#%e5%ae%8c%e5%85%a8%e5%90%88%e4%bd%9c%e8%ae%be%e5%ae%9a" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>具有理论支撑的合作型 MARL 主要针对以下情境设计：</p>
<h3 id="同构智能体">同构智能体<a href="#%e5%90%8c%e6%9e%84%e6%99%ba%e8%83%bd%e4%bd%93" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>所有智能体共享相同的奖励函数（在这种设定下，NE 变为团队均衡，在满足 NE 的一般特性上还满足全局最优的特性），该奖励函数能协调所有智能体的利益，在智能体数量极大的设定下，同构性智能体意味着智能体在系统演化中可互换，难以区分（即智能体之间没有区别）。</p>
<h4 id="mamdp-和-马尔可夫团队">MAMDP 和 马尔可夫团队<a href="#mamdp-%e5%92%8c-%e9%a9%ac%e5%b0%94%e5%8f%af%e5%a4%ab%e5%9b%a2%e9%98%9f" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h4>
<p>考虑马尔可夫博弈，当满足 \(R_1 = R_2 = \cdots = R_N = R\)，其中奖励函数 \(R: S \times A \times S \to \mathbb{R}\) 受联合动作 \(A = A_1 \times \cdots \times A_N\) 的影响，此时，各智能体的 \(Q\) 函数相同。一个直接的算法是在每个智能体处执行标准的 Q-learning 更新，但在目标项中对联合动作空间的后继动作 \(a' \in A\) 取最大值（即将标准Q-learning 更新中对于单智能体动作空间的后继动作取最大值，替换为联合动作空间的后继动作取最大值）。在状态与动作空间均有限时，有论文论证了最优或者说均衡 \(Q\) 函数的收敛性。
然而，\(Q\) 函数的收敛并不必然意味着马尔可夫团队的均衡策略（可能是任何一种均衡，此处可能指 NE ）收敛：当均衡策略不唯一且智能体无法协调选择时，逐个智能体提取的均衡策略的任意组合可能并不构成一个团队均衡（每个智能体都找到了奖励相同的团队均衡点，但是他们选的不是同一个团队均衡点，导致联合策略不能达到一个团队均衡点）。因而，收敛到 NE 策略仅在以下两种设定下得到保证：要么假设均衡唯一，要么智能体在均衡选择上达成协调。后一思路在合作重复博弈中得到验证——这是一种具有单一状态的马尔可夫团队，其中智能体作为联合动作学习者维护联合动作的 \(Q\) 值，并学习他人的经验模型；对于一般设定还没有理论证明收敛。
在真实的马尔可夫团队设定下，有研究利用了这种协调思想并提出了“最优自适应学习”（OAL），这是首个对均衡策略收敛具有证明保证的 MARL 算法。最优自适应学习（OAL）的运作机制如下：它首先通过交互经验来估计博弈模型。随后，在每一个决策点，它都会构建一个内部的“虚拟博弈”。这个虚拟博弈是经过设计的，它围绕一个核心的策略候选集合（偏置集合，基于对历史的分析所确定的），并确保智能体在这些策略上的互动能够避免循环、趋向稳定（此性质被称为弱非循环）。接着，OAL 引入一种能够适应不同策略情境的学习算法，作用于这些虚拟博弈之上。正是通过这一系列精巧的设计，理论上证明了OAL的行为最终能够收敛至 NE。
除均衡选择的问题外，马尔可夫团队相较单智能体 RL 还需处理可扩展性问题。由于独立 Q-learning 可能不收敛，面向 MMDPs 的可扩展且收敛的早期尝试是：提出一种分布式 Q-learning 算法，可在确定性、有限的 MMDPs 上收敛。每个智能体仅维护关于状态 \(s\) 与本地动作 \(a_i\) 的 \(Q\) 表，并在更新中依次对联合动作 \(a'\) 做最大化；各个体无法获取他人的动作及其历史。
为缓解可扩展性，业界提出了若干启发式（缺乏理论支撑）的奖励或价值函数因子化方法如 VDN、QMIX、QTRAN 。其中 QTRAN 对“价值因子化”给出了严格的条件刻画；另一项理论工作假设一种单向树形依赖结构，使得整体 MMDPs 的最优策略可被局部策略在理论上良好逼近；也有人研究了共同利益博弈（包含马尔可夫团队），提出一种仅依赖状态、局部动作与奖励的分散式 RL 算法。在与独立 Q-learning 相同的信息结构下，该算法保证收敛到“团队最优均衡策略”（而不仅仅是任意均衡策略）。这点尤为重要，因为一般而言，次优均衡的性能可能与最优均衡相差悬殊。
对于基于策略的方法，据作者所知只有“两时间尺度”的 Actor-Critic 拟似博弈（fictitious play）算法有理论论证，其内容为：慢时间尺度上，Actor 在当前策略与相对于本地 \(Q\) 估计的最优反应之间做混合（相当于平滑更新）；快时间尺度上，Critic 进行策略评估，仿佛所有智能体的策略是静态的（确保准确估计Q值）。其收敛性已在“同时行动的多阶段博弈、具有共同奖励”这一马尔可夫团队特例下证明：该特例从初始状态出发，经吸收态终止（确保了有限时间范围，使值函数有界），且每个状态仅被访问一次（没有重复访问和优化，不会因为重复访问产生依赖循环）。</p>
<h4 id="马尔可夫势博弈">马尔可夫势博弈<a href="#%e9%a9%ac%e5%b0%94%e5%8f%af%e5%a4%ab%e5%8a%bf%e5%8d%9a%e5%bc%88" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h4>
<p>从博弈论视角，更一般地能包括合作设定的框架是势博弈：存在一个所有智能体共享的势函数，使得任一智能体单方面改变策略时，其奖励的变化等于或正比于该势函数的变化。尽管多数势博弈是无状态的，但马尔可夫势博弈（MPGs）这种扩展框架因能建模序列决策问题而日益受到关注；其中状态满足马尔可夫性且其演化受联合动作影响。实际上，马尔可夫团队是 MPGs 的一个特例，其势函数即公共奖励；这类动态博弈在策略上等价于马尔可夫团队。在这一模型下，有文献给出了可验证条件以判定一个马尔可夫博弈是不是马尔可夫势博弈，并证明了在马尔可夫势博弈中寻找闭环纳什均衡与求解单智能体最优控制问题等价；因此，可直接借助单智能体强化学习算法来求解此类 MARL 问题。</p>
<h4 id="均值场">均值场<a href="#%e5%9d%87%e5%80%bc%e5%9c%ba" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h4>
<p>针对可扩展性问题的另一解决思路是将环境建模为均值场，其中包括大量同构的智能体。此时，每个体对整体系统的影响趋于无穷小，智能体间因此可互换或者说不可区分；与他人的交互可由某个均值场量简洁刻画，例如平均状态或状态的经验分布。每个体只需对均值场求最优响应，显著简化了分析的复杂度。这种多智能体系统的均值场视角已通过以下模型实现：均值场博弈模型、具有均值场共享的团队模型、具有均值场行为的博弈模型。注意均值场团队和均值场博弈的区别在于求解的目标不同，均值场团队求解最优解，均值场博弈求解均衡解。
直到最近（2021年的最近），基于这些模型的MARL算法才开始探索，多集中于均值场中的非合作设定。对于合作设定，有文献研究了具有均值场共享的马尔可夫团队的强化学习：与均值场博弈相比，该模型假设智能体共享一个仅依赖本地状态与均值场的公共奖励函数，从而鼓励合作；同时，“均值场”在此指有限群体的状态经验平均（当智能体数量有限时使用智能体的状态的经验分布近似均值场（均值场一半要求智能体趋于无穷）的智能体状态概率分布），区别于 MFGs 中无限群体的期望或概率分布。基于该模型的动态规划分解（基本上是说贝尔曼方程了），若干常见的 RL 算法可直接迁移到此种模型下。有文献采用均值场控制（MFC）来刻画大规模合作决策者：策略梯度方法被证明在线性二次 MFC 上收敛；也有人证明了均值场 Q-learning 在一般 MFC 上的收敛性。
注：均值场团队与均值场博弈的区别主要在解概念——“最优”与“均衡”，分别对应一般动态团队理论与博弈论。尽管前者可视为后者的特例，但相关研究通常分开回顾。</p>
<h3 id="网络化智能体的去中心范式">网络化智能体的去中心范式<a href="#%e7%bd%91%e7%bb%9c%e5%8c%96%e6%99%ba%e8%83%bd%e4%bd%93%e7%9a%84%e5%8e%bb%e4%b8%ad%e5%bf%83%e8%8c%83%e5%bc%8f" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>在实际多智能体系统中，协作智能体并非总是同构的。智能体可能具有不同的偏好，即奖励函数，但它们仍然组成团队以最大化团队平均奖励 \(\bar{R}\) 的回报，其中 \(\bar{R}(s, a, s') = \frac{1}{N} \cdot \sum_{i \in N} R_i(s, a, s')\)。主要是，奖励函数有时无法与其他智能体共享，因为偏好对每个智能体来说是私有的。这种设定在传感器网络、智能电网、智能交通系统和机器人学等工程系统中有着广泛的应用。
网络化智能体的去中心范式可以将同构智能体视为一种特例，但是这种网络化的智能体显然需要更多的协调机制，例如，在不知道其他智能体奖励函数的设定下，全局价值函数无法在本地估计。在有中央控制器的设定下，同构智能体设定中的大多数 MARL 算法可以直接应用，因为控制器可以收集和平均奖励，并将信息分发给所有智能体。然而，由于成本、可扩展性或鲁棒性考虑，这样的控制器在前面提到的大多数应用中可能不存在。取代这种方法的是，智能体或许能够通过可能时变且稀疏的通信网络与其邻居共享/交换信息。尽管这种去中心或者分布式范式的 MARL 显然具有很大的发展潜力，但与解决静态或单阶段优化问题的分布式或一致性算法（指分布式静态优化领域的算法）的广泛研究结果相比，它的研究相对较少，分布式静态优化领域的算法与 MARL 不同，不涉及系统动态，也不最大化序贯决策问题的长期目标。</p>
<h4 id="学习最优策略">学习最优策略<a href="#%e5%ad%a6%e4%b9%a0%e6%9c%80%e4%bc%98%e7%ad%96%e7%95%a5" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h4>
<p>最重要的目标是学习最优联合策略，与此同时每个智能体只能访问本地和网络上的邻居信息。网络化智能体的 MARL 思想可以追溯到09年的文献 Efficient distributed reinforcement learning through agreement 。据作者所知，在这种设定下第一个可证明收敛的 MARL 算法来自 A collaborative distributed strategy for multiagent reinforcement learning through consensus + innovations，该算法将”一致性和创新”的思想融入到标准 Q-learning 算法中，产生了 QD-learning 算法，其更新规则如下：
</p>
$$
Q_t^{i+1}(s, a) \leftarrow Q_t^i(s, a) + \alpha_{t,s,a} \left[ R_i(s, a) + \gamma \max_{a' \in A} Q_t^i(s', a') - Q_t^i(s, a) \right] - \beta_{t,s,a} \sum_{j \in \mathcal{N}_t^i} \left[Q_t^i(s, a) - Q_t^j(s, a)\right]
$$<p>
其中 \(\alpha_{t,s,a}, \beta_{t,s,a} > 0\) 是步长，\(\mathcal{N}_t^i\) 表示智能体 \(i\) 在时间 \(t\) 的邻居智能体集合。与 Q-learning 更新相比，QD-learning 附加了一个创新项，该项捕获了与其邻居的 Q 值估计的差异。在步长的某些条件下，该算法保证在表格设定（Q-table 专门存储精确 Q 值的表格）下收敛到最优 Q 函数。
由于可扩展性问题，函数逼近在 MARL 中至关重要，这需要开发基于策略的算法。作者之前的工作，为这种设定提出了分散式 Actor-Critic 算法。特别地，每个智能体通过某个参数 \(\theta_i \in \mathbb{R}^{m_i}\) 参数化其自己的策略 \(\pi_\theta^i : S \to \Delta(A_i)\)，回报的策略梯度首先推导为：
</p>
$$
\nabla_{\theta^i} J(\theta) = \mathbb{E}[\nabla_{\theta^i} \log \pi_{\theta^i}^i(s, a^i) \cdot Q_\theta(s, a)] \quad
$$<p>
其中 \(Q_\theta\) 是在联合策略 \(\pi_\theta\) 下对应于 \(\bar{R}\)（这是团队平均奖励） 的全局价值函数（注意此处的全局价值函数是对于团队平均奖励而言的，而非对于一个额外定义的全局奖励），定义为 \(\pi_\theta(a \mid s) := \prod_{i \in \mathcal{N}} \pi_{\theta^i}^i(a^i | s)\)。与标准 Q-learning 中的策略梯度相比，此处涉及本地得分函数 \(\nabla_{\theta^i} \log \pi_{\theta^i}^i(s, a^i)\) 和全局 Q 函数 \(Q^\theta\) 乘积的期望。然而，全局 Q 函数无法在每个智能体处单独估计。因此，通过将 \(Q^\theta(\cdot, \cdot)\) 的每个本地副本（全局 Q 函数在每个本地智能体上的部分）参数化为智能体 \(i\) 的 \(Q^\theta(\cdot, \cdot; \omega_i)\)（使用神经网络从本地对全局 Q 函数估计），我们提出以下基于一致性的 TD 学习用于 Critic 步骤，即估计 \(Q^\theta(\cdot, \cdot)\)：
</p>
$$
\tilde{\omega}_t^i = \omega_t^i + \beta_{\omega,t} \cdot \delta_t^i \cdot \nabla_\omega Q_t(\omega_t^i), \quad \omega_{t+1}^i = \sum_{j \in N} c_t(i, j) \cdot \tilde{\omega}_t^j \quad
$$<p>
其中 \(\beta_{\omega,t} > 0\) 是步长，\(\delta_t^i\) 是使用 \(Q^\theta(\cdot, \cdot; \omega_i)\) 计算的本地 TD 误差（使用本地奖励计算）。第一个关系执行标准 TD 更新，然后是邻居估计 \(\tilde{\omega}_t^j\) 的加权组合。这里的权重 \(c_t(i, j)\) 由通信网络的拓扑决定，只有当两个智能体 \(i\) 和 \(j\) 在时间 \(t\) 连接时才有非零值。它们还需要在期望上满足双随机性质（每一行之和为零，每一列之和为零），以便如果 \(\omega_t^i\) 收敛，则对所有 \(i \in N\) 达到一致值。然后，每个智能体 \(i\) 在 Actor 步骤中使用其自己的\(Q^\theta(\cdot, \cdot; \omega_t^i)\)，按照去中心化 AC 的随机策略梯度更新其策略。作者在那篇文章中还引入了一个变体算法，该算法不依赖于 Q 函数，而是依赖于状态价值函数逼近来估计全局优势函数。
基于上述考虑，这类去中心化 Actor–Critic 算法在采用线性函数进行值函数逼近时，能够获得几乎必然的收敛性（作者在此前的研究证明过了，提出了分散式 AC 算法）。类似的思想也可以扩展到连续动作空间，此类场景通常使用确定性策略梯度（DPG）。由于确定性同策略（on-policy）往往探索不足，DPG 需要借助随机行为策略进行 off-policy 探索；但在多智能体设定中，其他智能体的策略未知，常见的 DPG 的 off-policy 手段不可直接适用。
受期望策略梯度（EPG）统一随机策略梯度（SPG）与确定性策略梯度（DPG）的启发，可以构造一种保持 on-policy、同时相较通用 SPG 显著降低方差的算法：推导多智能体版本的 EPG，据此开发可去中心化执行的 Actor 更新步骤；Critic 更新则沿用分散式 AC 的办法。在线性函数逼近下，该算法同样能够建立几乎必然的收敛性。
沿此方向，还可将强调时序差分（ETD）的分析方法融入分散式 AC，形成在 off-policy 设定下的扩展框架，并获得几乎必然收敛的保证。与此同时，亦存在另一种 off-policy 方案：智能体不共享价值函数估计，而是通过对全局最优策略估计达成共识来实现协同；该架构采用本地 Critic 与共识 Actor，同样具备可证明的收敛性。
除了多智能体设定外，去中心网络化的 MARL 也在多任务设定中得到了研究。在某种意义上，多任务可以被视为多智能体的简化版本，其中每个智能体处理一个不受其他智能体影响的独立 MDP，而目标仍然是学习考虑所有智能体平均奖励的最优联合策略。有人提出了一种分布式 Actor-Critic 算法，假设状态、动作和奖励都是每个智能体的本地信息。每个智能体执行基于本地 TD 进行 Critic 更新，然后执行基于一致性的 Actor 更新，该步骤通过交换邻居信息计算梯度方向进行策略优化。然后证明了平均回报的梯度随着迭代趋于无穷而收敛到零。有文献基于对偶理论开发了 Diff-DAC，这是该设定的另一种分布式 Actor-Critic 算法。更新类似于作者提出的分散式 AC 中的更新，但提供了额外的见解，即 Actor-Critic 更新实际上是求解线性规划的对偶上升方法的一个应用。
注意，所有上述收敛保证都是渐近的，即算法随着迭代次数趋于无穷而收敛，并且仅限于线性函数逼近的情况。这无法量化使用有限迭代和有限样本中存在任意一种或者两种时的性能，更不用说使用深度神经网络等非线性函数逼近时。作为在这种设定下使用更一般函数逼近进行有限样本分析的初步分析，作者在以往的工作中研究了批量 RL （离线 RL ）算法，具体研究的是拟合 Q 迭代（FQI）的去中心变体，偏重理论没有使用 DNN 作为函数逼近器，因为如果用了 DNN 那 FQI 就成了著名的 DQN 算法。作者既研究了适用于网络化智能体的合作设定的 FQI 变体，也研究了适用于两个这样的网络化智能体团队的竞争设定的 FQI 变体。在前一种设定中，所有智能体合作迭代更新全局 Q 函数估计，使用非线性最小二乘回归估计目标值。设 \(\mathcal{F}\) 为 Q 函数逼近器类别，\(\{(s_j, \{a_j^i\}_{i \in N}, s'_j)\}_{j \in [n]}\) 为所有智能体可用的大小为 \(n\) 的批量转移数据集，\(\{r_j^i\}_{j \in [n]}\) 为每个智能体私有的本地奖励样本，\(y_j^i = r_j^i + \gamma \cdot \max_{a \in A} Q_t^i(s'_j, a)\) 为本地目标值，其中 \(Q_t^i\) 是智能体 \(i\) 在迭代 \(t\) 的 Q 函数估计。然后，所有智能体合作通过求解以下问题找到共同的 Q 函数估计：
</p>
$$
\min_{f \in \mathcal{F}} \frac{1}{N} \sum_{i \in \mathcal{N}} \frac{1}{2n} \sum_{j=1}^n [y_j^i - f(s_j, a_j^1, \cdots, a_j^N)]^2 \quad (4.3)
$$<p>
该问题可以归类为分布式或者说一致性优化框架，如果 \(\mathcal{F}\) 使得对每个 \(i\)，\(\sum_{j=1}^n [y_j^i - f(s_j, a_j^1, \cdots, a_j^N)]^2\) 是凸的，则其全局最优解可以通过现有文献中的传统算法得到。如果 \(\mathcal{F}\) 是线性函数类，确实是可以的。然而，由于分布式优化算法的有限迭代（在实践中很常见），智能体可能无法达到精确一致，导致每个智能体的 Q 函数估计偏离上式的实际最优值的误差。当使用非线性函数逼近时，这种误差也存在。考虑到这种由去中心计算引起的误差，作者源于单智能体批量 RL 的误差传播分析，评估了所提出算法的有限样本性能，即算法输出的准确性如何依赖于函数类 \(\mathcal{F}\)、每次迭代内的样本数 \(n\) 和迭代次数 \(t\)。</p>
<h4 id="策略迭代">策略迭代<a href="#%e7%ad%96%e7%95%a5%e8%bf%ad%e4%bb%a3" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h4>
<p>与控制不同，在该设定下的方法仅专注于策略评估（policy evaluation），即 Actor-Critic 中的 Critic 步骤。由于策略固定，采样分布变为稳态；并且在线性函数逼近下，目标函数是凸的。这使得有限时间/有限样本分析成为可能，相比多数仅具渐近保证的控制算法更可操作。
在联合策略 \(\pi\) 下，假设每个智能体用线性函数类参数化价值函数
</p>
$$
V_\omega(s) := \phi^\top(s)\,\omega,\quad \phi(s)\in\mathbb{R}^d,\ \omega\in\mathbb{R}^d.
$$<p>
其中 \( \phi^\top(s) \) 是状态 \( s \) 的特征向量，为记号简便，记 \(\Phi := (\cdots;\ \phi^\top(s);\ \cdots)\in\mathbb{R}^{|S|\times d}\)，即将状态向量堆叠为一个矩阵，\(D := \mathrm{diag}(\{\eta_\pi(s)\}_{s\in S})\in\mathbb{R}^{|S|\times |S|}\) 即使用状态占用测度 \(\eta_\pi\) 构造的对角矩阵，\(\bar R_\pi(s) := \frac{1}{N}\sum_{i\in N} R_{i,\pi}(s)\)，其中
</p>
$$
R_{i,\pi}(s) := \mathbb{E}_{a\sim\pi(\cdot|s),\ s'\sim P(\cdot|s,a)}[R_i(s,a,s')],
$$<p>
以及转移矩阵 \(P^\pi\in\mathbb{R}^{|S|\times|S|}\) 的元素
</p>
$$
[P^\pi]_{s,s'} := \sum_{a\in A} \pi(a|s)\,P(s'|s,a).
$$<p>
则所有智能体的目标是联合最小化团队平均奖励下的均方投影贝尔曼误差（MSPBE）：
</p>
$$
\mathrm{MSPBE}(\omega) := \big\|\Pi_\Phi\big(V_\omega - \gamma P^\pi V_\omega - \bar R_\pi\big)\big\|^2_{D}
= \big\|A\omega - b\big\|^2_{C^{-1}}\quad (4.4),
$$<p>
其中 \(\Pi_\Phi := \Phi(\Phi^\top D \Phi)^{-1}\Phi^\top D\) 是将状态空间到子空间 \(\{\Phi\omega:\ \omega\in\mathbb{R}^d\}\) 的投影算子，\(A := \mathbb{E}[\phi(s)(\phi(s)-\gamma\phi(s'))^\top]\)，\(C := \mathbb{E}[\phi(s)\phi^\top(s)]\)，\(b := \mathbb{E}[\bar R_\pi(s)\phi(s)]\)。
将期望替换为样本并使用 Fenchel 对偶，MSPBE 的有限和版本可重写为分布式鞍点问题：
</p>
$$
\min_{\omega}\ \max_{\{\lambda_i\}_{i\in N}}\ \frac{1}{Nn}\sum_{i\in N}\sum_{j=1}^{n}\Big(2\,\lambda_i^\top A_j\,\omega - 2\,(b_j^{\,i})^\top \lambda_i - \lambda_i^\top C_j \lambda_i\Big)\quad (4.5),
$$<p>
其中 \(n\) 为数据规模，\(A_j, C_j, b_j^{\,i}\) 分别是 \(A, C, b^i := \mathbb{E}[R_{i,\pi}(s)\phi(s)]\) 的样本估计。上式关于 \(\omega\) 为凸，关于 \(\{\lambda_i\}_{i\in N}\) 为凹。
以 MSPBE 为目标在多智能体策略评估中是标准做法；鞍点重构也被用于：基于扩散策略的分布式强化学习算法，分布式 GTD 算法，双重平均 MARL 算法，MARL 中带线性函数逼近的分布式TD(0)算法的有限时间分析。有文献引入了 MSPBE 的一个变体——H 截断的 \(\lambda\) 加权 MSPBE，以控制与实际均方贝尔曼误差最优解的偏差。基于 MSPBE，有文献开发了分布式的梯度 TD 方法，并用常微分方程（ODE）方法证明了渐近收敛。有文献提出了结合动态一致性与 SAG 算法的“双重平均”方案，以线性速率求解 MSPBE 的有限和版本。有文献将方差降低思想（ AVRG ）引入到基于梯度 TD 的策略评估，在达到与双重平均算法相同的线性速率的同时，有三点优势：1. 与数据量无关的内存需求；2. 使用资格迹（Eligibility Trace）；3. 采样无需同步。标准 TD 学习（而非 gradient-TD）也被推广到该 MARL 设定，重点在于有限样本分析。有文献研究了分布式 TD(0)，要求对迭代做投影并假设样本独立同分布。进一步地，有文献给出了更一般的分布式 TD(\(\lambda\)) 在无需投影与噪声假设下的有限时性能分析。对于网络化但独立 MDP 的设定，有文献研究了基于重要性采样的离策略评估；因为 MDP 之间无耦合，智能体不需要知道其他智能体的动作。随后提出了扩散式分布式 GTD，并证明了其以次线性速率在均方意义上的收敛。有文献在时变通信网络下为该设定设计了 TD 学习的两个变体（GTD2 与 TDC ），并基于一般随机近似理论证明了弱收敛。也有工作考虑了独立 MDP 设定，得到与实际 MARL 设定一致的结果。</p>
<h4 id="其他学习目标">其他学习目标<a href="#%e5%85%b6%e4%bb%96%e5%ad%a6%e4%b9%a0%e7%9b%ae%e6%a0%87" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h4>
<p>在网络化智能体的去中心化 MARL 中，研究者们还探索了其他几种学习目标。有文献考虑了最优一致性问题，其中网络中的每个智能体跟踪其邻居以及领导者的状态，从而通过联合策略最小化一致误差。该研究引入了一种策略迭代算法，进一步设计了使用神经网络进行函数逼近的 Actor-Critic 算法。也有文献在&quot;合作多智能体图博弈&quot;框架下采用了类似的一致误差目标，通过 CTDE 架构开发了 off-policy 强化学习算法。
通信效率作为该设定下算法设计的关键要素，受到极大的关注。有文献开发了惰性聚合策略梯度（LAPG），这是一种分布式策略梯度算法，通过精心设计通信触发规则，可以减少智能体与中央控制器之间的通信轮次。有文献解决了与双重平均算法相同的策略评估问题，并通过提出与双随机混合矩阵不同的混合矩阵进行一致化，开发了一种分层分布式算法，允许智能体之间的单向信息交换以节省通信。相比之下，有工作提出的分布式 Actor-Critic 算法通过每次迭代仅传输其状态向量的一个标量条目来减少通信，同时保持与一般分布式 AC 中相同的可证明收敛性。</p>
<h3 id="部分观测模型">部分观测模型<a href="#%e9%83%a8%e5%88%86%e8%a7%82%e6%b5%8b%e6%a8%a1%e5%9e%8b" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>该部分只介绍一种重要且具有挑战性的模型——智能体部分可观的场景。尽管在实践中很常见，与完全可观测设定相比，该设定下的 MARL 算法理论分析仍相对稀缺（注意前两种设定都是全局观测的）。
一般而言，该设定可用去中心化部分可观测马尔可夫决策过程（ Dec-POMDP ）建模，它与马尔可夫博弈或者马尔可夫团队在奖励函数、转移模型等几乎所有要素上保持一致，区别在于每个智能体仅能获得系统状态 s 的局部观测。由于无法获取其他智能体的观测，单个智能体无法获知全局的信念状态（是指给定历史观测和动作序列的前提下，真实状态 s 的后验概率分布，即智能体可能处于的所有状态的概率）——这是单智能体 POMDP 中用于决策的充分统计量（即所有的历史观测和动作都可以压缩到信念状态中，不损失决策质量）。因此，Dec-POMDP 被证明为 NEXP 完全（NEXPTIME-complete），即在最坏情况下求解需要超指数时间（多重指数时间，不可能在有限时间解出来）。
针对 Dec-POMDP 的规划和学习算法研究正日益增长。多数算法采用 CTDE 范式：首先将去中心化问题重构为中心化问题，在中央控制器上使用所有智能体的观测数据进行求解；随后基于数据，优化或者学习策略，并分发至各智能体执行。有限状态控制器（FSCs）常用于表示各智能体的本地策略，它将局部观测历史映射到动作。有文献提出了贝叶斯非参数方法以确定可变规模 FSC 的控制器大小。
为高效求解中心化问题，提出了一系列自上而下算法。有文献将 Dec-POMDP 转换为不可观测 MDP（NOMDP，信念状态不变，导致Agent对转移状概率奖励的计算方式始终不变），并用启发式树搜索算法求解。作为该转换的扩展，有文献将 Dec-POMDP 转换为占用态 MDP（oMDP），其状态为占用态即信念状态的分布作为状态。由于 oMDP 的价值函数具备分段线性与凸性，有文献开发出了可处理的规划算法与基于价值的学习算法。
为进一步提升计算效率，还提出了若干基于采样的规划/学习算法：结合策略迭代的蒙特卡洛采样与期望—最大化算法。此外，蒙特卡洛树搜索也已用于若干特殊的 Dec-POMDP 类，如多智能体 POMDP 与多机器人主动感知。在该中心化学习范式下，也可构建基于策略梯度的算法，采用 CTDE 架构。对于表格设定（有限状态—动作空间），还建立了有限样本分析。
也有若干工作尝试在 Dec-POMDP 中实现去中心化学习：当智能体共享部分公共信息/观测时，有文献将问题重构为一个中心化 POMDP，把公共信息视为虚拟中央控制器的观测；这样，每个智能体都能独立求解该中心化 POMDP。有文献进一步用有限状态 MDP 近似该重构的 POMDP，近似误差指数递减，并以 Q-learning 求解。最近，有工作针对该中心化 POMDP 开发了基于树搜索的算法，有趣的是它与直接求解 Dec-POMDP 的启发式方法 相呼应，但具备更坚实的理论基础。需要注意的是，在有限状态 MDP 和基于树搜索的方法中，所有智能体共用一个随机数发生器，以避免智能体间通信并实现去中心化学习方案，即所有智能体进行的探索方向提前约定一致。</p>
<h3 id="完全竞争设定">完全竞争设定<a href="#%e5%ae%8c%e5%85%a8%e7%ab%9e%e4%ba%89%e8%ae%be%e5%ae%9a" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>竞争性场景通常被建模为零和博弈。在计算复杂度层面，求解两人与多人零和博弈存在显著差异。特别需要指出的是，即使是最简单的三人矩阵博弈，也被证明属于 PPAD 完全问题（有向图上的多项式奇偶参数，PPAD 这类问题里最难计算的那个问题）。因此现有关于竞争性多智能体强化学习的研究主要聚焦于两人零和博弈。</p>
<h3 id="基于值的方法">基于值的方法<a href="#%e5%9f%ba%e4%ba%8e%e5%80%bc%e7%9a%84%e6%96%b9%e6%b3%95" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>与单智能体 MDP 类似，基于值的方法旨在找到最优价值函数，从中可以提取联合纳什均衡策略。最优价值函数是贝尔曼算子（描述价值函数更新的数学算子）的唯一不动点，可以通过动态规划类方法获得（就是说可以通过迭代收敛到最优解）。具体而言，对于同步移动（所有智能体同时选择动作）的马尔可夫博弈，价值函数满足 \(V^1_{\pi^1,\pi^2} = -V^2_{\pi^1,\pi^2}\)，因此任何纳什均衡 \(\pi^* = (\pi^{1,*}, \pi^{2,*})\) 满足
</p>
$$
V^1_{\pi^1,\pi^{2,*}}(s) \leq V^1_{\pi^{1,*},\pi^{2,*}}(s) \leq V^1_{\pi^{1,*},\pi^2}(s), \quad \text{对于任意 } \pi = (\pi^1, \pi^2) \text{ 和 } s \in S. \quad
$$<p>
即左侧玩家1单方面改变策略，玩家1的价值不会增加，玩家1的策略已经是最优响应；右侧玩家2单方面改变策略，玩家1的价值不会减少，所以玩家2的价值不会增加，说明玩家2的策略已经是最优响应。类似于正则形式/矩阵（正则形式就是矩阵形式）零和博弈中的极小极大定理（对于玩家1而言他选择了某个策略，对于玩家2一定会选择对玩家1最不利的策略，那么玩家1就会选择在最坏情况下收益最高的策略，而玩家2则会选择玩家1在最好情况下收益最小的策略，即玩家1最大化最小收益，玩家2最小化最大收益，冯·诺依曼极小极大定理指出有限双人零和博弈中，极大极小值等于极小极大值），对于具有有限状态和动作空间的两人零和马尔可夫博弈，可以定义最优价值函数 \(V^*: S \to \mathbb{R}\) 为
</p>
$$
V^* = \max_{\pi^1} \min_{\pi^2} V^1_{\pi^1,\pi^2} = \min_{\pi^2} \max_{\pi^1} V^1_{\pi^1,\pi^2}, \quad
$$<p>
那么双人博弈价值纳什均衡和双人零和马尔可夫博弈的最优价值函数定义意味着重合（因为极小化极大值就意味着玩家2无法通过改变自己策略损害玩家1的利益，极大化极小值意味着玩家1无法通过改变自己策略增加自己的利益）并且任何达到最优价值函数中上确界和下确界的策略对 \(\pi^1\) 和 \(\pi^2\) 构成一个纳什均衡。此外，与 MDP 类似，有研究表明 \(V^*\) 是贝尔曼方程的唯一解，并且可以基于 \(V^*\) 构造纳什均衡。具体而言，对于任意 \(V: S \to \mathbb{R}\) 和任意 \(s \in S\)，定义
</p>
$$
Q_V(s, a^1, a^2) = \mathbb{E}_{s' \sim P(\cdot | s,a^1,a^2)} \left[R^1(s, a^1, a^2, s') + \gamma \cdot V(s')\right],
$$<p>
联合动作价值函数定义为联合动作奖励和下时刻状态价值折扣的期望，其中 \(Q_V(s, \cdot, \cdot)\) 可以视为 \(\mathbb{R}^{|A^1| \times |A^2|}\) 中的一个矩阵。然后我们通过求解关于 \(Q_V(s, \cdot, \cdot)\) 作为收益矩阵的矩阵零和博弈来定义贝尔曼算子 \(\mathcal{T^*}\)，即对于任意 \(s \in S\)，可以定义
</p>
$$
(\mathcal{T}^*V)(s) = \text{Value}[Q_V(s, \cdot, \cdot)] = \max_{u \in \Delta(A^1)} \min_{v \in \Delta(A^2)} \sum_{a \in A^1} \sum_{b \in A^2} u_a \cdot v_b \cdot Q_V(s, a, b),
$$<p>
其中我们使用 \(\text{Value}(\cdot)\) 表示矩阵零和博弈的最优值，可以通过求解线性规划获得，其中\( \Delta(A^*) \)代表玩家1可能的混合策略的集合，\( {u_a, v_b} \)分别代表玩家 1 和玩家 2 选择动作\( a, b \)的概率，\( A^* \)是玩家动作集合，对状态价值函数进行贝尔曼计算的含义是寻找一个混合策略能够最大最小化联合动作价值函数的期望。贝尔曼算子 \(\mathcal{T}^*\) 在 \(\ell_\infty\)范数（即最大范数）下是 \(\gamma\)压缩的（能保证价值函数最大范数逐渐减小），且 \(V^*\) 是贝尔曼方程 \(V = \mathcal{T}^*V\) 的唯一解。此外，令 \(p^1(V)\), \(p^2(V)\) 为上式优化问题的任意解，有 \(\pi^* = (p^1(V^*), p^2(V^*))\) 是纳什均衡。因此，基于贝尔曼算子 \(\mathcal{T}^*\)，有人提出了价值迭代算法，该算法创建一个满足 \(V_{t+1} = \mathcal{T}^*V_t\) 的价值函数序列 \(\{V_t\}_{t \geq 1}\)，该序列以线性速率收敛到 \(V^*\)。具体而言，有
</p>
$$
\|V_{t+1} - V^*\|_\infty = \|\mathcal{T}^*V_t - \mathcal{T}^*V^*\|_\infty \leq \gamma \cdot \|V_t - V^*\|_\infty \leq \gamma^{t+1} \cdot \|V_0 - V^*\|_\infty.
$$<p>
此外，价值迭代更新可以分解为两个步骤。具体而言，令 \(\pi^1\) 为玩家 1 的任意策略，\(V\) 为任意价值函数，我们定义贝尔曼算子 \(\mathcal{T}^{\pi^1}\) 为
</p>
$$
(\mathcal{T}^{\pi^1}V)(s) = \min_{v \in \Delta(A^2)} \sum_{a \in A^1} \sum_{b \in A^2} \pi^1(a | s) \cdot v_b \cdot Q_V(s, a, b),
$$<p>
当玩家2策略不变时最小化当前策略的状态价值函数期望，然后可以等价地将价值迭代更新写为
</p>
$$
\mu_{t+1} = p^1(V_t) \quad \text{和} \quad V_{t+1} = \mathcal{T}^{\mu_{t+1}}V_t.
$$<p>
这种分解激发了两人零和博弈的策略迭代算法，该算法已在此类马尔可夫博弈的不同变体进行了研究。具体而言，从玩家 1 的角度来看，策略迭代创建一个满足
</p>
$$
\mu_{t+1} = p^1(V_t) \quad \text{和} \quad V_{t+1} = (\mathcal{T}^{\mu_{t+1}})^\infty V_t,
$$<p>
即 \(V_{t+1}\) 是 \(\mathcal{T}^{\mu_{t+1}}\) 的不动点。玩家 2 的更新可以类似地构造。贝尔曼算子 \(\mathcal{T}^{\mu_{t+1}}\) 是 \(\gamma\)-压缩的，其不动点对应于与 \((\mu_{t+1}, \text{Br}(\mu_{t+1}))\) 相关联的价值函数，其中 \(\text{Br}(\mu_{t+1})\) 是当玩家 1 采用 \(\mu_{t+1}\) 时玩家 2 的最佳响应策略。因此，在策略迭代的每一步中，玩家首先基于当前函数 \(V_t\) 找到一个改进的策略 \(\mu_{t+1}\)，然后通过假设对手采用最佳对抗策略 \(\text{Br}(\mu_{t+1})\) 来获得一个保守的价值函数。有研究表明，对于回合制零和马尔可夫博弈，价值函数序列 \(\{V_t\}_{t \geq 0}\) 以线性收敛速率单调递增到 \(V^*\)。
注意到价值和策略迭代算法都是基于模型的，因为需要计算贝尔曼算子 \(\mathcal{T}^{\mu_{t+1}}\)。通过数据驱动近似估计贝尔曼算子，有文献提出了极小极大 Q 学习（minimax-Q learning），将著名的 MDP Q 学习算法扩展到零和马尔可夫博弈。具体而言，极小极大 Q 学习是一种在线、离策略的表格方法，基于转移数据 \(\{(s_t, a_t, r_t, s'_t)\}_{t \geq 0}\) 更新动作价值函数 \(Q: S \times A \to \mathbb{R}\)，其中 \(s'_t\) 是 \((s_t, a_t)\) 的下一个状态，\(r_t\) 是奖励。在第 \(t\) 次迭代中，它只更新 \(Q(s_t, a_t)\) 的值，并保持 \(Q\) 的其他条目不变。
具体而言，有
</p>
$$
Q(s_t, a^1_t, a^2_t) \leftarrow (1 - \alpha_t) \cdot Q(s_t, a^1_t, a^2_t) + \alpha_t \cdot \{r_t + \gamma \cdot \text{Value}[Q(s'_t, \cdot, \cdot)]\},
$$<p>
其中 \(\alpha_t \in (0, 1)\) 是步长。在类似于单智能体 Q 学习的条件下，上式生成的函数 \(Q\) 收敛到最优动作价值函数 \(Q^* = Q_{V^*}\)，该函数由矩阵零和博弈的最优值和联合动作价值函数组合定义。可以通过下式定义动作价值函数的贝尔曼算子 \(\mathcal{T}^*\)：
</p>
$$
(T^*Q)(s, a^1, a^2) = \mathbb{E}_{s' \sim P(\cdot | s,a^1,a^2)} \left[R^1(s, a^1, a^2, s') + \gamma \cdot \text{Value}[Q(s', \cdot, \cdot)]\right],
$$<p>
那么 \(Q^*\) 是 \(\mathcal{T}^*\) 的唯一不动点。由于目标值 \(r_t + \gamma \cdot \text{Value}[Q(s'_t, \cdot, \cdot)]\) 是 \((\mathcal{T}^*Q)(s_t, a^1_t, a^2_t)\) 的估计量，极小极大 Q 学习可以视为计算 \(\mathcal{T}^*\) 不动点的随机逼近算法。
极小极大 Q 学习可以进一步扩展到函数逼近设置，其中 Q 函数由参数化函数近似。然而，即使使用线性函数逼近，这种极小极大 Q 学习的收敛保证仍未被充分理解。这种线性价值函数逼近也适用于一类重要的具有连续状态-动作空间的零和马尔可夫博弈实例，即线性二次（LQ）零和博弈，其中奖励函数关于状态和动作是二次的，而转移模型遵循线性动态。在这种设置下，基于 Q 学习的算法可以保证收敛到纳什均衡。
为了适应一般的函数类，批量强化学习的框架可以适配多智能体设置。每个智能体通过使用最小二乘拟合目标值来迭代更新 Q 函数。具体而言，令 \(\mathcal{F}\) 为目标函数类，令 \(\{(s_i, a^1_i, a^2_i, r_i, s'_i)\}_{i \in [n]}\) 为数据集。对于任意 \(t \geq 0\)，令 \(Q_t\) 为第 \(t\) 次迭代中的当前迭代值，并对所有 \(i \in [n]\) 定义 \(y_i = r_i + \gamma \cdot \text{Value}[Q_t(s'_i, \cdot, \cdot)]\)。然后我们通过在 \(\mathcal{F}\) 中求解最小二乘回归问题来更新 \(Q_t\)，即
</p>
$$
Q_{t+1} \leftarrow \arg\min_{f \in \mathcal{F}} \frac{1}{2n} \sum_{i=1}^n [y_i - f(s_i, a^1_i, a^2_i)]^2.
$$<p>
关于其他有限样本分析，最近有研究探讨了零和回合制随机博弈（TBSG），这是当转移模型嵌入某个特征空间（转移概率不再显式建模，而是使用低维的特征表示参数化）且生成模型可用（有一个仿真环境）时的一种简化零和马尔可夫博弈，并为此设置提出了两种基于 Q 学习的算法并进行了分析。另有研究，通过扩展先前针对 MDP 的近乎最优 Q 学习算法，为具有生成模型的一般零和 TBSG 实现了近乎最优的样本复杂度的算法。
在在线设置中，学习者仅控制其中一个玩家与任意对手对抗，有研究提出了 UCSG，一种用于平均奖励零和马尔可夫博弈的算法，使用了面对不确定性的乐观原则。当与任意对手竞争时，UCSG 被证明能够实现相对于博弈值的次线性遗憾（遗憾的增长速度比线性还慢），并且如果对手采用乐观最佳响应，也能实现 \(\tilde{O}(\text{poly}(1/\epsilon))\) 的样本复杂度（准多项式样本复杂度，双向学习的话，学起来很快）。
此外，针对不完全信息的零和博弈，有研究提出使用序列形式表示将扩展式博弈转换为正则形式博弈，从而通过线性规划实现均衡寻找。另外，通过将状态空间提升到信念状态空间，也有研究将动态规划方法应用于零和随机博弈。这两种方法都保证找到纳什均衡，但仅对小规模问题有效。
最后，具有 UCB 类型动作选择规则的蒙特卡洛法也可以应用于具有不完全信息的两人回合制博弈，这为深度强化学习在围棋中的成功奠定了基础。此外，这些方法被证明收敛到博弈的极小极大解，因此可以视为带有蒙特卡洛采样的极小极大 Q 学习的对应物。</p>
<h3 id="基于策略的方法-1">基于策略的方法<a href="#%e5%9f%ba%e4%ba%8e%e7%ad%96%e7%95%a5%e7%9a%84%e6%96%b9%e6%b3%95-1" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>基于策略的强化学习方法也可扩展至多智能体场景。与寻找贝尔曼算子的不动点不同，相当数量的方法仅关注单个智能体，旨在最大化该智能体的期望回报，而忽略其他智能体的策略。具体而言，从单个智能体视角观察，由于其他智能体同时调整策略，环境呈现时变特性。基于策略的方法旨在通过最小化（外部）遗憾值，使得智能体在其他智能体采取任意策略时仍能获得最优性能，即寻找与事后最优固定策略性能相当的行动序列。若算法具有可忽略的平均整体遗憾值，则称为无遗憾算法或汉南一致算法。已知在重复正则博弈中，任何汉南一致算法均具备以下两个理想特性：首先，当其他智能体采用静态策略时，该算法构建的时间平均策略（将策略按照时间平均，策略是一个概率分布）会收敛至最佳响应策略（针对其他智能体使用的策略）；更重要的是，在双人零和博弈中，当双方均采用汉南一致算法且平均整体遗憾值均不超过 \( \epsilon \) 时，其联合时间平均策略将构成 \( 2\epsilon \) 近似纳什均衡。因此，任何汉南一致的单智能体强化学习算法均可通过自我博弈方式求解双人零和博弈的纳什均衡。此类方法大多属于以下两大类别：虚拟博弈与反事实遗憾最小化。
虚拟博弈是博弈论中研究的经典算法，玩家通过重复进行博弈，每个个体采用针对其他智能体平均策略的最优响应策略。该方法最初用于求解正则形式博弈——这是马尔可夫博弈的简化形式（其状态集\( S \)为单点集且折扣因子\( \gamma = 0 \)）。具体而言，对于\( N \)个智能体的任意联合策略\( \pi \in \Delta(A) \)，令\( \pi_{-i} \)表示除玩家\( i \)外所有玩家的边际策略。当\( t \geq 1 \)时，假设前\( t \)个阶段中智能体已执行动作序列\( \{a_\tau: 1 \leq \tau \leq t\} \)，定义\( x_t \)为该序列的经验分布，即对任意\( a \in A \)满足\( x_t(a) = t^{-1} \sum_{\tau=1}^t \mathbb{1}_{\{a_\tau = a\}} \)（\( \mathbb{1} \)是指示函数，当且仅当智能体选择动作 \( a \) 时指示函数值为 \( 1 \)，该函数估计动作 \( a \) 被选中的概率 ）。在第\( t \)阶段，每个智能体\( i \)根据针对\( x_{t}^{-i} \)的最优响应策略选择动作\( a_i^t \in A_i \)。换言之，每个智能体根据历史数据推断其他智能体策略后执行最优对抗策略。此处对任意\( \epsilon > 0 \)和策略\( \pi \in \Delta(A) \)，用\( \text{Br}_\epsilon(\pi^{-i}) \)表示玩家\( i \)的\( \epsilon \)-最优响应策略，该策略满足以下条件：
</p>
$$
R^i(\text{Br}_\epsilon(\pi^{-i}), \pi^{-i}) \geq \sup_{\mu \in \Delta(A_i)} R^i(\mu, \pi^{-i}) - \epsilon
$$<p>
此外，我们定义 \( \text{Br}_\epsilon(\pi) \) 为联合策略 \( (\text{Br}_\epsilon(\pi^{-1}), \ldots, \text{Br}_\epsilon(\pi^{-N})) \in \Delta(A) \)，并在 \( \epsilon = 0 \) 时省略下标。通过这种表示法，将每个 \( a \in A \) 视为 \( \Delta(A) \) 的一个顶点，我们可以等价地将虚拟博弈过程写为：
</p>
$$
x_t - x_{t-1} = (1/t) \cdot (a_t - x_{t-1}) ，\text{其中} a_t \sim \text{Br}(x_{t-1})
$$<p>
当 \( t \to \infty \) 时，上式中的更新可以近似地由微分包含描述：
</p>
$$
\frac{dx(t)}{dt} \in \text{Br}(x(t)) - x(t)
$$<p>
这被称为连续时间虚拟博弈。尽管离散时间虚拟博弈一般不是汉南一致的，但有文献表明连续时间虚拟博弈是汉南一致的，利用随机逼近的工具，基于平滑或随机扰动等技术对离散时间虚拟博弈的各种修改已被证明收敛于连续时间虚拟博弈，因此离散时间虚拟博弈是汉南一致的。因此，将这些方法与自我博弈结合应用，可证明能找到双人零和正则形式博弈的纳什均衡。
此外，虚拟博弈方法也已扩展到无需模型知识的强化学习环境中。具体而言，利用序列形式表示，有文献提出了首个适用于扩展形式博弈的虚拟博弈算法，该算法与正则形式博弈的广义弱化虚拟博弈的实现等价。关键洞见在于：正则形式策略的凸组合可以写为使用实现概率的行为策略的加权凸组合。
具体来说，智能体 \( i \) 的信息状态集合记为 \( S^i \)。当博弈具有完美回忆时，每个 \( s^i \in S^i \) 唯一地定义了智能体 \( i \) 为到达状态 \( s^i \) 所执行的动作序列 \( \sigma_{s^i} \)。那么，智能体 \( i \) 的任何行为策略 \( \pi^i \) 都会为智能体 \( i \) 的每个序列 \( \sigma \) 诱导一个实现概率 \( \text{Rp}(\pi^i; \cdot) \)，其定义为：
</p>
$$
\text{Rp}(\pi^i; \sigma) = \prod_{(\sigma_{s'}, a) \subseteq \sigma} \pi^i(a | s')
$$<p>
其中乘积遍历所有 \( s' \in S^i \) 和 \( a \in A^i \)，使得 \( (\sigma_{s'}, a) \) 是 \( \sigma \) 的子序列。使用实现概率的表示法，对于智能体 \( i \) 的任意两个行为策略 \( \pi \) 和 \( \tilde{\pi} \)，
</p>
$$
\frac{\lambda \cdot \text{Rp}(\pi, \sigma_{s^i}) \cdot \pi(\cdot \mid s^i)}{\lambda \cdot \text{Rp}(\pi, \sigma_{s^i}) + (1 - \lambda) \cdot \text{Rp}(\tilde{\pi}, \sigma_{s^i})} + \frac{(1 - \lambda) \cdot \text{Rp}(\tilde{\pi}, \sigma_{s^i}) \cdot \pi(\cdot \mid s^i)}{\lambda \cdot \text{Rp}(\pi, \sigma_{s^i}) + (1 - \lambda) \cdot \text{Rp}(\tilde{\pi}, \sigma_{s^i})} \quad \forall s_i \in S_i,
$$<p>
\( \pi \) 和 \( \tilde{\pi} \) 的和是 \( \pi \) 和 \( \tilde{\pi} \) 的混合策略，权重分别为 \( \lambda \in (0, 1) \) 和 \( 1 - \lambda \) 。再结合\( \epsilon \)最优响应策略，有文献中的虚拟博弈算法计算一个策略序列 \( \{\pi_t\}_{t \geq 1} \)。具体而言，在第 \( t \) 次迭代中，任何智能体 \( i \) 首先计算 \( t+1 \)-最优响应策略 \( \tilde{\pi}_t^{i+1} \in \text{Br}_{t+1}(\pi_{-i}^t) \)，然后将 \( \pi_t^{i+1} \) 构造为 \( \pi_t^i \) 和 \( \tilde{\pi}_t^{i+1} \) 的混合策略，权重分别为 \( 1 - \alpha_{t+1} \) 和 \( \alpha_{t+1} \)。这里，\( \epsilon_t \) 和 \( \alpha_t \) 都随着 \( t \) 趋于无穷大而收敛到零，并且 \( \sum_{t \geq 1} \alpha_t = \infty \)。
然而，尽管这种方法通过自我博弈可证明收敛到零和博弈的纳什均衡，但由于需要在每次迭代中遍历博弈的所有状态，它遭受维度灾难的困扰。为了计算效率，有文献提出了一个数据驱动的虚拟自我博弈框架，其中最优响应通过拟合 Q 迭代为单智能体强化学习问题进行计算，而混合策略通过监督学习学习。这个框架后来被采用，整合其他单智能体强化学习方法，如深度 Q 网络和蒙特卡洛树搜索。
此外，有文献提出了一个平滑虚拟博弈算法，用于具有同时移动的零和多阶段博弈。算法将 AC 框架与虚拟自我博弈相结合，并通过策略评估隐式推断对手的策略。具体而言，当两个玩家采用联合策略 \( \pi = (\pi^1, \pi^2) \) 时，从玩家1的角度来看，它通过时间差分学习估计 \( Q^{\pi^1,\pi^2} \) 来隐式推断 \( \pi^2 \)，其中 \( \bar{Q}^{\pi^1,\pi^2}: S \times A^1 \to \mathbb{R} \) 定义为
</p>
$$
\bar{Q}^{\pi^1,\pi^2}(s, a^1) = \mathbb{E} \left[ \sum_{t \geq 0} \gamma^t R^1(s_t, a_t, s_{t+1}) \middle| s_0 = s, a^1_0 = a^1, a^2_0 \sim \pi^2(\cdot | s), a_t \sim \pi(\cdot | s_t), \forall t \geq 1 \right]
$$<p>
这是玩家1的动作价值函数，通过 \( \pi^2 \) 进行边际化处理（即考虑策略的所有可能动作分布计算的期望值）。此外，最优响应策略通过相对于 \( Q^{\pi^1,\pi^2} \) 的软贪心策略获得，即：
</p>
$$
\pi^1(a^1 | s) \leftarrow \frac{\exp[\eta^{-1} \cdot Q^{\pi^1,\pi^2}(s, a^1)]}{\sum_{a^1 \in A^1} \exp[\eta^{-1} \cdot Q^{\pi^1,\pi^2}(s, a^1)]},
$$<p>
其中 \( \eta > 0 \) 是平滑参数。最后，该算法同时执行策略评估和策略更新，使用双时间尺度更新，确保在使用自我博弈时，策略更新可以由一个常微分方程来描述，其渐近稳定解是博弈的平滑纳什均衡。
没时间读这篇了，这篇写的是极其系统和严谨的。适合多花点时间仔细阅读，但是我读了太长时间，先这样。</p>
]]></content></item><item><title>EFT阅读</title><link>https://blog.hieros.me/zh/posts/eft/</link><pubDate>Thu, 16 Oct 2025 22:00:00 +0800</pubDate><author>BLESS</author><guid>https://blog.hieros.me/zh/posts/eft/</guid><description>NIPS2024论文笔记——EFT</description><content type="text/html" mode="escaped"><![CDATA[<h1 id="eft---情景未来思维机制">EFT - 情景未来思维机制<a href="#eft---%e6%83%85%e6%99%af%e6%9c%aa%e6%9d%a5%e6%80%9d%e7%bb%b4%e6%9c%ba%e5%88%b6" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h1>
<p>这篇论文作者不多，仅两位，看起来像是学生与导师的组合，同样是国内作者。论文附带公开代码，整体感觉比 AgA 更易读。</p>
<p>论文地址：https://nips.cc/virtual/2024/poster/93443<br>
项目地址：https://github.com/DongsuLeeTech/EFTM</p>
<h2 id="摘要">摘要<a href="#%e6%91%98%e8%a6%81" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>针对多智能体系统中智能体间的异构性问题，作者受动物认知过程启发，为每个智能体设计了一种<strong>情景未来思维机制</strong>（EFT）。首先，作者开发了一种<strong>多角色策略</strong>，用于捕捉多样化的行为特征。在多角色策略中，智能体的性格被定义为奖励组分的不同权重组合。具备 EFT 机制的智能体会收集目标智能体的观测-行动轨迹，利用训练好的多角色策略推断其性格特征。一旦完成推断，该智能体即可预测目标智能体的后续运动，对未来进行推演模拟，从而获得更高的奖励。</p>
<h2 id="介绍">介绍<a href="#%e4%bb%8b%e7%bb%8d" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>认知科学研究所表明，人类会运用反事实思维或未来情景模拟来优化决策。尽管反事实思维已在多智能体强化学习（MARL）中得到广泛应用，但情景未来思维的研究仍相对不足。</p>
<p>传统方法通常通过基于模型的强化学习进行未来轨迹预测，但这需要一个准确的状态转移模型。然而在 MARL 中，由于智能体间的复杂依赖关系，学习状态转移模型变得极其困难。因此，作者在部分可观测马尔可夫决策过程框架下，将奖励函数各部分的权重差异定义为角色特征（例如更偏好安全性或行驶速度），从而形成智能体间差异化的策略与行为模式。</p>
<p>实施 EFT 机制需要两个功能模块：多角色策略与角色推断模块。多角色策略覆盖不同角色的行为模式，支持在连续空间进行部分状态观测，并处理由离散与连续组成的混合动作空间。角色推断模块借鉴&quot;逆向理性控制（IRC）&quot;，即假设每个智能体都有一个并不完美的内部世界模型，寻找最能解释其行为的模型（概念本身也值得学习，参见 <a href="https://doi.org/10.48550/arXiv.2009.12576" target="_blank" >https://doi.org/10.48550/arXiv.2009.12576</a>）。该模块通过最大化目标智能体观测—动作轨迹的对数似然来推断角色：在多角色策略的所有可能参数中，找到最可能产生这些动作的参数（即该角色）。两者结合使智能体具备 EFT 功能，从而在异构多智能体交互中预测他者行为并实现更主动的交互。</p>
<p>要使用 EFT 机制，智能体首先作为观察者收集目标智能体的观测—动作轨迹。随后利用角色推断模块得到目标智能体的角色特征。基于该特征并调用多角色策略，在固定自身动作为&quot;无动作&quot;的前提下预测其他智能体的行为，并模拟未来观测状态。通过这种心智模拟，智能体可估计&quot;其他目标智能体已完成动作而自身尚未行动&quot;时刻的观测，并据此选择最优动作。总体而言，EFT 使智能体能够在异构多智能体交互中实施前瞻性行为。</p>
<p>该机制确实具有前瞻性，但也存在几个潜在不足：其一，自身&quot;无动作&quot;的设定可能使未来观测的模拟存在偏差；其二，EFT 需要对可能出现的角色预先建模，即奖励由若干清晰的组成部分并可通过权重定义角色，这在奖励不明显或策略不明确（如稀疏奖励）场景中适用性受限。</p>
<h2 id="相关工作">相关工作<a href="#%e7%9b%b8%e5%85%b3%e5%b7%a5%e4%bd%9c" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>这篇论文的相关工作很有意思，值得仔细阅读。非 MARL 的相关工作比较多，对于认知科学和认知神经科学的研究，仅作简单翻译。</p>
<p><strong>情景未来思维</strong>：认知神经科学旨在理解人类如何运用记忆进行决策。有研究指出，大脑区域神经激活在反事实推理（即模拟上一情景的替代后果）与未来思维（即模拟未来可能发生的情景）方面呈现出相似趋势，参见 <a href="https://onlinelibrary.wiley.com/doi/10.1111/jpr.12496" target="_blank" >https://onlinelibrary.wiley.com/doi/10.1111/jpr.12496</a>。文献 <a href="https://www.pnas.org/doi/10.1073/pnas.1706589115" target="_blank" >https://www.pnas.org/doi/10.1073/pnas.1706589115</a> 研究了未来思维与决策之间的关系，证实人类会执行面向未来的决策。在需要多智能体交互的场景中（例如社会决策），诸如策略制定等决策能力也具有重要意义。已经有很多研究致力于赋予智能体这种前瞻性的能力，比如有人做了面向智能汽车的多智能体联合的未来轨迹预测、基于时空相关性的短期交通状态预测，但这些多智能体系统预测都只预测了系统整体情况，没有对每个智能体给出预测；有人做了基于改进深度信念网络的横向与纵向驾驶行为预测，也仅预测了智能体的行为，没有显式地将预测结果用于决策上。智能体在搭载 EFT 的情况下，在当前观测和对其他智能体行为的预测的基础上能够预测未来可能的观测，从而做出前瞻性动作。</p>
<p><strong>基于模型的强化学习（MBRL）</strong>：不管是已知环境模型还是使用最大似然估计学习，如果已有环境模型（指代状态转移方程和奖励函数），则可以预测未来轨迹。基于此，智能体可以用一些无模型强化学习用不了的宏观的全局的方法：Dreamer 利用预测轨迹的奖励来优化价值函数，而 MBPO 则将预测轨迹作为增强数据样本进行策略训练，也有工作将这两种算法扩展到了多智能体情况。但是 MBRL 过于理想化，首先必须有全局观测才可能对环境直接建模或者学习，且获取到的数据可能有噪声导致模型存在固有偏差，且智能体越多行为越复杂，这个环境模型就越不好构建。</p>
<p><strong>机器心智理论</strong>：认知科学中存在心智理论（ToM），假设人类先天就能够以类推方式，假定其他人拥有与自己类似的心智，并根据这个假设来观察周围，作出合乎社会期望的反应与行动。或者工程点说，每个人都一个内部模型，人会对别人的内部模型进行估计来预测他的行为，然后做出决策。基于此有人提出了机器心智理论（Machine ToM），给智能体引入 ToM-net 来模拟人的 ToM 能力，ToM-net 包括角色嵌入、心理状态估计、行为预测三个模块，通过观测别的智能体学习他们的潜在意图，预测未来动作；在此基础上有人提出了动态系统 ToM，使用 MDP 实现 ToM；还有人实现了贝叶斯 ToM 框架增强人机团队协作；还有人实现了&quot;推断的推断&quot;框架，使用贝叶斯方法递归地建模多智能体推理过程，智能体不止预测其他智能体的行为，还会预测其他智能体如何看待自己，使用概率图模型捕捉嵌套推理在博弈任务中表现优秀；还有人提出了逆向理性控制，结合 ToM 用以从部分可观测的连续非线性动态中推断智能体的目标和意图，通过学习动态模型和逆向优化推测智能体的行为逻辑（目标函数等）。作者说上面这些套路只适用于智能体少、动作空间小、角色差异不大的场景，我没看出来为什么，但是直观上看计算量和网络复杂度应该是随智能体数量增加而迅速增加的。作者的工作和他们的相比，总的来看就是规定了智能体有哪些类型，提前把对应类型每个智能体的行为给训练出来，然后每个智能体在训练时看别的智能体只需要对号入座就行，另外他也把动作空间从连续的拓展到了混合型。</p>
<p><strong>错误共识效应（False Consensus Effect）</strong>：是说心理学研究中发现，人会倾向于认为自身特质行为等具有普遍性，还是那篇 Machine ToM，他们发现 AI 也会有这个问题。所以作者为了比对 EFT 的重要性，设计了一个基于 FCE 的对照，对比智能体会认为其他智能体的角色与自身角色一致。</p>
<h2 id="基于多角色策略的角色推断">基于多角色策略的角色推断<a href="#%e5%9f%ba%e4%ba%8e%e5%a4%9a%e8%a7%92%e8%89%b2%e7%ad%96%e7%95%a5%e7%9a%84%e8%a7%92%e8%89%b2%e6%8e%a8%e6%96%ad" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<h3 id="多智能体决策的问题表述-ma-pomdp">多智能体决策的问题表述-MA-POMDP<a href="#%e5%a4%9a%e6%99%ba%e8%83%bd%e4%bd%93%e5%86%b3%e7%ad%96%e7%9a%84%e9%97%ae%e9%a2%98%e8%a1%a8%e8%bf%b0-ma-pomdp" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>定义</p>
$$
M = \langle E, S, {O_i}, {A_i}, T, {\Omega_i}, {R_i}, \gamma \rangle_{i \in E} 
$$<p>其中 \(E\) 是智能体的索引集合，连续状态 \(s_t \in S\) ，连续观测 \(o_{t,i} \in O_i\) ，混合动作 \(a_{i,t} = \{ a_{t,i}^c, a_{t,i}^d \} \in A_i\) ，其中 \(a_{t,i}^c\) 是连续动作，离散动作 \(a_{t,i}^d \in A_i^d = \{w: | w | \leq W, w \in \mathbb{Z}, W \in \mathbb{N}\}\) ，离散动作空间规模为 \(|A_i^d| = 2W + 1\) 。</p>
<p>令 \(A := A_1 \times A_2 \times \cdots \times A_N\) ，有 \(T: S \times A \to S\) 是状态转移概率， \(O_i: S \times A \to O_i\) 是观测概率， \(R_i: S \times A \to \mathbb{R}\) 是奖励函数， \(\gamma \in (0, 1)\) 是折扣因子。</p>
<p>时刻 \(t\) 所有智能体动作的无序集合记为 \(a_t = \langle a_{t,1}, \cdots, a_{t,i}, \cdots, a_{t,N} \rangle = \langle a_{t,i}, a_{t,-i} \rangle \in A\) ，其中下标 \(-i\) 表示集合 \(E\) 中除智能体 \(i\) 外所有智能体的索引。因此， \(a_{t,-i} = \langle a_{t,1}, \cdots, a_{t,i-1}, a_{t,i+1} \cdots, a_{t,N} \rangle\) 表示时刻 \(t\) 除 \(a_{t,i}\) 外所有智能体的动作集合。状态转移概率记为 \(T(s_{t+1}|s_t, a_t)\) 。注意，状态转移基于所有智能体的动作组合 \(a_t\) ，而非单个智能体的动作 \(a_{t,i}\) 。</p>
<p>接下来， \(c_i = \{c_{i,1}, c_{i,2}, \cdots, c_{i,K}\} \in C \in \mathbb{R}^K\) 表示智能体 \(i\) 的 \(K\) 维角色向量。角色 \(c_i\) 可以参数化智能体 \(i\) 的奖励函数，即 \(R_{t,i} = R_i(s_t, a_{t,i}, s_{t+1}; c_i)\) 。直观理解：奖励函数取决于当前状态、下一状态、动作以及角色。</p>
<p>智能体的目标是学习最优策略，在给定观测和角色的情况下返回最优动作 \(a^*_{t,i} \sim \pi^*(\cdot|o_{t,i}; c_i)\) 。具体而言，智能体的目标是通过构建最佳策略 \(\pi\) 来最大化期望折扣累积奖励：</p>
$$
J(\pi) = E_\pi \left[ \sum_t \gamma^t R_i(s_t, a_{t,i}, s_{t+1}; c_i) \right]
$$<p>这定义了状态-动作价值函数：</p>
$$
Q^\pi(s, a; c_i) = E_\pi \left[ \sum_t \gamma^t R_i(s_t, a_{t,i}, s_{t+1}; c_i) \bigg| s_0 = s, a_0 = a \right]
$$<h3 id="训练多角色策略">训练多角色策略<a href="#%e8%ae%ad%e7%bb%83%e5%a4%9a%e8%a7%92%e8%89%b2%e7%ad%96%e7%95%a5" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>多角色策略包括连续空间的输入（如观测 \(o_{t,i}\) 和角色 \(c_i\) ）和混合空间的输出（如动作 \(a_{t,i}\) ）。为了构建在连续空间上泛化的策略，作者采用了 Actor-Critic 架构。该架构近似策略 \(\pi_\phi(\cdot|o_{t,i}; c_i)\) 和 Q 函数 \(Q_\theta(o_{t,i}, a_{t,i}; c_i)\) ，其中 \(\phi\) 表示 Actor 网络的参数， \(\theta\) 表示 Critic 网络的参数。</p>
<p>用于训练 Actor 和 Critic 网络的损失函数分别为：</p>
<ul>
<li>\(L(\phi) = -Q_\theta(o_{t,i}, \pi_\phi(\cdot|o_{t,i}; c_i))\)</li>
<li>\(L(\theta) = |y_t - Q_\theta(o_{t,i}, \pi_\phi(\cdot|o_{t,i}; c_i))|^2\)</li>
</ul>
<p>其中， \(y_t = R_{t,i} + Q_{\theta'}(o_{t+1,i}, \pi_{\phi'}(\cdot|o_{t+1,i}; c_i))\) 表示时序差分（TD）目标， \(\theta'\) 和 \(\phi'\) 表示目标网络。</p>
<p>接下来，作者提出了一个后处理器 \(g(\cdot)\) 来处理混合动作空间。设原型动作 \(\bar{a}^d_{t,i}\) 为 Actor 网络的输出。后处理器 \(g(\cdot)\) 通过将连续的原型动作 \(\bar{a}^d_{t,i}\) 离散化为离散的后动作 \(a^d_{t,i}\) 来执行量化过程，即：</p>
$$
a^d_{t,i} = g(\bar{a}^d_{t,i}, W) = \min\left(\left\lfloor \frac{2W + 1}{2W} \left( \bar{a}^d_{t,i} + \frac{W}{2W + 1} \right) \right\rfloor, W\right)
$$<p>其中 \(\lfloor \cdot \rfloor\) 表示向下取整函数。</p>
<p>后处理函数构建过程推导如下，先证明区间映射规则：</p>
$$
a^d_t = w, \text{ 如果 } w - \frac{W + w}{2W + 1} < \bar{a}^d_t \leq w + \frac{W - w}{2W + 1}
$$<p>为了让每个连续值都均匀地映射到某个离散值，区间不重叠没空洞，边界无特殊处理，就需要每个区间的长度都为 \(\frac{2W}{2W + 1}\) ，区间可以写成以 \(w\) 为中心的左右偏移，即：</p>
$$
w - L(w) \leq \bar{a}^d_t < w + R(w)
$$<p>再令连续两个区间边界对齐有：</p>
$$
w + R(w) = (w + 1) - L(w + 1)
$$<p>左右边界需对齐有</p>
$$
\begin{aligned}
L(- W) &= - W \\
R(W) &= W
\end{aligned}
$$<p>设左右偏移随 \(w\) 线性变化，解的表达式为：</p>
$$
\begin{aligned}
L(w) &= w - \frac{W + w}{2W + 1} \\
R(w) &= w + \frac{W - w}{2W + 1}
\end{aligned}
$$<p>该条件可以写成 \(a^d_t = w\) 的范围：</p>
$$
\frac{2W + 1}{2W} \left( \bar{a}^d_t - \frac{W}{2W + 1} \right) \leq w < \frac{2W + 1}{2W} \left( \bar{a}^d_t + \frac{W}{2W + 1} \right)
$$<p>它可以重新表述为：</p>
$$
w = \min\left( \left\lfloor \frac{2W + 1}{2W} \left( \bar{a}^d_t + \frac{W}{2W + 1} \right) \right\rfloor, W \right)
$$<p>其中 \(\min(\cdot, W)\) 防止 \(w\) 超出动作空间 \([-W, W]\) 的范围。这里，在不等式的右侧使用了向下取整函数。在该不等式左侧也可以使用向上取整函数作为替代，配合最大值函数 \(\max(\cdot, -W)\) 。</p>
<p>后处理器函数 \(a^d_t = g(\bar{a}^d_t, W)\) 最终表述如下：</p>
$$
g(\bar{a}^d_t, W) = \min\left( \left\lfloor \frac{2W + 1}{2W} \left( \bar{a}^d_t + \frac{W}{2W + 1} \right) \right\rfloor, W \right)
$$<p>训练时，每个 episode 开始随机选择一个角色 \(c_i\) 应用于该 episode，Actor 仅输出连续值 \(\{ a_{t,i}^c, \bar{a}^d_{t,i} \}\) ，随后通过后处理器 \(g(\cdot)\) 得到离散动作 \(a^d_{t,i}\) 。</p>
<h3 id="推理目标智能体的角色">推理目标智能体的角色<a href="#%e6%8e%a8%e7%90%86%e7%9b%ae%e6%a0%87%e6%99%ba%e8%83%bd%e4%bd%93%e7%9a%84%e8%a7%92%e8%89%b2" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>完成多角色策略的训练后，需要推断目标智能体 \(j \in E\) 的角色 \(c_j\) 。智能体首先收集目标智能体的观测-动作轨迹用于角色推断。随后，它利用多角色策略来识别最能解释收集数据的角色 \(c_j\) ，可以通过最大化观测-动作轨迹的对数似然 \(\ln P(o_{1:T,j}, a_{1:T,j}|c_j)\) 来估计。这可以表述如下：</p>
$$
\hat{c}_j = \arg \max_c \ln P(o_{1:T,j}, a_{1:T,j}|c) = \arg \max_c \sum_{t=1}^T [\ln \pi(a^c_{t,j}|o_{t,j}; c) + \ln \pi(a^d_{t,j}|o_{t,j}; c)]
$$<p>其证明过程如下：</p>
<p>为使上式可计算，我们从对数证据开始，构造一个可优化的下界并逐步分解到策略项。令 \(q(s_{1:T}) := P(s_{1:T} \mid o_{1:T,j}, a_{1:T,j} \mid c)\) （后验状态分布），有：</p>
$$
\hat{c}_j
= \arg\max_c \ln P(o_{1:T,j}, a_{1:T,j} \mid c)
= \arg\max_c \ln \int  P(o_{1:T,j}, a_{1:T,j} \mid c) \, ds_{1:T}
$$<p>等价地，分子分母同乘 \(P(s_{1:T} \mid o_{1:T,j}, a_{1:T,j}; c)\) 可写为：</p>
$$
= \arg\max_c \ln \int P(s_{1:T} \mid o_{1:T,j}, a_{1:T,j}; c) \times \frac {P(s_{1:T}, o_{1:T,j}, a_{1:T,j} \mid c)} {P(s_{1:T} \mid o_{1:T,j}, a_{1:T,j}; c)} \, ds_{1:T}
$$<p>将 \(P(s_{1:T} \mid o_{1:T,j}, a_{1:T,j}; c)\) 视为某随机变量的概率密度函数， \(\frac {P(s_{1:T}, o_{1:T,j}, a_{1:T,j} \mid c)} {P(s_{1:T} \mid o_{1:T,j}, a_{1:T,j}; c)}\) 视为作用于该随机变量上的某函数，对凹函数 \(\ln(\cdot)\) 使用 Jensen 不等式（描述凹凸函数，期望的函数和函数的期望关系的不等式） \(f(\mathbb{E}[X]) \ge \mathbb{E}[f(X)]\) ，得到对数证据的下界（ELBO）：</p>
$$
\geq \arg\max_{c} \int P(s_{1:T} \mid o_{1:T,j}, a_{1:T,j}; c) \times \ln \frac {P(s_{1:T}, o_{1:T,j}, a_{1:T,j} \mid c)} {P(s_{1:T} \mid o_{1:T,j}, a_{1:T,j}; c)} \, ds_{1:T}
$$$$
= \arg\max_{c} \int P(s_{1:T} \mid o_{1:T,j}, a_{1:T,j}; c) \times (\ln {P(s_{1:T}, o_{1:T,j}, a_{1:T,j} \mid c)} - \ln {P(s_{1:T} \mid o_{1:T,j}, a_{1:T,j}; c)}) \, ds_{1:T}
$$<p>
由熵的定义式 \(H(\cdot) = - \int P(\cdot) \ln P(\cdot)\) ，有：</p>
$$
=  \arg\max_{c} \{
\int {P(s_{1:T} \mid o_{1:T,j}, a_{1:T,j}; c)} \ln P(s_{1:T}, o_{1:T,j}, a_{1:T,j} \mid c) \, ds_{1:T} + H[{P(s_{1:T} \mid o_{1:T,j}, a_{1:T,j}; c)}]
\}
$$<p>由于熵 \(H(\cdot) \ge 0\) ，进一步得到更简洁的可优化目标：</p>
$$
\ge \arg\max_c \int P(s_{1:T} \mid o_{1:T,j}, a_{1:T,j}; c) \ln P(s_{1:T}, o_{1:T,j}, a_{1:T,j} \mid c) \, ds_{1:T} \tag{6}
$$<p>接下来用马尔可夫性质分解联合概率：</p>
$$
P(s_{1:T}, o_{1:T,j}, a_{1:T,j} \mid c)
= P(s_1) \prod_{t=1}^T \Omega_j(o_{t,j} \mid s_t)
\prod_{t=1}^T \pi(a_{t,j} \mid o_{t,j}, s_t; c)
\prod_{t=1}^{T-1} T(s_{t+1} \mid s_t, a_t)
$$<p>因此</p>
$$
\arg\max_c \int P(s_{1:T}, o_{1:T,j}, a_{1:T,j} \mid c) [\ln P(s_1) + \sum_{t=1}^T \ln \Omega_j(o_{t,j} \mid s_t) + \sum_{t=1}^T \ln \pi(a_{t,j} \mid o_{t,j}, s_t; c) + \int \sum_{t=1}^{T} \ln T(s_{t+1} \mid s_{t,j}, a_{t,-j})da_{1:T,-j}] ds_{1:T}
$$<p>式中转移概率由于不知道别的智能体的动作所以只能使用期望替代。</p>
<p>由于 \(\ln P(s_1)\) 、 \(\ln \Omega_j(\cdot)\) 、 \(\ln T(\cdot)\) 不依赖于角色 \(c\) ，对 \(c\) 的最大化时可忽略这些项，仅保留与策略相关的项：</p>
$$
= \arg\max_c \int P(s_{1:T}, o_{1:T,j}, a_{1:T,j} \mid c) \sum_{t=1}^T \ln \pi(a_{t,j} \mid o_{t,j}, s_t; c) \, ds_{1:T} 
$$<p>策略在实现上只以观测 \(o_{t,j}\) 作为输入（MA-POMDP 中的 actor 不显式用 \(s_t\) ），因此可以忽略对于状态的积分：</p>
$$
= \arg\max_c \sum_{t=1}^T \ln \pi(a_{t,j} \mid o_{t,j}; c) \tag{9}
$$<p>在混合动作空间下，策略对连续与离散分量进行因子分解： \(\pi(a_{t,j} \mid o_{t,j}; c) = \pi(a^c_{t,j} \mid o_{t,j}; c) \cdot \pi(a^d_{t,j} \mid o_{t,j}; c)\) ，于是</p>
$$
= \arg\max_c \sum_{t=1}^T \Big[
\ln \pi(a^c_{t,j} \mid o_{t,j}; c) + \ln \pi(a^d_{t,j} \mid o_{t,j}; c)
\Big] \tag{10}
$$<p>其中离散分量的观测 \(a^d_{t,j}\) 已由环境产生；训练推断时仅需对策略离散分支在该值上的对数概率求和。</p>
<p>实现上，在每个观测-动作轨迹上，对目标智能体角色的计算式 \(\hat{c}_j\) ，采用梯度上升法优化 \(c_j\) 到最可能的角色，实现某个智能体对目标智能体角色的估计。</p>
<h2 id="基于情景未来思维机制的预见性动作选择">基于情景未来思维机制的预见性动作选择<a href="#%e5%9f%ba%e4%ba%8e%e6%83%85%e6%99%af%e6%9c%aa%e6%9d%a5%e6%80%9d%e7%bb%b4%e6%9c%ba%e5%88%b6%e7%9a%84%e9%a2%84%e8%a7%81%e6%80%a7%e5%8a%a8%e4%bd%9c%e9%80%89%e6%8b%a9" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<h3 id="动作预测">动作预测<a href="#%e5%8a%a8%e4%bd%9c%e9%a2%84%e6%b5%8b" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>在&quot;动作预测&quot;这一步，具备多角色策略的智能体使用&quot;预先推断的角色&quot;与观测，来预测邻近智能体的动作。对目标智能体 \(j\) （ \(j \in E,\, j \ne i\) ），基于已训练的多角色策略 \(\pi_\phi\) 与已推断角色 \(\hat c_j\) 进行预测：</p>
$$
\hat a_{t,j} \sim \pi_\phi(\cdot \mid o_{t,j}; \hat c_j).
$$<p>由此，其他智能体的预测动作集合 \(\hat a_{t,-i}\) 为：</p>
$$
\hat a_{t,-i} = \langle \pi_\phi(o_{t,1}; \hat c_1),\, \cdots,\, \pi_\phi(o_{t,i-1}; \hat c_{i-1}),\, \pi_\phi(o_{t,i+1}; \hat c_{i+1}),\, \cdots,\, \pi_\phi(o_{t,N}; \hat c_N) \rangle.
$$<h3 id="下一观测模拟">下一观测模拟<a href="#%e4%b8%8b%e4%b8%80%e8%a7%82%e6%b5%8b%e6%a8%a1%e6%8b%9f" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>在&quot;下一观测模拟&quot;这一步，我们介绍如何用预测的动作集合 \(\hat a_{t,-i}\) 来模拟智能体的下一观测。注意：该预测来源于智能体 \(i\) 的&quot;脑模拟&quot;，其假设自身在当前时刻未执行动作，即 \(a_{t,i} = \varnothing\) （ \(\varnothing\) 表示&quot;空动作&quot;，即不采取任何动作）。这样做是为了模拟&quot;其他目标智能体均已执行动作、但智能体 \(i\) 尚未执行&quot;的时刻的观测。</p>
<p>定义下一观测模拟函数 \(D(\cdot)\) ：</p>
$$
\hat o_{t+1,i} = D(o_{t,i}, \hat a_{t,-i},\, a_{t,i}=\varnothing).
$$<p>通过 \(\hat a_{t,-i}\) 与当前观测 \(o_{t,i}\) ，即可确定模拟的下一观测 \(\hat o_{t+1,i}\) 。使用 \(\hat o_{t+1,i}\) 进行动作选择，能够让智能体&quot;忽略其他体动作的影响&quot;，因为在脑模拟中，下一状态仅由自身动作 \(a_{t,i}\) 决定——其他体动作的影响已在 \(\hat o_{t+1,i}\) 中提前应用。</p>
<h3 id="动作选择">动作选择<a href="#%e5%8a%a8%e4%bd%9c%e9%80%89%e6%8b%a9" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>当智能体得到模拟的下一观测 \(\hat o_{t+1,i}\) 后，即可进行前瞻性决策。智能体以 \(\hat o_{t+1,i}\) 与自身角色 \(c_i\) 作为输入，使用多角色策略 \(\pi_\phi\) 获得原型动作：</p>
$$
a_{t,i}^\text{proto} = \{a^c_{t,i},\, \bar a^d_{t,i}\} = \pi_\phi(\cdot \mid \hat o_{t+1,i}; c_i),
$$<p>随后应用后处理器 \(g(\cdot)\) 得到执行的离散动作：</p>
$$
a^d_{t,i} \leftarrow g(\bar a^d_{t,i}, W),\quad a_{t,i} = \{a^c_{t,i},\, a^d_{t,i}\}.
$$<p>换言之，智能体能够在&quot;考虑其他体即将采取的行为&quot;的前提下，选择更具适应性的当前动作。</p>
<h2 id="半个结论">半个结论<a href="#%e5%8d%8a%e4%b8%aa%e7%bb%93%e8%ae%ba" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>EFT 应该是一个在仅 act 过程中的模块，但是进一步的情况得仔细读代码了，这篇比 AgA 更不好读，公式推导已经给我干废一半了，代码阅读之后再说，粗看他使用的flow 和 rllib 框架，我没用过阅读也有点难度。</p>
<h2 id="1017改">10.17改<a href="#1017%e6%94%b9" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>代码这块，我不是很懂他的结构，应该是把各个部分都定义好，然后送到 flow 里训练，很多组件都在 flow 中定义好了。总体来看，训练过程中没有使用到 EFT 模块，只在 act 过程中使用了 EFT 模块。多角色策略的使用和定义在 characterinference 中，里面有轨迹收集和 loss 等，但我确实没有显式地看到训练过程。在 visualize 中只有加载，没有训练过程，训练过程在 train_rllib 中，但没有显式的训练结构。他提到的角色向量是指奖励中各部分的权重所构成的权重向量，使用训练好的多角色策略结合当前观测和权重向量即可获知下一个 action。他的状态转移非常简单，所以可以在不动用环境的前提下直接算出来，然后智能体根据下个状态做行动。思路就是这么个思路，细节一些的就有点难找了，譬如哪些信息是全局的、哪些又是局部的等等，只能借鉴思路了，迁移应该不大简单。</p>
<p>实验就不看了我觉得既然不方便迁移我就觉得没必要。</p>
]]></content></item><item><title>AgA阅读</title><link>https://blog.hieros.me/zh/posts/aga/</link><pubDate>Wed, 15 Oct 2025 23:00:00 +0800</pubDate><author>BLESS</author><guid>https://blog.hieros.me/zh/posts/aga/</guid><description>NIPS2024论文笔记——AgA</description><content type="text/html" mode="escaped"><![CDATA[<h1 id="多智能体协作中个体与集体目标的对齐">多智能体协作中个体与集体目标的对齐<a href="#%e5%a4%9a%e6%99%ba%e8%83%bd%e4%bd%93%e5%8d%8f%e4%bd%9c%e4%b8%ad%e4%b8%aa%e4%bd%93%e4%b8%8e%e9%9b%86%e4%bd%93%e7%9b%ae%e6%a0%87%e7%9a%84%e5%af%b9%e9%bd%90" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h1>
<p>看着很高级，还是国人写的，感觉应该会很有收获，作者主要在曼彻斯特大学和上交，可惜没代码，什么时候复现试试。</p>
<p>论文地址： <a href="https://nips.cc/virtual/2024/poster/96810" target="_blank" >https://nips.cc/virtual/2024/poster/96810</a></p>
<h2 id="前置知识">前置知识<a href="#%e5%89%8d%e7%bd%ae%e7%9f%a5%e8%af%86" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>我吃了不会数学的亏，先研究了一下博弈。</p>
<p>简单入门基础概念可以看 <a href="https://copy2049.github.io/blog/html/2020/11/Game-Theory.html" target="_blank" >https://copy2049.github.io/blog/html/2020/11/Game-Theory.html</a> ，感觉不错，短小精悍。</p>
<h3 id="混合动机博弈">混合动机博弈<a href="#%e6%b7%b7%e5%90%88%e5%8a%a8%e6%9c%ba%e5%8d%9a%e5%bc%88" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p><strong>Mixed-Motive Game</strong>，是指合作和竞争并存、非零和的博弈。合作和竞争是指智能体既要考虑整体目标，又要考虑个体目标，既有可能合作扩大整体利益，也有可能破坏合作扩大自身利益；非零和是指智能体间的总体利益不是一个常数。</p>
<h3 id="可微分博弈">可微分博弈<a href="#%e5%8f%af%e5%be%ae%e5%88%86%e5%8d%9a%e5%bc%88" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p><strong>differential game</strong>，一种运用在动态系统中的博弈理论，主要研究在连续时间的过程中，多方参与者如何进行策略选择，以实现自己的目标。这种博弈和 MARL 的随机博弈略有差异，侧重点不一样：可微博弈强调策略可微，重点研究的是优化方法；随机博弈强调环境的动态和不确定性，重点研究的是策略互动。</p>
<h2 id="摘要">摘要<a href="#%e6%91%98%e8%a6%81" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>作者将多智能体学习中的混合动机博弈建模为可微分博弈，以解决个体目标和集体目标的协调问题，避免人工的奖励设计。提出了名为**利他梯度调整（AgA）**的优化方法，通过梯度调整逐步协调个体与集体目标，从理论上证明了 AgA 在兼顾个体利益的同时能将梯度有效吸引至集体目标的稳定不动点，并做了验证。</p>
<h2 id="介绍">介绍<a href="#%e4%bb%8b%e7%bb%8d" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>多智能体合作主要分为两大研究方向：<strong>纯动机合作</strong>和<strong>混合动机合作</strong>。纯动机合作是指智能体只考虑整体目标，竞争不明显；混合动机合作是指智能体既要考虑整体目标，又要考虑个体目标，竞争与合作并存。</p>
<p>在混合动机合作方向下，目前促进合作的方式依赖于人工设计某些机制，譬如：</p>
<ul>
<li><strong>声誉体系</strong>：通过记录智能体过去的行动（例如是否合作、是否遵守规则），为其分配声誉分数。其他智能体会根据声誉选择是否与其交互；</li>
<li><strong>规范约束</strong>：智能体集体可以制裁不遵循社会规范的智能体，规范约束减少不合作或有害行为；</li>
<li><strong>契约机制</strong>：智能体通过&quot;签约&quot;同意遵循特定规则，执行特定任务，并根据契约条款获得奖励或惩罚。</li>
</ul>
<p>还有将个体奖励与集体奖励相融合的研究；偏好奖励研究，通过分析其他智能体的奖励或行为，偏好信号为智能体提供&quot;社会线索&quot;，鼓励利他；学习智能体行为对他人产生的潜在影响。</p>
<p>贡献总结这块有个点值得注意一下，作者开发了一个名为 <strong>selfish-MMM2</strong> 的大规模混合动机协作环境，同时在多个场景里验证了所提出的算法。</p>
<h2 id="背景介绍">背景介绍<a href="#%e8%83%8c%e6%99%af%e4%bb%8b%e7%bb%8d" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<h3 id="可微分博弈-1">可微分博弈<a href="#%e5%8f%af%e5%be%ae%e5%88%86%e5%8d%9a%e5%bc%88-1" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>微分博弈可以定义为 \(\{N, w, l\}\)，其中 \(N = \{1, \ldots, n\}\) 表示玩家集合，\(w = [w_i]^n \in \mathbb{R}^d\) 代表所有玩家的参数集合，其中 \(w_i \in \mathbb{R}^d\) 是第 \(i\) 个玩家的参数向量，\(d = \sum_{i=1}^n d_i\) 是每个玩家参数向量的维度的综合。损失函数定义为 \(l = \{l_i : \mathbb{R}^d \to \mathbb{R}\}_{i=1}^n\)，损失函数至少二阶可微，每个玩家 \(\{i \in N\}\) 都有一个策略，这个策略由参数 \(w_i\) 确定，目标是最小化损失函数 \(l_i\)。</p>
<p>定义 \(\xi(w) = (\nabla_{w_i} l_i, \ldots, \nabla_{w_n} l_n) \in \mathbb{R}^d\) 为玩家的梯度集合，命名为<strong>同时梯度</strong>，\(\nabla_{w_i} l_i\) 是损失函数 \(l_i\) 对玩家 \(i\) 参数 \(w_i\) 的梯度。微分博弈中<strong>黑塞矩阵</strong>被定义为同时梯度的雅各比矩阵，即 \(H(w) = (\nabla_{w_i} \nabla_{w_j} l_i, \ldots, \nabla_{w_i} \nabla_{w_n} l_n) \in \mathbb{R}^{d \times d}\)。</p>
<p>黑塞矩阵是一个多元函数所有二阶偏导构成的矩阵，雅各比矩阵则是对一个多元函数在某一个点上求梯度的结果。这样描述不够准确，给出严谨定义：假设某多元函数从 \(f : \mathbb{R}^n \to \mathbb{R}^m\) 即从向量 \(x \in \mathbb{R}^n\) 映射到向量 \(f(x) \in \mathbb{R}^m\)，其雅各比矩阵是一个 \(m \times n\) 的矩阵：</p>
$$
\mathbf{J}
= \left[ \frac{\partial \mathbf{f}}{\partial x_1} \quad \cdots \quad \frac{\partial \mathbf{f}}{\partial x_n} \right]
= \begin{bmatrix}
\frac{\partial f_1}{\partial x_1} & \cdots & \frac{\partial f_1}{\partial x_n} \\
\vdots & \ddots & \vdots \\
\frac{\partial f_m}{\partial x_1} & \cdots & \frac{\partial f_m}{\partial x_n}
\end{bmatrix}
$$<p>不严谨地说，是指每个方向的分函数对于输入向量的每个元素的偏导，组成一个 \(m \times n\) 的矩阵，或者说对每个方向的分函数求梯度，组成一个 \(m \times n\) 的矩阵。</p>
<p>由于同时梯度是每个玩家的损失对自身参数的梯度，即</p>
$$
\xi(w)=
\begin{bmatrix}
\nabla_{w_1}l_1 \\[4pt]
\nabla_{w_2}l_2 \\[4pt]
\vdots \\[4pt]
\nabla_{w_n}l_n
\end{bmatrix}
\in \mathbb{R}^{d}
$$<p>由于参数向量 \(w\) 是 \(d\) 维向量，所以同时梯度也是 \(d\) 维向量，再对 \(w\) 计算雅各比矩阵，得到黑塞矩阵：</p>
$$
H(w) = \mathbf{J}^T \mathbf{J}
= \begin{bmatrix}
\nabla_{w_1} \nabla_{w_1} l_1 & \cdots & \nabla_{w_1} \nabla_{w_n} l_n \\
\vdots & \ddots & \vdots \\
\nabla_{w_n} \nabla_{w_1} l_1 & \cdots & \nabla_{w_n} \nabla_{w_n} l_n
\end{bmatrix}
$$<p>其中每个元素 \(H_{ij}= \frac{\partial^{2} l_i}{\partial w_i \partial w_j}\) 表示玩家 \(i\) 的损失函数 \(l_i\) 关于自身参数 \(w_i\) 与玩家 \(j\) 的参数 \(w_j\) 的二阶混合偏导，刻画了玩家 \(j\) 的策略变化对玩家 \(i\) 的交叉影响，其对角线元素为玩家 \(i\) 损失函数 \(l_i\) 关于自身参数 \(w_i\) 的二阶偏导，即 \(H_{ii} = \frac{\partial^{2} l_i}{\partial w_i^2}\)。这就是微分博弈中黑塞矩阵被定义为同时梯度的雅各比矩阵的含义。</p>
<p>作者提到的微分博弈的<strong>学习动态</strong>是一阶方法例如梯度下降，不显式使用黑塞矩阵，可以表示为：</p>
$$
w_{t+1} \leftarrow w_t - \alpha_t \xi(w_t)
$$<p>其中 \(\alpha_t\) 是学习率，\(\xi(w_t)\) 是同时梯度。这一更新规则意味着所有玩家在同一时刻沿着自身损失函数的负梯度方向同步调整参数，各自独立地最小化自身损失。</p>
<h3 id="梯度调整优化">梯度调整优化<a href="#%e6%a2%af%e5%ba%a6%e8%b0%83%e6%95%b4%e4%bc%98%e5%8c%96" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p><strong>梯度调整优化</strong>就我理解是指在微分博弈中如何让玩家的策略向<strong>稳定不动点</strong>方向调整，与 MARL 结合，其核心应该是促进收敛，减少循环和不稳定性。</p>
<p>首先是<strong>不动点</strong>的概念，在微分博弈中，若 \(w^*\) 是一个不动点，则说明该点处<strong>同时梯度</strong> \(\xi(w^*) = 0\)，即所有玩家没有动力更新其策略；在不动点 \(w^*\) 处，若<strong>黑塞矩阵</strong> \(H(w^*)\) 为半正定矩阵且可逆时，\(w^*\) 称为<strong>稳定不动点</strong>，若黑塞矩阵 \(H(w^*)\) 为负定矩阵，则 \(w^*\) 称为<strong>不稳定不动点</strong>。</p>
<p>一种朴素的引导学习动态收敛到不动点的思路是，最小化同时梯度的平方范数，也是构造了一个<strong>李雅普诺夫函数</strong>，即：</p>
$$
\min{\frac{1}{2} \| \xi(w) \|^2}
$$<p>因为，这个就不推了，我矩阵论水平很次</p>
$$
\nabla{\frac{1}{2} \| \xi(w) \|^2} = H^T\xi
$$<p>当 \(H(w^*)\) 可逆时，\(H^T\xi = 0\) 等价于 \(\xi = 0\)，即在黑塞矩阵可逆时，最小化同时梯度的平方范数，等价于寻找一个不动点，直观地看这个点可能是不稳定的。</p>
<p>还有一种叫**共识优化（CGA）**的方法，引入梯度调整项，然后使用调整过的同时梯度进行更新：</p>
$$
\tilde{\xi} = \xi + \lambda \cdot \nabla\tfrac{1}{2} \| \xi(w) \|^2
$$<p>还有<strong>辛梯度下降（SGA）</strong>，也引入了一个修改项，即：</p>
$$
\tilde{\xi} = \xi + \lambda \cdot A^T\xi
$$<p>其中 \(A^T\) 是黑塞矩阵的<strong>广义亥姆霍兹分解</strong>，简单说就是对称反对称分解，即：</p>
$$
S = \frac{1}{2} (H(w) + H(w)^T)
A = \frac{1}{2} (H(w) - H(w)^T)
$$<p>\(A\) 是黑塞矩阵的<strong>反对称部分</strong>，在零和博弈中，\(A \approx H\) SGA 退化为 CGA，一般和博弈中，只使用反对称部分更新，为什么效果好，我没看懂，效果好的原因参见 <a href="https://arxiv.org/abs/1802.05642" target="_blank" >https://arxiv.org/abs/1802.05642</a>。</p>
<h2 id="主要方法">主要方法<a href="#%e4%b8%bb%e8%a6%81%e6%96%b9%e6%b3%95" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<h3 id="混合动机微分博弈">混合动机微分博弈<a href="#%e6%b7%b7%e5%90%88%e5%8a%a8%e6%9c%ba%e5%be%ae%e5%88%86%e5%8d%9a%e5%bc%88" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p><strong>可微分混合动机博弈（Differentiable Mixed-Motive Game, DMG）</strong>，基本定义与微分博弈一致，区别在于可微的损失函数具有<strong>混合动机特性</strong>：个体目标与集体目标之间存在冲突；除去同时梯度外，定义<strong>集体损失梯度</strong> \(\xi_c(w) = (\nabla_{w_1} l_c, ..., \nabla_{w_n} l_c)\)。</p>
<p>微分混合动机博弈中存在<strong>对齐困境</strong>，分别优化个体损失和集体损失，会导致玩家策略向不同方向调整。如果使用梯度下降法对集体损失进行优化，如果存在<strong>奇异点</strong>，即梯度为零但黑塞矩阵奇异的点，那么梯度下降无法收敛到这个点。</p>
<p>作者举了一个例子阐述他的优化方法：</p>
<p>一个两玩家的可微分博弈，玩家 1 的损失函数为
</p>
$$l_1(a_1, a_2) = -\sin(a_1 a_2 + a_2^2)$$<p>
玩家 2 的损失函数为
</p>
$$l_2(a_1, a_2) = -[\cos(1+a_1-(1+a_2)^2+a_1a_2^2)]$$<p>
其中 \(a_i\) 表示玩家 \(i \in \{1, 2\}\) 的动作变量，且 \(a_i \in \mathbb{R}\)，每个玩家的奖励为损失函数的相反数，定义 \(l_c = l_1 + l_2\) 为<strong>集体损失函数</strong>。</p>
<p>作者对比了四种方法：没有改进的学习动态、CGA、SGA、使用集体损失的学习动态。结论是，前三种方法只能将解收敛到不稳定点和局部最大值，而使用集体损失可以将解收敛到集体奖励的稳定不动点，但是玩家 1 的奖励没有收敛到一个不动点，这表明更新没有考虑到玩家 1 的个体目标。</p>
<h3 id="aga---利他梯度调整">AgA - 利他梯度调整<a href="#aga---%e5%88%a9%e4%bb%96%e6%a2%af%e5%ba%a6%e8%b0%83%e6%95%b4" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>类似于 CGA 和 SGA 的思路，<strong>AgA</strong> 引入了一个<strong>梯度调整项</strong>，即：</p>
$$
\tilde{\xi} = \xi_c + \lambda\xi_{adj} = \xi_c + \lambda (\xi + H_c^T\xi_c)
$$<p>其中 \(\lambda \in \mathbb{R}\) 是一个<strong>对齐系数</strong>，\(\lambda\xi_{adj}\) 是梯度调整项，\(\xi_c\) 是<strong>集体损失梯度</strong>，在集体梯度的基础上，调整项给它做修正，\(H_c^T\) 是集体损失黑塞矩阵的转置。注意，黑塞矩阵 \(H_c\) 是一个对称矩阵，该形式只是为了和 CGA 和 SGA 的形式保持一致，定义 \(\nabla \mathcal{H}_c\) 为 \(\nabla_w\frac{1}{2} \| \xi(w) \|^2\)，等价于 \(H_c^T\xi_c\)，前文有说明，在该公式里不需要直接算黑塞矩阵而是计算黑塞矩阵和同时梯度向量的积，速度很快。</p>
<p>在选择合适的 \(\lambda\) 时，AgA 可以确保稳定地收敛到<strong>稳定不动点</strong>即
</p>
$$
\theta(\tilde{\xi}, \nabla \mathcal{H}_c) \leq \theta(\xi_c, \nabla \mathcal{H}_c) 
$$<p>也会远离<strong>不稳定的不动点</strong>即</p>
$$
\theta(\tilde{\xi}, \nabla \mathcal{H}_c) \geq \theta(\xi_c, \nabla \mathcal{H}_c) 
$$<p>当且仅当 \(\lambda\) 满足</p>
$$
\lambda \cdot \langle\xi_c, \nabla\mathcal{H}_c\rangle\,(\langle\xi, \nabla\mathcal{H}_c\rangle + \|\nabla\mathcal{H}_c\|^2) \geq 0.
$$<p>其中 \(\theta(a, b)\) 是向量夹角，\(\langle a, b\rangle\) 是向量内积，使用 \(\tilde{\xi} = u + \lambda v\) 表示 AgA 的调整梯度，\(u\) 是 \(\xi_c\)，\(v\) 是 \(\xi + H_c^T\xi_c\)。</p>
<p>定义 \(\theta_\lambda(\tilde\xi, w)\) 是 AgA 梯度和参考更新方向的夹角。</p>
<p>拓展<strong>微分对齐</strong>的定义到 AgA 梯度，使用余弦相似度的平方定义 AgA 梯度与参考更新方向的吻合程度，考虑局部变化所以对 \(\lambda\) 求导，反映 \(\lambda = 0\) 的两侧 AgA 梯度的变化率，即：</p>
$$
\text{align}(\tilde\xi, w) := \frac{d\{\cos^2\theta_\lambda\}_{|\lambda=0}}{d\lambda}
$$<p>直观上，当 \(u^Tw \geq 0\)，\(u\) 与 \(w\) 同方向时，若 \(\text{align} > 0\)，\(v\) 驱动 \(u\) 向参考方向靠拢，若 \(\text{align} < 0\)，\(v\) 推动 \(u\) 向远离参考方向，若 \(u\) 与 \(w\) 方向不一致，\(v\) 会牵引 \(u\) 向参考方向趋近。</p>
<p>令 \(w = \nabla \mathcal{H}_c\) 给出<strong>对齐方向判定法</strong>，</p>
$$
\text{sign}(\text{align}(\tilde\xi, \nabla \mathcal{H}_c)) = \text{sign}(\langle\xi_c, \nabla\mathcal{H}_c\rangle(\langle\xi, \nabla\mathcal{H}_c\rangle + \|\nabla\mathcal{H}_c\|^2))
$$<p>NIPS2024 下载的原文这块有个公式脚标写错了，证明结论和给出的公式不一样，这块给出的公式是修改过的了，证明过程就不写了，概括为把余弦相似的平方展开，带入 \(\tilde\xi\) 的定义式，分子对 \(\lambda\) 做一阶等价无穷小近似，然后进一步展开，分母为平方项，微分对齐的定义为 \(\lambda = 0\) 时的一阶导的值，公式的一阶导的符号与分母无关，由泰勒恒等式分子的一阶导为上文提到的公式。</p>
<p>对于对齐方向判定公式，对于 \(\langle\xi_c, \nabla\mathcal{H}_c\rangle\) 显然等于 \(\xi_c^T H_C \xi_c\)，由于 \(H_C\) 是对称矩阵，假设 \(\xi_c \neq 0\)，有若 \(H_c\) 半正定，则 \(\langle\xi_c, \nabla\mathcal{H}_c\rangle \geq 0\)，若 \(H_c\) 负定，则 \(\langle\xi_c, \nabla\mathcal{H}_c\rangle < 0\)。</p>
<p>此处相当于是对前文的直观理解给出了一个<strong>分类讨论</strong>：</p>
<ul>
<li>
<p><strong>情形一（稳定不动点附近）</strong>：
若 \(\langle \xi_c, \nabla \mathcal{H}_c \rangle \ge 0\)，则 \(\xi_c\) 与 \(\nabla \mathcal{H}_c\) 指向相同方向，即 \(\theta(\xi_c, \nabla \mathcal{H}_c) \le \frac{\pi}{2}\)。当 \(\langle \xi_c, \nabla \mathcal{H}_c \rangle \ge 0\) 时，align\((\tilde{\xi}, \nabla \mathcal{H}_c)\) 的符号与 \(\langle \xi, \nabla \mathcal{H}_c \rangle + \|\nabla \mathcal{H}_c\|^2\) 的符号一致。若令</p>
$$
  sign(\lambda) = sign(\langle \xi, \nabla \mathcal{H}_c \rangle + \|\nabla \mathcal{H}_c\|^2) = sign(align)
  $$<p>有：</p>
<ul>
<li>当 sign(align) \(\ge 0\) 时，sign\((\lambda) \ge 0\)，向量 \(v\) 将把 \(u\) 拉向 \(w\)；</li>
<li>当 sign(align) \(< 0\) 时，sign\((\lambda) < 0\)，负的 \(\lambda\) 反向作用，使 \(v\) 将 \(u\) 推离 \(w\)</li>
</ul>
<p>因此，只要令 sign\((\lambda)=\)sign\((\langle \xi, \nabla \mathcal{H}_c \rangle + \|\nabla \mathcal{H}_c\|^2)\)，\(v\) 均能确保 \(u\) 被拉向 \(w\)。</p>
<p>在稳定不动点邻域内，若令</p>
$$
  \lambda \cdot \langle \xi_c, \nabla \mathcal{H}_c \rangle (\langle \xi, \nabla \mathcal{H}_c \rangle + \|\nabla \mathcal{H}_c\|^2) \ge 0
  $$<p>则 AgA 梯度 \(\tilde{\xi}\) 相比 \(\xi_c\) 更靠近 \(\nabla \mathcal{H}_c\)。</p>
</li>
<li>
<p><strong>情形二（不稳定不动点附近）</strong>：
证明思路与情形一相似。若令 sign\((\lambda)\) 满足同样条件</p>
$$
  \lambda \cdot \langle \xi_c, \nabla \mathcal{H}_c \rangle (\langle \xi, \nabla \mathcal{H}_c \rangle + \|\nabla \mathcal{H}_c\|^2) \ge 0
  $$</li>
</ul>
<p>则优化过程具有下述性质：在不动点邻域，</p>
<ol>
<li>若该点稳定，AgA 梯度被拉向该点，即 \(\theta(\tilde{\xi}, \nabla \mathcal{H}_c) \le \theta(\xi_c, \nabla \mathcal{H}_c)\)；</li>
<li>若该点不稳定，AgA 梯度被推出该点，即 \(\theta(\tilde{\xi}, \nabla \mathcal{H}_c) \ge \theta(\xi_c, \nabla \mathcal{H}_c)\)。</li>
</ol>
<p>这个证明很大程度上是说为什么 \(\lambda\) 要满足 \(\lambda \cdot \langle \xi_c, \nabla \mathcal{H}_c \rangle (\langle \xi, \nabla \mathcal{H}_c \rangle + \|\nabla \mathcal{H}_c\|^2) \ge 0\)，没有说明一定会收敛到稳定不动点，只是说明在稳定不动点附近，\(\lambda\) 满足条件时，AgA 梯度会向稳定不动点靠拢，可能在别的论文里证明过了等等。</p>
<h2 id="其他">其他<a href="#%e5%85%b6%e4%bb%96" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>其他都是实验了，先写这么多，等到复现成了这份工作再详细介绍原文中只提了一小段的 AgA 怎么和 MAPPO 集成。</p>
]]></content></item><item><title>JaxMARL阅读</title><link>https://blog.hieros.me/zh/posts/jaxmarl/</link><pubDate>Mon, 13 Oct 2025 08:56:59 +0800</pubDate><author>BLESS</author><guid>https://blog.hieros.me/zh/posts/jaxmarl/</guid><description>NIPS2024论文笔记——JaxMARL</description><content type="text/html" mode="escaped"><![CDATA[<h1 id="在jax中多智能体强化学习环境和算法">在JAX中多智能体强化学习环境和算法<a href="#%e5%9c%a8jax%e4%b8%ad%e5%a4%9a%e6%99%ba%e8%83%bd%e4%bd%93%e5%bc%ba%e5%8c%96%e5%ad%a6%e4%b9%a0%e7%8e%af%e5%a2%83%e5%92%8c%e7%ae%97%e6%b3%95" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h1>
<p>这篇笔记算算是NIPS论文精读的第一步，还是得精读论文来学习，乱找别人的总结还是不能加深对方向现状的理解。这次选的是JaxMARL，一篇NIPS2024关于MARL的论文。NIPS2024总共4538篇论文，Topic明确为MARL的只有33篇，这方向，，，，回头再看看别的顶刊，顶会的情况再下判断。</p>
<p>论文链接： <a href="https://doi.org/10.48550/arXiv.2311.10090" target="_blank" >https://doi.org/10.48550/arXiv.2311.10090</a></p>
<p>代码链接： <a href="https://github.com/flairox/jaxmarl" target="_blank" >https://github.com/flairox/jaxmarl</a></p>
<h2 id="介绍">介绍<a href="#%e4%bb%8b%e7%bb%8d" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>强化学习环境通常运行在CPU上，效率比较低，需要通过硬件加速和并行化来解决这个问题，简单来说就是把环境搬到GPU上跑。要在GPU上跑环境需要很多非Python代码的支持，好在这些基础工作已经有人做了，JAX可以在GPU上实现并行化和即时编译，在此基础上又诞生了PureJaxRL，直接在GPU上并行跑训练，<strong>比CPU快了4000倍</strong>，让大规模强化学习算法的实现变得可能。JAXMARL就是在PureJaxRL、JAX等的基础上搭建的一个MARL基准，包含了环境和算法的GPU运算实现。</p>
<p>作者还提到一个有趣的现象：在近75篇MARL论文中，<strong>50%只用了一个评估环境，30%用了两个</strong>。所以他们实现了很多环境，希望大家能在多种场景下进行评估。其中重点实现了SMAX和STORM，SMAX是对SMAC（星际争霸2多智能体环境）的近似实现，定制化程度更高，<strong>速度快了40000倍</strong>；STORM是受 melting pot 启发开发的一个博弈环境，后文介绍STORM。关于速度提升，作者列举了很多数字，我觉得最核心的数字是<strong>12500倍</strong>，在向量化多环境下。</p>
<h2 id="smax">SMAX<a href="#smax" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>SMAC有一些局限性，对复杂策略缺乏足够的随机性（可以参考&quot;An improved benchmark for cooperative multi-agent reinforcement learning&quot;这篇文章），<strong>开环策略——也就是仅依赖时间步、不需要观测的策略，在SMAC环境中居然表现不错</strong>。而且SMAC环境内存占用大、速度慢，所以作者提出了SMAX环境，和SMAC类似但更轻量化，有着不容易被智能体钻空子的AI，包含了SMAC的场景和SMACv2的类似场景，定制性很高。</p>
<h2 id="storm">STORM<a href="#storm" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>STORM全称是Spatial-Temporal Representations of Matrix Games，中文应该是矩阵博弈时空表征环境。先说说矩阵游戏的概念，就像囚徒困境那样，表现形式是这样的：</p>
<table>
	<thead>
			<tr>
					<th>玩家1 \ 玩家2</th>
					<th>合作</th>
					<th>背叛</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td><strong>合作</strong></td>
					<td>(3, 3)</td>
					<td>(0, 5)</td>
			</tr>
			<tr>
					<td><strong>背叛</strong></td>
					<td>(5, 0)</td>
					<td>(1, 1)</td>
			</tr>
	</tbody>
</table>
<p>表格中的数字表示(玩家1收益, 玩家2收益)。可以看到，如果双方都合作，各得3分；如果一方背叛一方合作，背叛者得5分，合作者得0分；如果双方都背叛，各得1分。囚徒困境的博弈点在于：虽然双方合作是最优解，但每个玩家都有背叛的动机，因为无论对方选择什么，背叛总能带来更高的个人收益，最终导致双方都选择背叛，陷入次优均衡。</p>
<p>其中每个智能体只能选择合作或者背叛，这样的设定太抽象了，或者说太简单了。所以就有了Melting Pot的In the Matrix游戏。这个环境我还不太了解，相关论文在 <a href="https://doi.org/10.48550/arXiv.2211.13746" target="_blank" >https://doi.org/10.48550/arXiv.2211.13746</a> ，后面再读读这篇文章。总之这是一个用来衡量多智能体博弈、合作、竞争等情况的环境，具有很强的社会性，看起来挺有意思的。STORM在Melting Pot的基础上加入了随机性要素。</p>
<h2 id="其他环境">其他环境<a href="#%e5%85%b6%e4%bb%96%e7%8e%af%e5%a2%83" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<ul>
<li><strong>Hanabi</strong>：花火，完全合作式部分可观测卡牌游戏，详细资料可以参照 <a href="https://zh.wikipedia.org/wiki/%E8%8A%B1%E7%81%AB_%28%E5%8D%A1%E7%89%8C%E9%81%8A%E6%88%B2%29" target="_blank" >https://zh.wikipedia.org/wiki/%E8%8A%B1%E7%81%AB_(%E5%8D%A1%E7%89%8C%E9%81%8A%E6%88%B2)</a> ，是零样本协作、心智理论与临时团队研究的基准。</li>
<li><strong>Overcooked</strong>：分手厨房，用于评估完全合作式全可观测人机协作任务的性能，玩过的都知道，详细资料可以参照 <a href="https://doi.org/10.48550/arXiv.1910.05789" target="_blank" >https://doi.org/10.48550/arXiv.1910.05789</a> ，没想到19年就有人拿分手厨房做RL环境了。</li>
<li><strong>MABrax</strong>：源于多智能体MuJoCo，是连续多智能体机器人控制任务的常用基准。</li>
<li><strong>Multi-Agent Particle Environment（MPE）</strong>：基于简单物理规则的2D世界，粒子智能体可以移动、通信并与固定地标交互。</li>
<li><strong>硬币游戏</strong>：模拟社会困境的双玩家网格世界环境，虽然是一般和博弈的常用基准，但STORM修正了其既有缺陷。</li>
<li><strong>开关谜题</strong>：作为调试工具的简易合作通信任务。</li>
</ul>
<h2 id="算法">算法<a href="#%e7%ae%97%e6%b3%95" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>作者使用PureJaxRL实现了IPPO和MAPPO，参照PyMARL实现了IQL、VDN和QMIX。</p>
<h2 id="使用推荐">使用推荐<a href="#%e4%bd%bf%e7%94%a8%e6%8e%a8%e8%8d%90" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>作者特别强调，这个基准环境被设计来推动<strong>CTDE、零试协调、一般和博弈、协作式连续动作</strong>这四个领域的研究，建议的评估如下：</p>
<table>
	<thead>
			<tr>
					<th>研究领域</th>
					<th>推荐环境</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>CTDE</td>
					<td>SMAX（全部场景）、Hanabi（2–5 人）、Overcooked</td>
			</tr>
			<tr>
					<td>零试协调</td>
					<td>Hanabi（2 人）、Overcooked（5 个基础场景）</td>
			</tr>
			<tr>
					<td>一般和博弈</td>
					<td>STORM（重复囚徒困境）、STORM（匹配硬币）</td>
			</tr>
			<tr>
					<td>协作式连续动作</td>
					<td>MABrax</td>
			</tr>
	</tbody>
</table>
<p>作者提出了一套评估指标计算方法：先对算法在相关环境类别上的表现进行标准化，计算每个随机种子的平均性能。然后，在每个环境中，基于这些汇总的统计数据计算四分位均值。这种方法可以对环境类别进行公平比较，不会因为某些类别包含更多独立场景而使其权重过高。他们还写了算指标的代码，可以直接用。</p>
<h2 id="性能评估">性能评估<a href="#%e6%80%a7%e8%83%bd%e8%af%84%e4%bc%b0" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>具体的对比情况还是直接看原文比较方便，这里给出作者的结论：在单个GPU上训练，对于MPE环境下的QMIX算法，只需要<strong>198.4秒就能完成1024次独立训练任务</strong>，而基于PyMARL的单一训练需要1小时10分钟，相当于每个智能体实现了<strong>21,500倍的加速比</strong>。附录中对IPPO算法的重复实验显示加速比为<strong>12,500倍</strong>。图5c展示了采用JaxMARL的IPPO实现在SMAX环境对比PyMARL在SMAC环境训练所获得的加速效果：在不同数量的环境推演线程下，JaxMARL最高可以实现<strong>31倍的加速比</strong>。</p>
<p>他们还对每个环境的实现效果进行了评估，这里就不详细说了。按照他们的说法，自然是和环境的经典实现效果上差别不大，部分有改进和简化在后文有说明，可以放心使用。相关工作和结论部分就不看了。</p>
<h2 id="附录">附录<a href="#%e9%99%84%e5%bd%95" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>附录里写了前面提到的每个环境的介绍，还有算法、API、环境的详细评估、默认超参等等，很细致。这里只聊聊他们实现的环境，其他部分还不如直接跑跑代码，看看文档。</p>
<h3 id="smax-1">SMAX<a href="#smax-1" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>说说一些重点差异。首先单位被建模成二维世界的一个圆，支持智能体自我对抗，还能自定义单位类型。观测方面：每个智能体可以感知视野范围内所有友方与敌方单位的生命值、上一步动作、位置坐标、武器冷却状态及单位类型，采用《星际争霸II》设定的动态视野与攻击范围，而不是SMAC的固定数值。奖励方面：SMAC的伤害输出在奖励中的占比会随智能体的数量进行线性缩放，SMAX把奖励均分为伤害输出和对战胜负，解决了在很多智能体的情况下伤害输出占比过大的问题，比如在27m_vs_30m场景里，随机策略甚至能得10/20，大部分奖励都来自于伤害输出。</p>
<p>AI这块，SMAX的AI是去中心化的，而SMAC和SMACv2的AI是中心化的，据说可以在去中心化的前提下达到和中心化AI一样的强度，不过这样<strong>从原理上保证任何低于50%的胜率都代表明确的学习失败</strong>，因为算法可以直接复制AI的策略。</p>
<p>执行上，SMAX部分动作是同步执行的，可能导致平局发生，此时双方奖励均为0。每个环境步包括8个小时间步，动作是离散的，由四向移动、停止及针对每个敌人的射击构成。</p>
<p>设定上，移除了异虫的回血机制（因为这对训练的影响很微弱，只有0.38/s），星灵的护盾机制（脱战10s开始回护盾，在微操任务中基本没用，以生命值补偿替代），删除了一些单位，比如医疗运输机、巨像、爆虫等，进行环境的精简。可惜了，不能看到智能体枪兵甩毒爆，运输机闪光头了。</p>
<p>初始位置生成机制和SMACv2一致，不过在&quot;surrounded&quot;这种初始位置设定下，盟友和敌人的初始位置是对称生成的，保证了50%胜率的理论可达性。</p>
<h3 id="storm-1">STORM<a href="#storm-1" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>这是一个8×8的网格环境，智能体只有四个动作：前进、左转、右转、交互。观测范围有限，碰撞时静止优先，如果都在运动则随机判定。智能体要去收集地图上的合作币和背叛币，收集到后颜色会转变，表示可以交互了。交互时向前方发射一道交互光束（挺有趣的设定），如果碰到一个也准备好的智能体就会发生交互，根据博弈矩阵给出奖励收益。交互完成后，两个智能体在五步内会陷入冻结状态，向周围的智能体公布它获取的硬币，解除冻结后在新位置重生，硬币归零，重新开始获取硬币。每个episode结束后，硬币的位置会随机改变。作者强调了STORM和melting pot的区别，不过这里就不介绍了，后面研究完melting pot再做介绍。他还特别强调了这个硬币随机改变机制的重要性。</p>
<h3 id="硬币博弈">硬币博弈<a href="#%e7%a1%ac%e5%b8%81%e5%8d%9a%e5%bc%88" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>这是一个双智能体的网格环境游戏，模拟了迭代囚徒困境等社会困境。地图是环形的，上下联通，左右联通，就像贪吃蛇的地图。红蓝两个智能体在其中移动，地图上有红蓝两种硬币，任何智能体捡到硬币就加一分，不过红色智能体收集到蓝色硬币会给蓝色智能体减2分，反之亦然。一个硬币被消耗后，同样的硬币会在地图随机位置刷新。如果两个智能体同时吃一个硬币，它们都可以吃到这个硬币。每个训练回合的step是固定的。博弈点在于，如果两个智能体都选择看到硬币就吃，那么总奖励期望是0。</p>
<h3 id="hanabi">Hanabi<a href="#hanabi" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>花火，完全合作式、部分可观测的多玩家卡牌游戏。玩家可以观察其他玩家的手牌却看不到自己的牌。玩家团队必须通过有限的线索交流，按特定顺序打出卡牌才能获胜。是零样本协作与临时团队研究领域的常用基准。作者的实现支持自定义游戏配置（如花色/等级数量、玩家数量、提示令牌数量），比经典实现更加灵活和可读。</p>
<h3 id="overcooked">Overcooked<a href="#overcooked" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>分手厨房，用来评估完全合作式、完全可观察的人机协作任务性能，看人玩玩就知道了。</p>
]]></content></item><item><title>About BLESS</title><link>https://blog.hieros.me/zh/about/</link><pubDate>Tue, 14 Nov 2023 00:00:00 +0000</pubDate><author>BLESS</author><guid>https://blog.hieros.me/zh/about/</guid><description>&amp;lt;no value&amp;gt;</description><content type="text/html" mode="escaped"><![CDATA[<p>我是 BLESS，一名来自山东大学的学生，也使用 BLESS 作为网名。</p>
<p>我目前主要关注多智能体强化学习、微电网优化调度，以及 LLM 的工具化应用。相比于只记住一个结论，我更喜欢顺着论文中的问题继续往下看：环境如何建模，算法如何实现，实验结果是否能够复现，以及代码里那些容易被忽略的细节。</p>
<p>平时会阅读强化学习、博弈论和机器学习相关的论文，也会尝试使用 JAX、MARL 环境和各种开源项目进行实验。对我来说，代码不仅是验证想法的工具，也是理解一个方法最直接的方式。遇到有意思的项目时，我通常会先阅读实现，再把自己的理解、修改和踩坑记录下来。</p>
<p>这个博客主要记录学习过程中的论文笔记、代码复现、实验观察，以及一些关于软件工具和工程实践的思考。内容可能不够系统，也不一定总是正确，但希望它们能留下真实的思考过程，并在以后回头看时仍然有价值。</p>
<p>如果你也对强化学习、智能体、开源代码或相关问题感兴趣，欢迎交流。</p>
<p><a href="https://github.com/Heironghuncheng" target="_blank" >GitHub</a> · <a href="mailto:blessingbrandro@gmail.com" >Email</a></p>
]]></content></item></channel></rss>