标题拆解

论文题目是 《Hybrid Internal Model: Learning Agile Legged Locomotion with Simulated Robot Response》 。

• Hybrid Internal Model (HIM，混合内部模型): 这是作者提出的新方法。“混合”指的是它不仅关注显式的速度跟踪，还关注隐式的稳定性 。
• Agile Legged Locomotion (敏捷足式运动): 目标不是走得稳，而是要能跑、能跳、能爬楼梯，适应各种地形。
• Simulated Robot Response (仿真机器人响应): 这是核心创新点。它不直接去“猜测”地形是什么样的（比如摩擦力多少、坡度多少），而是去“猜测”机器人遇到地形后会产生什么反应 。

为什么要做这件事？(痛点)

在足式机器人控制中，通常面临两个大难题：

1. “盲人摸象”： 机器人的传感器（IMU、电机编码器）只能感知自己（本体感知），很难准确知道外部环境的具体参数（比如地面摩擦系数、具体的凹凸不平程度） 。
2. 传统方法的缺陷： 之前的流行做法是“Teacher-Student”（教师-学生）架构 。
   • 先在仿真里用一个拥有上帝视角的“老师”策略（能看到摩擦力等所有信息）训练。
   • 然后再训练一个“学生”策略去模仿老师，但学生只能看本体传感器数据。
   • 问题： 这个模仿过程会有信息损失，导致效果打折，且训练流程复杂 。

论文的解决方案 (HIM)

作者提出了一种不依赖“环境参数估计”，也不需要复杂的“教师-学生”两阶段训练的方法：借鉴经典控制理论中的 Internal Model Control (IMC，内模控制) ，把所有外部环境因素（摩擦、地形高度等）都看作是干扰 (Disturbance) ，训练一个模型，根据机器人过去的一系列动作和传感器数据，去预测**“机器人接下来会发生什么反应”**（即 Response），如果能预测准这个反应，策略网络就能据此调整动作，抵抗干扰。

在技术手段上，使用了 对比学习 (Contrastive Learning) 来训练这个预测模型，而不是简单的回归（Regression） 。这提高了鲁棒性。

研究方法

系统的输入与输出 (What goes in, What comes out)

首先，要搞清楚控制器需要什么数据。

• 输入 (Proprioception $o_t^a$): 这是一个“盲”的输入，只有本体感知。
  • 关节编码器: 关节位置 $\theta$ 和速度 $\dot{\theta}$ 。
  • IMU: 基座的角速度 $\omega$ 和重力方向 $g_t$ 。
  • 指令: 用户想要的速度（比如：前进 1.0 m/s）。
  • 历史信息: 这一点很关键。模型不仅看当前这一帧，而是看过去 $H$ 帧的数据（论文中默认为 5帧）。
• 输出 (Action $a_t$):
  • 直接输出 12 个电机的目标位置偏移量（Target Joint Positions）。这和标准的强化学习控制没有区别。

核心组件：混合内部模型 (Hybrid Internal Model, HIM)

即上图中间黄色的部分，也是论文最大的创新。它就像在控制回路里加了一个“直觉模块”，接收历史观测数据 $o_{t-H:t}^a$，然后吐出一个 “混合内部嵌入 (Hybrid Internal Embedding)” 给策略网络 。

这个“嵌入”由两部分组成，所以叫“混合 (Hybrid)”：

1. 显式部分 ($\hat{v}_t$ - Velocity): 预测机器人的实际线速度。
   • 作用： 让机器人知道自己实际跑得有多快（因为没有外部传感器，它很容易打滑，不知道自己其实没动）。
   • 训练方式： 简单的监督学习（Regression），用仿真里的真值去监督它 。
2. 隐式部分 ($\hat{l}_t$ - Implicit Response): 一个潜在向量（Latent Vector，维度为16）。
   • 作用： 捕捉那些难以量化的“状态”，比如“脚下是不是很滑”、“刚才是不是绊了一下”。作者称之为“稳定性的隐式表达” 。
   • 训练方式： 对比学习 (Contrastive Learning)。

训练方法：对比学习 (Why Contrastive?)

在上图的右上角，可以看到 “Pull Closer” 和 “Push Away” ，这是整篇文章的精华部分。

• 传统做法 (Regression): 试图让网络直接预测环境参数（例如：预测摩擦系数 = 0.5）。
  • 缺点： 仿真里的摩擦系数 0.5 和现实世界的 0.5 可能完全不是一回事（Sim-to-Real Gap）。如果网络死记硬背这个数字，到了现实世界就傻了。
• 本文做法 (Contrastive Learning):
  • 作者认为：不管环境参数是多少，“如果两段历史轨迹看起来很像，那么它们接下来的反应（下一帧状态）也应该很像”。
  • 正样本对 (Positive Pair): 拿一段“历史观测” ($o_{t-H:t}$) 和它紧接着发生的“未来一帧状态” ($o_{t+1}$)。模型要把这两者的特征向量拉近 (Pull Closer) 。

作者使用了 SwAV (Swapping Assignments between Views) 算法来实现这个对比学习 。这是一种无监督学习方法，不需要人工标注“这是冰面”或“这是楼梯”，机器人自己通过大量试错就学会了归类。

实验验证

作者在 Unitree A1（小型狗）和 Aliengo（大型狗）上进行了测试。不仅仅是平地走，他们设计了三个极具挑战性的场景 ：

• 长楼梯 (Long-range Stairs): 这是一个连续决策过程。
• 混合地形 (Compositional Terrain): 碎石路接楼梯。这对机器人的状态切换要求很高。
• 抗干扰 (Anti-disturbance):
  • 拖拽测试 (Dragging): 在机器人腿上绑重物（模拟被草缠住或甚至电机老化阻力变大）。
  • 侧向撞击 (Lateral Hit): 用重物从侧面撞击机器人。

该表比了 HIM 和 RMA (Rapid Motor Adaptation，之前的SOTA方法)。数据非常惊人：

• 短楼梯成功率： HIM 100% vs RMA 60%。这意味着 RMA 走两次大概率会摔一次，而 HIM 极其稳定。
• 抗拖拽能力： HIM 能承受 10kg 的拖拽，而 RMA 只能承受 10kg (虽然数字一样，但结合楼梯表现看，HIM 的综合鲁棒性更强)。
• 未知地形 (Unseen Terrains): 面对训练中没见过的“软坡 (Deformable Slope)”，HIM 成功率 55%，而 RMA 只有 10%。这证明了 HIM 的泛化能力更强。

注意 MoB (Multiplicity of Behavior) 和 Built-in MPC 这两列。它们在楼梯和复杂地形上的成功率几乎是 0。这说明传统的模型预测控制 (MPC) 和一些较早的学习方法在应对这种非结构化极端地形时，几乎完全失效。

作者通过设计消融实验，确定了“隐式响应”的重要性：

• 去掉速度预测 (w/o vel. inp.): 楼梯成功率从 100% 降到 85%。
• 去掉隐式响应 (w/o lat. inp.): 楼梯成功率从 100% 骤降到 50%。
• 结论： 那个通过对比学习训练出来的“隐式响应 (Internal Latent)”，才是这一整套系统的灵魂。它捕捉到了那些无法用语言描述的动态特性。

总结

这篇论文提出了一种高效、鲁棒的“盲式”足式机器人运动控制框架，核心在于利用对比学习来预测机器人的隐式响应，从而极大地提高了机器人对未知地形和干扰的适应能力。对于想要低成本实现高性能机器狗控制的开发者来说，这是目前性价比最高的复现方案之一。

日期：2025-11

系统环境：Ubuntu 22.04 LTS

显卡要求：NVIDIA 显卡（支持 CUDA >= 11.7）

核心组件：Isaac Gym (Preview 4) + RSL_RL (v1.0.2) + Legged Gym

基础环境准备

Ubuntu 22.04 默认系统库较新，而 Isaac Gym 较旧，因此必须严格锁定 Python 和 PyTorch 版本。

注：显卡驱动和CUDA安装相对较容易，可以自行寻找教程

创建 Conda 环境

miniconda安装指南

使用 Python 3.8 以获得最佳兼容性。

conda create -n legged_gym python=3.8
conda activate legged_gym

安装 PyTorch 1.13

为了适配 Isaac Gym 且不引发 CUDA 兼容问题，使用以下特定版本：

pip install torch==1.13.1+cu117 torchvision==0.14.1+cu117 torchaudio==0.13.1 --extra-index-url [https://download.pytorch.org/whl/cu117](https://download.pytorch.org/whl/cu117)

验证安装： 进入 Python 输入 import torch; print(torch.cuda.is_available()) 应返回 True。

安装 Isaac Gym (模拟器)

Isaac Gym下载地址

解压与安装

建议建立专门的工作目录（如 ~/workspace），不要在 Downloads 或 /tmp 下安装。

# 假设压缩包已在当前目录
tar -xf IsaacGym_Preview_4_Package.tar.gz
cd isaacgym/python
pip install -e .

解决 Ubuntu 22.04 核心兼容问题 (Critical)

现象：运行示例时报错 ImportError: libpython3.8.so.1.0: cannot open shared object file。 原因：系统找不到 Conda 环境内的动态链接库。 错误尝试：不要将路径直接写入 ~/.bashrc，这会导致系统命令（如 nano, ls）因库冲突而发生“段错误”或崩溃。

正确解决方案： 在运行时动态指定环境变量。后续我们将通过启动脚本 (train.sh) 来一劳永逸地解决此问题。

安装 RSL_RL (算法库)

RSL_RL仓库地址

这是配置中最容易出错的环节。官方最新版 (master 分支) 适配了新版 PyTorch 2.x，会导致依赖冲突（如 ModuleNotFoundError: tensordict 或 pyproject.toml 格式错误）。

解决方案：强制降级到 v1.0.2 版本。

cd ~/workspace  # 回到工作根目录
git clone [https://github.com/leggedrobotics/rsl_rl](https://github.com/leggedrobotics/rsl_rl)
cd rsl_rl

# 切换到稳定旧版本
git checkout v1.0.2

# 安装
pip install -e .

安装 Legged Gym (训练环境)

legged_gym仓库

安装本体

cd ~/workspace
git clone [https://github.com/leggedrobotics/legged_gym](https://github.com/leggedrobotics/legged_gym)
cd legged_gym
pip install -e .

解决 NumPy 版本冲突

现象：运行时报错 AttributeError: module 'numpy' has no attribute 'float'。 原因：Isaac Gym 依赖旧版 NumPy，而新版（1.24+）废弃了部分属性。 解决：

pip install "numpy<1.24"

补充缺失工具

如果不安装 Tensorboard，训练时会报错。

pip install tensorboard

运行与显存优化

创建通用启动脚本 (推荐)

为了解决 libpython 路径问题，且避免使用不稳定的 alias，在 legged_gym/scripts 目录下创建 train.sh。

cd legged_gym/scripts
# 写入脚本内容
echo '#!/bin/bash' > train.sh
echo 'export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$CONDA_PREFIX/lib' >> train.sh
echo 'python train.py "$@"' >> train.sh

# 赋予权限
chmod +x train.sh

解决显存溢出 (CUDA OOM)

现象：报错 RuntimeError: CUDA error: CUBLAS_STATUS_ALLOC_FAILED。 原因：默认配置开启 4096 个环境并行，显存需求大（需 8G+）。 解决： 修改 legged_gym/envs/a1/a1_config.py (或对应机器人的 config)。

class A1RoughCfg( LeggedRobotCfg ):
    class env( LeggedRobotCfg.env ):
        num_envs = 1024  # <--- 将 4096 改为 1024 或 512

启动训练

./train.sh --task=a1

常见报错速查表

   习惯是一种可怕的力量。它会给一个人留下刻骨的痕迹，又会将这些痕迹磨灭，直到所有经历都飘散在风中，将一个人变得面目全非，就像忒修斯之船。过去之我，今日之我，未来之我，我们终将是三个互不相交的个体。今日之我不必悔恨过去的选择，未来之我的担子也不该跨过时空压到今日之我的身上。

   恍惚间，我已经习惯了孤独。林语堂说孤独是稚儿擎瓜柳蓬下，细犬逐蝶深巷中。在热闹之中，但是在热闹之外，就是孤独。从什么时候开始的呢，大抵是在高中吧。因为些什么呢，大抵是些情感吧。一些傲娇，一些矫情，再加上一些别扭，青春期啊就是这么奇妙，不是吗。

   细碎的感情线杂乱无章地散步在时间织成的毛衣上，拍不掉，理不清，思不尽。花季少男少女的内心并不如青春文学中描写得那般纯粹，当然更没有日本动漫中展示得那种可爱。长大后的人们似乎都在用时间的滤镜看待过去，扭曲和掩盖了一些黑暗面。所以思来想去，我还是先不剖析一些难以启齿的龌龊想法，以免未来的我不肯原谅现在的我。

   那么对于过去的我，我当然不会释然。有太多太多的遗憾，是他一手酿成的。或许他可以早点开窍不要那么幼稚，或许他可以克制一些不要那么冲动，或许他可以深思熟虑一些不要那么想当然，或许他可以在某个夜晚有耐心一些，或许他可以在面对某个人时更坦白一些，嘴不要那么笨，又或许他可以高考时再多考几分让我现在更轻松一些……人生啊似乎就是由遗憾构成的，大大小小的遗憾围成了大大小小的圈，我们身在圈里，向往被挡住的可能性。然而又能怎么样呢。既然都在说不要美化未走过的那条路，那我只能原谅过去的我了。希望未来的我你也不要怪罪现在的我，有些事就让它失败吧，有些人就让ta错过吧，毕竟你无法穿越回来揍我一顿，那就让我的懦弱和拧巴肆无忌惮地绽放吧。

   那么现在呢，步入大学之后的第三年，成人之后的第三年，我已飘然孤立于人群之外，用刻薄挑剔的眼光观察着世间庸人。当然，也叫不合群，孤僻，自以为是。我并不吝以最恶毒的词汇描述我自己，因为我深知我是怎样的人。当然还因为我内心充满了骄傲，这让自辱变成了一种自我衬托。极度自信又自负的人，强大而脆弱，但归根结底是脆弱的，或许前方某一时刻，就有天降的钢钎准备穿过我的胸膛。

   写到这里似乎有些跑题，但是看到这里，你还认为我会充满热情吗。至于为什么不再充满热情，可能只能怪这个阴的没边的世界了。

   我在无人但不寂静的深夜写下这些文字。因为有舍友翻来覆去哼哼唧唧，有舍友满身搔痒像是爬满了虱子，楼道外有哗哗的流水声，还有不知从哪间宿舍传来的狗叫声。所以我祝他们早日超生，世界早点毁灭。 那么，晚安💤。

读完《卡拉马佐夫兄弟》许久，许多人影都已模糊，唯有伊凡的身影始终清晰。

他是另一个拉斯柯尔尼科夫，是那种我总能在身上看到自己影子的同一种人。他们都习惯用理性解剖一切，却最终把刀刃对准了自己。这种精神困境，根植于智识上的骄傲——一种最终会为自己建起无形囚笼的骄傲。

而书中那篇石破天惊的《宗教大法官》，便是这种思想的凝练。

“如果说，为了赎买真理，必须让孩子们也一同受苦，让他们的眼泪也汇入那苦难的总和，那么我预先声明，这真理根本不值这个价。…… 我不要和谐，我是出于对人类的爱才不要它。我宁愿守着那未获报复的苦难。…… 因此，我赶紧退还我的入场券。…… 我不是不接受上帝，阿辽沙，我只是最恭敬地把入场券还给他。”

伊凡通过《宗教大法官》这则寓言，构建了他的思想核心。故事发生在宗教裁判最严酷的西班牙，耶稣重返人间，施行神迹，却被一位年迈的大法官下令逮捕。在地牢里，面对始终沉默的耶稣，大法官展开了一场振聋发聩的单方面审判。

大法官的逻辑冷酷而清晰：自由，是耶稣赠予人类的根本性错误。因为人的本质是软弱卑贱的，他们无法承受自由选择的重负，他们不需要虚无缥缈的天上面包，而只要实实在在的地上食粮。因此，教会必须“修正”神的错误，收回自由，并代之以奇迹、神秘和权威。用这三者，为民众建造一个幸福安稳的蚁穴，让他们交出思考的权利，换取温饱与顺从的一生。

“哦，我们将会说服他们，他们只有把自由交给我们、顺从我们的时候，才会得到真正的自由。…… 我们将给予他们那种温顺的、谦卑的幸福，那种适合于他们这种天生软弱的生物的幸福。…… 他们将惊奇地望着我们，把我们看作神，因为我们既然肯领导他们，就说明我们甘愿为他们忍受他们所畏惧的自由，甘愿统治他们。”

这位大法官，实际上就是伊凡精神的化身。他的全部理论，都源于一个无比骄傲的前提：我，比上帝更懂人性。他用理性剖析一切，得出的结论是：为了绝大多数人的幸福，思考和统治的重负必须由少数精英承担。这便是智识的骄傲。当讲述这个故事时，伊凡正站在自己思想囚笼的顶端，俯瞰着那些他既怜悯又鄙视的芸芸众生。

这座看似坚固的囚笼，实则建立在虚无之上。它的根基，源于一个致命的谬误：为思想的优越性排序。

伊凡的根本问题，在于他坚信思想有高低之分，活法有贵贱之别。然而事实是，思想无所谓高度，人只是活着。用自己的尺度去衡量整个世界，或许正是知识分子永恒的诅咒。而现实，则以最残酷的方式嘲弄了伊凡的骄傲。这嘲弄并非来自更高明的哲学家，而是他最鄙视的私生子斯麦尔佳科夫。斯麦尔佳科夫忠实地理解并执行了伊凡无神论的终极结论——“一切都是允许的”，于是他动手杀死了父亲。

“您才是真正的凶手，我不过是您的工具，是您忠实的仆人，我只是奉了您的意旨办事。”

宏大的哲学思辨，最终沦为了卑劣的弑父借口。当斯麦尔佳科夫对伊凡说出“您才是真正的凶手”时，那座思想的囚笼便从内部被彻底击碎了。他无法忍受自己深刻的思想，竟结出如此肮脏的果实。击垮伊凡的，从来不是更强的逻辑，而是一个他无法否认的、肮脏的事实。他的精神崩溃，也证明了纯粹的理性在人性的混乱面前，终将破产。

大法官说完了。他将自己的骄傲、孤独和罪孽，全部倾泻在那个沉默的囚徒面前，等待着反驳与审判。

但他等来的，不是辩驳，而是一个吻。耶稣走上前，在他那干瘪衰老的唇上，轻轻印了一下。

这个吻，不代表认同，也无关辩论，它是一种超越了所有逻辑的悲悯。它仿佛在说：我看见了你的痛苦，也理解你的挣扎。我不评判你的思想，我只爱你这个受苦的人。

神爱世人，所以他也爱大法官，爱伊凡。在神的眼中，人的思想并无高下之分，大法官自以为是的深刻，与民众浑浑噩噩的幸福，不过都是人的活法而已。这才是对伊凡那座思想囚笼的最终回答：出路，不在于构建一个更完美的逻辑体系，而在于走出逻辑本身，去承认世界的复杂，接受人性的混沌，拥抱一种无条件的、不问对错的爱。

伊凡构建了宏大的理论，却始终无法理解这个简单的吻。所以，他只能被困在自己的囚笼里，走向最后的崩溃。

“你这是要去完成一桩英雄壮举，可是你又不信奉壮举，这就是你的痛苦和愤怒的所在，这就是你满怀怨恨的原因。”

伊凡死了吗？没有。他活在我们中间，甚至就活在我们某些幽暗的角落里。

我们每一个试图用理性丈量世界的人，内心深处都可能藏着一个伊凡。我们用知识构建壁垒，用逻辑审判情感，用自以为是的深刻，去疏远真实的生活。我们看透了世界的荒谬，却也因此失去了拥抱世界的能力，最终把自己关进头脑的囚笼，奇怪于世界的冰冷。

走出头脑，去拥抱一个具体的人； 去做一件无用之事； 去爱一个不完美的人，连同他的愚蠢和不堪。

这或许，才是对所有伊凡们的最终救赎。

前言

   神经网络作为人工智能领域的核心分支，是一种旨在模拟生物神经系统结构与功能的计算范式。其根本目标在于构建能够从经验数据中自动学习复杂模式与潜在规律的计算模型，这标志着从传统基于规则的编程向数据驱动的自适应智能的根本性转变。
   神经网络的发展历程是理论突破与技术瓶颈交织的非线性过程。其理论基础可追溯至20世纪40年代 McCulloch 与 Pitts 对神经元的数学形式化，以及50年代 Rosenblatt 提出的“感知机”模型，这些早期工作奠定了连接主义（Connectionism）的基础。然而，由于 Minsky 与 Papert 在1969年深刻揭示了单层感知机的理论局限性（如无法解决XOR问题），该领域的研究一度陷入停滞。直至80年代，随着多层感知机及反向传播（Backpropagation）算法的重新发现与推广，神经网络才得以克服早期瓶颈，具备了表达非线性复杂函数的能力。尽管如此，诸如“梯度消失”等深度网络训练难题，使其在20世纪末的声誉再次被支持向量机（SVM）等统计学习方法所超越。
   进入21世纪，神经网络迎来了决定性的复兴。这一复兴并非源于单一突破，而是三大因素协同作用的结果：第一，以图形处理器（GPU）为代表的并行计算硬件提供了前所未有的算力支持；第二，互联网的普及带来了海量、高质量的标注数据集（Big Data）；第三，算法层面的持续创新，包括新型激活函数（如ReLU）、优化策略及正则化技术，有效缓解了深度网络的训练困境。自2012年 AlexNet 在 ImageNet 竞赛中取得革命性成果以来，以深度神经网络（DNN）为核心的深度学习已成为人工智能研究与应用的主流范式。
   理解神经网络的意义至关重要，它不仅是实现图像识别、自然语言处理、语音识别等应用任务的关键技术，更代表了一种强大的特征表示学习（Representation Learning）框架。它驱动了从消费电子到自动驾驶、从金融科技到医疗诊断等众多领域的重大技术革新。因此，掌握神经网络的理论基础与实践方法，是理解并参与当前人工智能技术发展的核心要求。

神经元模型

   各学科对神经网络的定义多种多样，而使用得最广泛的一种，即 “神经网络是由具有适应性的简单单元组成的广泛并行互连的网络，它的组织能够模拟生物神经系统对真实世界物体所作出的交互反应” 。

   神经网络中最基本的成分是 神经元(neuron)模型 ，即上述定义中的“简单单元”。在机器学习中，神经元模型也被称为 “M-P神经元模型”（以其提出者McCulloch和Pitts的名字命名）。它是一个简化的数学模型，用来模拟生物神经元接受和处理信息的过程。每个神经元接收多个输入，对这些输入进行加权计算，然后通过一个“激活函数”来决定最终的输出。一个神经元主要由以下几个部分组成：

• 输入(Inputs, $x_i$) ：神经元来自其他神经元或外部数据源的信息。一个神经元可以有多个输入。
• 权重(Weights. $w_i$) ：每一个输入都对应一个权重。权重代表了这个输入的重要性。权重越高，说明这个输入对神经元的最终输出影响越大。 在模型训练过程中，机器主要就是学习和调整这些权重值 。
• 阈值(Threshold, $\theta$) ：神经元被激活所需要达到的内部标准或门槛。
• 求和函数 (Summation Function)：神经元会将所有的输入值与它们对应的权重相乘，然后将所有结果加起来，最后再减去阈值项。这个过程叫做“加权求和”。
• 激活函数(Activation Function, $f$)：这是神经元的“决策”部分。加权求和的结果会经过一个激活函数处理，最终得到这个神经元的输出。激活函数的主要作用是加入 非线性 因素，使得神经网络能够学习和拟合更复杂的模式。如果没有激活函数，那无论多少层的神经网络，最终都只是一个线性模型。
• 输出 (Output, $y$)： 经过激活函数处理后得到最终的输出值。这个值会作为下一个神经元的输入，或者直接作为整个网络的最终结果。

   神经元的工作可以概括为两步：

1. 计算加权和：将所有输入与其对应的权重相乘后求和，得到输入信号的总强度

   $$ net = \sum_{i=1}^{n} w_i x_i $$

2. 激活判断与输出：激活函数判断“加权和”是否超过“阈值”，并产生输出

   $$ y = f(net - \theta) = f(\sum_{i=1}^{n} w_i x_i - \theta) $$

理想的激活函数是如下的阶跃函数，它将输入值映射为输出值“0”或“1”：

显然“1”对应于神经元兴奋，“0”对应于神经元抑制。然而，阶跃函数具有不连续、不光滑等不太好的性质，因此实际常用 Sigmoid 函数作为激活函数：

它把可能在较大范围内变化的输入值挤压到 $(0, 1)$ 输出值范围内，因此有时也称为“挤压函数”(squashing function)。

感知机与多层网络

   感知机(Perceptron) 是神经元模型的一个实例，由两层神经元组成，输入层接收外接输入信号后传递给输出层，输出层是 M-P 神经元，亦称 “阈值逻辑单元”(threshold logic unit) 。

   注意到如图 $y = f(\sum_i w_ix_i - \theta) = f(w_1 x_1 + w_2 x_2 - \theta)$ ，给定训练数据后，权重 $w_i$ 和阈值 $\theta$ 可以通过学习得到。阈值 $\theta$ 可以看做一个固定输入为 $-1.0$ 的 “哑结点”(dummy node) 所对应的连接权重 $w_{n+1}$ 。感知机的学习规则如下

1. 对训练样例 $(\boldsymbol{x}, y)$ ，假设当前感知机的输出为 $\hat y$ ；

2. 感知机的权重作如下调整：

   $$ w_i \leftarrow w_i + \Delta w_i ,\\ \Delta w_i = \eta (y - \hat y)x_i $$

   其中 $\eta \in (0,1)$ 称为学习率(learning rate)。

可以看出，若感知机对训练样例预测正确，即 $y = \hat y$ ，则不发生变化，否则将根据错误的程度进行权重调整。

   值得注意的是，感知机能实现与、或、非运算，例如：

• 令 $w_1=w_2=1, \theta=2$ ，则 $y = f(1 \cdot x_1 + 1 \cdot x_2 - 2)$ ，仅在 $x_1=x_2=1$ 时，$y=1$ ；
• 令 $w_1=w_2=1, \theta=0.5$ ，则 $y = f(1 \cdot x_1 + 1 \cdot x_2 - 0.5)$ ，当 $x_1=1$ 或 $x_2=1$ 时，$y=1$ ；
• 令 $w_1=-0.6, w_2=0, \theta=-0.5$ ，则 $y = f(-0.6 \cdot x_1 + 0 \cdot x_2 +0.5)$ ，当 $x_1 = 1$ 时，$y = 0$ ，当$x_1 = 0$ 时，$y=1$ 。

能够实现以上运算的本质原因是与、或、非问题都是线性可分问题，即存在一个线性超平面将它们分开，此时感知机的学习过程一定会收敛，从而求得合适的权重向量。而对于非线性可分问题，感知机学习过程会发生 振荡(fluctuation) ，不能求得合适的解，比如异或问题。

   多层网络通过增加 ”隐藏层“(hidden layer) 来解决该问题，其核心在于两个方面：

• 功能组合：复杂问题可以分解为简单问题的组合。比如异或(XOR)的逻辑可以分解为OR AND NAND。从而可以通过两层神经元来拟合出异或的逻辑。
• 线性变换：这是多层网络的本质，即神经网络的每一层都在对数据进行一次空间变换。隐藏层接收原始坐标，通过线性变换将原始坐标系变换到新的特征空间，原始的非线性可分数据被重新排列，从而变得线性可分。

   更一般的结构称为 “多层前馈神经网络”(multi-layer feedforward neural networks) ，每层神经元与下一层神经元全互连，神经元之间不存在同层连接或跨层连接。其中输入层神经元接收外界输入，隐藏层与输出层神经元对信号进行加工，最后由输出层神经元输出。神经网络的学习过程，就是 根据训练数据来调整神经元之间的“连接权”以及每个功能神经元的阈值；换言之，神经网络“学”到的东西，蕴涵在连接权与阈值中 。

误差逆传播算法

   假设我们有一个多层网络，其中有大量的权重( $w$ ) 和阈值( $\theta$ )。这些参数的初始值通常是随机设置的，我们的目标就是找到一套最佳参数，使得网络对于任何给定的输入，其输出都能 尽可能地接近真实值 。

   首先需要一个量化的指标来衡量网络输出值与( $\hat y$ )真实值( $y$ )之间的差距，即 损失函数 。常用的损失函数是均方误差。对于单个样本，其损失 $E$ 可以表示为：

注：前面的 $\frac{1}{2}$ 是为了后续求导计算方便，约掉一个系数2，对优化目标没有影响。

我们的目标，就是通过调整网络中的所有权重和阈值，来让损失的值变得尽可能小。

这里需要注意，标准 BP 算法 的更新规则是基于单个样本的 $E_k$ 推导而得，如果以累积误差来推导，最终得到 累积 BP 算法 ，即 累积误差逆传播(accumulated error backpropagation)算法 。二者侧重点不同，前者更新频率较快，适合训练集较大的情况，后者更新频率较慢，适合训练集不那么大的情况。下面的推导以累积误差为例。

   为了实现该目标，我们常使用 梯度下降 的方法。给定一个初始值，要找到损失最小的地方，最直观的方法是向减小最快的方向移动，在数学上就是 负梯度 的方向，而移动的距离由学习率来控制：

这个公式意味着：计算出损失对当前权重的梯度（最速上升方向），然后乘以一个学习率（步长），从当前权重中减去这个值，得到新的、更好的权重。

   误差逆传播(Backpropagation, BP)算法 ，本质上是一种高效计算梯度的技巧，其数学基础是微积分中的链式法则。

   BP 算法的执行可分为两个阶段：

阶段一：前向传播(Forward Propagation)

1. 从输入层开始，将训练数据输入网络；
2. 信号逐层向前传递，计算每一层神经元的净输入和激活后的输出值；
3. 最终在输出层得到网络的预测值 $\hat y$ ；
4. 根据预测值 $\hat y$ 和真实值 $y$ ，计算出总损失 $E$ 。

这个过程是为了得到“结果”和“差距”。

阶段二：反向传播(Backward Propagation)

   先定义一个三层神经网络的结构和符号：

• 输入层 (索引为 $i$) -> 隐藏层 (索引为 $j$) -> 输出层 (索引为 $k$)；
• $w_{ij}$：从输入层神经元 $i$ 到隐藏层神经元 $j$ 的权重；
• $w_{jk}$：从隐藏层神经元 $j$ 到输出层神经元 $k$ 的权重；
• $y_j$：隐藏层神经元 $j$ 的输出值；
• $y_k$：输出层神经元 $k$ 的输出值（即预测值 $\hat y$ ）；
• $t_k$：输出层神经元 $k$ 对应的真实目标值；
• $net_j = \sum_i w_{ij}x_i$：隐藏层神经元 $j$ 的加权输入和（为简化，暂时忽略阈值）；
• $net_k = \sum_j w_{jk}y_j$：输出层神经元 $k$ 的加权输入和；
• $y_j = f(net_j)$：$net_j$ 经过激活函数 $f$ 后的输出；
• $E = \frac{1}{2} \sum_k (t_k - y_k)^2$：对单个输出神经元的均方误差损失。

首先计算输出层权重的梯度 $\frac{\partial E}{\partial w_{jk}}$ ，我们想知道改变隐藏层到输出层的权重 $w_{jk}$ 会对最终的损失 $E$ 造成多大影响，根据链式法则，这个影响可以分为两步：

1. 权重 $w_{jk}$ 的改变，会引起输出神经元 $k$ 的 加权输入和 $net_k$ 的改变；
2. $net_k$ 的改变，会引起最终损失 $E$ 的改变。

因此可以写出：

因为 $net_k = \sum_{j^{'}} w_{j^{'}k}y_{j^{'}}$ ，显然有

而 $y_k = f(net_k)$ ，则

• $\frac{\partial E}{\partial y_k} = -(t_k - y_k)$
• $\frac{\partial y_k}{\partial net_k} = f'(net_k)$

从而得到：

将这一整项定义为 输出层误差项 $\delta_k$：

则输出层权重的最终梯度为：

然后计算隐藏层权重的梯度 $\frac{\partial E}{\partial w_{ij}}$，同理，用链式法则展开为：

由于 $net_j = \sum_{i^{'}} w_{i^{'}j}x_{i^{'}}$ ，则

而 $net_j$ 通过 $y_j = f(net_j)$ 影响损失，但 $y_j$ 会作为所有下一层神经元的输入，所以它的影响会通过多条路径传递到最终的损失 $E$ ：

• $\frac{\partial y_j}{\partial net_j} = f'(net_j)$
• 计算 $\frac{\partial E}{\partial y_j}$ 时，需要将 $y_j$ 传递到所有输出层神经元的路径上的影响全部加起来：$\frac{\partial E}{\partial y_j} = \sum_k \left( \frac{\partial E}{\partial net_k} \frac{\partial net_k}{\partial y_j} \right)$ ，我们可以发现 $\frac{\partial E}{\partial net_k}$ 正是第一步中定义的输出层误差项 $\delta_k$ ，而 $\frac{\partial net_k}{\partial y_j}$ 则是连接神经元 $j$ 和 $k$ 的权重 $w_{jk}$ ，所以有$$\frac{\partial E}{\partial y_j} = \sum_k \delta_k w_{jk}$$

将最后的乘积定义为 隐藏层误差项 $\delta_j$：

隐藏层权重的最终梯度为

可以看出，误差是从后向前、层层传递的，因此称为“误差逆传播算法”。这个“前向计算结果 -> 反向传播误差 -> 更新参数”的完整流程，被称为一次迭代 (Iteration)。通过成千上万次迭代，网络的参数被不断微调，使得总损失越来越小，网络的预测也越来越准。

   由于其强大的表示能力，BP 神经网络经常遭遇过拟合，训练误差持续降低，但测试误差却可能上升。由两种策略来缓解过拟合：

• “早停”(early stopping) ：将数据分成训练集和验证集，训练集用来计算梯度、更新连接权和阈值，验证集用来估计误差，若训练集误差降低但验证集误差升高，则停止训练，同时返回具有最小验证集误差的连接权和阈值；

• “正则化”(regularization) ：其基本思想是在误差目标函数中增加一个用于描述网络复杂度的部分，例如连接权与阈值的平方和，仍令 $E_k$ 表示第 $k$ 个训练样例上的误差，$w_i$ 表示连接权和阈值，则误差目标函数改变为

  $$ E = \lambda \frac{1}{m} \sum_{k=1}^m E_k + (1-\lambda)\sum_i w_i^2 $$

  其中 $\lambda \in (0, 1)$ 用于对经验误差与网络复杂度这两项进行折中，常通过交叉验证法来估计。

全局最小与局部极小

   在上一节中，我们优化的目标是找到一组参数，使得损失函数 $E$ 的值达到最小。

• 全局最小值(Global Minimum) ：这是损失函数在整个参数空间中的真正最低点。找到了它，就意味着我们找到了理论上最优的模型解。
• 局部极小值 (Local Minima): 这是损失函数在一个局部邻域内的最低点。

核心问题在于，标准的梯度下降算法本身无法区分停下的地方是局部极小值还是全局最小值，如果陷入了一个比较差的局部极小值，那么无论再怎么训练，模型的效果也无法达到最优化。尤其是神经网络的损失函数是一个在 极高维度空间 中（参数动辄成千上万甚至上亿）的、极其复杂的 非凸函数 (Non-convex Function) ，这意味着它的“地形”异常复杂，充满了无数的局部极小值、以及比局部极小值更麻烦的 鞍点 (Saddle Points) 和 平坦区域 (Plateaus) 。因此，在训练过程中，优化算法很容易被“困住”。

   为了解决这个问题，研究者们提出了很多比朴素梯度下降更强大的优化策略。它们的核心思想，都是 给优化过程增加一些“扰动”或“惯性” ，帮助它冲出局部极小值的陷阱。

1. 随机梯度下降 (Stochastic Gradient Descent, SGD) 标准的梯度下降在每一步都使用全部训练数据来计算梯度，路线平滑但容易陷入局部最小。而SGD在每一步只随机取一个样本来计算梯度。这样做会带来大量的噪声，使得下降的路径变得非常“曲折和摇晃”。这种“摇晃”有时反而能帮助算法“震荡”出浅的局部极小值，去寻找更广阔的空间。小批量梯度下降 (Mini-batch GD) 是一个折中方案，每次使用一小批数据，既保证了效率，又引入了适度的噪声。
2. 动量 (Momentum) 这个方法为梯度下降引入了“惯性”的概念。想象一个从山上滚下来的铁球，即使它滚到一个小坑里（局部极小），由于自身的惯性（动量），它很可能会直接冲出这个小坑，继续向下滚动。在数学上，它不仅考虑了当前步骤的梯度，还结合了一定比例的上一步更新的方向。
3. 自适应学习率算法 (Adaptive Learning Rate) 例如 Adam、RMSprop 等。这些是目前最主流的优化器。它们不再对所有参数使用固定的学习率 $\eta$ ，而是为每个参数动态地、自适应地调整学习率。在平坦区域，它们可能会加大步长以快速通过；在陡峭的峡谷，它们会减小步长以防“冲过头”。这种精细化的控制，使得它们在复杂地形中（尤其是穿越鞍点时）表现得非常出色。
4. 随机初始化 (Random Initialization) 既然一次下降可能会走到错误的谷底，那就多尝试几次不同的位置。在实践中，我们会用不同的随机初始值多次训练同一个网络，然后选择在验证集上表现最好的那个模型。

现代观点：在现代深度学习中，随着网络变得越来越大、参数越来越多，一个有趣的现象是，真正的“坏”的局部极小值问题似乎没有想象中那么严重了。很多研究表明，在高维空间中，大部分局部极小值点的损失与全局最小值相差无几。目前，优化算法面临的更大挑战是如何快速穿越广阔的鞍点和平坦区域，而动量和自适应学习率算法在应对这些问题上效果显著。

深度学习

   由于深度学习将来会专门学习，在此只作为一个拓展与总结。

   深度学习的“深”，直截了当地说，就是其核心模型——神经网络的层数非常多。相对于只有一两个隐藏层的传统神经网络，深度神经网络（Deep Neural Networks, DNN）拥有成百上千的层次。我们熟知的CNN、RNN等，在现代应用中都属于DNN的范畴。

   我们为何追求“深度”？因为深度赋予了网络一种强大的能力：层次化特征学习。网络会自动地从原始数据中学习：

• 底层网络 学习基础特征（如边缘、颜色）；
• 中层网络 组合基础特征，形成复杂特征（如眼睛、纹理）；
• 高层网络 组合复杂特征，识别出具体概念（如人脸、汽车）。

这种逐层抽象的能力，使得深度网络能够以一种高效的方式理解高度复杂的数据，而这是浅层网络难以企及的。通过多层处理，逐渐将初始的“底层”特征表示转化为“高层”特征表示后，用“简单模型”即可完成复杂的分类等学习任务，因此可将深度学习理解为进行“特征学习”(feature learning)或“表示学习”(representation learning)。

   深度学习是建立在基础神经网络理论之上，由数据、算力和算法共同推动的一场技术革命。它通过构建深度模型来自动学习数据的层次化表示，从而在计算机视觉、自然语言处理等诸多领域取得了前所未有的突破。

引言

版本控制

• 版本控制的必要性：在软件开发、文档撰写等项目中，我们经常需要追踪文件的每一次变更、回溯到历史版本，或与他人协同工作。传统的文件命名方式（如 report_v1.doc, report_v2.doc, report_final.doc）极易导致版本混乱、修改丢失和协作困难。版本控制系统（Version Control System, VCS）正是为解决这些难题而设计的专业工具。

• 版本控制系统的类型：

  • 集中式版本控制系统 (CVCS)：如 Subversion (SVN)，所有开发者都从一个中央服务器检出文件和提交更新。其缺点是必须联网才能工作，且中央服务器的单点故障风险较高。
  • 分布式版本控制系统 (DVCS)：如 Git，每个开发者都拥有一个包含完整历史记录的本地仓库。这使得离线工作成为可能，并极大地提升了数据安全性和操作速度。

Git 系统简介

• Git 的起源：Git 由 Linux 内核的创造者 Linus Torvalds 于 2005 年开发。其初衷是为了更有效地管理庞大且复杂的 Linux 内核代码库，取代当时使用的商业版本控制软件。

• Git 的核心特性：

  • 速度与效率：Git 的绝大部分操作都在本地完成，无需网络延迟，因此响应速度极快。
  • 分布式架构：每个克隆的仓库都是一个完整的备份，这为备份和恢复提供了极大的便利。
  • 强大的分支模型：Git 的分支创建和合并操作轻量且高效，极大地鼓励了并行开发和功能实验。
  • 数据完整性：Git 通过 SHA-1 哈希算法确保内容的完整性。所有文件和提交在存储前都会计算校验和，任何损坏或篡改都能被轻易发现。

Git 与 GitHub

• 工具与平台的关系：可以理解为，Git 是一个协议或工具，就像电子邮件协议（SMTP）一样；而 GitHub 则是一个基于该工具构建的服务平台，类似于 Gmail。Git 可以在任何地方独立运行，而 GitHub 则是托管 Git 仓库并提供协作功能的网站。

• GitHub 提供的附加价值：GitHub 在 Git 的基础上，提供了图形化的用户界面、强大的协作功能（如 Pull Requests）、问题追踪（Issues）、项目管理、代码审查等一系列服务，构建了一个庞大的开发者社区。

• 其他代码托管平台：除了 GitHub，还有 GitLab、Bitbucket 等类似的服务平台，它们都使用 Git 作为核心技术。

环境搭建：安装与初始化配置

Git 的安装流程

由于笔者使用 Windows 系统，暂时只介绍 Windows 平台的安装流程

Windows 平台

1. 访问git-scm.com
2. 根据自己的系统下载相应的版本
3. 运行安装程序
4. 安装完成后，打开“开始”菜单，找到 “Git Bash” 并运行它，出现一个命令行窗口，即表示安装成功

初始化配置

安装完成后，需要设置用户名称和电子邮件地址。每一次 Git 提交都会使用这些信息，它们会被永久地嵌入到提交记录中。

打开打开 Git Bash（Windows）或终端（macOS/Linux），执行以下两条命令，请将引号内的内容替换为自己的信息。--global 参数表示正在设置全局配置，这台计算机上所有的 Git 仓库都会默认使用这个配置。

• 配置用户身份标识（用户名）：

  git config --global user.name "Your Name"

• 配置用户身份标识（邮箱）：

  git config --global user.email "youremail@example.com"

  建议使用在 GitHub 或其他代码托管平台上注册的邮箱。

• 验证配置信息：

  • 要检查配置，可以运行以下命令：

    git config --list

  • 这会列出所有的 Git 配置信息。请确保能看到刚才设置的 user.name 和 user.email。

核心操作与基础工作流

掌握 Git 的关键在于理解其背后的核心概念和基本操作流程。本章将详细介绍 Git 的三个核心区域，并演示从初始化仓库到创建第一个提交的完整过程。

• 三大核心区域：工作区、暂存区与本地仓库
  • 工作区 (Working Directory)：这是在计算机上能直观看到并进行编辑的文件夹。它包含了项目的所有文件，是进行代码编写、修改、添加或删除文件的场所。
  • 暂存区 (Staging Area / Index)：这是一个位于 .git 目录下的特殊文件，它记录了即将要被提交到本地仓库的文件快照信息。可以选择性地将工作区的某些修改放入这个清单，准备进行下一次提交。
  • 本地仓库 (Local Repository)：这也是一个位于项目根目录下的 .git 文件夹。它存储了项目的所有版本历史、元数据以及对象数据库。当执行 git commit 命令时，Git 会将暂存区中的内容制作成一个永久的快照（即一次“提交”），并保存在本地仓库中。

1. 仓库的初始化

• 要对一个项目进行版本控制，首先需要将其初始化为一个 Git 仓库。

• 操作步骤：

  • 通过命令行工具进入项目文件夹；

  • 运行以下命令：

    git init
    
    // 如果要将分支设置为远程仓库的主分支，可以强制命名
    git init -b main

  • 命令效果：执行该命令后，Git 会在当前目录下创建一个名为 .git 的子目录。这个目录包含了所有Git仓库必需的文件和元数据。从此，Git 便开始追踪该目录下的所有文件变更。

2. 标准工作流程：修改、暂存与提交

• 这是 Git 最基本也是最常用的工作循环。

• 第一步：查看状态 git status

  • 这是在任何时候都应该首先使用的命令，它可以清晰地告诉你当前仓库的状态。
  • git status 会显示哪些文件被修改过、哪些文件是新增的（未被追踪的）、哪些文件已经被放入暂存区等。

• 第二步：添加至暂存区 git add

  • 当在工作区完成了一些修改后，需要使用 git add 命令将其添加到暂存区，以备提交。

  • 添加单个文件：

    git add <filename>

  • 添加所有已修改或新增的文件：

    git add .

• 第三步：提交至本地仓库 git commit

  • 将所有希望本次记录的更改都添加到暂存区后，就可以执行提交操作了。

  • 运行以下命令，其中 -m 参数后的字符串是本次提交的说明信息，这是必不可少的

    git commit -m "必要的说明信息"

  • 提交说明 (Commit Message)：编写清晰、有意义的提交说明是一个至关重要的好习惯。

3. 提交历史的审查与追溯

• 提交完成后，可以使用 git log 命令来查看仓库的版本历史。

• 查看详细历史 git log：

  此命令会按 时间倒序 列出所有的提交记录。每条记录包含：

  • Commit Hash：一个唯一的 SHA-1 校验和，是该次提交的唯一标识符。
  • Author：作者的姓名和邮箱地址（即在全局配置中设置的信息）。
  • Date：提交的日期和时间。
  • Commit Message：提交时填写的说明信息。

• 查看简洁历史 git log --oneline：

  如果觉得默认的日志输出信息太多，可以使用此命令来查看一个更紧凑的版本，每条提交仅显示一行。

Git 分支：核心机制与应用

Git 极其重要的一个特性就是其轻量而强大的分支模型。分支允许在主开发线之外开辟一个独立的工作空间，进行新功能开发、Bug 修复或实验性尝试，而不会影响到主线的稳定。

1. 分支（Branch）的概念与应用场景

• 什么是分支？ 在技术上，Git 的分支本质上是一个指向某次提交（Commit）的可移动指针。默认情况下，Git 创建的第一个分支名为 master 或 main。每当进行一次新的提交，这个指针就会自动向前移动，指向最新的提交。
• 分支的功用（为什么需要分支）？
  • 隔离开发：假设你需要开发一个复杂的新功能，预计需要几天时间。如果直接在主分支上编码，那么在开发完成前，主分支将一直处于不稳定状态，这会严重影响团队其他成员的工作。通过创建一个新的“功能分支”，就可以在一个完全隔离的环境中工作，直到功能开发完毕、测试通过后，再将其合并回主分支。
  • 并行工作：在一个团队中，不同的开发者可以创建各自的分支来同时进行不同的任务，互不干扰。
  • 版本管理：通常会维护一个长期稳定的主分支（如 main），用于发布生产版本。同时创建一个 develop 分支用于日常开发。当需要发布新版本时，再从 develop 分支合并到 main 分支。这种工作流被称为 Git Flow，是业界流行的分支策略之一。

2. 分支管理的基础指令

• 列出分支：查看当前仓库中所有的本地分支。

  git branch

  • 当前所在的分支名前会有一个星号 * 标记。

• 创建新分支：

  git branch <branch-name>

  • 例如：git branch feature-login。这个命令只创建了新分支，但仍然停留在当前分支。

• 切换分支：

  • 现代 Git 推荐使用 switch 命令，其语义更清晰。

    git switch <branch-name>

  • 传统上使用 checkout 命令，至今仍广泛使用。

    git checkout <branch-name>

• 创建并立即切换到新分支：这是日常开发中最常用的命令之一。

  • 使用 switch：

    git switch -c <branch-name>

  • 使用 checkout：

    git checkout -b <branch-name>

• 删除分支：当一个分支的工作完成并已合并到主线后，通常可以将其删除.

  git branch -d <branch-name>

  • -d 是 --delete 的缩写，它只在分支被完全合并后才允许删除。如果分支上有未合并的提交，Git 会提示错误。
  • 如果一定要强制删除一个未合并的分支，可以使用 -D 大写参数。

3. 分支的合并策略

• 当在一个分支上的工作完成后，就需要将其成果合并回主开发线（例如 main 分支）。

• 操作步骤：

  1. 首先，切换回希望并入的目标分支。

     git switch main

  2. 然后，执行 merge 命令，将指定分支合并过来。

     git merge <branch-name-to-merge>

• 合并类型：

  • 快进式合并 (Fast-forward)：如果目标分支（main）在创建功能分支后没有任何新的提交，那么合并时 Git 只会简单地将 main 指针直接移动到功能分支的最新提交上。这个过程非常快，因为没有需要整合的工作。
  • 三方合并 (Three-way Merge)：如果在开发功能分支的同时，目标分支（main）上也有了新的提交，Git 就无法进行快进式合并。此时，Git 会执行三方合并。它会找到两个分支的共同祖先，并将两个分支各自的修改与共同祖先进行比较，然后生成一个新的“合并提交”（Merge Commit）。这个新的提交会有两个父提交。

4. 合并冲突的识别与解决

• 什么是合并冲突？ 当两个不同的分支对同一个文件的同一部分进行了修改时，Git 无法自动判断应该保留哪个版本，这时就会产生合并冲突（Merge Conflict）。Git 会暂停合并过程，等待手动解决冲突。

• 解决冲突的流程：

  1. 识别冲突文件：执行 git merge 后，如果出现冲突，Git 会在命令行中明确提示。也可以使用 git status 查看哪些文件处于冲突状态。

  2. 编辑冲突文件：打开冲突的文件，可以看到类似下面的标记：

     <<<<<<< HEAD
     这是当前分支（例如 main）的内容。
     =======
     这是要合并过来的分支（例如 feature-login）的内容。
     >>>>>>> feature-login

     • <<<<<<< HEAD 到 ======= 之间是当前所在分支（HEAD）的内容。
     • ======= 到 >>>>>>> 之间是要合并过来的分支的内容。

  3. 手动解决：需要根据实际需求，决定保留哪部分内容，或者将两部分内容重新整合。解决冲突的关键就是删除 Git 添加的这些特殊标记 (<<<<<<<, =======, >>>>>>>)，并将文件修改为最终想要的样子。

  4. 标记为已解决：当完成文件的修改并保存后，需要使用 git add 命令来告诉 Git，这个文件的冲突已经解决了。

     git add <conflicted-file-name>

  5. 完成合并：当所有冲突文件都通过 git add 标记为已解决后，最后执行一次 git commit 来完成整个合并过程。Git 会自动生成一个默认的合并提交信息，也可以自行修改。

远程协作：与远程仓库的交互

到目前为止，我们所有的操作都局限在本地仓库中。为了与团队成员协作，或将代码备份到云端，我们需要与远程仓库（Remote Repository）进行交互。

1. 远程仓库（Remote）

• 什么是远程仓库？ 远程仓库是托管在网络服务器上的项目版本库。它可以被团队中的多名成员访问，用于同步和分享彼此的工作成果。

• 作用：

  • 团队协作：提供一个所有成员都可以访问的“中央”代码库，方便大家交换代码和协同开发。
  • 代码备份：将本地的代码库完整地备份到云端，防止因本地设备损坏导致的数据丢失。

• 以 GitHub 为例：GitHub 是全球最大的代码托管平台。您可以在 GitHub 上免费创建公开或私有的远程仓库。本教程将主要以 GitHub 作为远程仓库的实例进行说明。

2. 远程仓库的连接与克隆

场景一：从零开始，加入一个现有项目

• 如果要参与一个已经在 GitHub 上存在的项目，最直接的方式就是使用 git clone 命令。

• git clone <repository-url>：此命令会完整地复制一个远程仓库到本地。它会自动创建一个与远程仓库同名的文件夹，下载所有版本历史，并自动将远程仓库的地址命名为 origin，设置好跟踪关系。

  git clone https://github.com/user/project.git

场景二：将已有的本地项目推送到远程

• 如果你已经在本地初始化了一个 Git 仓库并进行了一些提交，现在想把它发布到 GitHub 上。

• 步骤：

  1. 在 GitHub 上创建一个新的空仓库（不要勾选初始化 README 等文件）。

  2. GitHub 会提供该仓库的 URL。

  3. 在本地仓库中，使用 git remote add 命令将本地仓库与远程仓库关联起来。

     git remote add origin https://github.com/user/new-project.git

     • origin 是远程仓库的默认别名，也可以使用其他名称。

  4. 可以使用 git remote -v 命令查看已配置的远程仓库信息。

需要注意的是，在 GitHub 上创建仓库时创建的主分支名称默认为 main ，而本地使用 git init 初始化的仓库主分支名称默认为 master ，如果想要将本地分支的内容直接推送到 GitHub 上的主分支，需要将两个命名统一。

可以使用前文提到的 git init -b <name> 来强制命名本地分支，也可以在 GitHub 设置中修改创建仓库时的默认分支名称。

如果在 GitHub 上创建仓库时勾选了初始化 README 等文件导致初始仓库不为空，第一次可能会推送不成功。此时需要先使用 git pull 命令将远程仓库合并到本地，再使用 git pull 推送。

3. 数据同步：推送（Push）与拉取（Pull）

• 推送 git push：将本地的提交分享到远程仓库。

  • git push <remote-name> <branch-name>：此命令会将本地指定分支上的所有新提交上传到远程仓库对应的分支。

  • 首次推送一个新创建的本地分支时，通常需要使用 -u (或 --set-upstream) 参数来建立本地分支与远程分支的跟踪关系。之后，就可以直接使用 git push 而无需指定远程和分支名。

    # 首次推送 feature 分支并建立跟踪关系
    git push -u origin feature
    
    # 之后在该分支上，可以直接推送
    git push 

• 拉取 git pull：从远程仓库获取最新的更改并合并到本地。

  • git pull <remote-name> <branch-name>：此命令会查找远程仓库指定分支上的更新，将其下载到本地，并尝试与本地的当前分支进行合并。

  • 如果已经建立了跟踪关系，可以直接使用 git pull。

    git pull origin main

4. git pull 与 git fetch 的功能对比

• 这是初学者经常混淆的一对命令。理解它们的区别对于避免不必要的合并冲突至关重要。
• git fetch：只下载，不合并
  • git fetch 命令会将远程仓库的最新历史记录下载到本地，但它不会修改当前的工作区或分支。它会将这些更新保存在一个特殊的命名空间下（例如 origin/main）。
  • 使用场景：当想要查看远程仓库有什么新的更新，但又不希望立即将这些更改合并到自己的工作中时，fetch 是一个安全的选择。可以在 fetch 之后，使用 git log origin/main 查看远程分支的提交历史，或者使用 git diff main origin/main 比较本地与远程的差异，然后再决定是否合并。
• git pull：下载并合并
  • git pull 命令在本质上是两个命令的组合：
    1. git fetch：从远程仓库下载最新的内容；
    2. git merge：将下载下来的远程分支（如 origin/main）合并到当前的本地分支（如 main）。
  • 使用场景：当确定希望立即获取远程更新并应用到本地工作时，git pull 是一个方便的命令。但需要注意，如果本地和远程有冲突的提交，pull 会直接触发合并冲突。

操作撤销与版本回滚

在开发过程中，犯错在所难免。无论是写错了代码、提交了多余的文件，还是想彻底放弃某个功能的尝试，Git 都提供了多种撤销操作的手段。本章将介绍如何针对不同阶段的错误进行“反悔”。

1. 修订最近一次提交 git commit --amend

• 适用场景：刚刚完成一次提交（git commit），但是发现：

  • 提交说明（Commit Message）写错了或不够清晰。
  • 漏掉了一两个文件没有添加到暂存区。

• 操作方法：

  1. 如果只是想修改提交说明，直接运行：

     git commit --amend

     这会打开默认文本编辑器，可以重新编辑上次的提交说明。

  2. 如果想将遗漏的文件也添加到上一次提交中，可以先 git add 这些文件，然后再运行 --amend：

     git add forgotten-file.txt
     git commit --amend

• 工作原理：这个命令并不会在原来的提交上进行修改，而是会创建一个全新的提交，用来替换掉刚才那次“错误”的提交。

• ⚠️注意：如果这个“错误”的提交已经被推送到了远程仓库，那么不建议使用 --amend。因为修改历史会与远程仓库产生冲突，给团队其他成员带来麻烦。只对尚未推送到公共仓库的提交使用 --amend。

2. 撤销暂存区中的文件 git reset

• 适用场景：使用 git add 将文件添加到了暂存区，但后来又不想将这个文件的更改包含在下一次提交中了。

• 操作方法：

  git reset HEAD <file-name>

  • HEAD 是一个指向当前分支最新一次提交的指针。这条命令的意思是，将暂存区里的指定文件恢复成和 HEAD 指向的版本一样，也就是把它从暂存区里“拿出来”。

• 文件会从暂存区（Staged）状态变回已修改（Modified）但未暂存（Unstaged）的状态。在工作区对该文件所做的修改内容会被保留。

3. 废弃工作区的本地修改 git checkout 或 git restore

• 适用场景：在工作区修改了一个文件，但后来觉得这些修改完全是错误的，想彻底放弃，恢复到该文件最近一次提交时的状态。

• 操作方法：

  • 传统方式：

    git checkout -- <file-name>

  • 现代方式（推荐）：新版 Git 提供了 restore 命令，语义更清晰。

    git restore <file-name>

• ⚠️注意 ：这是一个危险且不可逆的操作！它会用仓库中该文件的最新版本直接覆盖掉在工作区的所有修改。一旦执行，所做的本地修改将永久丢失，无法找回。

4. 历史版本的恢复策略：reset 或 revert

• 当需要撤销的不是某个文件的修改，而是整个或某几个历史提交时，就需要用到版本回退了。Git 提供了两种主要的回退方式：reset 和 revert。

• git reset：移动指针，重写历史

  • 工作原理：git reset 命令会直接移动当前分支的 HEAD 指针以及分支指针到指定的某个历史提交上。根据参数不同，它对暂存区和工作区的影响也不同。
  • 常用模式 git reset --hard <commit-id>：这是最彻底也是最危险的模式。它会：
    1. 将分支指针移动到 <commit-id>。
    2. 将暂存区更新为 <commit-id> 的内容。
    3. 将工作区也强制更新为 <commit-id> 的内容。 这意味着从 <commit-id> 之后的所有提交记录以及所有未提交的本地修改都会被彻底删除。
  • 适用场景：仅用于私有分支或未被推送到公共仓库的提交。当确定自己本地的某段提交历史完全是错误的，并且想彻底抹除它们时使用。绝对不要对已经推送到公共仓库的提交使用 git reset --hard。

• git revert：创建反向操作，保留历史

  • 工作原理：git revert 不会删除或修改任何历史记录。相反，它会分析指定的那个历史提交，然后创建一个全新的提交，这个新提交的内容刚好是用来抵消掉那个历史提交所做的所有更改。

  • 操作方法：

    git revert <commit-id>

  • 适用场景：这是在公共分支上撤销提交的标准且安全的方式。因为它不改变项目历史，只是在历史的末尾追加一次“反向提交”，所以对于已经推送到远程并被团队成员拉取的提交，使用 revert 不会造成历史冲突。其他成员只需正常 git pull 即可同步这次撤销操作。

• 总结对比：

  特性	git reset –hard	git revert
  历史记录	修改（删除）现有历史	不修改历史，而是追加新历史
  操作结果	HEAD 指针和分支指针移动到过去	在当前分支顶端创建一个新的“反向”提交
  安全性	危险，会丢失数据	安全，保留所有记录
  适用范围	仅限本地私有提交	公共、共享的提交

高级功能与技巧

此处内容暂不详细学习，仅做了解。

1. 使用 .gitignore 排除文件；
   • 配置该文件以指定不需要纳入版本控制的文件或目录。
2. 版本标记（Tagging）的应用；
   • git tag：为特定的提交（例如软件发布版本）创建永久性的标记。
3. 工作进度的临时储藏（Stashing）
   • git stash：临时保存当前工作目录和暂存区的状态。
4. 提交历史的重写（Rebasing）
   • git rebase：用于合并一系列提交，以创造一个更线性的提交历史。

总结

1. 核心概念回顾

• 三大区域：我们所有的本地工作都在工作区进行，通过 git add 将选定的更改放入暂存区，最后通过 git commit 将这些更改永久记录到本地仓库。

• 分支：分支是 Git 的核心，它允许我们创建独立的工作空间来开发新功能或修复问题，而不影响主线的稳定性。git branch, git switch, git merge 是我们的主要工具。

• 远程协作：通过 git clone, git push, git pull 等命令，我们可以与 GitHub 等远程平台进行交互，实现团队协作和代码备份。

2. 常用命令速查表

3. 编写高质量的 Commit Message (选学)

业界公认的格式：

<type>: <subject>

[optional body]

[optional footer]

• <type> (类型)：说明本次提交的类别，常用的有：

  • feat: 新功能 (feature)
  • fix: 修复 bug
  • docs: 文档变更
  • style: 代码格式（不影响代码运行的变动）
  • refactor: 重构（既不是新增功能，也不是修改 bug 的代码变动）
  • test: 增加测试
  • chore: 构建过程或辅助工具的变动

• <subject> (主题)：用一句话简要描述本次提交的目的，不超过 50 个字符。

• body (正文)：可选。对本次提交进行更详细的描述，解释“为什么”要这样修改。

• footer (脚注)：可选。通常用于关闭 Issue (例如 Closes #123)。

示例：

feat: Add user login functionality

Implement the user login API endpoint and basic validation.
The endpoint accepts username and password, and returns a JWT token upon successful authentication.

Closes #42

基本概念

   决策树（Decision Tree） 是一种基础的监督学习模型，广泛应用于分类与回归任务。其核心思想是通过一个树状结构来对实例进行决策。该结构本质上是一系列if-then规则的集合，具有很强的可解释性。

   一个决策树模型包含以下几个基本组成部分：

• 根节点 (Root Node): 整棵树的起点，代表了对数据集的第一个划分问题。
• 内部节点 (Internal Node): 也叫决策节点，代表一个特征或属性的判断问题。
• 分支 (Branch): 从内部节点延伸出来的路径，代表对问题的一个可能回答（比如“是”或“否”，“大于”或“小于”等）。
• 叶子节点 (Leaf Node): 也叫终端节点，代表最终的决策结果或分类标签。从根节点到叶子节点的每一条路径，都构成了一条决策规则。

   决策树的目标是构建一个泛化能力强，且尽可能简单的模型。它通过从数据特征中学习，自动生成一套简单有效的“决策规则”，从而对新的数据进行预测。例如，根据一个人的年龄、收入、职业等特征，来预测他是否会购买某个产品。其基本流程遵循简单而直观的 “分而治之”(divide-and-conquer) 策略。

   决策树的生成是一个递归过程，在基本算法中有三种情形会导致递归返回：
   1. 当前结点包含的样本全属于同一类别，无需划分；
   2. 当前属性集为空，或是所有样本在所有属性上取值相同，无法划分；
   3. 当前结点包含的样本集合为空，不能划分。

划分选择

   由上述算法可以看出，决策树学习的关键是选择最优划分属性。决策树的目标是，通过每次提问（划分），让数据的“不确定性”变得越来越小，让划分后的每个分支都尽可能地“纯粹”，即结点的 “纯度”(purity) 越来越高。衡量“纯度”的最常用的数学指标有信息熵 (Information Entropy) 和 基尼不纯度 (Gini Impurity) ，后者也称为 “基尼指数”(Gini index)。

信息熵与信息增益

   ”信息熵(information entropy) 是信息论中的一个概念，它衡量的是一个系统（在这里就是我们的数据集）的 不确定性 或 混乱程度 。

• 熵越大 ，代表系统越混乱，不确定性越高。
• 熵越小 ，代表系统越有序，不确定性越低。

假定当前样本集合 $D$ 中第 $k$ 类样本所占的比例为 $p_k(k=1,2,\dots,|\mathcal{Y}|)$ ，则 $D$ 的信息熵定义为：

$Ent(D)$ 的值越小，则 $D$ 的纯度越高。

   信息增益 (Information Gain) 则是用来衡量一个特征划分“好不好”的指标。它的思想很简单：

假定离散属性 $a$ 有 $V$ 个可能的取值 $\{a^1, a^2, \dots, a^V \}$ ，那么使用 $a$ 来划分就会产生 $V$ 个分支结点，每个结点的信息熵之和就是划分后的信息熵。考虑到不同的分支结点包含的样本数不同，给分支结点赋予权重 $|D^v|/|D|$ ，即样本数越多的分支结点的影响越大，于是可计算出信息增益：

一般来说，信息增益越大，说明数据集不确定性减少的程度越大，即纯度提升越大。因此决策树会选择信息增益最大的特征进行划分。

信息增益率

   思考一个极端情况。假设我们的数据集中有一个特征是“学号”或“订单ID”，这个特征的特点是，每个人的学号或 ID 都是独一无二的。如果决策树使用信息增益作为划分标准，那么按照 ID 来划分数据时，每个分支都只会包含一个样本。此时每个分支的“纯度”都达到了100%，信息熵为0，于是决策树会选择“学号”或 ID 来作为根节点划分，但是这样的划分没有意义，我们称之为 过拟合(Overfitting) 。
结论：信息增益准则对那些“可取值数目较多”的特征有所偏好。

   为了修正这种偏好，我们引出"信息增益率"的概念。它出自 C4.5 决策树算法。

    信息增益率 (Information Gain Ratio) 在信息增益的基础上，增加了一个惩罚项，这个惩罚项会随着特征的可取值数目增多而变大，从而抑制了模型对这类特征的偏好。增益率定义为：

其中，

• $\text{Gain}(D, a)$ 是信息增益。
• $\text{IV}(a)$ 就是新增的惩罚项，它被称为特征 $a$ 的 **固有值(Intrinsic Value) ** 或 分裂信息(Split Information)。

固有值 $\text{IV}(a)$ 的计算公式为：

可以发现这个公式与信息熵的计算公式非常相似，不同之处在于：

• 信息熵 衡量的是 类别标签 的混乱程度（比如“是/否”购买的比例）。
• 固有值 衡量的是 特征取值 的混乱程度（比如特征“天气”有“晴天、阴天、下雨”3个值的比例）

如果一个特征的取值越多，每个取值下的样本数就越少，那么计算出的 $\text{IV}(a)$ 值通常会越大。把它作为分母，就可以有效地 惩罚 那些取值数目过多的特征。

   值得注意的是，增益率准则对可取值数目较少的属性有所偏好，因此C4.5算法并不是直接选择增益率最大的特征，而是采用一种启发式策略：
  1. 先从候选划分特征中找出信息增益高于平均水平的特征。
  2.  然后再从这些特征中选择信息增益率最高的那个。
这样做可以平衡信息增益和增益率，避免了对取值数目少的特征产生不公平。

基尼指数

   基尼指数(Gini index) ，也称为 基尼不纯度(Gini Impurity) ，是另一个衡量数据不确定性的指标，它比信息熵的计算速度更快一些，在很多决策树算法(如 CART (Classification and Regression Tree) 决策树算法)中被广泛使用。

   基尼指数的含义是：从一个数据集中随机抽取两个样本，其类别标签不一致的概率。

• 基尼指数越小，代表数据集的纯度越高。

• 基尼指数越大，代表数据集的纯度越低。

对于一个数据集 $D$ ，其基尼指数的定义为：

在评估“划分”时，我们用“基尼指数”指代一次划分操作的优劣程度。在这种情况下，“基尼指数”指的是划分后，所有子节点基尼不纯度的加权平均值 ：

此时，在候选属性集合 $A$ 中，选择那个使得划分后基尼指数最小的属性作为最优划分属性，即 $a_* = \arg \min_{a\in A} \text{Gini\_index}(D, a)$ 。

剪枝处理

   到目前为止，我们已经知道决策树是如何通过选择最优特征来一步步构建起来的。但一个关键问题是：这棵树应该长到什么时候才停下来？ 如果让它一直生长，直到每个叶子节点都只包含一种类型的样本（即达到100%纯度），这样就是最好的吗？答案是否定的。这会引出机器学习中一个非常普遍且重要的问题——过拟合。

过拟合

   过拟合指的是一个模型在训练数据上表现得过于完美，以至于把训练数据中的一些噪声、特例和无关紧要的细节都学习了进去，导致模型的泛化能力下降。这样的模型，在面对它“背过答案”的训练集时，准确率可能高达100%；但一旦遇到新的、没见过的数据（测试集），表现就会非常糟糕。

   为了解决过拟合问题，我们需要对决策树进行简化，这个过程就叫做剪枝 (Pruning)。剪枝是一种正则化技术，它通过主动去掉一些分支来降低模型的复杂度，从而提高模型的泛化能力。

   剪枝分为两大类：预剪枝 (Pre-pruning) 和 后剪枝 (Post-pruning)。

预剪枝

   预剪枝 (Pre-pruning) 是指在决策树生成过程中，对每个结点在划分前先进行估计，若当前结点的划分不能带来决策树泛化性能的提升，则停止划分并将当前结点标记为叶节点。

   判断决策树泛化性能是否提升，可以考虑使用 模型评估与选择 一节中的性能评估方法，比如采用留出法，预留一部分数据用作”验证集“以进行性能评估。除此之外，还有一些更简单的预剪枝策略：

• 限制树的深度 (Max Depth)：规定决策树最多能长多深，一旦达到指定深度就停止生长。

• 限制叶子节点的最少样本数 (Min Samples Leaf)：规定一个叶子节点至少要包含多少个样本，如果分裂后某个子节点的样本数少于这个阈值，则不进行分裂。

• 限制节点划分的最小样本数 (Min Samples Split)：规定一个节点至少要有多少个样本才能进行划分。

• 限制信息增益的阈值：规定信息增益（或基尼增益）必须大于某个阈值，否则不进行分裂。

   预剪枝的优点在于，在书的构建过程中就提前停止，速度快，计算开销小，同时生成的决策树通常规模更小，更简单等；而它的缺点是具有“短视”的风险，有些划分可能当前看起来收益不大（甚至会降低验证集准确率），但它后续的划分却可能会带来巨大的收益。预剪枝基于“贪心”本质禁止这些分支展开，给预剪枝决策树带来了欠拟合的风险。

后剪枝

   后剪枝 (Post-pruning) 与预剪枝相反。它允许决策树先完全生长，然后再从下往上地审视每个结点，尝试将一些子树替换为单个叶子结点，看看这样做能否提升模型的泛化能力。

   最常见的后剪枝方法是降低错误剪枝 (Reduced Error Pruning, REP)：

1. 将数据分为训练集和验证集。

2. 用训练集生成一棵完整的决策树。

3. 从下往上遍历树中的每一个非叶子结点。

4. 尝试将这个结点对应的子树替换成一个叶子结点（该叶子结点的类别由子树中占多数的样本决定）。

5. 用验证集评估，如果剪枝后的树在验证集上的准确率更高或持平，则确定进行剪枝，用叶子结点替换该子树。

6. 重复这个过程，直到无法再通过剪枝提升验证集准确率。

   后剪枝的优点是眼光更长远，因为它是在一棵完全长成的树上进行全局考察，通常能保留更多有用的分支，所以剪枝后模型的泛化性能往往优于预剪枝；缺点是计算开销大，同时需要先生成一棵完整的树，所以时间成本更高。

两种剪枝策略对比

连续值与缺失值

   目前为止我们讨论的例子，特征都是 离散值 (Categorical Values) ，但在现实学习任务重，数据往往包含了大量的 连续值 (Continuous Values) 。同时，数据也常常不完整，存在 缺失值 (Missing Values) 。一个完善的算法必须能够妥善处理这些情况。

连续值处理

   对于连续的特征（如温度、长度等），我们无法像离散特征那样，为每个可能的值都创建一个分支。因为连续值的可能性有无穷多个。此时，可以使用 连续值离散化 (Discretization) 。其核心思想是，将连续特征转换为一个离散的二分特征。具体来说，就是寻找一个最优的 “切分点” (Split Point) ，将数据一分为二，比如将“温度”特征变为“温度 ≤ 24.5℃”和“温度 > 24.5℃”两个分支。

   关于如何找到这个最优的切分点，C4.5算法提供了一个简单有效的方法：

1. 排序 ：给定样本集 $D$ 和连续属性 $a$ ，假定 $a$ 在 $D$ 上出现了 $n$ 个不同的取值，将这些值从小到大进行排序。假设排序后的值为 ${a^1,a^2,\dots,a^n}$ ；
2. 生成候选切分点 ：基于划分点 $t$ 可将 $D$ 分为 $D_t^-$ 和 $D_t^+$ 。显然对于相邻的属性取值 $a^i$ 与 $a^{i+1}$ 来说，$t$ 在区间 $[a^i, a^{i+1})$ 中取任意值所产生的划分结果相同。因此可以将每两个相邻值的中点作为候选切分点，此时可以得到包含 $n-1$ 个元素的候选切分点集合：
   $$T_a = \left\{\frac{a^i + a^{i+1}}{2} | 1 \leq i \leq n-1 \right\}；$$
3. 选择最优切分点 ：此时，像计算离散特征一样，我们可以计算每次二次划分的信息增益，从而得到最优切分点对应的划分
   $$\begin{align*} \text{Gain}(D,a) &= \max_{t \in T_a} \text{Gain}(D,a,t) \\ &= \max_{t \in T_a} \text{Ent}(D) - \sum_{\lambda \in\{-,+\}}\frac{|D_t^{\lambda}|}{|D|} \text{Ent}(D_t^{\lambda}) \end{align*}$$
   其中 $\text{Gain}(D,a,t)$ 是样本集 $D$ 基于划分点 $t$ 二分后的信息增益，于是我们就可以选择使 $\text{Gain}(D,a,t)$ 最大化的划分点。

缺失值处理

   现实任务中常会遇到不完整样本，即样本的某些属性值缺失，我们需要解决两个问题：(1) 如何在属性值缺失的情况下进行划分属性选择？(2) 给定划分属性，若样本在该属性上的值缺失，该如何对样本进行划分？C4.5算法巧妙地解决了这个问题，主要分两步：

第一步：在计算信息增益时

假设特征 $A$ 有缺失值：

1. 首先，忽略掉所有在特征 $A$ 上有缺失值的样本，得到一个无缺失的数据子集 $\widetilde{D}$ ；
2. 只用这个无缺失子集 $\widetilde{D}$ 来正常计算特征 $A$ 的信息增益 $\text{Gain}(\widetilde{D},A)$；
3. 最后，将计算出的信息增益乘以一个权重。这个权重就是 无缺失样本所占的比例。
   例如， 总共有100条数据，特征 A 在其中80条数据上没有缺失值，那么权重就是 80/100 = 0.8。最终特征 A 的信息增益就是 $0.8 \times \text{Gain}(\widetilde{D}, A)$ 。

这样做相当于对有缺失值的特征施加了一个“惩罚”，缺失值越多，它最终的信息增益就越低，被选中的概率也就越小。

第二步：在划分数据时

   假设最终还是选择了有缺失值的特征 A 来进行划分（比如特征A有“取值1”和“取值2”两个分支）。那么，那条在特征 A 上有缺失值的样本该被分到哪个分支去呢？

   C4.5的做法是，将这个缺失值样本按比例分配到所有的子节点中。这个比例，就是无缺失样本在各个分支中所占的比例。例如，在无缺失的样本中，有60%的样本被划入了“取值1”分支，40%被划入了“取值2”分支。那么，这个缺失值样本就会被赋予一个0.6的权重并划入“取值1”分支，同时被赋予一个0.4的权重并划入“取值2”分支。之后在子节点中继续计算信息熵时，这些带有权重的样本也会被相应地考虑进去。

总结

主要优缺点

优点

• 可解释性强：模型的结果易于理解和可视化，可以生成清晰的if-then规则，是典型的“白盒模型”。
• 数据准备要求低：通常无需对数据进行归一化或标准化，并且能同时处理数值型和类别型数据。
• 预测速度快：一旦决策树构建完成，对新样本的预测过程非常高效。

缺点

• 容易过拟合：若不加限制，决策树会倾向于完美拟合训练数据，导致泛化能力差，因此剪枝是必不可少的步骤。
• 不稳定性：训练数据中的微小变动可能会导致生成一棵完全不同的树。
• 贪心本质：决策树的生成过程是贪心的，在每一步都寻求局部最优解，但这并不能保证得到全局最优的树结构。
• 学习能力局限：决策树的划分边界与坐标轴平行，这使得它在学习某些具有对角线关系的数据时效率不高。

决策树在现代机器学习中的角色

   尽管单个决策树存在上述缺点，但它依然是现代机器学习中极为重要的算法之一，因为它构成了许多强大**集成学习(Ensemble Learning)**模型的基础。

• 随机森林 (Random Forest)：通过构建大量的决策树，并让它们对结果进行“投票”，极大地克服了单个决策树不稳定的问题，是一种非常强大和流行的算法。
• 梯度提升决策树 (Gradient Boosted Decision Tree, GBDT)：通过迭代地构建决策树，每一棵新树都致力于修正前面所有树的残差。以GBDT为核心思想的XGBoost、LightGBM等算法，是当前在处理表格数据任务中最顶尖的算法之一。

线性判别分析的代码实现参考GitHub

先来回顾一下协方差矩阵的概念。
1. 方差
   方差用来衡量 单一变量 的数据有多么分散。数学上表示为 $Var(X)$​ 。
2. 协方差
   将一个变量从一个增加到两个，就引出了协方差。

• 协方差是做什么的？ 它用来衡量 两个变量 如何 协同变化。也就是说，当一个变量变化时，另一个变量是倾向于朝相同方向变化，还是相反方向变化。

• 三种情况：

  1. 正协方差 (Positive Covariance): 当变量X增大时，变量Y也倾向于增大。我们称之为“正相关”。
  2. 负协方差 (Negative Covariance): 当变量X增大时，变量Y却倾向于减小。我们称之为“负相关”。
  3. 零协方差 (Zero Covariance): 两个变量之间没有明确的线性关系。

核心： 协方差描述的是 两个 变量之间的方向关系。数学上表示为 $Cov(X,Y)$。

3. 协方差矩阵
  当有多个变量时，我们需要有一个工具来同时展示所有变量两两之间的协方差关系。

协方差矩阵是做什么的？ 它是一个方阵（行数和列数相等），整齐地排列了多个变量中，每一对变量之间的协方差。

矩阵的结构： 假设我们有三个变量：X, Y, Z。那么协方差矩阵就是一个 3x3 的矩阵。

• 对角线上的元素 (Diagonal Elements): 对角线上的值是 每个变量自身的方差。因为一个变量和它自己的“协同变化”程度，就是它自身的分散程度（方差）。所以 $Cov(X,X)=Var(X)$。
• 非对角线上的元素 (Off-diagonal Elements): 非对角线上的值是 不同变量两两之间的协方差。
• 结构示例： 对于变量 X, Y, Z，其协方差矩阵看起来是这样的：

重要特性：对称性 (Symmetry) 。这个矩阵是对称的。因为X和Y的协方差 $(Cov(X,Y))$ 与Y和X的协方差 $(Cov(Y,X))$ 是完全一样的。所以矩阵中，位置 (i, j) 的元素和 (j, i) 的元素是相等的。

线性判别分析

   线性判别分析 (Linear Discriminant Analysis, LDA) 是一种经典的线性学习方法，其思想非常朴素：简单来说，LDA 试图找到一种看待数据的方式 (一个视角或者一个投影) ，在这种方式下，不同类别的数据点能够被最清晰地分开。

LDA 的核心思想是：

• “类间距离最大化，类内方差最小化”
  (Maximize the distance between classes, and minimize the variance within each class.)

我们把它拆开看：

1. 类内方差最小化 (Minimize Within-class Variance):
   • 我们希望同一个类别的数据点，在投影到新的维度后，它们的分布尽可能地集中和紧凑。就像把原来散开的队伍，重新整队变得密集一样。这表示“高内聚”。
2. 类间距离最大化 (Maximize Between-class Distance):
   • 我们希望不同类别的数据中心点，在投影后，它们之间的距离尽可能地远。这能让不同类别之间有一道清晰的“鸿沟”。这表示“低耦合”。

LDA 要找的，就是能够同时满足这两个条件的完美投影方向。

LDA 的工作原理

   假设我们有一个数据集，包含 $C$ 个类别。

• $D_i$ ：第 $i$ 个类别 $ (c_i) $ 的样本集合
• $N_i$ ：第 $i$ 个类别 $ (c_i) $ 中的样本数量
• $x$ ：一个数据样本，多维列向量
• $\mu_i$ ：第 $i$ 个类别的均值向量。
      $\mu_i = \frac{1}{N_i} \sum x \{x \in D_i\}$
• $\mu$ ：全体样本的均值向量
• $w$ ：要寻找的最佳投影方向。投影后的新坐标为 $z = w^Tx$ 。

类内散度矩阵

   “类内方差最小化“指的是同一个类别内部的数据点要尽可能紧凑。我们用 类内散度矩阵(Within-class Scatter Matrix) $S_w$ 来衡量这一点。

   首先，对于单个类别 $c_i$ ，其散度矩阵 $S_i$ 定义为该类中所有样本点到其均值 $\mu_i$ 的协方差矩阵(乘以常数 $N_i$)。

这里 $(x - \mu_i)(x - \mu_i)^T$ 是一个外积，结果是一个矩阵，它捕捉了数据的分散情况。
然后，我们将所有类别的散度矩阵相加，就得到了总的类内散度矩阵 $S_w$ ：

$S_w$ 综合了所有类别内部的分散程度。我们的目标是让数据在投影后的类内散度尽可能小。

类间散度矩阵

   “类间距离最大化”指的是不同类别的中心点要尽可能分开。我们用 类间散度矩阵 (Between-class Scatter Matrix) $S_b$ 来衡量。
    $S_b$ 衡量的是各个类别的均值向量 $\mu_i$ 相对于全局均值 $\mu$ 的分散程度，并用该类的样本数 $N_i$ 进行加权。

$S_b$ 越大，说明不同类别中心点之间的距离越远。我们的目标是让数据在投影后的类间散度尽可能大。

构建目标函数

   现在，我们有了 $S_w$ 和 $S_b$ 。它们都是矩阵，一个矩阵包含了非常丰富的信息：

• 对角线元素代表了在各个坐标轴方向上的方差。
• 非对角线元素代表了不同坐标轴之间的协方差(数据分布的倾斜方向和程度)。

   这带来了一个核心难题：我们如何判断散度矩阵的“优劣”？我们无法直接比较 $S_w$ 和 $S_b$ 这两个矩阵本身的大小。一个矩阵可能在 X 方向方差大，另一个在 Y 方向方差大，无法简单地说哪个“更优”。所以 LDA 的目标不是在原始的多维空间里进行比较，而是要降维。
   简单来说，因为散度矩阵本身描述的是多维度空间中的“总体”混乱程度，而LDA的目标是找到一个“一维”的最佳观察视角（投影线）。因此，我们必须有一种方法来“测量”和“比较”在不同观察视角下，这种混乱程度变成了多少。向量投影 $w^T S w$ 正是完成这个测量的数学工具。
   来做一个简单的推导：假设我们只考虑一个类别，它的散度矩阵是 $S = \sum (x-\mu)(x-\mu)^T$ 。

1. 原始数据点：$x$ (一个向量)
2. 投影后的数据点：$z = w^T x$ (一个标量，也就是一维直线上的一个坐标点)
3. 原始均值：$\mu$ (一个向量)
4. 投影后的均值： $\bar{z} = w^T \mu$ (一个标量)

现在，我们来计算投影后这些点 z 的总方差(也就是总散度)：

• 总方差的定义： $$ \sum (z_i - \bar{z})^2 $$
• 代入上面的定义： $$ \sum (w^T x_i - w^T \mu)^2 $$
• 提取公共项 $w^T$： $$ \sum (w^T (x_i - \mu))^2 $$

这里的 $w^T (x_i - \mu)$ 是一个标量。对于任何标量 a，我们都有 $a^2 = a \cdot a^T$。所以：

• 展开平方项： $$ \sum \left[ w^T (x_i - \mu) \right] \left[ w^T (x_i - \mu) \right]^T $$
• 根据矩阵转置法则 $(AB)^T = B^T A^T$，我们对第二部分进行转置：$\left[ (x_i - \mu)^T w \right]$
• 重新组合： $$ \sum w^T (x_i - \mu) (x_i - \mu)^T w $$
• 提出 $w$： $$ w^T \left( \sum (x_i - \mu) (x_i - \mu)^T \right) w =w^TSw $$

这样，我们就把多维的散度矩阵“压缩”成了一个能够代表投影线上散度大小的标量。

   LDA 的目标就是找到一个投影方向 $w$ ，使得投影后的类间散度尽可能大，同时类内散度尽可能小。这自然地导出了一个目标函数，即两者的比值，我们称之为 费雪判别准则 (Fisher’s Criterion)：

$J(w)$ 也被称为 广义瑞利商 (Generalized Rayleigh Quotient) 。这时的任务是一个最优化问题，即找到一个 $w$ ，使 $J(w)$ 最大化。

求解最佳投影

   由瑞利商的性质，我们实际上可直接得到最佳投影的结果，在这里对其做一定的推导。
   注意到，对于一个解 $w$ ，任意缩放 $k \cdot w$ (其中 $k$ 是常数)并不会改变 $J(w)$ 的值，因为分子分母中的 $k^2$ 会被约掉，说明我们只关心 $w$ 的方向，不关心其大小。
   因此，我们可以为求解过程增加一个约束条件来固定分母，例如令 $w^TS_w w=1$ ，这样，问题转化为：

这是一个典型的 拉格朗日乘数法 (Lagrange Multiplier) 可以解决的约束优化问题，构造拉格朗日函数 $L(w, \lambda)$ ：

对 $w$ 求导并令其为 0：

整理后得到：

通常 $S_w$ 是可逆的，我们可以把它移到左边：

这正是矩阵的广义特征值问题。

• $\lambda$ 是矩阵 $S_w^{-1}S_b$ 的特征值。
• $w$ 是对应的特征向量。

这个方程的解，就是我们所有局部最优解的集合。

特征值求解与投影

  上一节的推导告诉我们，LDA 的优化目标最终归结为一个特征值问题。

 * 特征值 $\lambda$ 的意义: 根据瑞利商的性质，每一个特征值 $\lambda$ 都直接对应了其特征向量 $w$ 作为投影方向时的输出 $J(w)$。

• 全局最优解: 因此，我们不需要担心陷入局部最优。我们只需要遍历所有的特征值，然后找到最大的那一个，其对应的特征向量就是全局最优的投影方向。

求解步骤如下：

1. 根据数据计算类内散度矩阵 $S_w$ 和类间散度矩阵 $S_b$。
2. 求解矩阵 $S_w^{-1}S_b$ 的特征值和特征向量。
3. 将所有特征值从大到小排序：$\lambda_1 \ge \lambda_2 \ge ... \ge \lambda_d$。
4. 根据我们希望降到的维度 $k$，选取前 $k$ 个最大的特征值对应的特征向量，组成一个投影矩阵 $W = [w_1, w_2, ..., w_k]$。

这个矩阵 $W$ 就是我们将数据从高维空间投影到低维空间的“桥梁”。

如何用LDA进行分类

   找到了最佳投影矩阵 $W$ 之后，我们不仅完成了降维，还可以用它来进行分类。对于一个未知的新数据点 $x_{new}$：

1. 投影: 将新数据点投影到我们找到的低维空间中： $$ z_{new} = W^T x_{new} $$
2. 计算距离: 分别计算这个新的投影点 $z_{new}$ 到每一个类别中心点的投影 $\mu_{i\_proj} = W^T \mu_i$ 的距离。
3. 判定类别: $z_{new}$ 离哪个类别的中心投影最近，就将其判定为哪个类别。通常使用欧氏距离进行度量。

一个经典对比：LDA 与 PCA

   很多人会将 LDA 与主成分分析 (PCA) 混淆，因为它们都能用来降维。但它们的目标和原理完全不同。

简单说，如果降维的目的是为了后续更好地分类，LDA 通常是更好的选择。如果只是想压缩数据，同时尽量不丢失信息，那就用 PCA。

LDA的假设与局限

   LDA 虽然强大，但不是万能的，它有一些基本的前提假设：

1. 高斯分布: LDA 假设每个类别的数据都大致呈正态分布（高斯分布）。
2. 同方差性: 经典 LDA 假设所有类别的协方差矩阵是相同且满秩的。如果这个假设不成立（比如一个类别分布是圆形，另一个是细长的椭圆形），LDA 的效果会打折扣。此时，二次判别分析(QDA)可能是更好的选择。
3. 线性可分: LDA 寻找的是线性的决策边界。如果类别间的边界是高度非线性的，LDA 就无能为力了。
4. 对离群点敏感: 由于 LDA 的计算涉及到样本均值和散度，因此离群点（Outliers）会对模型的性能产生较大影响。

📷封面源于网络，侵删

基本形式

   给定由 $d$ 个属性描述的示例 $\boldsymbol{x} = (x_1;x_2;\dots;x_d)$ ，其中 $x_i$ 是 $\boldsymbol{x}$ 在第 $i$ 个属性上的取值，线性模型(linear model)是指学得一个通过属性的线性组合来进行预测的函数：

即

线性回归

$\boldsymbol{w}$ 和 $b$ 就是要学得的参数。而确定$\boldsymbol{w}$ 和 $b$ 的关键是如何衡量 $f(x)$ 和 $y$ 之间的差别，最常见 的度量是均方误差：

求解 $w^*$ 和 $b^*$ 的过程，称为线性回归模型的最小二乘 “参数估计” ，令

由于该式是一个凸函数，其全局最优解在梯度为零处，因此我们可将其对 $w$ 和 $b$ 分别求导，得

分别令其为零，求解方程组可得到 $w$ 和 $b$ 的闭式解

其中 $\overline x = \frac{1}{m} \sum_{i=1}^m x_i$ 为 $x$ 的均值。

   对于更一般的问题，样本会有多个属性，此时可行域和参数集都变为高维，我们可将均方误差扩展为欧氏距离，要求得的 “直线” 就是所有样本到其的欧式距离之和最小的直线，称为 “多元线性回归” 。

   方便起见，我们令 $\hat {\boldsymbol w} = (\boldsymbol w; b) = (w_1;...;w_d;b) \in \mathbb R^{(d+1) \times 1}$ ，$\hat{\boldsymbol x} = (x_{i1}; ...; x_{id}; 1) \in \mathbb R^{(d+1) \times 1}$ ，则有

利用向量内积的定义，有

其中

所以

同理，可以用梯度为零的方法得到闭式解：

此时要求 $\boldsymbol{X}^T\boldsymbol{X}$ 为满秩矩阵或正定矩阵。

前言

   本文的问题背景是设计一个信号分离装置，可以分离由两个正弦波信号合成的混合信号，也就是说要测量两个原始信号的频率、幅度和相位，并尽可能提高精度。原始信号的频率范围为 $100Hz \sim 10kHz$ ，且信号的频率差最小为 $100Hz$ 。
   设计的难点在于测量精度，对于分析混合信号，我们会首先想到快速傅里叶变换，即 FFT ，但是 FFT 要做到 5% 甚至 1% 的精度，必须将采样点数取得足够大，根据奈奎斯特采样定律，本设计中采样率最低应为 $20kHz$ ，为了留有一些容差，实际采样率应大于 $25kHz$ ，此时要做到 $1Hz$ 的测量精度，采样点数就应取 $25kHz / 1Hz = 25000$ ，而 FFT 一般要求采样点数为 $2$ 的幂次方，所以必须取到 $32768$ ，显然对于单片机来说这是一个超大的数组，一般 STM32 又以 uint16_t 类型存储 ADC 采样值，这时采样数组所需要的内存就有 $2 \times 32768Bytes = 64KB$ ，而进行 FFT 时又需要将数据进行零填充或转化为复数存储，所需要的空间又会成倍数增长，对于单片机来说这样的大小是无法做到的，所以我们需要采取其他方法来提高测量精度。
   如标题所言，本文将介绍一种所谓跨帧相位差法的算法，理论上能够使测量频率无限逼近于真实频率，当频率测量足够准确时，幅度和相位就可以使用很简单的算法得到足够高的精度。在使用该算法之前，首先要得到频谱图中与信号真实频率最接近的频率 bin 索引。

在 FFT 之前

   由傅里叶变换衍生而来的 快速傅里叶变换(Fast Fourier Transform, FFT) 能够将时域信息转化为频域信息，从而提供了分析信号的工具。理想的傅里叶变换需要求和整个时域的数据，即从0到无穷，而我们采样的点数是有限的，因此直接用采样得到的数据做 FFT 时，就会出现第一个问题：频谱泄露。

频谱泄露

   专业地来说，当我们对一个时域信号进行离散傅里叶变换 (Discrete Fourier Transform, DFT) 以分析其频率成分时，如果这个信号不是周期性的，或者它的周期与我们进行DFT的窗口长度不完全匹配，那么信号的能量就会“泄露”到相邻的频率 bin (频率分辨率的最小单位) 中，原本应该集中在某个频率上的能量会扩散开来，形成一些不属于信号真实频率成分的“旁瓣”。

   想象一下，你用一个固定长度的“窗户”去观察一段无限长的波浪。如果这个波浪的完整周期正好能被这个窗户的长度完美包含，那么你看到的频率成分就会很干净。但是，如果波浪的周期和窗户的长度不匹配，那么在窗户的边缘就会出现“截断”效应，这个截断就相当于给原始信号乘以了一个非理想的窗函数。

   这个非理想的窗函数在频域上也有其对应的形状，它不是一个完美的冲击函数，而是具有一定的宽度和旁瓣。原始信号的真实频谱会和这个窗函数的频谱进行卷积，导致原始频谱的能量扩散到周围的频率上，形成了我们所说的频谱泄露。

   从数学角度来讲，给定一个原始连续信号 $y(t)$ ，采样的时间为 $[0, T]$ ，那么采样得到的离散时间信号 $x[n]$ 就可以看做是 $y(t)$ 乘以一个矩形窗函数 $w(t)$ ：

然后对 $y(t) w(t)$ 采样得到 $x[n]$ 。不妨先令 $x[n] = y[n]w[n]$ ，根据傅里叶变换相关定理，时域的乘积的傅里叶变换就是频域的卷积，即 $X(e^{jw}) = Y(e^{jw}) * W(e^{jw})$ ，显然这不是我们想要的结果，事实上，矩形窗函数的频域函数为 $sinc$ 函数，使用 Matlab 等工具可以看到频谱的形状：

N = 64;

rectangular_window = ones(1, N);
rectangular_window(1, 1:16) = 0;
rectangular_window(1, 49:64) = 0;

fft_rectangular_window = fft(rectangular_window);

frequency_axis = linspace(-pi, pi - 2*pi/N, N);

figure;
subplot(2, 1, 1);
stem(0:N-1, rectangular_window);
title('矩形窗时域波形');
xlabel('采样点 (n)');
ylabel('幅度');
grid on;

subplot(2, 1, 2);
plot(frequency_axis, abs(fftshift(fft_rectangular_window))/N);
title('矩形窗频域幅度谱 (线性尺度)');
xlabel('归一化角频率 (弧度/采样)');
ylabel('幅度');
grid on;
xlim([-pi, pi]);

   频谱泄露会带来一些问题：

• 频率分辨率降低： 本来很接近的两个频率成分可能会因为能量泄露而模糊在一起，难以区分。
• 幅度估计不准确： 泄露的能量会影响到真实频率成分的幅度估计。
• 产生虚假的频率成分： 一些本来不存在的频率成分（旁瓣）可能会被误认为是信号的一部分。

处理采样数据

   要减轻频谱泄露，常用的有以下几种方法：

1. 加窗(Windowing)

   对时域信号乘以窗函数以减小截断效应：

   • 常用窗函数：汉宁窗（Hanning）、汉明窗（Hamming）、布莱克曼窗（Blackman）、凯泽窗（Kaiser）、布莱克曼-哈里斯窗(Blackman-Harris)
   • 窗函数可以减少主瓣宽度或降低旁瓣能量，从而减小频谱泄露。

2. 增加采样点数(Zero Padding)

   在原始信号后添加零点(Zero Padding)，提高频率分辨率，使频谱更平滑，便于观察泄露现象。

3. 选择整数周期采样

   在截取信号时，尽可能让信号包含整数个周期，可显著减少频谱泄露。

   其中加窗和增加采样点数是最常用的方法，但是如果要使用针对 arm 优化后的 CMSIS-DPS 库进行 FFT ，其中的 FFT 函数有点数上的限制，无法随意地进行零填充，因此加窗其实是更普适的方法，在这里给出一些常用的窗函数生成代码，为提高运行速度使用 arm_math 中的函数

// FFT_SIZE 是要进行 FFT 的点数
// 汉宁窗
for(i = 0; i < FFT_SIZE; ++i)
    window[i] = 0.5f * (1.0f - arm_cos_f32(2.0f * M_PI * i / (FFT_SIZE - 1)));
	
// 汉明窗
for(i = 0; i < FFT_SIZE; ++i)
    window[i] = 0.54f - 0.46f * arm_cos_f32(2.0f * M_PI * i / (FFT_SIZE - 1));

// 布莱克曼窗
for(i = 0; i < FFT_SIZE; ++i)
    window[i] = 0.42323f - 0.49755f * arm_cos_f32(2.0f * M_PI * i / (FFT_SIZE - 1)) + 0.07922f * arm_cos_f32(4.0f * M_PI * i / (FFT_SIZE - 1));
		
// 布莱克曼-哈里斯窗
for(i = 0; i < FFT_SIZE; ++i)	
    window[i] = 0.35875f - 0.48829f * arm_cos_f32(2.0f * M_PI * i / (FFT_SIZE - 1)) + 0.14128f * arm_cos_f32(4.0f * M_PI * i / (FFT_SIZE - 1)) - 0.01168f * arm_cos_f32(6.0f * M_PI * i / (FFT_SIZE - 1));

得到频率 bin 索引

   DFT将时域信号转换到频域，频域上的输出也是离散的，分布在所谓的频率“桶”(frequency bins) 里。每个频率桶代表一个特定的频率。频率分辨率就是这些相邻频率桶之间的间隔。

   想象一下，在一个固定的时间窗口 $T$ 内观察一个信号。在这个时间窗口内，能够被完整观察到的最低频率（除了直流分量 $0Hz$ 之外）就是其周期恰好等于 $T$ 的频率。这个频率就是 $f_{min} = 1/T$。

   这个 $1/T$ 就是我们能分辨出来的最小频率变化量。任何频率变化如果小于这个值，在长度为 T 的观测窗口内就无法完整地展现出一个周期的差异，从而难以区分。

   显然，这个时间窗口就是采样的总时长，即 $T = NT_S = N/f_s$ ，将其代入最小频率表达式，有

跨帧相位差法测频

   加窗并进行 FFT 之后，计算频域幅值得到频谱图，就可以得到每个信号的频率 bin 索引，至此完成了算法的前期准备工作，那么，接下来该怎么做呢？

   首先，设信号为正弦波，那么时域中采样得到的数据可表示为

 其中 $T_s = \frac{1}{f_s}$ 为采样周期，$f_s$ 为采样频率，我们知道频谱图中的频率分辨率为 $\Delta f = f_s/N$ ，那么对于真实频率 $f$ ，我们假定一个理想索引

此处 $m$ 不一定为整数，因为无法保证所测频率一定卡在频谱图的栅格上。此时真实频率 $f$ 可以表示为

因此我们只要找到这个 $m$ 的值，就可以精准得到真实频率。跨帧相位差法就是间接地计算 $m$ ，从而得到精度极高的测量频率。

   我们先将正弦转换到复数域中：

对一帧 $N$ 点实信号 $x[n]$ ，我们知道其第 $k$ 个 DFT 系数为

所以我们对正频率一侧做 DFT ，有

我们不需要关注求和部分，因此将求和无关项提出，这里需要注意如果加了窗函数，那么求和部分也会有窗函数的影响，

其中 $W(offset)$ 是由窗函数和偏移量共同决定的复因子。

   已知一帧长度为 $N$ ，采样周期为 $T_s$ ，可以得到一帧的时长

把同一信号往后拖一帧，即 $n' = n + N$ ，那么有

再次做 DFT ，容易得到

可以看出，同一点的 DFT 系数，在时域信号延后了一帧之后，相位仅多了转过的角度 $2\pi fT$ ，不妨设 $\Delta \varphi = 2\pi fT$ ，即两点绝对相位差，则

显然，如果我们能得到这个绝对相位差，就能完全复原出真实频率。但是我们计算相位差的过程实际上是两点测量的相位作差，得到的结果 $\Delta \varphi_{mea} \in [-\pi, \pi]$ ，这个结果实际上没有加上转过的整圈数，也就是说

注意到我们之前标定的理想索引 $m$ ，

设 $\Delta bi n = m-k$ ，则

所以真实频率为

   根据此算法，理论上可测得频率无限接近于真实频率，即使考虑到采样过程中存在的噪声以及计算的误差，也可以达到极高的精度，经笔者测试，平均误差仅有 $0.002\%$ 。

   在这里给出实现算法的主要程序，注意要连续采两帧数据运行两次：

// 开启FFT
FFT_start(BLACKMAN_HARRIS);
	
// 找到两信号粗估计bin下标
uint32_t k1 = 0, k2 = 0;
find_peaks(&k1, &k2);

float32_t f1 = (float32_t)k1 * (float32_t)SAMPLE_RATE / (float32_t)FFT_SIZE;
float32_t f2 = (float32_t)k2 * (float32_t)SAMPLE_RATE / (float32_t)FFT_SIZE;

// 相位差法进一步精确
float32_t *c1 = &fft_outputbuf[k1 * 2U];	// 得到复数频率点
float32_t *c2 = &fft_outputbuf[k2 * 2U];
float32_t phi1_now, phi2_now;				// 计算当前相位
arm_atan2_f32(c1[1], c1[0], &phi1_now);
arm_atan2_f32(c2[1], c2[0], &phi2_now);

float32_t frameT = (float32_t)FFT_SIZE / (float32_t)SAMPLE_RATE;	// 频移周期，即每帧间隔 4096 / 40k = 0.1024 s
if (prev[0].k == k1) 
{
    float32_t phi_prev;
	arm_atan2_f32(prev[0].im, prev[0].re, &phi_prev);
    float32_t delta_phi = phi1_now - phi_prev;
    if (delta_phi >  M_PI) 
		delta_phi -= 2.0f * M_PI;
    if (delta_phi < -M_PI) 
		delta_phi += 2.0f * M_PI;

    f1 += delta_phi / (2.0f * M_PI * frameT);
}
if (prev[1].k == k2) 
{
    float32_t phi_prev;
	arm_atan2_f32(prev[1].im, prev[1].re, &phi_prev);
    float32_t delta_phi = phi2_now - phi_prev;
    if (delta_phi >  M_PI) 
		delta_phi -= 2.0f * M_PI;
    if (delta_phi < -M_PI) 
		delta_phi += 2.0f * M_PI;

    f2 += delta_phi / (2.0f * M_PI * frameT);
}

// 更新前帧结构体
prev[0] = (bin_prev_t){c1[0], c1[1], k1};
prev[1] = (bin_prev_t){c2[0], c2[1], k2};
		
tones[0].f = f1;  tones[1].f = f2;

最小二乘法测幅测相

   在测频算法中已经得到了精度较高的频率，因此使用最小二乘法测量幅度与相位能达到很好的效果。下面介绍一下最小二乘法：

   对于

其中 $w_1$ ，$w_2$ 已通过 FFT 和相位差法标定，$\varepsilon[n]$ 为残差，有

其中 $I_k = A_kcos(\varphi_k)$ ，$Q_k = A_ksin(\varphi_k)$ ，于是有

其中

将其写成矩阵形式，

其中，$N$ 为采样点数，

   最小二乘估计定义为：

令

得到

使用高斯消元法求解该线性方程组，即可得到

此时即可计算出幅度与相位

   最小二乘代码实现如下：

/**
 * @brief       最小二乘法计算幅度与相位
 * @note        无
 * @param       f1, f2:            已确定频率
 * @param       x:                 采样序列
 * @param       I1, Q1, I2, Q2:    求解参数组
 * @retval      无
 */
void least_square(float32_t f1, float32_t f2, const float32_t *x, float32_t *I1, float32_t *Q1, float32_t *I2, float32_t *Q2)
{
    // 计算一次角增量
    float32_t w1 = 2.0f * M_PI * f1 / SAMPLE_RATE;
    float32_t w2 = 2.0f * M_PI * f2 / SAMPLE_RATE;
	
    // 迭代生成sin, cos序列
    float32_t c1 = arm_cos_f32(w1), s1 = arm_sin_f32(w1);
    float32_t c2 = arm_cos_f32(w2), s2 = arm_sin_f32(w2);
    float32_t cn1 = 1, sn1 = 0, cn2 = 1, sn2 = 0;
	
    float32_t Scc1 = 0,Sss1 = 0,Scc2 = 0,Sss2 = 0;
    float32_t Scc12 = 0,Scs12 = 0,Ssc12 = 0,Sss12 = 0;
    float32_t SxC1 = 0,SxS1 = 0,SxC2 = 0,SxS2 = 0;
    for (uint32_t n = 0; n < FFT_SIZE; ++n) 
    {
        float32_t xn = x[n];
        // 同频能量
        Scc1 += cn1 * cn1;
        Sss1 += sn1 * sn1;
        Scc2 += cn2 * cn2;
        Sss2 += sn2 * sn2;
        // 跨频交叉项
        Scc12 += cn1 * cn2;
        Scs12 += cn1 * sn2;
        Ssc12 += sn1 * cn2;
        Sss12 += sn1 * sn2;
        // 数据投影
        SxC1 += xn * cn1;
        SxS1 += xn * sn1;
        SxC2 += xn * cn2;
        SxS2 += xn * sn2;
        // 迭代sin/cos
        float ncn1 = cn1 * c1 - sn1 * s1;
        float nsn1 = sn1 * c1 + cn1 * s1;
        float ncn2 = cn2 * c2 - sn2 * s2;
        float nsn2 = sn2 * c2 + cn2 * s2;
        cn1 = ncn1; 
        sn1 = nsn1; 
        cn2 = ncn2; 
        sn2 = nsn2;
    }
	
    // 构建正交矩阵和投影向量，部分交叉项可近似为0
    float32_t H[4][4] = {
        {Scc1,    0,      Scc12,  Scs12},
        {0,       Sss1,   Ssc12,  Sss12},
        {Scc12,   Ssc12,  Scc2,   0    },
        {Scs12,   Sss12,  0,      Sss2 }
    };	
    float32_t b[4] = {SxC1, SxS1, SxC2, SxS2};
	
    // 高斯消元
    for (int k = 0; k < 4; k++) 
    {
        // 主元选择
        int m = k;
        float_t maxv = fabsf(H[k][k]);
        for (int i = k + 1; i < 4; ++i) 
        {
            if(fabsf(H[i][k]) > maxv)
            {
                m = i;
                maxv = fabsf(H[i][k]);
            }
        }
        // 交换行		
        for(int j = k; j < 4; ++j) 
        {
            float32_t t = H[k][j]; 
            H[k][j] = H[m][j]; 
            H[m][j] = t;
        } 
        float32_t tb = b[k]; 
        b[k] = b[m]; 
        b[m] = tb;
        
        // 标准化主行
        float32_t diag = H[k][k];
        for (int j = k; j < 4; ++j) 
            H[k][j] /= diag; 
		
        int test = 0;
        if(k == 3)
            test = 1;
		
        b[k] /= diag;
		
        // 消去下方得到上三角式
        for (int i = k + 1; i < 4; ++i) 
        {
            float_t factor = H[i][k];
            for(int j = k; j < 4; ++j) 
                H[i][j] -= factor * H[k][j];
			
            b[i] -= factor * b[k];
        }
    }
	
    // 回代求解
    float32_t theta[4];
    for(int i = 3; i >= 0; --i)
    {
        float32_t sum = b[i];
        for(int j = i + 1; j < 4; ++j) 
            sum -= H[i][j] * theta[j];
		
        theta[i] = sum;
    }
    
    *I1 = theta[0];
    *Q1 = theta[1];
    *I2 = theta[2];
    *Q2 = theta[3];
}

   虽然使用跨帧相位差法可以得到精度极高的频率，但是最小二乘法仍有一定的误差，经笔者测试平均误差约为 $1.7\%$ 。其原因可能是单片机 ADC 采样存在一定的误差，且信号本身存在噪声，导致采得的电压值存在误差，这种误差对于测频算法影响较小，但最小二乘法直接用到了每个采样点的信息，因此容易受采样误差的影响。

结语

   以上算法仅测量分离了两个信号的频率、幅度和相位，而要实现“数字滤波”的效果，还需要将其中一个信号输出，这里涉及到与原信号同步稳定显示的问题。

   不论使用单片机的 DAC 模块还是外部 DDS 模块，由于内部模块与外部信号源采用了各自独立的时钟基准，这两个时钟源之间不可避免地存在频率偏差和相位漂移。这种时钟异步性会导致在长时间观测下，单片机采样时刻与信号源实际相位之间的相对关系发生持续变化，即产生相位差的累积效应。累积效应作用的结果是，当通过滤波器对处理后的信号进行观测时（例如在示波器上显示），会发现滤波输出信号与原始输入信号之间存在一个逐渐增大的相位差，表现为两个波形在时间轴上相对滑动或漂移。

   要解决该问题，最粗暴的方法其实是统一信号源与信号发生模块的时钟源，但大多数情况无法实现；其次可以通过引入闭环控制，实时追踪信号源的相位并跟随，做到相对静止。笔者尝试使用了 DAC 模拟 DDS 输出信号，由于硬件和性能原因，引入闭环控制后未能达到理想的效果，可能需要使用专门的 DDS模块来实现。

🍃本文中所涉及的算法已经使用STM32F407VET6单片机实现，工程文件已上传至GitHub，欢迎访问。