Github链接 教程英文版链接 manim文档

1 安装 manim

首先参考Github链接

2 做一个简单的视频

2.1 场景和动画

Scenes ＆ Animation

3 更多可以使用的形状

3.1 方向矢量

Direction Vectors

3.2 制作一个简单的动画

4 添加文字

Text

4.1 文字变形

4.2 文字的旋转和高亮

5 数学公式

5.1 给对象上色

6 对齐文本并使用大括号

7 坐标轴和绘图

7.1 配置文件

8 更高级的绘图

9 向量场

9.1 简单向量场

9.2 带有变量的向量场

10 运动电荷场例子

10.1 更进一步的优化

11 3D场景

12 SVG格式支持

是什么

二叉搜索树（Binary Search Tree）BST是大名鼎鼎的搜索算法。在算法界，$O(n)$ 到 $O(\log_2 n)$ 的效率优化大多和BST有关

用白话文来说，二叉搜索树是一颗对于所有节点左孩子 ＜ 根，右子树 ＞ 根的二叉树

基本操作

构建

相关例题：108. Convert Sorted Array to Binary Search Tree

已经给出了定义，Leetcode中有一道将升序数组转换成平衡二叉搜索树的题目。根据二叉树遍历一节的内容，中序遍历的顺序是左 ➜ 根 ➜ 右，再结合二叉搜索树的定义。观察知，二叉搜索树的中序遍历就是一个升序数组。那么问题就转换成了，哪颗平衡二叉树的中序遍历是这个升序数组

因为题目要求平衡二叉树，保证所有子树的高度一样，必须二分输入序列

假设输入序列为[-10,-3,0,5,9]，根节点一定在mid = (start + end) // 2 位置，由递归思维：假设再次调用的函数的返回值是已经完成的子树，也就是说只需把[0, mid-1]代表的树作为左子树，和[mid+1, end]代表的树作为右子树即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class Solution:
    def sortedArrayToBST(self, nums):
        """
        :type nums: List[int]
        :rtype: TreeNode
        """
        if not nums: return None
        
        mid = len(nums) // 2
        root = TreeNode(nums[mid])
        root.left = self.sortedArrayToBST(nums[ : mid])
        root.right = self.sortedArrayToBST(nums[mid+1 : ])

        return root

查找

相关例题：700. Search in a Binary Search Tree

最常见的二叉树操作，查找一个对应节点，平均查找长度为 $\log_2(n)$ 。二叉搜索树性质，左孩子＜根＜右孩子，按照规律进行递归即可。省略迭代写法，只需要按照顺序进行一个节点一个节点顺下即可，非常简单

1
2
3
4
5
6
7
8
9
10

class Solution:
    def searchBST(self, root, val):
        """
        :type root: TreeNode
        :type val: int
        :rtype: TreeNode
        """
        if not root or root.val == val:
            return root
        return self.searchBST(root.left, val) if val < root.val else self.searchBST(root.right, val)

判断

相关例题：98. Validate Binary Search Tree

【输入】给定一个树的结构【操作】判断这颗树是不是二叉搜索树【输出】True or False

① 使用中序遍历，结果是升序序列则为二叉搜索树（前面讲定义的时候已经讲解的原因）

② 去重复操作。①中在遍历过程就可做判断，不需要重新再做一次升序判断

这里实现使用迭代写法，递归写法比较简单

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class Solution(object):
    def isValidBST(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        
        if root is None: return True
        stack, inorder = [], []   
        p_node = root
        pre_node_val = float("-inf")
        while stack or p_node:  
            while p_node:
                stack.append(p_node)
                p_node = p_node.left      
            cur_node = stack.pop()
            inorder.append(cur_node.val)
            if pre_node_val >= cur_node.val:
                return False
            pre_node_val = cur_node.val      
            if cur_node.right:
                p_node = cur_node.right     
        return True

删除

二叉查找树中的删除节点操作，详见链接

需要分为3种情况进行讨论

• 没有孩子的节点 ➜ 直接将它删除即可，它的父节点的孩子替换成空
• 只有一个孩子的节点 ➜ 直接上升孩子的位子替代被删除的即可
• 有两个孩子的节点 ➜ 此种情况比较麻烦，需要参看详细链接

相关题目

遍历算法总览

遍历的含义就是把树的所有节点（Node）按照某种顺序访问一遍。包括前序，中序，后续，广度优先（队列），深度优先（栈）5中遍历方法

遍历方法	顺序	示意图	应用
前序	根 ➜ 左 ➜ 右		想在节点上直接执行操作（或输出结果）使用先序
中序	左 ➜ 根 ➜ 右		在二分搜索树中，中序遍历的顺序符合从小到大（或从大到小）顺序的 要输出排序好的结果使用中序
后序	左 ➜ 右 ➜ 根		后续遍历的特点是在执行操作时，肯定已经遍历过该节点的左右子节点 适用于进行破坏性操作 比如删除所有节点，比如判断树中是否存在相同子树
广度优先	层序，横向访问		当树的高度非常高（非常瘦） 使用广度优先剑节省空间
深度优先	纵向，探底到叶子节点		当每个节点的子节点非常多（非常胖），使用深度优先遍历节省空间 （访问顺序和入栈顺序相关，想当于先序遍历）

关于应用部分，选择遍历方法的基本的原则：更快的访问到你想访问的节点。先序会先访问根节点，后序会先访问叶子节点

需要说明的是，递归是一种拆分思维的具体问题类别的思维方法，其核心的思维我觉得和动态规划非常类似，都是假设子节点搞定了我现在应该干什么这个问题

先确定Python语言下的TreeNode定义

1
2
3
4
5

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

需要输出遍历结果时直接输出保存val的数组即可

关于递归算法的解释，博主打算写一份【直观算法】汉诺塔问题最全解答，过后可能会更新，是一篇小品文，比较短，这篇文章只是希望让所有阅读的人能一次就直观的搞明白汉诺塔的算法是怎么做的，永远记住它，也搞懂递归算法

三种遍历方法，都有一个特点，无论是先序根 ➜ 左 ➜ 右，中序左 ➜ 根 ➜ 右，后序左 ➜ 右 ➜ 根，所谓的访问顺序，根是最重要，根才代表了访问这个动作（在我们的代码中，就是把节点中的值加入到输出数组中），⭐️而根在的位置决定了是否可以访问的条件

比如对于中序来说，根在左的后面，意味着，只要当前操作的节点有左节点，就不能输出根里面的值

对于后序来说，有了这个直观理解，对理解三者的迭代算法有帮助

先序遍历

在线刷题：Leetcode 44. Binary Tree Preorder Traversal

递归算法

所谓递归（Recursive），即把函数本身看成一个已经有解的子问题

定义函数preorderTraversal(self, node)返回以node为答案的先序遍历结果的数组，假设它的两个孩子node.left和node.right已经搞定了，即可以返回答案的输出数组。那么思考最终的输出数组是什么样的，很明显要满足根 ➜ 左 ➜ 右的规则，应该返回[node.val] + preorderTraversal(self, node.left) + preorderTraversal(self, node.right)（函数返回的就是一个数组，只需要把它们拼接起来即可）

之后再完善防御性编程的基本步骤（保证函数输入有效），按照这个思路就可以写出先序遍历的递归代码。Python代码的特点是可读性比较强，这样一行代码简洁明了，能简洁的表达上面的逻辑链推理过程

1
2
3
4
5
6
7
8

class Solution:
    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if root is None: return []
        return [] if root is None else [root.val] + self.preorderTraversal(root.left) + self.preorderTraversal(root.right)

当然，如果不使用Python，在语法上无法写的这么简短。常见的标准写法是使用helper()函数，具体实现见下

1
2
3
4
5
6
7
8
9
10

def preorderTraversal1(self, root):
    result = []
    self.helper(root, result)
    return result
    
def helper(self, root, result):
    if root:
        result.append(root.val)
        self.helper(root.left, result)
        self.helper(root.right, result)

迭代算法

同理，递归算法使用系统栈，不好控制，性能问题比较严重，需要进一步了解不用递归如何实现。为了维护固定的访问顺序，使用栈数据结构的先入后出特性

先处理根节点，根据访问顺序根 ➜ 左 ➜ 右，先入栈的后访问，为了保持访问顺序（先入后出），⭐️先把右孩子入栈，再入栈左孩子（此处需要注意，出栈才是访问顺序）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

class Solution:
    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root: return []
        
        result, stack = [], [root]
    
        while stack:
            cur_node = stack.pop() # 访问根节点，直接进行操作(输出到数组)
            result.append(cur_node.val)
            if cur_node.right: # 先入栈右节点
                stack.append(cur_node.right)
            if cur_node.left: # 后入栈左节点，这样下一轮循环先访问左节点，维护了访问顺序
                stack.append(cur_node.left)
                
        return result

中序遍历

在线刷题：94. Binary Tree Inorder Traversal

递归算法

同理于前序遍历，一模一样的处理方法，考虑访问顺序为左 ➜ 根 ➜ 右即可，快速模仿并写出代码

1
2
3
4
5
6
7
8

class Solution:
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if root is None: return []
        return [] if root is None else self.inorderTraversal(root.left) + [root.val] + self.inorderTraversal(root.right)

同理在这里也附上使用helper()函数的标准写法，代码上来说，只变了名称和访问顺序

1
2
3
4
5
6
7
8
9
10

def inorderTraversal1(self, root):
    result = []
    self.helper(root, result)
    return result
    
def helper(self, root, result):
    if root:
        self.helper(root.left, result)
        result.append(root.val)
        self.helper(root.right, result)

迭代算法

核心思路依旧是利用栈维护节点的访问顺序：左 ➜ 根 ➜ 右。使用一个p_node来指向当前访问节点，p是代表指针point，另外有一个变量cur_node表示当前正在操作节点（把出栈节点值加入输出数组中），算法步骤如下（可以对照代码注释）

① 访问当前节点，如果当前节点有左孩子，则把它的左孩子都入栈，移动当前节点到左孩子，重复第一步直到当前节点没有左孩子

② 当当前节点没有左孩子时，栈顶节点出栈，加入结果数组

③ 当前节点指向栈顶节点的右节点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

class Solution:
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if root is None: return []
        result, stack = [], []
        
        p_node = root # 当前访问节点指针
        while p_node or stack:
            
            while p_node: # 把所有当前访问节点的左孩子都入栈
                stack.append(p_node)
                p_node = p_node.left
            
            cur_node = stack.pop() # 操作栈顶节点，如果是第一次运行到这步，那么这是整棵树的最左节点
            result.append(cur_node.val) # 因为已经保证没有左节点，可以访问根节点
            if cur_node.right:
            p_node = cur_node.right # 将指针指向当前节点的右节点
        
        return result

如果想要精简代码，从逻辑上来看，p_node可以使用root代替，这样写只是为了让代码更可读，和逻辑链相切合，方便理解

后续遍历

在线刷题：145. Binary Tree Postorder Traversal

递归算法

同理先序遍历，代码如下

1
2
3
4
5
6
7
8

class Solution:
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if root is None: return []
        return [] if root is None else self.postorderTraversal(root.left) + self.postorderTraversal(root.right) + [root.val]

节省版面，使用helper()函数的写法只需要改变函数名和访问顺序

迭代算法 1

后序遍历访问顺序要求为左 ➜ 右 ➜ 根，在对访问节点进行操作的条件是，它的左子树和右子树都已经被访问。这样算法的框架就出来了：只需要对每个节点进行标记，表示这个节点有没有被访问，一个节点能否进行操作的条件就是这个节点的左右节点都被访问过了。

因为栈先入后出，为了维护访问顺序满足条件，入栈顺序应该是根 ➜ 右 ➜ 左（和要求访问顺序相反）。代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

class Solution:
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if root is None: return []
        
        result, stack = [], [(root, False)]
        
        while stack:
            cur_node, visited = stack.pop()
            if visited: # 只有访问状态为True的节点才能被操作
                result.append(cur_node.val)
            else:
                stack.append((cur_node, True))
                if cur_node.right:
                    stack.append((cur_node.right, False))
                if cur_node.left:
                    stack.append((cur_node.left, False))
                    
        return result

迭代算法 2

还有一种迭代算法利用后序遍历的本身属性，注意到后序遍历的顺序是左 ➜ 右 ➜ 根，那么反序的话，就直接倒序的输出结果，即反后序：根 ➜ 右 ➜ 左，和先序遍历的根 ➜ 左 ➜ 右对比，发现只需要稍微改一下代码就可以得到反后序的结果，参考先序遍历，代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

class Solution:
    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if root is None: return []
        
        result, stack = [], [root]
    
        while stack:
            cur_node = stack.pop()
            result.append(cur_node.val)
            if cur_node.left: # 修改顺序
                stack.append(cur_node.left)
            if cur_node.right: # 修改顺序
                stack.append(cur_node.right)
                
        return result[::-1] # 反序操作

广度遍历

从上到下的层序102. Binary Tree Level Order Traversal

从下到上的层序（Bottom-up） 107. Binary Tree Level Order Traversal 2

按照层序进行遍历的的过程，有两种说法，一种是按照层序的从顶到底的（level order），另一种是从底到顶的（bottom up），具体实现上来说，就是输出反序即可。在具体问题设计上可能有区别，但是基本思路不变

广度遍历的核心思路就是使用队列，即先进先出 First-in First-out，这里很关键的一点就是以层来作为入队和出队的判断条件。并且因为按照层的顺序，是从左到右，所以遍历顺序（入队顺序）为左 ➜ 右

基本思路参看代码注释，逻辑比较简单。实现上，使用Python中的自带类deque来实现，新建为queue = deque([])，入队为queue.append()，出队为queue.popleft()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

from collections import deque

class Solution:
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if root is None: return []
        result, queue = [], deque([root])
        
        while queue:
            level_len = len(queue) # 记录现在队列中的节点数量
            level_nodes = [] # 每层输出
            while level_len > 0: # 具体出队入队操作，保证本层所有节点的子节点都入队
                cur_node = queue.popleft()
                level_nodes.append(cur_node.val)
                if cur_node.left:
                    queue.append(cur_node.left)
                if cur_node.right:
                    queue.append(cur_node.right)
                level_len -= 1
            result.append(level_nodes)
        
        return result

Brew作者被拒的题

226. Invert Binary Tree，就是一道基本的树的遍历题。有故事说Mac包管理工具Brew的作者Max在Google被面试这道题，没写出来，被拒了。之后Max去了Apple。个人感觉，对于遍历的理解，如果是真的根据逻辑链理解，且对递归有着深刻的理解，那实在不应该写不出这道题，因为真的很简单

题目是这样说的，要求把一颗二叉树的所有左右子树互换位置

递归算法

假设左右子树都搞定了，那么当前节点需要的操作为：把当前节点的左右孩子互换即可，写成递归非常简洁

1
2
3
4
5
6
7
8
9
10
11
12
13

class Solution:
    def invertTree(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        if root is None: return []
        # 在本节点的操作，左右孩子互换
        root.left, root.right = root.right, root.left
        # 已经搞定的左右孩子，使用递归的思路写出函数表达式  
        self.invertTree(root.right) # 下面两句的顺序并不重要
        self.invertTree(root.left)
        return root

迭代算法

因为对于每一个节点，只需要把它的左右孩子互换位置，并且依次遍历即可，使用DFS或BFS都是一样的，这里用使用栈的深度优先搜索举例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class Solution:
    def invertTree(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """   
        if root is None: return []
        stack = [root]
        
        while stack:
            cur_node = stack.pop()
            # 对当前节点进行操作
            cur_node.left, cur_node.right = cur_node.right, cur_node.left
            # 进行入栈操作，保证访问到每一个节点
            if cur_node.left: stack.append(cur_node.left)
            if cur_node.right: stack.append(cur_node.right)
            
        return root

总结

二叉树遍历问题最关键的逻辑链记忆点如下

1. 遍历顺序

   ⭐️遍历顺序非常重要，即某 ➜ 某 ➜ 某。如果这一点你不太记得，我认为在考试的过程中可以尝试向面试官确认，某的带选项只有三个，就是根，左，右，全排列也只有6种，长时间不用不记得也是情有可原的。所以在这里非常优秀

2. 递归 ➜ 假设搞定了

确认遍历顺序后，写出递归方法的核心思维是：⭐️假设左右孩子搞定了（搞定的方式就是调用函数本身，替换自变量即可），现在怎么做才能得到最终答案

3. 迭代 ➜ 根的位置

一般面试官会继续询问迭代方法如何写，这里的核心思维是：⭐️关注根的位置，根对应的就是出栈输出的操作（在例题中就是添加到输出数组）

那么根据遍历顺序，⭐️只要根之前的左或右孩子不为空就不能出栈输出，要继续入栈（办法自己想即可，每次可能写出来的代码都不同，但是思路相同。需要例子，可以参考中序和后序里的迭代算法部分）

分享者是最大的受益者，感谢您的阅读！知乎文章链接，走过路过求个赞，相关问题答案

1. 题目描述

有栋楼高100层，一个鸡蛋从第x层以上($>$)的楼层落下来会摔碎， 在第x层和以下($\leqslant$)的楼层落下不会摔碎。给你2个鸡蛋，设计方案找出x，保证在最坏情况下， 最小扔鸡蛋尝试的次数

有时候仍的东西会变，比如瓶子

这道题目的整个解答过程涉及给类逻辑思维，工程思维，当真是一道海纳百川的面试题，也难怪Goolge会以这道题做了多年的试金石

1.1 求什么？

利用抽象思维，符号化题目描述

⭐️〔题目要求〕找到 $x$ 层落下不会碎，$x+1$ 层落下会碎的临界层所需要的最少尝试次数 $r$ (r for result)

2. 解题思路

使用等价思维，如何计算出最小的尝试次数？使用函数方法表示为：如何计算出这个结果，找出公式 $r = f()$

2.1 一个鸡蛋

假设最后结果设为 $r$ 次（r for result）。使用归纳思维，先看只拥有1个鸡蛋的情况，思考什么是最坏情况。你可能说可以直接使用二分法，请注意，只有1个鸡蛋，必须保证找到临界层。所以，1个鸡蛋的情况下，最坏情况为 $r = 100$ （楼高）

大多数情况下，我们都低估了理解题意的重要性

这么思考还不够究竟，缺乏抽象思维

通过逻辑思考，可得 $r =100$ ，但有没有一个抽象的公式化结论？或者说，如何通过一个公式算出 $r$ ？接下来就来解决这个问题

假设临界层分别为 $x = 1,2,3 \dots 100$ ，因为你只有1个鸡蛋，不知道会在哪层碎，所以唯一策略是从1层开始一层一层试，对应的每个策略都有一个尝试步数（比如 $x = 95$ ，从1层开始尝试为95次），可得到临界层 $x$ 在所有可能取值下对应的 $r = 1,2,3 \dots 99,100$，最终选择最坏情况，即 $r = 100$

可抽象化得到待求的符号表达式
$$
r = \max_{1 \leqslant x \leqslant N}(\forall S_i(x)) \tag{1}
$$
公式的语言型描述是：对于每一个可能的临界层 $x$，得到使用可选择策略 $S_i()$ 需要的尝试步数。在每一轮 $x$ 的遍历中，取最大值（即最坏情况），为 $r$。无论临界层 $x$ 在哪一层，只有一个鸡蛋的情况下，总需考虑最坏情况

这道题，对1个鸡蛋问题的深刻理解异常重要。只有深刻理解基石逻辑才能更好的解决问题

2.2 两个鸡蛋

2.2.1 粗调和细调

依据粗条细调思维，我们有一次试错的机会。可以思考，假设第一个鸡蛋在 $k$ 层碎了，意味着什么？意味着，待求的临界层 $x$ 一定满足 $1 \leqslant x \lt k$ ，记为 $[1,k)$ ，就把待求量限制到了一个更小的范围内，可以提高找到目标值的效率

也就是说，使用第一个鸡蛋做粗调，碎了后，用第二个鸡蛋，参照1个鸡蛋的尝试策略细调。下一步，问题就变成了一个策略问题，即❓第一个鸡蛋应该在哪些层仍

在某层楼，丢一个鸡蛋，有两种结果：碎了和没碎。这句话是一个极为关键的信号，背后告诉我们这是一个树形结构问题

把数据结构与问题描述的勾连能力是衡量算法能力的重要指标

• 没有分叉，一路推理 ➜ 〔线性结构〕
• 看到决策结果有分叉 ➜ 〔树形结构〕
• 若在推理过程中，产生交汇 ➜ 〔图结构〕

下一节主要分析这条树形结构链

2.2.2 树形结构

假设第一个鸡蛋的楼层策略是 $k_1, k_2,\cdots,k_p$ ，其中 $p$ 是仍的总次数，楼高记为 $N$ 。比如如果你选择在 $20,40,60,80$ 层仍，那么 $p=4$ ，根据题意，有 $1 \lt k_1 \lt k_2 \lt \cdots \lt k_{p-1} \lt k_p \lt N$ 。画出树形示意图，如下图所示

图最上方的数轴就是一个横放的楼，$k_0 = 1$ 为第一层

〔解释这棵树〕在每一层扔下一个鸡蛋时，都有两种可能，碎了和没碎，分别对应了两个子树。一旦碎了，那么就使用1个鸡蛋的问题思路来解题，直到找到临界层。在 $k_1$层没碎，那么需在 $k_2$ 层继续尝试，直到最高层 $N$ 找到临界层（上图的标注不是树高，是灰色图例标识出部分的树高）

观察这颗树，怎样从树中得到对应问题的答案呢？

〔输入自变量〕 $k_1, k_2,\cdots,k_p$ 〔待求〕最小的尝试次数（即所有策略中最大值的最小值）等价于➜ 求一个策略组合 $k_1, k_2,\cdots,k_p$，使得树的高度最小

如果还是有些无法理解，此时，最好的方法就是看特例（举例子）

🌰 比如 $k_1 = 50$，意思是在50层扔下第一个鸡蛋

• 如果碎了，那么接下来的尝试方法就是从第1层开始一个一个往上尝试，直到49层，所以我们的答案 r = 50 （不记得如何计算这个值可以参考一个鸡蛋）
• 如果没碎，那么第一个鸡蛋继续在 k_2 = 75 层扔，假设还是没碎，继续从 k_3 = 90 层的地方扔下，此时碎了，那么第二课鸡蛋就需要从76层开始，一层一层往上尝试直到89层，需要 89-76+1=24 次，第一个鸡蛋已经扔了3次，最后得到没碎情况下的例子的答案 r=27 次

在上面的例子中，$k_1=50,k_2=75, k_3=90$ 就是一个可选策略

体会最坏情况下的最小值的意义非常重要，或者说，尝试的最大步数的最小值。如何判断对一道题目有没有完全吃透，看能否清晰的走完每一个例子，就能一窥一二

2.2.3 最优解的情况证明

⭐️ 接下里需要确定树的形状（同时也是确定策略的过程）。从直觉来看，如果树的形状倾向于满二叉树，那么树的高度最小。❓ 如何证明这个直觉的正确性呢？既然要计算树高，那么就把每一个叶子节点的树高一个一个列出来
$$\left.\begin{array}{l}k_1 \\k_2 -k_1 +1 \\k_3-k_2 +2 \\\cdots \\k_p - k_{p-1} +{p-1} \\N- k_p + p \\\end{array}\right\} \sum = N + \frac{(1+p)p}{2} \tag{2}$$

经计算发现，所有树高的和是个定值。那么使用反证法，假设这棵树不是满树，因为高度和为定值，那么必定有一个高于平均值得树存在，记为 $T$ 。根据最高树的最小值的要求 $H_a ＜ H_T$ （$H_a$为满树的高度），答案是$H_a$ ，与不是满树的假设矛盾 。所以，是满树。证毕

再参考树的示意图，所谓类似满二叉树是指每棵子树的树高相等，比如列出下面等式（每一行都是左右两颗子树相等，比如 $k_2$ 那棵树的树高即 $k_2 - k_1 -1 +2$），一层一层带入，都换成 $k_1$ 的表达式
$$\begin{array} \\k_1 &= k_2 - k_1 + 1 &\implies &k_2 = 2k_1 - 1 = k_1 + (k_1 - 1) \\k_2 -k_1 +1 &= k_3-k_2 +2 &\implies &k_3 = 3k_1 -3 = k_1 + (k_1 -1) + (k_1 -2) \\\cdots \\k_{p-1} -k_{p-2} +p-2 &= k_{p}-k_{p-1}+ p - 1 &\implies &k_p = \underbrace{ k_1 + (k_1-1) + (k_1-2) + \cdots }_{p项}\end{array} \tag{3}$$

根据上述推倒发现规律：要满足条件每颗子树的树高相等，$k_p$ 的表达式是一个递减等差数列，最终必须在第 $N$ 层尝试（最后一次尝试走 $N - k_p$ 步，必须覆盖最后一层 $N$） 。即在最小可分割的整数等差递减数列中，令 $k_p \sim N$ （趋近于），前半句加粗的话翻译成公式为

$$
k_1 + (k_1-1) + (k_1-2) + \cdots + 1 \sim N \implies \frac{k_1(k_1 + 1)}{2} = N \tag{4}
$$

解得 $k_1 \approx 13.65$ ，考虑到，所有尝试楼层都是整数，第一颗鸡蛋最后一次1颗鸡蛋的尝试区间需包含第 $N$ 层，所以 $k_1 = \lceil k_1\rceil = 14$ 。如果不明白为什么取上整数不取下整数，试试 $k_1 = 13$ 或 $k_1 = 14$ 对比一下答案，看看谁的尝试次数少即可

有了 $k_1$ ，带回（2）式，可以知道第一个鸡蛋的尝试楼层策略为 $14,27,39,50,60,69,77,84, 90,95,99$

使用这个策略，带回（1）式，假设临界层从1到N层，分别计算所需要的最多尝试次数，可得 $r = 14$

如果楼高 $N=200$，可计算得 $r = k_1 = 20$，策略为：第一次从20层开始尝试，没多一次尝试递减1

⭐️ 到此为止，2个鸡蛋问题解决：找到了一个明确的函数，利用抽象思维，写出它的表达式 $r = f(2, N)$，而这个 $f()$ 即求方程 $\frac{x(x+1)}{2} = N$ 解 $x$ 的上整数 $\lceil x \rceil$

3. 问题拓展

2个鸡蛋100层楼已经解决，深究下去，H层楼M个鸡蛋的问题呢？Leetcode有这道题：887. Super Egg Drop

刷题多的读者会快速反应出，这个问题是一道动态规划题，但在这里我还是想用一种推理的思维来尝试分析一遍，逻辑链上的关键锚点才是知识的精华

如果你通过观察题目，快速确定此题可用动态规划求解，这种能力是熟练能力，类似弹钢琴的熟能生巧，背书的死记硬背。与之相对，即分析能力。很有趣的是，这两种能力的分野十分明显，前者对应高效，后者对应求知

如果你需要快速通过面试，找工作或通过考试，那大量做题才是最短路径，可学习的目的不止是谋生，还有一种更高级的快乐来自于钻研本身，心理学管这种快乐为心流

回到问题，总结一下，通过上面的解答我们有了什么一些什么直观的结论

① 1个和2个鸡蛋的问题已经解决

② 理解了最大值的最小值在本题中的含义

③ 答案的值只和楼层高度有关，和最低楼层与最高楼层无关

以这三个结论为基石，想一想这道更一般化的问题怎么解决

3.1 符号化描述

首先，最容易想到的思考链条来自一个设问：❓我们能不能尝试把鸡蛋的数量减少？即不断的往2个鸡蛋的问题上靠拢？有一个很简单的办法，就是扔 ➜ 扔碎一个，鸡蛋数量就减少一个

照这个思路，进行一个抽象推演：假设在某一个时刻，我们拥有 $m$ 个鸡蛋，需要实验的层高为 $h$ （h for height），此刻在 $k \in [1, h]$ 层楼扔下一个鸡蛋

〔情况 1〕 碎了

假设我们已经知道 $1$ 到 $k-1$ 层楼最优解的值，❓ 那怎么用一个函数来表示这个值呢？首先看我们需要的自变量有哪些

• 1）此时剩下的鸡蛋数，这个非常明显，符号化记为 $m$ 个鸡蛋
• 2）根据2个鸡蛋难题时的结论可知，第二个自变量是此时未知情况楼层的层高（未知情况只楼层范围内还从来没有用鸡蛋尝试过，无法缩小范围），符号化记为 $h$ 层（h for height）

⭐️ 用一个表达式 $r = f(h, m)$ 表示楼高为 $h$ 时，还剩下 $m$ 个鸡蛋时的最少尝试步数

因为在 $k$ 层碎了，所以不用考虑[k+1, N]层的情况（肯定都碎），并且因为此刻这一个鸡蛋碎了，剩下 $m-1$ 个鸡蛋，用式子 $f(k-1, m-1)$ 表示已经知道的 $1$ 到 $k-1$ 层楼最少尝试步数的值，总最小尝试次数为 $f(k-1, m-1)+1$

〔情况 2〕没碎

在 $k$ 层没碎，直接不用考虑[1, k]情况了（肯定都不碎），同理，计算出此时楼高 $h_{now} = h - (k+1) + 1 = h - k$，且因为此刻这个鸡蛋没碎，剩下 $m$ 个鸡蛋，即 $f(h-k, m)$ ，总最小尝试次数为 $f(h-k, m)+1$

3.2 构造逻辑链

此时，我们已经有了三个表达式

1️⃣ 楼高为 $h$ ，剩下 $m$ 个鸡蛋时的最少尝试步数：$f(h, m)$

2️⃣ 在第 $k$ 层扔下1个鸡蛋碎了后的最少尝试步数：$f(k-1, m-1)$

3️⃣ 在第 $k$ 层扔下1个鸡蛋没碎后的最少尝试步数：$f(h-k, m)$

那么，假设2️⃣3️⃣的表达式的答案已知，是否能用这二者推出1️⃣？如果上述逻辑链成立，就可以用归纳思维（数学归纳法）算出任意 $f(h, m)​$ 。因为1️⃣只能从2️⃣3️⃣推出

〔推倒 $a$〕考虑到2️⃣3️⃣是一种策略选择后的可能性，根据上面的分析（最大值的最小值原理）两种策略中临界层 $x$ 可能在任何一层。遍历所有 $x$ 的情况时，最终尝试步数的结果是其中的最大值，所以选择2️⃣3️⃣中值更大的那个

〔推倒 $b$〕1️⃣需要仍一次鸡蛋，尝试步数 $+1$

〔推倒 $c$〕$k$ 是一个自变量，在这个情况下，可取到 $[1, h)$ 中的任意值，⭐️假设2️⃣3️⃣已知，只要在定义域内穷举出所有 $k$ 的可能值，并找出最大尝试步数中的最小值即可

接下来就可以把这个逻辑链的用抽象化的公式表达出来
$$
f(h, m) = \underbrace{\min_{1 \leqslant k \leqslant h} {\overbrace{\overbrace{\max [f(k-1, m-1), f(h-k,m)]}^{a}+1}^{b}}}_{c}\tag{5}
$$

有了具体的公式，为了锻炼工程思维，要时刻保持严谨，思考全集和完备性，再来看看边界条件和自变量定义域

3.2.1 自变量的定义域

依据题意楼高 $h \geqslant 1$ 且为整数，剩余鸡蛋数 $m \geqslant 1$ 且为整数

3.2.2 边界条件

$f(h, 1) = h$ ，当剩余鸡蛋数为1的时候，答案为现在的楼高

$f(0, m) = 0$ ，当楼高为0时，无法尝试，答案记为0 ，或者 $f(1,m) = 1$，表示楼高为1时，最小尝试次数为1

3.3 动态规划

现在反过头来再看，计算机学科中，有一部分专门研究这类问题的工具，即动态规划

上面的符号化描述被称为定义状态，构造逻辑链被称为构造状态转移方程，而背后的工程思维是拆分思维、抽象思维和归纳思维。再究竟一些，动态规划是一类特殊的图算法。

• 〔拆分思维〕拆分问题的能力。大问题化小问题，无后效性，当前状态与未来状态无关。
• 〔抽象思维〕使用状态来描述问题的能力，或说用抽象符号或状态机来描述问题的能力
• 〔归纳思维〕数学归纳法，逻辑推导能力。由 $\lt i$ 的所有状态推倒出 $i$ 时刻状态的能力

之所以要研究这类问题和计算机本身是一个巨大的状态机有关。动态规划提供了一套工具和思维框架去优化问题，找到最优解。思维框架和优化方法才是最厉害最有价值的，看到后面优化部分的详解你就能直观的体会到这点。

4. 实现优化和分析

这部分，通过一步一步剖析优化思路，和对应的代码实现（使用python，所有代码可在Leetcode题目中AC），希望能直观的说明一个问题，❓ 到底高级程序员和一般的码农程序员区分在哪里？

每个人都有自己擅长的领域，管理大师吉姆·柯林斯的第一本畅销书《基业长青》，书内研究了18家企业成功的秘密。

后来，他又出了一本书《从平庸到伟大》，对这个变化的界定是非常严格的。平庸意味着这家公司的业绩低于市场的平均水准，变得伟大意味着业绩保持在平均水准的3倍以上，并持续至少15年。他研究了1435家公司，只找到了11家

通过研究，他总结了这些企业的6个秘诀。其中一个就是著名的三环理论，如果把企业的三环理论推广到个人，就是问自己下面三个问题：我的擅长是什么？我的热爱是什么？我的机会是什么？

而选择三者交集作为一辈子的努力方向大概率就算是走对了路

作为程序员，可能只是你开始职业生涯的第一步，后面如何发展，需要对自己的追求和个人能力做一个更深入的挖掘，才能有个定论

下面即将剖析的优化过程完美的阐述了作为一个伟大的程序员需要什么样的基础能力（至少在算法优化这个小领域），这需要长时间的训练和极强的天赋。如果你感觉想出这些解答很吃力，相对应的，你又想这辈子有所作为，追逐伟大。那么应该尝试去找一条非程序员的路努力一生。毕竟，计算机思维，数据分析和机器学习未来会成为像数学一样的基础能力，无论在哪一行都对解决问题有极大的助益

4.1 基础版

根据思路直接写出的最直观代码。如果对递归理解的深，容易读懂。用我能想到最直白的语言来描述就是：假设子状态的结果已知，现在需要做些什么操作，就能得到此状态的答案，并且把这个答案返回给函数（借鉴知乎回答的答案，加上了lru_cache装饰器用于优化）

1
2
3
4
5
6
7
8
9
10

import functools
# python3的functools的一个自带函数, 可以对函数返回结果进行LRU cache, 下次以相同参数调用就不重复计算了
# maxsize=None 不限制大小, 其实就变成是全部都cache下来, 不考虑LRU了
@functools.lru_cache(maxsize=None) # 装饰器 
def f(h, m):
    if h == 0: return 0
    if m == 1: return h

    result = min ( [ max ( [ f( i - 1, m - 1 ), f( h - i, m ) ] ) for i in range( 1, h + 1 ) ] ) + 1
    return result

🔄〔优化〕Recursive（递归）的写法虽然清晰明了，但在工程上有调用函数的开销，系统栈深度限制等弊端，所以最好写成循环版本，否则在工作中可能返工

4.2 循环版本

1
2
3
4
5
6
7
8
9
10
11

def solve(h, m):
    if h < 1 and m < 1: return 0

    f = [ [ i for i in range(h+1) ] for j in range(m+1) ]

    for m_i in range( 2, m + 1 ):
        for h_j in range( 1, h + 1 ):
            for k in range( 1, h_j ):
                f[m_i][h_j]= min ( f[m_i][h_j], 1 + max( f[m_i -1][k - 1], f[m_i][h_j - k]) )
    
    return f[m][h]

🔄〔优化〕分析一下时间复杂度和空间复杂度，时间复杂度为 $O(mh^2)$ ，空间复杂度为 $O(hn)$ ，很明显，空间上可以优化到 $O(h)$，原因是状态转移方程只和 $m$ 与 $m-1$ 有关，使用两个数组滚动即可

4.3 空间优化版本

1
2
3
4
5
6
7
8
9
10
11
12

def solveSpace(h, m):
    if h < 1 and m < 1: return 0
    
    f_pre = f_cur = [i for i in range(h + 1)]

    for m_i in range( 2, m + 1 ):
        for h_j in range( 1, h + 1 ):
            for k in range ( 1, h_j ):
                f_cur[h_j] = min ( f_cur[h_j], 1 + max( f_pre[k - 1] , f_cur[h_j - k]) )
        f_pre = f_cur[:]
    
    return f_cur[h]

基本到这，对美国FAANG的入门级SDE，就十分优秀了。后面的所有的内容，属于高手的领域（博主完全不是高手，只是好奇，所以阅读了其他人的牛逼的解题报告，重新做了理解和整理）

对于这一套状态描述和状态转移方程，优化方向在时间复杂度上。思考，❓是否有一些数学定理可以提供答案取值的下界呢？（找边界是剪枝的有效方法）

🔄〔优化〕这里需要使用数据结构中折半查找判定树理论。假设我们对鸡蛋的数量不做限制，那么这棵树

就会变为一个满二叉树，而叶子节点数量有 $h+1$ 个（因为最大尝试步数能取到的总数就是 $h+1$ 种，需包含0次）树的高度至少为 $\lceil \log_2(h+1)\rceil$。假设鸡蛋 $m$ 的数量大于 $\lceil \log_2(h+1)\rceil $ ，那么上面的树变成满树，无论怎么尝试，答案（树高）都有一个下界（不可能大于这个值）

如果还不明白，即在 $m \geqslant \lceil \log_2(h+1)\rceil $ 时，这道题会变成二分查找（鸡蛋太多，随便扔，就当楼层是排序好的即可）最终答案直接取 $\lceil \log_2(h+1)\rceil$

🌰 如果还是不明白，上终极杀招，举例子。假设16层楼，但有4个鸡蛋。根本不用设计，二分查找即可，效率肯定最高。比如16层楼，只要鸡蛋数大于4，最大尝试次数就是4，可以直接算出答案

4.4 下界优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

def solveBoundary(h, m):
    if h < 1 and m < 1: return 0
    
    f_pre = f_cur = [i for i in range(h + 1)]
    
    for m_i in range( 2, m + 1 ):
        for h_j in range( 1, h + 1 ):
            t = math.ceil( math.log2( h_j + 1 ) )
            if m_i >= t:
                f_cur[h_j] = t
            else:
                for k in range ( 1, h_j ):
                    f_cur[h_j] = min ( f_cur[h_j], 1 + max( f_pre[k - 1] , f_cur[h_j - k]) )
        f_pre = f_cur[:]
    
    return f_cur[h]

这时候时间复杂度优化为 $O(mhlog_2(h))$。此时，如果列出所有状态转移的过程（行为鸡蛋数 $m$，从2开始；列为楼高 $h$ ，从1开始），如下图（红色框表示 $k$ 的移动，蓝色双向箭头表示 $\max$ 操作，然后还需要加1后和之前的 $f(m,h)$ 进行 $\min$ 操作。下图展示的是 $m_i=2,h_j=11,k=5$ 时的情况）（这幅图也能帮助理解下界优化，注意 $m_i=5$ 和 $m_i=4$ 在 $h < 20$ 的情况）

🔄 观察发现，有一个很重要的规律，即单调性，写成公式为 $f(m, h) \geqslant f(m, h-1)$ 当 $h \geqslant 1$ 。如果满足单调性，那么又可以在搜索时使用二分查找。先姑且不考虑如何证明单调性，工程上，在资源允许的情况下，先尝试，看看能不能得到正确结果（用正确算法和这个尝试算法进行验证）直到验证在很大的定义域内都正确，可大胆猜测这个猜测性质是对的（不严谨，但效率较高）

通过这一层优化，体现出了理论和工程的分野，即你猜想出了一个优化方法，当然可以先直接尝试，不管这个猜测的条件是不是正确。

反过头来仔细一寻摸，总是心里不踏实（可能出现特殊情况就让整个算法崩溃）此时，理论出山，用严谨的数学逻辑去证明这些结论，让算法具有完备性（本题单调性是正确的，证明过程参见参考文献）

另外，观察和总结答案的分布规律也是非常重要的思考手段，你会发现，这简单的一句话说开去，是一个新的学科，名叫统计学

4.5 单调性优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

def solveBinarySearch(h, m):
    if h < 1 and m < 1: return 0

    t = math.floor( math.log2( h ) ) + 1
    
    if m >= t: return t
    else:
        f_cur = f_pre = [i for i in range(h + 1)]

        for m_i in range(2, m + 1):
            f_cur[0] = 0
            for h_j in range(1, h + 1):
                f_cur[h_j] = 1000000
                start, stop = 1, h_j
                # 二分查找
                while start <= stop:
                    mid = (start + stop) // 2
                    if f_pre[mid - 1] > f_cur[h_j - mid]:
                        if f_pre[mid - 1] + 1 < f_cur[h_j]:
                            f_cur[h_j] = f_pre[mid - 1] + 1
                        stop = mid - 1
                    elif f_pre[mid - 1] < f_cur[ h_j - mid]:
                        if f_cur[h_j - mid] + 1 < f_cur[h_j]:
                            f_cur[h_j] = f_cur[h_j - mid] + 1
                        start = mid + 1
                    else:
                        f_cur[h_j] = f_cur[h_j - mid] + 1
                        break
            f_pre = f_cur[:]
        return f_cur[h]

🔄 结果的简单特性部分挖掘完了，继续观察上面的状态转移图，发现很多项是相等的，那么可不可以找到，在某种条件满足时，状态可以直接推出，而不用进行 $k$ 的遍历搜索？这个时候就需要从状态转移方程本身入手是挖掘其中的数学特性，这部分不是非常关键，较难，可直接跳过

又因为 $f$ 具有单调性，可得 $f(h - 1, m) \leqslant f(h, m) \leqslant f(h - 1, m) +1$ 其中 $h\geqslant 1$

上面的式子非常有意思，使用标准的逻辑推理来看

• 若某个决策 $k$ 可使得 $f(h - 1, m) = f(h, m)$ ，则一定 $f(h, m) = f(h-1, m)$

• 若所有决策 $k$ 都不能使 $f(h - 1, m) = f(h, m)$ ，则一定 $f(h, m) = f(h - 1, m) + 1$

那么，是否可以构造这样一个决策，使得状态转移直接计算呢？具体过程略过，有兴趣的读者详见参考文献

假设这个决策的楼高 $h = p$ ，推倒出当 $f(m, p)<f（m-1， h-p-1)$ 时，无论任何决策都不能使 $f(m, h) = f(m, h-1)$，所以，此时 $f(m, h) = f(m, h-1) + 1$

也就是说，根据 $f(m, p)$ 和 $f(m-1,h-p-1)$ 的大小关系就可以直接确定 $f(m, h)$

4.6 状态转移方程优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

def solveTransferFunction(h, m):
    if h < 1 and m < 1: return 0

    t = math.floor( math.log2( h ) ) + 1  
    if m >= t: return t
    else:
        f_cur = [i for i in range(h + 1)]
        f_pre = [i for i in range(h + 1)]

        for m_i in range(2, m + 1):
            p = f_cur[0], f_cur[1] = 0, 1
            for j in range(2, h + 1):
                if f_cur[p] >= f_pre[j - p - 1]:
                    f_cur[j] = f_cur[j - 1]
                else:
                    f_cur[j] = f_cur[j - 1] + 1
                    p = j - 1
            f_pre = f_cur[:]
        
        return f_cur[h]

此时，状态转移过程时间复杂度变成 $O(1)$，整体时间复杂度随之变成 $O(m\log_2{h})$

在这种依照题意直接定义状态并找到状态转移方程的方法已经优化到极致了。那么，❓ 如果从不同的角度定义问题呢？

4.7 不同角度看问题

4.7.1 状态定义

改变对问题的状态描述方法，用 $h(i,j)$ [h for height]表示用 $j$ 个鸡蛋尝试 $i$ 次在最坏情况下能找到的最小尝试次数的楼高。

4.7.2 边界条件

当尝试次数 $i=1$ 时，$h(1,j)=1\quad(j \geqslant 1)$

当使用 $j = 1$ 个鸡蛋时，尝试 $i$ 次可以尝试 $i$ 层楼，即 $h(i,1)=i$

4.7.3 状态转移方程

核心思路：每一次 $h()$ 所能尝试的楼高必须要尽可能的大，这样才能做到尝试次数最小

在某层扔下一个鸡蛋

• 〔碎了〕那么在后面的 $i-1$ 次里，需用 $j-1$ 个鸡蛋在下面的楼层中确定楼高。为了使 $h(i,j)$ 达到最大，希望下面的楼层数（楼高）最大，根据状态定义，记为 $h(i-1, j-1)$
• 〔没碎〕那么在后面的 $i-1$ 次里，需用 $j$ 个鸡蛋在上面的楼层中确定楼高。同理，需要楼层数达到最大，记为 $h(i-1,j)$

综上，状态转移方程写为 $h(i,j) = h(i-1, j-1)+h(i-1,j) + 1$

而最终结果可以写为，找到一个 $x$ ，使得 $x$ 满足 $h(x-1, M) < H$ 且 $h(x, M) \geqslant H$ （$M$ 为鸡蛋总数，$H$ 为楼层总高度），其实也就是用公式描述的临界层的具体含义

4.7.4 代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

def g(h, m):
    if h < 1 and m < 1: return 0

    t = math.floor( math.log2( h ) ) + 1 
    if m >= t: return t
    else:
        g_cur = g_pre = [ 1 for i in range(m + 1) ]
        g_cur[0] = g_pre[0] = 0

        if g_cur[m] >= h: return 1
        elif h == 1: return h
        else:
            for i in range(2, h + 1):
                for j in range( m, 1, -1):
                    g_cur[j] = g_pre[j - 1] + g_pre[j] + 1
                    if g_pre[j] < h and g_cur[j] >= h:
                        return i
                g_cur[1] = i
                if m == 1 and g_cur[1] >= h:
                    return i
                print( g_cur, end="\n")
                g_pre = g_cur[:]

4.7.5 继续优化

这又是一个全新的状态定义和状态转移方程，同理，可尝试输出整个转移矩阵的具体值，先观察一下总没有错，如下图所示

从形式上来说，不需要滚动数组，在转移过程中，使用一个 $g$ 函数即可。在最后输出的时候，只需要判断g[m]的情况输出 $i$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

def gOptimization(h, m):
    if h < 1 and m < 1: return 0

    t = math.floor( math.log2( h ) ) + 1
    
    if m >= t: return t
    else:
        g = [ 1 for i in range(m + 1) ]
        g[0] = 0

        if g[m] >= h: return 1
        elif h == 1: return h
        else:
            for i in range(2, h + 1):
                for j in range( m, 1, -1):
                    g[j] = g[j - 1] + g[j] + 1
                    if j == m and g[j] >= h:
                        return i
                g[1] = i
                if m == 1 and g[1] >= h:
                    return i

要分析时间复杂度，挺难的。通过证明可以有一个结论（具体证明详见参考文献）$xM \leqslant H$ ，再通过一系列骚操作，可以证明时间复杂度为 $O(\sqrt{h})$，空间复杂度 $O(m)$

至此，Leetcode上这道题目的执行时间打败了85.7%的答案（虽然Leetcode时间并不靠谱），做这道题的人不多，前面只有一个答案，思路类似，代码写的更漂亮

5. 工程思维总结和感悟

5.1 工程思维

⭐️ 这一部分是【直观算法】系列的最终目的。求同遵异，寻找每一道算法题背后的工程思维，提升自己真正解决工程问题的能力。博主对自己的定位是【机器学习+区块链产品经理】，但同时对技术也有好奇心，喜欢钻研，才开坑写【直观算法】系列

5.1.1 抽象思维

把语言描述转化为符号描述的能力，符号是信息和逻辑的纽带

5.1.2 等价思维

沟通的效率和信息的冗余度成正比，所以一个人能否把同一个概念，从不同的角度，用不同的案例类比，抑或各类精彩直观的比喻表达出来，这个能力很重要，它可以让人们更加准确快速的理解你想表达的意思

⭐️ 学习的真正本质：是在一个领域内不断的去建立这种沟通共识的框架。举个例子，学过线性代数的人，只要提到矩阵，就能想到变换。这就是都学过线性代数的人交流密码，如矩阵的逆 = 一个具体的反向变换。没学过这门课的人是无法和学过的人进行沟通的。这也从很大程度加强了人们沟通的效率，所以，学习带来的终极成效之一其实是降低了人类社会的沟通时间，提高了效率

再举个例子：机器学习中，提到正则化，必须建立一套与之相关的知识架构，包括，过拟合，最优化函数曲面空间理解，范数等，成树状结构继续推而广之，这每一个名词，背后也对应了一个更加直观，更加易懂的描述方式。但是我们需要知道，如果我为了表达正则化，为了让你明白我的意思，我需要用一大堆描述性语言，那我们两人的沟通效率就十分低下了

这也就是知识体系，一门学科，一门专业的最终含义，学习是为了构建这门学科的通识沟通框架，降低同行之间的沟通成本。当然，这有一个必要前提，把学习的目的理解降低沟通成本必须是你做的工作是规模化的，涉及协作

如果你是爱因斯坦，是能开拓学科新领域的0级工程师（来自于吴军老师谷歌方法论），独自想象钻研。那么，学习的本质可能在于给你更多的角度（认知能力），更多的工具（锤子锯子）去更好的探索这个世界的本质和规则，在这样的条件下，关于学习本质的描述就需要调整了

5.1.3 反推思维

从结论出发反推逻辑链

5.1.4 归纳思维

数学归纳法，使用已有的条件信息，归纳推出待求的内容

5.1.5 粗条细调思维

对于这道题，首先考察的是程序员的粗条细调思维。工程中经常会有对测量精度的要求，那么是如何做的？比如常见的千分尺，首先是一个横向的卡尺来接近目标值，然后用一个滚轮形的第二级继续细调。同样，显微镜也有对应的调整方法。都可以总结为粗条细调思维

首先大步接近最优解，再调整迭代速度，更加细微的接近最优解。机器学习中的，Adam优化器也是用类似的思维来设计的

5.1.6 拆分思维

问题是否能拆分几个黑盒，只给输入输出，里面的逻辑链做到精简，或者有已经可用的轮子和算法直接应用的能力。

能看到这的读者我衷心感谢您的求知欲和耐心（我写的比较啰嗦，为了权衡不同背景的读者），下面的一部分个人认为才是最重要的

5.2 工程应用

到了这一步，基本压榨了本题所有的潜力。但是，下一个值得思考的问题就是，这道题目对应的算法在实际工程和解决问题的具体情况中有没有什么应用呢？答案是肯定的

🌰 如果要找学科分类，鸡蛋难题属于运筹学问题，典型应用是破坏性试验，如测试汽车、飞机、火箭等的若干极限性能。举个例子，汽车保全乘客安全的最高碰撞末速，那么为了保证能找这个值，一定会用类似的思路来解决问题。

你可能也已经发现，具体问题一定还是具体分析，但这道题目对应的工程思维更像是工具箱里面的一种更强大的工具。

记得罗辑思维中提过一个问题：为什么物理学领域老一辈的物理学家现在拿奖的人越来越少？其中一个重要的原因是他们熟悉的物理学工具没有新生一辈的能力强大的。不同于数学这类逻辑学科，物理学是可验证学科，实验，测量工具和理论工具等都必不可少

博主笃定，算法80%是要为解决问题服务的，勾起人们学习的最佳动力就是举实际生活中遇到的难题是如何用这个算法解决。从这个侧面，有关字符串的算法就非常能勾起学习的兴趣，正是因为涉及到字符串处理的情景太多。

关于鸡蛋难题，总的看下来，完美的诠释了直观 ➜ 抽象的思维链条。所有高效的，精简的算法，就是要找到事物或者逻辑发生的本质规律，如果不谈完备性的证明，用图表和直观的性质来描述，这道题目的优化思路并不难（相对的，完备性时间复杂度的证明才是难点）

关于剩下的20%，此时又想起黎曼猜想，所有非平凡零点的有关性质。趋向于无穷、所有、任意这些定义方式是人类为了寻找边界而设计的工具。趋向于无穷大，趋向于无穷小都还有很多问题没有解决。罗胖说，创业者是在开垦商业的边疆，那么理论科学家就是拿着这些强大的工具开拓逻辑和思维的边疆，在一片荒芜上安营扎寨，仰望星空。这可能就是人类群体中最有魅力的事业吧？

【参考文献】

非常感谢计算机信息学奥赛国家队朱前辈的论文，对这道题目做了完美的剖析，也勾起了我的好奇心，一探究竟，才有了这篇万字长文

吴育昕的回答 - 知乎

参考文献：朱晨光：《优化，再优化！——从《鹰蛋》一题浅析对动态规划算法的优化》

﹝信息流转学﹞2021-07-01 信息流转学综述

﹝机器学习﹞2018-01-19 微信跳一跳解题报告 ┃⭐️2017-10-18 深入浅出看懂AlphaGo元 ┃⭐️2017-05-27 深入浅出看懂AlphaGo如何下棋 ┃2017-09-30 Pandas-Wiki ┃⭐️2017-10-03【直观详解】什么是正则化 ┃📝【直观详解】什么是PCA、SVD ┃2017-09-20【直观详解】拉格朗日乘法和KKT条件 ┃2017-09-19【直观详解】支持向量机SVM ┃2017-09-12 【直观详解】机器学习分类器性能指标详解 ┃⭐️2017-09-11【直观详解】信息熵、交叉熵和相对熵 ┃2017-09-04【直观详解】Logistic Regression

﹝理论基础﹞⭐️2018-09-20【直观详解】通俗易懂了解什么是黎曼猜想 ┃⭐️2018-02-18【直观详解】让你永远忘不了的傅里叶变换解析 ┃⭐️2018-02-16【直观详解】泰勒级数 ┃⭐️2017-10-06【直观详解】线性代数的本质 ┃2017-10-17【直观详解】线性代数中的转置正交正规正定

﹝区块链﹞⭐️2018-03-03【区块链】共识算法与如何解决拜占庭将军问题 ┃2017-09-25【区块链】比特币与金融、ICO和监管 ┃2017-09-25【区块链】现代区块链与新技术 ┃⭐️2017-09-24【区块链】一文看懂区块链：一步一步发明比特币

﹝计算机技术﹞📝2019-10-01【教程】manim 动画制作工具┃ ⭐️⭐️2018-10-11【直观算法】Egg Puzzle 鸡蛋难题┃ ⭐️2017-10-13 程序员技能图谱 ┃2017-08-28 Xpath-Wiki ┃📝2017-07-01 LeetcodeNote

﹝能力提升﹞⭐️2018-06-20 那些值得一看的TED演讲附全文文稿笔记 ┃2017-07-29 PDF复制粘贴去除多余的回车符 ┃2017-05-13 English-abbreviation

﹝原创﹞⭐️2017-06-17 幕布-全平台笔记思维导图工具 ┃⭐️2017-05-13【散文】有关中国诗的那些事

﹝清单和百科﹞2017-11-05 Dota2-A帐效果 ┃2017-09-18 Dota2伤害类型详解 ┃2017-09-05 Dota2机制总结 ┃2017-05-14 【摘抄】清欢 - 林清玄

机器学习入门？先上手玩玩看！

是什么（What）

TensorSpace是一款3D模型可视化框架，一动图胜千言。官网链接，Github链接

⭐️TensorSpace擅长直观展示模型结构和层间数据，生成的模型可交互。官方支持手写字符识别，物体识别，0-9字符对抗生成网络案例等

为什么（Why）

本部分说明：❓为什么要使用这个框架❓这个框架主要解决了什么问题❓我们的灵感来源于何处

3D神经网络可视化一片空白

在机器学习可视化上，每个机器学习框架都有自己的【御用工具】，Tensorboard之于Tensorflow ，Visdom之于Pytorch，MXboard之于MXnet。这些工具的Slogan不一而同的选择了Visualization Learning(TensorBoard的Slogan)，也就是面向专业机器学习开发者，针对训练过程，调参等设计的专业向可视化工具

但面向一般的计算机工程师和非技术类人才（市场，营销，产品），一片空白，没有一个优秀的工具来帮助他们理解❓机器学习模型到底做了什么，能解决一个什么问题

机器学习开发和工程使用并不是那么遥不可及，TensorSpace搭建桥梁链接实际问题和机器学习模型

3D可视化的信息密度更高更直观

市面上常见的机器学习可视化框架都是基于图表（2D），这是由它们的应用领域（训练调试）决定的。但3D可视化不仅能同时表示层间信息，更能直观的展示模型结构，这一点是2D可视化不具备的。例如在何凯明大神的Mask-RCNN论文中：

有这么一幅图来描述模型结构（很多模型设计类和应用落地类的论文都会有这么一副图）而TensorSpace可以让用户使用浏览器方便的构建出一个可交互的神经网络3D结构

更进一步的，利用3D模型的表意能力特点，结合TensorFlow.js，可在浏览器中进行模型预测（跑已经训练好的模型看输入输出分别是什么❗️），帮助理解模型

【模型结构】黑盒子的真面目是什么？

模型就像是一个盛水的容器，而预训练模型就给这个容器装满了水，可以用来解决实际问题。搞明白一个模型的输入是什么，输出是什么，如何转化成我们可理解的数据结构格式（比如输出的是一个物体标识框的左上角左下角目标）就可以方便的理解某个模型具体做了什么

例如，❓Yolo到底是如何算出最后的物体识别框的？❓LeNet是如何做手写识别的？❓ACGAN是怎么一步一步生成一个0-9的图片的？这些都可以在提供的Playground中自行探索

如下图所示，模型层间的链接信息可通过直接鼠标悬停具体查看

【层间数据】神经网络的每一层都做了什么？

3D模型不仅仅可以直观的展示出神经网络的结构特征（哪些层相连，每一层的数据和计算是从哪里来），结合Tensorflow.js，可在浏览器中进行模型预测。由于我们已经有了模型结果，所有的层间数据直观可见，如下图所示：

可以通过 TensorSpace Layer的对象属性方便的拿到每一层的输出数据（未经处理），工程和应用上，了解一个模型的原始输出数据方便工程落地

怎么建（How）

首先你需要有一个使用常用框架训练好的的预训练模型，常见的模型都是只有输入输出两个暴露给用户的接口。TensorSpace可以全面的展示层间数据，不过需要用户将模型转换成多输出的模型，过程详见此文档。具体流程如下图所示：

用TensorSpace构建对应模型这一步，下面一段构建LeNet的代码可能更加直观，如果要在本地运行，需要Host本地Http Server

你最需要的是模型结构的相关信息，Tensorflow，Keras都有对应的API打印模型结构信息，比如Keras的model.summary()。还有类似生成结构图的方式，生成如下图的模型结构2D示意图

是的，你需要对模型结构非常了解才可能构建出对应的TensoSpace模型，未来版本已计划推出自动脚本，通过导入对应的模型预训练文件，一键生成多输出模型。但是TensoSpace的Playground会未来子项目会力所能及的收集更多的模型，在模型应用落地和直观展示这个领域努力做出自己的贡献

谁可能用（Who）

做这样一款开源框架，除了填补3D可视化的一般解决方案的框架空白外，还思索了几个可能可行的应用场景

前端开发者过度机器学习

前端（全栈）开发者，产品经理等

未来，前端的重复性工作可能会慢慢减少。最近有一个原型图 ➜ HTML代码的项目，另一个2017年的开源项目都在尝试利用机器学习自动化一些Coding中的重复劳动，提高效率

机器学习一定不会取代前端工程师，但掌握机器学习工具的工程师会有优势（这种工具会不会整合进Sketch等工具不好说），既然入了工程师行，终身学习势在必行！

TensorSpace虽然不是能帮忙训练和设计模型，但擅长帮助工程师理解已有的模型，找到可应用的领域。并且在接驳光法开发者到机器学习的大道上做了一点微小的工作，走一个可视化的Model Zoo

机器学习教育

机器学习课程教育者

使用Tensorspace直观的在浏览器上显示模型细节和数据流动方向，讲解常见模型的实现原理，比如ResNet，Yolo等，可以让学生更直观的了解一个模型的前世今生，输入什么，输出什么，怎么处理数据等等

我们只是提供了一个框架，每一个模型如果需要直观的展示对数据的处理过程，都值得3D化

模型演示和传播

机器学习开发者

JavaScript最大的优势就是可以在浏览器中运行，没有烦人的依赖，不需要踩过各种坑。有一个版本不那么落后的浏览器和一台性能还成的电脑就可以完整访问所有内容

如果您的项目对展示自己的模型可以做什么，是怎么做的有需求，私以为，不应错过TensorSpace

用TensorSpace教学模型原理效果非常好。提供了一个接口去写代码，搞清楚每一个输出代表了什么，是如何转化成最后结果（从输出到最后结果的转换还是需要写JavaScript代码去构建模型结构，在这个过程中也能更进一步理解模型的构造细节）

现在还没有完成的Yolov2-tiny就是因为JavaScript的轮子较少（大多数处理轮子都使用Python完成），所有的数据处理都需徒手搭建。时间的力量是强大的，我们搭建一个地基，万丈高楼平地起！

致谢

机器学习部分

我们最初的灵感来源于一个真正教会我深度卷积网是如何工作的网站：http://scs.ryerson.ca/~aharley/vis/conv/（源码只能下载，我Host了一份在Github上）

这个网站的效果，也是团队未来努力的方向（大网络上，因为实体过多，性能无法支持。为了解决性能问题，我们优化为：不是一个Pixel一个Pixel的渲染，而是一个特征图一个特征图的处理）

前端部分

使用Tensorflow.js Three.js Tween.js 等框架完成这个项目，感谢前人给的宽阔肩膀让我们有机会去探索更广阔的世界

开发团队们

感谢每一个为这个项目付出的伙伴，没有你们每个人，就没有这个开源项目破土而出！团队中负责开发的syt123450（主力）和Chenhua Zhu，设计师Qi(Nora)，感谢他们！还有负责机器学习模型部分和文档的我

也欢迎你有什么想法给我留言，或直接在Github上提出Pull Request

分享者是最大的受益者，感谢各位莅临阅读！

【说明】本文科普为主，是3B1B视频（版权来源）的笔记。会有很多废话来增加信息冗余度，方便对复分析之类概念不熟悉的读者理解。有基础的读者可以选择跳过一些在你们看来是在说废话的内容。就像重要的事情说三遍一样，废话增加信息的冗余度，减慢节奏，降低认知负担，希望这么做后能有更多人真正看懂什么是黎曼猜想。

八卦黎曼

黎曼全名格奥尔格·弗雷德里希·波恩哈德·黎曼 〔德语〕Georg Friedrich Bernhard Riemann（1826 - 1866），德国数学家。黎曼的父亲是个牧师，在他长大之后，就读于哥廷根大学（德国西南部）神学系

后来在大学听了一场高斯有关最小二乘法的讲座，发现了命中天赋所在。征得父亲同意后，转到柏林大学改修数学，拜入雅可比和狄利克雷门下（雅克比行列式，第一个玩椭圆的人；机器学习中的狄利克雷分布，证明费马大定理 n=5 的人；没错就是这两个大牛）

历史背景

不谈历史背景的人物介绍都是耍流氓，好，回过头来看看黎曼生长的德国（当时还不能叫德国）当时在干啥

1806年拿破仑覆灭统治几百年的神圣罗马帝国。1815年以日耳曼民族为主的德意志邦联成立，在这个联邦中，以普鲁士和奥地利最为强大，两大势力得争个高下。一直到1862年脾斯麦执政，才走向一统。最终，1871年，德意志帝国成立，黎曼没能见到这一天

19世纪5、60年代普鲁士完成了工业革命，这必定伴随着思想和科学的蓬勃发展。黎曼是生在一个好时代，这个时代，整个科学领域，一片蓝海，名家辈出，群星璀璨

有意思的是，K12这个名词就发源于普鲁士。K指Kindergarten，及幼儿园，12指12年级，也就是高三。K12泛指基础教育。虽然这工业化的流水线教育模式可能更多的是为了培养流水线式的工业人才或士兵，但不能否认，重视教育则学界兴盛

成就

黎曼成就斐然，最有名的当然是黎曼几何（积分），黎曼流形和复分析之父。当然还有本篇文章的主人公，1859年提出的黎曼猜想

黎曼猜想被收录进1900年希尔伯特（Hilbert）提出的23个重大难题，这些难题经过100年的岁月，还剩下6道没有被完全解决

【补充1】因为代数几何中有关椭圆曲线的相关研究还没有兴盛，著名的费马大定理：$x^n + y^n = z^n \; 当\;n>2\;没有整数解$ 未出现在列表中，虽然当时这个猜想也没有被证明

【补充2】在希尔伯特的问题列表中，黎曼猜想并不单独为一题。包含黎曼猜想的第8题是：黎曼猜想及哥德巴赫猜想和孪生素数猜想，这每一个猜想都闻名遐迩。三位一体，由此可见这三个问题之间是存在关联的

21世纪黎曼猜想又被列为千禧年7道世纪难题之一，克雷数学研究所承诺：解决一道题 ➜ 100万美元

P/NP问题 | 霍奇猜想 | 庞加莱猜想（已证明）| 黎曼猜想 | 杨-米尔斯存在性与质量间隙 | 纳维-斯托克斯存在性与光滑性 | 贝赫和斯维讷通-戴尔猜想

黎曼猜想的专业定义

先搬运Wiki百科对黎曼猜想的定义：黎曼$\zeta$函数，$\zeta(s) = \frac{1}{1^s} + \frac{1}{2^s} + \frac{1}{3^s} + \frac{1}{4^s} + \cdots$ 的非平凡零点（在此情况下是指 $s$ 不为-2，-4，-6…等点的值）的实数部分是 $\cfrac{1}{2}$

这个表述可以继续简述为：所有黎曼$\zeta$函数非平凡零点的实数部分是 $\cfrac{1}{2}$

【补充（只为严谨，可以跳过）】把上面的式子称为黎曼$\zeta$函数并不严谨，严谨的来说：定义域必须纳入考虑，才能完整写出黎曼$\zeta$函数的形式

设一复数s，其实数部份 >1 ${s: Re(s) > 1}$ 且
$$
\zeta(s) = \sum_{n=1}^{\infty} \frac{1}{n^s}
$$

它亦可以用积分定义
$$
\zeta(s) = \frac{1}{\Gamma(s)}\int_{0}^{\infty} \frac{x^{s-1}}{e^x - 1} dx
$$

在区域{s : Re(s) > 1}上，此无穷级数收敛并为一全纯函数。黎曼认识到：$\zeta$ 函数可以通过解析开拓来扩展到一个定义在复数域 $ s, s≠ 1$上的全纯函数 $\zeta(s)$

相信大部分读者如果是第一次看到这个定义，估计头都大了，但是列出不明白概念的清单是学习一个全新事物的有效办法，就按照这个思路来列一个清单

• ❓ 黎曼$\zeta$函数是个什么函数？ 若读者的数学基础为高中，那么博主猜测您有疑惑的是…这个符号，它的含义很简单：按照1 2 3 4每次加1的规律一直重复前一项的形式。举个例子：

$$
\zeta(s) = \frac{1}{1^s} + \frac{1}{2^s} + \frac{1}{3^s} + \frac{1}{4^s} + \frac{1}{5^s} + \frac{1}{6^s} + \frac{1}{7^s} + \frac{1}{8^s} + \cdots = \sum_{n=1}^{\infty} \frac{1}{n^s}
$$

• ❓ 什么是非平凡零点？ 本博文想说清楚的问题
• ❓ 实数部分指的什么？难不成还有虚数部分？ 这部分涉及虚数的概念，虚数定义为 $\sqrt{-1}$ 记为符号 i，接下来就需要一些复数基础，这一点跳不过，但本博文也尝试帮你解决这个问题
• ❓ $\frac{1}{2}$ 这个数是怎么来的？ 本博文想说清楚的问题

从知识构建的角度来说，搞清楚黎曼猜想的知识网父节点有基础复分析（知道复数以及如何分析）和微积分中的求导

还有另一个说法也和黎曼猜想有关，即 $1 + 2 + 3 + \cdots = - \cfrac{1}{12}$ ，怎么看这个式子都应该是无穷大啊，为啥等于 $-\cfrac{1}{12}$ 呢？看完后，你应该就能明白为什么会有这个令人不解的说法

可视化黎曼$\zeta$函数

第3部分就一步一步展开黎曼猜想这副瑰丽的“画卷”，希望在图穷过程中，能带来给您带来几个Aha时刻，感受数学之美

黎曼$\zeta$函数

首先，我们为了逻辑链的完整，先用一副动图再定义一下我们的主角黎曼$\zeta$函数，并且假设我们带入$s=2$ 会是什么情况

你可以继续带入其他值，如果 $s>1$ ，可算出一个确定的值，但你会发现如果 $s<1$ ，那这个无穷级数（级数就是一长串数字 or 序列的数学专有名词）就会越加越大，无法收敛，又称发散

参考上面的动图，带入负数，明显越来越大呀？其实这里和定义域的选取有关，黎曼$\zeta$函数只有在 $s>1$ 的时候能求出值（收敛），这个函数才有意义，那么定义域外的情况怎么处理呢？

如果你对黎曼猜想研究过，可能看过类似的结论 $\zeta(-2n) = 0$ 和 $\zeta(-1) = -\cfrac{1}{12}$ ，这又是为啥呢？

定义域扩展到复数

在传统的定义域中，就是把 $s$ 作为输入带入黎曼$\zeta$函数，重新映射到数轴上的另一个数上，如下面的动图所示。如果你很好奇为什么这个级数的和是 $\cfrac{\pi^2}{6}$，这个数从何而来，另一篇博文会解答这个问题（3B1B的另一个视频的总结笔记），我会晚些时候更新

黎曼做了一个扩展，他说：如果 $s$ 能取到复数会是一种什么情况呢？先添加一个复平面，并另 $s=2+i$，过程参看下面的动图

所谓定义域扩展其实非常好理解：之前 $s=1$，它是一个实数。现在让 $s = 2 + i$ ，变成一个复数，这就是复数域扩展

❓这里可能会出现两个问题 ➜ ① 什么是复平面？ ② $\left(\cfrac{1}{2}\right)^{2+i}$ 怎么计算？几何含义是什么？

复平面

复数是拥有实部和虚部的表示法，写为 $a + bi$ ，$a$ 为实部，$b$ 为虚部， $\sqrt{-1}$ 定义为 $i$，称为虚数单位 。而复平面（complex plane）是用水平的实轴与垂直的虚轴建立起来的复数的几何表示，如下图所示（来源维基百科）

研究复数有什么意义？其中有一点和我们这个主题有关，$i$ 虚数单位和幂指数函数勾连起来在复分析中能连接上旋转这个概念。具体来说，参看我的这篇【直观详解】让你永远忘不了的傅里叶变换解析博文

虚数单位为幂指数

这一小节的思路非常重要，不仅仅对理解黎曼猜想有帮助，对信号分析，傅里叶变换等也非常有帮助

$2^x$ ，这个 $x$ 就是幂指数，$2^i$ 即虚数单位为幂指数

第二个问题，我们可以把 $\left(\cfrac{1}{2}\right)^{2+i}$ 拆开写成 $\left(\cfrac{1}{2}\right)^{2}× \left(\cfrac{1}{2}\right)^{i}$ ，前面一半很好理解，关键是后面一半怎么理解

这里涉及到一个非常基础并且十分重要的理念：复平面中，纵轴（虚数部分）的幂指数函数的映射关系代表的是旋转。一下子不懂没关系，下面有通过两幅动图来帮助理解，如果还是有疑惑并且十分想了解，参看博文复平面和旋转

首先，下面这副动图表示，假设我们把指数 $i$ 前加一个自变量 $t$ ，就构造了一个函数 $f(t) = \left(\cfrac{1}{2}\right)^{ti}$ ，可以看到左边的黄色点在纵轴（虚轴）上移动，表示的就是引入一个自变量

接着，我们把左边的输入带入 $f(t)$ 得到右边的output像空间，即 $\left(\cfrac{1}{2}\right)^{ti}$ 的值。会有下面一副动图所示的对应关系（移动黄色点，粉色点作为输出联动）。如果改变底数 $\cfrac{1}{2}$ ➜ $\cfrac{1}{9}$ ，左边黄点移动的时候，右边粉点的旋转速度变快，这就是幂指数函数在复数域上的映射规律

总结一下，以上对两个问题的阐述是为了建立一个直观概念：幂指数是虚数单位的乘法对应了复平面内的旋转，接下来一张动图就来看看 $\left( \cfrac{1}{2} \right) ^{2+i}$ 是怎么算的：（关注红色线段，即最后的结果）

① 实部把点收缩到 $\cfrac{1}{4}$ 的位置

② $\left( \cfrac{1}{2}\right)^i$ 不改变长度（因为是虚部），只旋转一个对应的角度

⭐️一步一步可视化

进行旋转

下面这副动图非常重要！先把实部部分加起来，再对每一项还需要乘一个 $(\cfrac{1}{2})^i$ ，也就是每一个线段都需要进行一个同样角度的旋转

这副动图可以多看几遍，应该是挺好理解的。这里有个很细节的问题：第一段线段没动，是不是意味着没有进行旋转呢？，对应相乘的部分是 $1^i$ ，这可能意味着这个旋转恰好是转过了一圈（时间有限，未能求证，大概率是这样理解）

接下来的动图展示了在 $s$ 变化的过程中，对应的螺旋线的变化情况，这幅动图看的有点上瘾

考虑定义域的话，实数部分要能收敛：即在下图右侧黄色高亮区域， $s$ 的实部大于1

变换黎曼$\zeta$函数

理解这个复函数一个好方法是通过变换来将其可视化，即将复函数看作变换，为了加深理解，在变换黎曼$\zeta$函数前，先变换一个比较简单的函数
$$
f(s) = s^2
$$
按照下面的动图，带入 $2$ 得到 $4$ ，带入 $-1$ 得到 $1$ ，带入 $1i$ 得到 $-1$

最后把所有的网格都标记彩色，下一幅动图同时变换网格上所有的点，形成新的网格：

同时观察所有点的变换比较吃力，你可以尝试在看的时候关注一个点的变化过程，比如关注 $(-1, 0)$ 这一点：它逆时针旋转了180° 。这副动图给了我们丰富的信息来直观的展现复函数变化到底做了什么

同理，可视化黎曼$\zeta$函数，如下列动图所示

如果这么漂亮的图像都完全无法激起你继续钻研复分析的兴趣，那么……

难受的停顿

你可能已经发现了，变换的图像左边有一个十分突兀的切面，停顿的很不自然，整个图像一场明显的表露除了一种希望冲破定义域的渴望

那么，我们专门高亮两条线：虚部等于 $i$ 和 $-i$ 的两条横线，然后进行变换。难道你没有冲动去补全它吗？

解析延拓

可以去想象，在 $Re(s)=1$ 的左半边，有一个改良版的函数（即下图蓝紫色的函数），可以完美的补全整个空间

用数学的形式来表示的话，问题就变成了，在左边一半的定义域内，这个函数是什么的问题，如下图（Re表示实部）

此时，我们就可以可视化出开篇提到的那个表达式 $\zeta(-1) = 1 + 2 + 3 + \cdots = - \cfrac{1}{12}$ ，你现在知道这个公式怎么来的了，因为钻了定义域不同函数形式不同的空子，其实上面这个式子的论断是很荒谬的

新的问题又出来了，补全的部分，如果没有条件限制，随便怎么画都行，补全这条路难道走不通?

真的是这样吗？并不是，黎曼$\zeta$函数自带一个限制（约束）条件：函数是解析函数，补全部分形式处处可导

这里有一个更加优雅的方法来理解处处可导（解析）这个条件

我们先来看 $f(s) = s^2$ ，它的导数形式是 $f’(s) = 2s$ ，在可视化部分来看，处处可导等价于变换后任意两条线段的夹角不变，又称保角（保证交角不变）特性，参看下图

这个规律在所有网格线中都成立，所以，解析的 = 保持交角不变，即可以把解析的理解成保角的。如果你是一个追根究底的人，就能发现其实还是有例外的，比如在原点的交角变换后呈整数倍的关系，没有保角特性

下面给一副平移的动图，解析函数处处保角

黎曼$\zeta$函数就是一个保角函数，或说解析函数，网格出处垂直，处处可导

因为黎曼$\zeta$函数是一个解析函数，那么要想在左定义域延拓，又要满足解析的性质，有且仅有一种延拓方法，这也是解析延拓的含义

可视化黎曼$\zeta$函数总结

按照解析延拓的方式进行了补全操作后，我们就走完了黎曼$\zeta$函数的可视化过程了，总结一下逻辑链

另，这里补充左半边延拓的解析形式，数学家们已经给出了解
$$
\zeta(s) = 2^s{\pi}^{s-1}\sin(\frac{\pi s}{2})\Gamma(1-s)\zeta(1-s)
$$

素数规律和黎曼猜想

再看黎曼猜想

在有了上述的直观理解后，我们再反回来看看黎曼猜想

有了变换的思维后，那么在这个变化后哪些点会落在原点呢？这个问题非常关键，因为它和求黎曼$\zeta$函数的零点等价

首先，所有满足 $Re(s) = -2n$ 的点都会落在原点，这些点被称为平凡零点（根据数学家的传统，他们太容易被发现了，太好理解了，所以被称为“平凡”）

那么非平凡零点呢？我们已知所有的非平凡零点都落在下图的这个临界带（Critical Strip）中。至于原因，如果再仔细看一下这个复数域可视化变换所有点移动的趋势，大概就知道为什么这么说了，简单来说，是复分析变换计算出来的结果

更加令人不可思议的是，这些非平凡零点的具体分布，蕴含着有关素数的海量信息。至于为什么有素数的海量信息，之后会写一篇博文讲讲这其中的奥妙（3B1B的另一个视频的总结笔记）

黎曼猜想就是在说：这些非平凡零点，都在实部 $Re(s)=\cfrac{1}{2}$ 的这条临界线（Critical Line）上，如下图所示。如果它成立，那么它能让我们深刻理解素数分布的规律，根据最新进展中和其他证明，这个规律应该符合某种分布的均匀分布

假设在变换过程中高亮 $Re(s)=\cfrac{1}{2}$ 这条线，以我们可以看到的可视化区域（就是动图中前面跳动的一下的部分）的变换过程如下图所示，貌似它并没有过零点？

其实不然，这个动图只绘出了可视区域内的线段的变换结果，如果我们把这个线段加长（不理解可以参考上面的动图，黄色就是可视化时候原图像的线），就得到了下面一个动图了

其中，如果你能证明所有的非平凡零点都在这条临界线上（也就是原命题中的 $\cfrac{1}{2}$），那黎曼猜想变成黎曼定理！同时你也证明了成百上千的现代数学结论，当然，还有100万美元的奖金

有趣的是，现在很多现代数学理论的证明，不管黎曼猜想是正确还是不正确都能被证明是正确的。看到一个叫做littlewood定理的证明就是这样，可算是数学奇妙的冰山一角了

素数规律

之前提及黎曼猜想中蕴含着海量的素数信息。并在开篇有说到，1900年希尔伯特的23大难题中，黎曼猜想、哥德巴赫猜想和孪生素数猜想同为第8题，寻找素数（分解质因数后只有1和他本身的数），素数分布的规律，质因数分解，还有复分析之间一定是有千丝万缕的联系的

建议大家可以观看李永乐老师的黎曼猜想第二期视频，将素数规律讲的非常好，我这里就当好学生，做一些笔记

素数个数

素数到底有多少个呢？这个问题已经被确定回答了，答案是有无穷多个。那是谁证明的呢？由欧几里得（他是公元前300年的人）证明，使用的是反证法，怎么说的呢？

设质数的个数是有限的，那么就有一个最大的自然数 $p$，可以写成一个素数序列： $2,3,5,\cdots,p$，令
$$
q = 2×3×5×\cdots × p + 1 \tag 1
$$
① 假设 $q$ 是质数 ➜ $q\gt p$ 这和 $p$ 是最大的质数这个假设矛盾

② 假设 $q$ 是合数（不是质数的数） ➜ $q$ 是有约数的，不是1也不是它本身 ➜ 那就一定是(1)式中 $2×3×5×\cdots × p$ 中的某一个，但是由（1）式可得，$q$ 除以$2×3×5×\cdots × p$ 中任何一个数都余1 ➜ 所以肯定不能整除，与假设 $q$ 是合数矛盾

证毕。这个证明简洁而优雅，数学之美牛皮

欧拉乘积公式

神人欧拉（1707-1783）出现，推导出了欧拉乘积公式，怎么个说法呢？

假设 $p$ 表示全体素数，有下面一个公式成立
$$
\prod\limits_{p} (1-p^{-s})^{-1} = \frac{1}{1-\cfrac{1}{2^s}}×\frac{1}{1-\cfrac{1}{3^s}}×\frac{1}{1-\cfrac{1}{5^s}}×\cdots = \cfrac{1}{1^s}+\cfrac{1}{2^s}+\cfrac{1}{3^s}+\cdots
$$

那这个公式有什么用呢？它告诉我们，黎曼函数和质数之间有隐含的关系。左边是和所有质数有关的项的乘积，右边是黎曼$\zeta$函数

素数定理

假设有这么一个表达式 $\pi(x)$ 表示小于 $x$ 素数的个数，有这么一个规律，参见下图

啥意思呢，横坐标就是自变量 $x$ 的取值，蓝色的线是 $\cfrac{\pi(x)}{\frac{x}{\ln(x)}}$ ，红色的线是 $\cfrac{\pi(x)}{\int_{2}^{x}\frac{1}{\ln t} dt}$ ，分母的 $\int_{2}^{x}\cfrac{1}{\ln t} dt$ 又被称成 $Li(x)$

可以看到，当 $x \to +\infty $ ，这个 $\pi(x)$ 函数是可以写出表达式的

二号神人高斯（1777-1855）研究了一下关于素数密度 $\rho$ 的问题，也就是1000个数里面，有多少个素数。对的，上面蓝线的规律是高斯最早发现，但当时高斯觉得这个发现貌似并不重要，就没有展开来研究。后来1798年勒让德（1752-1833）发现了下面那个红色曲线的表达式，在学界有个涟漪，高斯在1849年就告诉勒让德，你这不行，是我先发现的啊，所以这公式被称为高斯-勒让德公式
$$
\pi(x) \sim \frac{x}{\ln x} \iff \pi(x) = \int_{0}^{x} \frac{dt}{\ln t} + C
$$
$\sim$ 符号表示趋近于，也就是当 $x \to +\infty $ 的意思。 $C$ 是一个常数，这个常数随着 $x$ 的变大而越来越小

再观察上面的图，明显发现红色的线收敛到1的速度更快，所以后面科勒（1870-1924）做了改进和提高。他说，如果黎曼猜想成立（写到这句话可是真不容易），那么这个关系误差式可更加精确，可大大改善素数定理误差的估计
$$
\pi(x) = Li（x）+ O(\sqrt{x}\ln x)
$$
$O()$ 被称为渐进符号，一般用来描述无穷级数的余项。在计算和表示算法复杂度方面也很用，比如$O(n^2)$ 其实就是忽略 $n$ 一次项和常数项的意思。因为在 $n$ 非常大时， $n$ 一次项对数值的贡献在量级上远小于 $n^2$ 二次项。这个余项的常数项的具体数值还没有算出来

之后50年，这个素数猜想被证明了出来，变成了素数定理。有趣的是，这份证明只是数学家研究黎曼猜想的边角料

素数，自然底数，虚数单位 $i$ 之间一定是存在的一些难以名状的关联，现在看来，有没有可能是量子力学叠加态在数理逻辑推理中的一种巧合的具象模式呢？静待未来，让数学家们给我们一个答案吧。胡适先生说过：哪管它真理无穷，进一寸有一寸的欢喜，切实能感同身受，可能就是这辈子最大的幸事之一了吧？

后记和思考

就在写作这篇博文的过程中，爵士阿蒂亚的证明过程的手稿已经公布（有点存疑是草稿，原文里面竟然有错别字weakly ➜ weekly），公开大会也已经结束，一张PPT证明黎曼猜想，有点诡异

但其中提及黎曼猜想和量子力学的关联给了我一些启发：素数和微观世界的规律一定有某种关联（在级数和等于 $\cfrac{\pi^2}{6}$ 部分的可视化解说里面就有很奇妙的规律关联）

无极生太极，其小无内，其大无外也，两面都是宇宙本源的运行规律，中华民族老祖宗《易经》已经有这种思维方法了，一面是精细结构常数，一面是引力常数

参照弦理论，高维度空间坍缩在很小的尺度内。那能不能猜想，正因为微观世界和高维度尺度更接近，导致被影响的程度也不一样，引力才一直没有统一（而其他三个力的规律已经统一）。相对应的，大尺度上的规律因时间尺度的限制（宇宙的寿命），我们作为人类从观测角度上来说，尺度太小。如果等葛立恒数年后，引力部分也会有一个类似微观世界的规律被发现呢？

这篇文章提到引力常数 $g$ 更加令人疑惑，是不是可能这个常数本身就是由两个量构成？大的那个符合微观规律，细调的那个因为观测受限（尺度太小）我们无法找到佐证的依据？现在人类追求佐证和实验，有没有可能这条路本身就是障碍？

最后还是希望直观详解这个系列能激起更多人的好奇心就心满意足了，附上一份目录

博客目录汇总（更新中）

【参考和来源】

所有动图来自：3B1B的视频【官方双语】黎曼ζ函数与解析延拓的可视化
李永乐老师1+2+3+4+…=-1/12？李永乐老师讲黎曼猜想（1）Youtube
质数有多重要？数学家欧拉和高斯是如何研究质数的 ？李永乐老师讲黎曼猜想（2）
wiki百科黎曼猜想

最后，和3B1B视频一样，来个看完彩蛋：黎曼$\zeta$函数的导数的可视化动图

结构化笔记软件：幕布

介绍

愿景

提升信息承载物的表意维度，掀起结构化记录的清单革命

表意维度

语言，文字，图片，音频，视频都是信息的载体。但语言和文字有一定局限性，具有认知方言特性

【认知方言】有着不同认知的人在看待同一个表意词汇，句子，段落时可能理解出来的重点，含义是不同的

• 苏格拉底一生未留下文字，他的著作都是由学生柏拉图等进行转述和记录。他认为写作是不可信的
• 孔子的学生子贡也说：“夫子之言性与天道，不可得而不闻也”。一些思维，一旦写成文字或多或少会产生一些误解和歧义

核心思路和愿景

我为什么要做这个总结，并且分享？

内容精炼

TED内容精炼推荐，给你有价值的内容，帮你省下选择的时间，我虽然并不能收钱，但是总结过程本身就是我学习的过程，何乐而不为，独乐乐不如众乐乐。

同时这也是对自己知识架构的健壮和拷问，在不断的学习和重复中，能把这些技巧和内容慢慢变成自己的洞见。不断的生产内容，是一种难得的锻炼

分享者才是最大的收获者！我一直笃信这一点

知识数据库

TED内容再整理，方便查阅，方便检索，方便重复，最终能变成你知识体系的一部分

这个时代最重要的就是数据，这一些内容也是我个人生产的数据源头，我把它称之为【知识数据库】，只有不断的重复，才能接近智慧

演讲才是精髓

TED演讲，还是在演讲上，只有听，才能感受到它的价值：声音的艺术，交流的艺术，表达的艺术，新颖的观点和出色的内容都在演讲这个核心之后

幕布是内容的良好承载物

本篇文章非常适合用幕布的形式进行呈现，这里给出链接，欢迎大家分享这个链接，并且最重要的也是这个链接，我强烈建议从这个链接去观看整篇文章（这篇博客更多的文案是为了我自己关于TED演讲推荐知乎回答做的准备）

作为幕布的开发者，布道幕布这种层次化梳理的表现知识承载形式，好的内容是有层次的，应该有更统一的，更直观的，更多维度的内容承载形式。也就是设计幕布七哲学的核心意义

幕布七哲学

TED演讲推荐

【01】下一个科学界大突破是什么

• 【体量】
  • 68主题 | 1440字 | 视频时长 10:51
  • 视频链接
• 【内容】
  • 以三个生物学界的发明和不断进步的故事为主线
  • 围绕生命科学的技术突破给出了自己的观点
  • 文稿精华总结笔记
• 【推荐点】
  • 演讲风格有魅力，用词精准漂亮
  • 内容上三个故事都有趣味性，但观点上见仁见智

【02】游戏奖励大脑的七种方式

• 【体量】
  • 66 主题 | 1137 字 | 视频时长 16:02
  • 视频链接
• 【内容】
  • 总结游戏设计哲学，提到十分精练的7个原则：用进度条度量进程 | 长期与短期目标 | 奖励成就 | 清晰反馈 | 不确定因素 | 提升注意力窗口 | 好胜心
  • 文稿精华总结笔记
• 【推荐点】
  • 用词十分漂亮，值得学习
  • 观点很有借鉴意义，从游戏角度来看事物本来就是对人性的一种挖掘

【03】未来这台电脑会帮你种菜

• 【体量】
  • 67 主题 | 1322字 | 视频时长 15:56
  • 视频链接
• 【内容】
  • 全新的农业模式，建造数字农场来连接全世界的粮食产业，可以结合大数据互联网等，提高农业的种植效率，强烈推荐！
  • 文稿内容总结笔记
• 【推荐点】
  • 非常有创造力的想法，不得不感叹，这世界有太多人在尝试去做一些伟大的任务，远远超出了我们想象
  • 可以帮助你去了解未来世界的可能面貌

【04】下一次工业革命就在眼前

• 【体量】
  • 51主题 | 812字 | 视频时长 12:27
  • 视频链接
• 【内容】
  • 下一次工业革命的基本特征进行的阐述，观点角度简练新颖
  • 文稿内容总结笔记
• 【推荐点】
  • 对整体工业化未来高科技领域有兴趣的读者可以关注
  • 观点简介明了，有启发意义

【05】人工智能将如何推动第二次工业革命

• 【体量】
  • 142主题 | 4412字 | 视频时长13:44
  • 视频链接
• 【内容】
  • 凯文凯利就《失控》《必然》几本书种的几个主要观点进行了阐释
  • 主要说明这是一个变革的时代，我们有三点认知需要认清：到底什么是智能 | AI会推动第二次工业革命 | 我们要和AI协作，不是对抗
  • 文稿内容总结笔记
• 【推荐点】
  • 无论是演讲技术，还是文案，都十分引人深思
  • 从头到尾到泛着大道至简的简约美感，强烈推荐！

【06】区块链将如何改变金钱与贸易

因为整理者是区块链行业者所以只有简单的笔记

• 【体量】
  • 23主题 | 241字 | 视频时长 18:49
  • 视频链接
• 【内容】
  • 什么是区块链，区块链有什么应用，区块链的价值在何处
  • 文稿内容总结笔记
• 【推荐点】
  • 关于区块链的内容非常丰富，适合不太了解区块链并想要被布道的人
  • 例子通俗易懂，能让人对区块链有一个自己的主观认识

【07】怎样说话人们才会听

• 【体量】
  • 79主题 | 1603字 | 视频时长 9:55
  • 视频链接
• 【内容】
  • 有关如何说话，总结说话七宗罪：流言蜚语 | 评判 | 消极 | 抱怨 | 借口 | 说谎 | 固执己见
  • 四个说话的正面HAIL：诚实 | 真实 | 正气 | 爱
  • 还有6个用来增强说话力量的工具，音域 | 音色 | 韵律 | 语速 | 音调 | 音量
  • 文稿内容总结笔记
• 【推荐点】
  • 演讲教科书，声音运用自如，语言精炼，用词精彩，强烈推荐！
  • TED观看排名第六（2800万+）

【08】如何成为一个更好的交谈者

• 【体量】
  • 136主题 | 5664字 | 视频时长 11:44
  • 视频链接
• 【内容】
  • 总结了十条成为更好交谈者的要点：不要三心二意 | 不要好为人师 | 使用开放式问题 | 顺其自然 | 不知道就是不知道 | 不要以己度人 | 尽量别重复 | 少说废话 | 认真倾听 | 简明扼要
  • 文稿内容总结笔记
• 【推荐点】
  • 演讲技巧和文稿结构同样值得推荐，整个论证过程严丝合缝，举例子 + PPT整合，是一场教学式演讲
  • TED观看人数排名靠前的演讲，强烈推荐！

【09】学校扼杀创造力

• 【体量】
  • 151主题 | 8656字 | 视频时长 19:22
  • 视频链接
• 【内容】
  • 对学校教育进行了深刻的思考，培养人才需要：多样化 | 充满活力 | 个性化，对现有的体系进行了深刻的批判
  • 文稿内容总结笔记
• 【推荐点】
  • TED观看人数排名第一的演讲（5000万+），强烈推荐！
  • 整个演讲过程十分风趣幽默，充满了西方式幽默哲学

【10】为什么好的领导者会让你感到安全

• 【体量】
  • 139主题 | 5408字 | 视频时长 11:56
  • 视频链接
• 【内容】
  • 内容也充实，例子有力量，主要提及了如何才能提升领导力
  • 归纳来说，还是同理心和自身强大的毅力和美好品，承担困难的超强能力
  • 文稿内容总结笔记
• 【推荐点】
  • 展现了精湛的语言发声艺术和演讲技巧，煽动性相当强
  • 举例子虽然不新颖，但是整体表达的方式值得学习

【11】姿势决定你是谁 - Amy Cuddy

• 【体量】
  • 134主题 | 7205字 | 视频时长 21:56
  • 视频链接
• 【内容】
  • 文稿内容总结笔记
  • 演讲中提到了姿势了力量，个人实践表示，是100%有效果的
  • 更高层次的说也就是转念的力量，是一种心理学暗示。只是通过了姿势这种对激素分泌有影响的具象形式表示出来，相信其实更加重要
• 【推荐点】
  • TED排名第二观看的演讲（4700万+），强烈推荐！
  • 虽然在中段稍显结构松散，但是这个演讲最厉害的是真诚和打动人的能力，让您感受到被震撼的力量，内容本身放佛已经不再那么重要，一次演讲能做到让人心潮澎湃，当真厉害！

【12】伟大的领袖如何激励行动

• 【体量】
  • 207主题 | 8909字 | 视频时长 17:58
  • 视频链接
• 【内容】
  • 黄金圈法则的出处（Why How What 思考模式），虽然视频古老，但是内容实沉
  • 文稿内容总结笔记
• 【推荐点】
  • TED观看数量第三的演讲（3900万+），强烈推荐！
  • 演讲技巧也十分有煽动性，节奏清晰
  • 观点上有超强的启发意义和智慧系统贯通的满足感，因为道法自然，说道深处，很多方法论都是相同的，无论是西方还是东方的，都是如此

首先，这个问题属于计算机科学领域。解决这个问题才是区块链最大的价值所在，因为这个问题一直是分布式系统的重要难题之一

什么是拜占庭将军问题

这个问题的定义者是图灵奖获得者，Lamport大神，分布式系统的关键性奠基人之一。有面包店算法，拜占庭将军问题，Paxos算法等著名成果

问题描述

9个将军带领9支军队，打一场攻城战役。假设每个将军都能独立根据眼前战况做出两种判断：进攻或撤退，要求（或者最终目的是）如何让这9个将军的命令是一致的（一致性，即共识）？要么一起进攻，要么一起撤退（每个将军之间也是互不信任的，也有消灭对方的动机）

最简单的策略即：投票（上图中的红色箭头和绿色箭头为每个将军做出的判断），超过半数支持某个决定，那么所有9个将军一定执行这个决定。如上图，5个将军决定进攻，4个将军决定撤退，那么所有将军都会下令：进攻！

这种策略需要每个将军把自己的判断通过一种途径（途中灰色箭头）传递到所有其他将军处。相对的，每个将军只有在收到了所有投票结果后，才会下令。如上面的例子，所有将军得到投票：4进攻5撤退，才下令撤退

这个投票策略的最大问题：假设出现了叛徒，如上图所示，会出现两种情况

• 【1】对自己位置的战场情况进行错误广播（比如他这个地方优势很大，但是投票给撤退）
• 【2】可以选择靠给不同的将军送去不同的消息破坏整体决定的一致性（导致左边四个将军选择撤退，右边四个将军选择进攻）

问题总结

此时总结一下，拜占庭问题的问题到底是什么：

• 所有将军如何才能达成共识去攻打（或撤退）城堡

根据相关的研究，得出一个【一般性的结论】：如果叛徒的数量大于或等于三分之一 ，那么拜占庭问题不可解，这个三分之一也被称为拜占庭容错，三模冗余是完全无法容错的（也就是说无解，不可能保持一致性）

解释方法使用副官模型即可

推广到计算机系统内，【将军】类比为【计算机】，而计算机因为物理或被感染等其他原因造成的【运行异常】就是【叛徒】，其实整个问题也是为了保证分布式系统的一致性和可用性

传统解决方案

在区块链之前，有两种解决方案：口头协议（又称为拜占庭容错算法）和书面协议

通常来说，大多数分布式系统使用的是书面协议确保一致性，中心机构背书。其中有实用拜占庭容错算法（PBFT）最为有名

PBFT概述

这个算法说起来也不难理解，他的核心思想是：对于每一个收到命令的将军，都要去询问其他人，他们收到的命令是什么。也就是说利用不断的信息交换让可行的节点确认哪一个记录选择是正确的，即发现其中的背叛者

采用PBFT方法，本质上就是利用通信次数换取信用。每个命令的执行都需要节点间两两交互去核验消息，通信代价是非常高的。通常采用PBFT算法，节点间的通信复杂度是节点数的平方级的

白话PBFT

还是用上面的将军的例子来举例，但为了方便我们把问题的定义稍作修改

【问题定义】总共4个将军，有1个是叛徒，每个将军需要在自己的战斗计划中添加一行内容 <什么时间>进攻

【目标】只需要3个将军达成一致在同一时间进攻，就可以攻占城市，否则进攻者全军覆没。最终目标还是统一一个一致的战斗计划，并按照计划同时实施（在去中心化系统中，即【记录】的一致性）

【方法】对于每一个收到命令的将军，都要去询问其他人，他们收到的命令是什么。在判断不出判断者的情况，执行更多的那个命令

【可视化直观】

其中每个将军投降下方的数字就是收到的攻击事件列表，在该规则下，可以看到能保证，当叛徒数量小于1/3维护系统的一致性，即无论是什么情况，都可以防止不一致的决定被执行（至少也是按兵不动，并且很容易定位叛徒是谁）

注意，在这种仅有4个节点的情况下看似复用信道和传递消息的数量不多。但随着结点的增加，时间复杂度和信道使用量级是节点数的平方。大规模网络基本瘫痪，效率太低

区块链解决方案

我们知道，区块链最强的地方就在于它的一致性（了解区块链原理，可移步另一篇博客 一文看懂区块链：一步一步发明比特币），同时这正是拜占庭问题的核心

案例拆解

我们先假设你已经完全了解了比特币区块链的运行原理，那么我们一步一步建立一个场景看一看区块链是如何解决拜占庭将军问题？

我们先假设信道一定是可靠的，传令兵死亡之类的事情我们不考虑，毕竟在一个非常复杂的网络中，还可以通过多条的方式连接任意两个节点，可靠性还是值得相信。主要破坏一致性的还是心怀不轨的【间谍】，或者总结为：如何防止【间谍】对整体决策（进攻还是撤退）进行破坏？

我们按照区块链模型构造一个下图所示的系统

每个将军本地都存储一份【记录】：记录所有将军的决定，比如“1：1”代表1号将军决定进攻

然后构造以下协议内容：

• 使用数字签名保证身份可可信
• 所有将军参与挖矿，国王以保证战役胜利为缘由，出资，奖励每一个挖到新区块俩的将军
• 每一个将军当本地维护的最新确认【记录】中包含了所有1-9号将军的决定后，正式做出自己的决定

在这个案例中，抛弃了代币的设定，因为不存在交易行为，而是由国王出资（保证战争不被间谍影响，我认为国王应该愿意出这笔钱）。在拜占庭时期，因为没有网络，构造上述这样的系统，是完全不可能的。而现在网络链路速度，效率越来越高，让区块链解决一致性问题得以解决

这里就引出了现在区块链的核心问题：应用场景与代价博弈。你要解决的痛点，到底值不值得这样的花费呢？无论是算力消耗，还是资源消耗，亦或是类似于上述案例中的国王出资（区块链代币价值为负数？），都是一种【代价】。完全的信任是不存在的，只有当造假（走捷径获得利润）的成本远远高于得到的利润，才能取得信任（一致性）

必须强调，在传统的拜占庭问题构造的情景中，只能是一个例子，这个应用情景是完全没有没有必要使用区块链来解决的！

总结

互联网技术的存在，让传输过程中，基本没有延迟（或说延迟很小可以基本忽略），解决了通讯延迟的问题

区块链使用链型数据结构 + 算力互相制约使得作假的成本随着时间的加长呈指数上升，解决了一致性问题。当然非对称秘钥部分的密码学，解决了身份确认问题

至少这个系统解决的问题不仅仅是金融领域，去中心化银行系统的问题所在，交易，其实只是其中很小的一部分

区块链共识算法

因为技术还在不断发展，可能有其他的算法被建立，但是只要谈到共识这个问题，核心一定是【中心化】和【去中心化】的权衡（Trade-off），而对应的就是效率，可以这么说，一致（信任）是需要成本的，这是本源法则，和线性向量空间的定义处在同一个层级

中本聪很厉害的地方就在于，之前的分布式一致性算法（PBFT）对大体谅节点系统的支持非常差，效率上来说，基本和无法实现是等等同的

下面的思维导图展示了现在基本的区块链共识算法总结

分布式一致性算法

即这篇文章前面提到的拜占庭容错。在此基础上，发展出的Paxos是理论上的高效算法，很难实现。而Raft是由Google牵头开发一个Paxos理论实现版本

【去中心化】【大规模节点无法支持】【效率低】

投票机制

其中有两个比较有名的【RPCA Ripple共识】【DPOS 股权代理人共识】，在规则和协议上稍有不同，但是核心的Idea还是使用类似人大代表选举的制度来保证新区块的产生不会由同一个人控制，即代表轮流挖矿

NEO使用的是【DBFT】，投票的拜占庭容错算法，算是结合了几个算法的优势和思路，也很有想法！容错能力和PBFT一样，但是效率更高，信道使用冗余更低

【半中心化】【大规模节点支持】【效率高】

PoW 工作量证明

最早的共识算法，使用算力来资源消耗来实现共识，详细方法见一步一步发明比特币

为了对抗ASIC矿机等专业化HASH算力硬件，也有一些PoW引入了内存HASH等禁止ASIC算力的方法。但是万变不离其中，最终还是归一化到一个【每Hash Rate/法币花费】博弈和平衡中

【PoC Proof of Capacity】容量证明，挖到区块和你的硬盘空间正相关

【去中心化】【大规模检点支持】【效率低】【资源消耗高】

PoS 权益证明

新建区块和你拥有的币的数量呈正相关，类似于利息的激励方式，可以参看权益证明

更多的【PoA Proof of Activity】活动证明，是一种Pow+PoS混合共识方式，基本被证明不靠谱了，提及一下

【去中心化】【大规模节点支持】【效率中】

其他

【PoET Proof of Elapsed Time】消逝时间证明：Intel使用HyperLedger建立的锯齿（Sawtooth）项目使用。在一种收信任的执行环境下保证随机的选择用户来生产区块，间隔时间提前约定。很奇怪的Idea，只适合于联盟链

总结

欢迎各位读者留言提示更多的不同共识算法，讨论交流，共同进步！

【完】

本篇博客为形象展示傅里叶变换和欧拉公式与初等群论两个视频的笔记结合，希望通过此篇让所有读者对傅立叶变换有一个全新的认知，并且宣传一波 3b1b 良心视频系列！重塑对未知和知识的渴求

知乎相关问题链接，小伙伴们求点赞！没有功劳也有苦劳啊！

欧拉公式与旋转

在开始一步一步接近【傅立叶变换】前，先说一下群论

提前说明，此部分有地方会提到【群论】这个概念，但博主并不是要试图把什么环、域、向量空间、代数结构、线性代数群、李群等等一大堆很抽象的概念灌输给大家，我们只是为了利用群论的概念，加深或者说建立一个对【理解傅立叶变换】极度有帮助的直观概念：

指数函数（逆操作对数函数同理）是加法和乘法运算的桥梁，在自变量包含复数时表示旋转

以具体的一个例子来说：

$e^{\pi i}$ 表示的是在单位圆上逆时针在旋转180°这个变换

等等，这不是排行世界上最伟大的十个公式第二名的欧拉公式（上帝公式）嘛？（BTW，我们今天的主角【傅立叶变换】排行第七，这阵容着实强大）
$$
e^{\pi i} + 1 = 0
$$
是的，这第一部分，捎带，会带你更进一步的重新认识这个公式的伟大

对称性 symmetry

首先，假设我们有以下陈述：

正方形是对称图形

那么从数学（定义 or 公式）角度上来说，怎么描述【对称】这个概念呢？我们作为【人】，肯定会想，不就是看着左右一样嘛？不够严谨，不够优雅，继续深入，可以这么考虑：

你能对正方形做些什么，并且在这个操作后，保持正方形的形态和操作前相同

我们把具有上述性质的操作都列出来，放在一起，如下面动图所示（左右旋转90°，旋转180°，四个轴对称，不变，这八个操作），就构成了一个有限群【对称群】，更专业的叫法是【八阶二面体群 Dihedral group of order 8】

此时，能观察和总结出一个现象：按照顺序应对一个正方面进行8个操作的某两个，恰好等同于8个操作中的其他的某一个（旋转群同理）。如下面的动图所示，把这些组合放到一起，才真正的表达了【群】这个概念

把这个数轴的概念拓展到平面坐标系，1D ➜ 2D。如果我们要把一个点，比如（1,0）移动到另一个点，应该如何操作？简单的说，只需要先在横轴方向上平移，再在纵轴方向上平移即可（核心思想类比于正方形的几个操作）

同理，除了平移外，使用伸缩加旋转也可以完成同样的事情（将任意一点移动到另一个位置），伸缩是乘法显而易见，但是旋转怎么表示呢？（当然直接改变坐标轴的定义也是能做到的，例子就是极坐标系，但我们并不想这么做），考虑构造以下思考链条：

1. 想做到把一个点变到另一个点：即从（1,0）通过伸缩和旋转到（-1,0），长度不变，只旋转就能实现

2. 此时，注意到了一个形式很有特点的定义： $-1 = i \times i$ ，-1 就是我们需要的目标位置，那如何从（1,0）出发进行两次同样的操作可以得到（-1,0）呢？（这个操作即 $i$ 这个虚数单位定义的操作）答案即：一个单位 $i$ 表示旋转90°即可

3. 更意外的发现，进行一次 $i$ 操作，如果是逆时针旋转90°，正好会落在二维平面y轴的（0,1）与单位长度不谋而合

4. 更大胆的假设，如果y轴自带虚数单位，如 $i,2i,3i……$ ，就有旋转操作了，是不是就就能通过乘法来描述处在这个平面上的所有变换了？

以上都是假设和推理，剥丝抽茧后，最关键的部分：如何使用单位 $i$ 表示逆时针旋转90° ，并且给出了一种可能的映射规则，x轴平移表示伸缩，y轴平移表示旋转，这样就可以保证群的特性？（几种操作一定可以组合成其他某个操作，有一个学名：保持群结构）

$i$ 怎么可能表示旋转呢？怎么看都不像啊，陷入僵局。那么不妨换个角度来思考，旋转到底是什么？

旋转，是沿着一个圆弧（有圆心，转过的角度）运动的过程

如果你对泰勒公式非常熟悉（不熟悉没关系，点开连接看看呗？），就可通过一系列公式推导（下面就是）得到一个完美桥梁：【指数函数】，形如 $f(x) = a^x$

如果底数 $a = e$ ，通过泰勒展开式，可完成一个十分优美的变形，如下：

将 $x = i\theta $ 带入（1）式（这里的 $\theta$ 是一个未知数，即自变量），整理项，移动，结合 $cos(x)$ 和 $sin(x)$ 的泰勒展开式，还有虚数单位的定义 $i \times i = -1$ ， 有下列推导：

这个公式有什么用呢？可视化后，如下图所示

假设纵坐标自带虚数单位 $i$ （复平面），那么，$sin(\theta)$ 为纵坐标（自带虚数单位 $i$ ），$cos(\theta)$ 为横坐标，则可以发现： $e^{i\theta}$ 表示一个圆心在原点，半径为1的单位圆（图中是 $\alpha$ ，因为作图软件的限制，换不成 $\theta$ ，但不影响）

$e^{i\theta}$ 这个公式等价于一种旋转，$\theta$ 为旋转角的度数（统一单位，弧度制，即把°转换成实数）$\theta = 2\pi$ 即为360°，是单位圆

我们已经优雅的找到了这个桥梁（链接平移和旋转），接下来仔细研究一下它意味着什么

指数函数 Exponentiation

指数函数有一个非常重要的特性：加法变乘法，即 $a^{x+y} = a^x \times a^y$

也就是说通过指数函数，可以做到使用平移变换来描述伸缩变换，这具体是什么意思呢？参考下面的动图

注意，所谓可以变的意思是说，加法运算可以成立，意味着先往左平移1单位，再往右平移一单位，组合起来的左右就是往右平移一到位（$-1+2 =1$，群论的保持结构特性），而乘法运算成立也要满足这个特性

复平面 Complex Plane

至此，构造复平面，把虚数单位 $i$ 加到纵轴上。我们就同时拥有了伸缩和旋转，最关键的是，有了这两个操作，我们同时也可以维持群的特性（使用乘法）

如下面动图所示，在复平面内，以指数函数为桥梁，实轴横向平移对应伸缩，虚轴纵向平移对应旋转

横坐标红线，横向平移映射到伸缩操作的可视化

纵坐标虚数单位，纵向平移映射到旋转操作的可视化，正为逆时针旋转

现在使用的桥梁是底数为2的指数函数 $f(x) = 2^x$ ，我们知道 $e^{i\pi}$ 代表的半个圆周，我们希望把底数变成 $e$ ，这样更加方便表达圆的概念

每走一个单位的纵向位移，在圆周上旋转的圆弧长度就是1，参照下面的动图，$e^{\pi i}$ 恰好代表逆时针旋转180°，并且落在的位置为（-1,0），这就是欧拉公式，或者说是欧拉公式的几何直观可视化

总结

这第一部分到底干了啥？其实就是想建立一个观念（或者说常识）

$e^{x}$ 在复平面，或者说 $x = ai$ （a为某个常数，就是弧度制的圆周长度）代表的变换是：旋转

如果你之前学过傅立叶变换，那么会明白为什么需要花费这么大篇幅来讲这个，因为公式中， $e^{i\pi}$ 那是可是相当重要的一部分啊

傅立叶变换

正式进入傅立叶变换的部分，老规矩，先做一下基本信息整理

什么是傅立叶变换

首先，还是先弄清楚我们理解的目标是什么

傅立叶变换（如果不加限定，这个词对应的是连续傅立叶变换）
傅立叶级数

傅立叶变换还有很多其他的内容：离散时间傅立叶变换，离散傅立叶变换，傅立叶逆变换，快速傅立叶变换等，进一步的拉普拉斯变换，小波变换，z变换等

公式表示

傅立叶变换，变换作用是时域映射到频域，公式是长这样的：

很多时候，这里的 $\hat f(\xi)$ 会写成 $F(w)$ 或 $F(f)$ 表示角速度或者频率，当然后面的公式的量纲也需要对应的修改；后面的自变量 $x$ 大多数时候都是写成 $t$ 表示时间。当然，他们表示的都是同一个东西

联想链条

既然是为了【理解】和【记忆】，那么我们还是需要定义一个联想链条：

傅立叶变换 ➜ 分解声音的过程

这么抽象实在是因为拆字法真的很难联想出什么东西来（傅里叶？变换？嗯，很难的样子），只能这样了。

接下来就是精华部分：3b1b的傅立叶变换讲解内的核心内容！在笔记完成后，会给出结合直观理解的完整联想链条，目的当然是【让你永远忘不了】喽，点题！

【看到】傅立叶变换

声音的表示

我们是如何记录声音的呢？如果你测量的是扬声器旁的气压，那么它会是一个随时间以正弦函数形态不断震荡的图像，一个标准音 A（下图黄色），它的频率是440Hz，表示每秒钟振动440次，比它低一些的D（下图紫红），是294Hz，振动的慢一些。如果这两个音同时发出，产生的气压随时间曲线怎么决定呢？如下动图，其实就是把所有时间点的振幅加起来

可视化方法

首先，假设我们有一个每秒钟3拍子的声音信号（440Hz实在太快了），它的图像如下（Intensity为强度，可以同理成气压），并且，我们只关注前面的4.5秒（即图像中画出来的部分）

绕圈记录法：同一事物的不同角度

千万不要眨眼！下面是最关键的一步，是【看到】傅立叶变换的核心部分，如下面动图所示

• 首先把黄色曲线缠绕到一个圆上，大小就是原本信号的振幅
• 圆周围的图像由白色的箭头绘制而成，速度可变，上图中的白色箭头移动速度是每秒钟转过半圈（这个速度是对于下面的圆形图像来说，每秒钟在圆形图像中转半圈），对应上面的则是虚线表示一圈走到的位置，0.5拍子/秒
• 此时，有两个频率在起作用，一个是信号的频率：3次震荡/秒，另一个是图像缠绕中心圆的频率，为0.5圈/秒，第二个频率可以自由改变，相当于一个变量，下面的动图直观的展现了缠绕速度变化时的可视化表现

其实，我们只是把一个水平的轴缠绕到一个单位圆上，并用另一个速度的记录标尺（白色箭头）来画图，从另一个角度（维度）来看我们的信号

质心记录法：新维度的特征提取

虽然新图像挺好看的，但是现在感觉并没法从中看出什么。也不尽然，我们直观的发现，当白色箭头记录的速度在某些特定的值时，画出来的图形非常稳定，形态清晰。那如何表现这个特征呢？

从两个角度来思考

（1）自变量是什么？（输入特征）

输入是一个可变化的转圈速度，既然可变，不妨把它看作自变量，即 $f(x)$ 中的 $x$

（2）输出（新的圆圈图）有什么特征？（输出特征）

观察到，当图像很混沌（没有规律，混乱的）时候，图像基本关于原点对称；稳定时，其实是“头重脚轻”的。描述“头重脚轻”最好的方法当然是用【质心】（它描述了物体的空间分布特征） ，下面的动图直观展现了质心特征对图像特征的描述能力（红色点为质心）

【输入（横坐标）】➜【进行采样的（白色箭头）的绕圈速度】

【输出（纵坐标）】➜【圆圈图的质心位置的横坐标】

按照上面的说明来记录绘出图像，记录每个缠绕频率（速度）对应的质心位置，参看下列动图，随着图像的绘制到3圈/秒这个位置的时候，是不是感到似曾相识呢？

好！有了这个工具，先把它应用到两个声音的组合图像中看看效果：（这是我最喜欢的一张动图）

公式表示

大家也发现了，我们已经通过这样一个缠绕机器完成了时域到频域的转换，总得来说，参看下面的动图

第一步：旋转的表示

如下面的动图所示，在这个工具中，非常关键的就是转圈，即表达旋转这种运动，根据第一大部分，这个桥梁，就是复平面，其背后的原理是指数函数结合泰勒公式

第二步：缠绕的表示

首先，依据下面的动图所示，在傅立叶变换中，我们规定旋转是顺时针的（规定只是为了统一标准，并且有时候也会考虑书写简洁和方便计算），所以先加一个负号。假设原来的函数是 $g(t)$ ，将两者的幅值相乘就能得到缠绕图像， $g(t) e^{-2 \pi ift}$ ，可以说是相当机智了！

第三步：质心的表示

那如何表示质心这一概念呢？粗略想一下感觉挺难的，但是看起来很难的问题，有一种解决问题的途径是【演绎推理】，先从简单的特例出发，推广到一般，最后证明正确性即可

考虑如何求一个正方形的质心位置，我们只需在边框上取n个等距离分布的点，并且算这几个点的位置的平均值。那么推广到一般情况，也使用类似的采样点的方式解决，如下面动图所示（紫红色的点即采样点），得到 $\frac{1}{N} \sum\limits _{k=1}^N g(t_k) e^{-2 \pi ift_k} $

最终步：整理积分限和系数

看到常数项系数 $\frac{1}{t_2 - t_1}$ ，如果忽略表达倍数关系的系数，对应的含义也会发生变化，不再是质心，而是信号存在的时间越久，位置是质心位置乘以一个倍数，它的值就越大。参看下面的动图，持续时长为3秒，那么新的位置就是原来质心位置的三倍；为6秒，就是原来的6倍

补充

相位

在表示质心的时候，我们只取用了x轴坐标，下面的图中的蓝色曲线就是纵坐标（y轴 or 虚部）的可视化,红色曲线是横坐标（x轴 or 实部）

原信号的长度

再追根究底一些，因为之前已经提到过，假设我们的信号有4.5s。

那么考虑原信号的长度的变化呢？首先，假设信号的长度很长，那么缠绕圆上的线就会更多，每次接近稳定图像质心的变化速度更快（即频域图像更加密集），参看下面动图

另外，可以自己思索一下，比如无穷时间的周期时域信号呢？又比如一个恒定振幅（一个电平）的时域信号呢？其实这里就给出了一个提示有关为什么傅立叶变换有那么多需要考虑的变形了，因为在缠绕这件事情发生的过程中，有几种情况是特别的（这部分3B1B视频并没有讲解，可能需要未来再更新了）

总结

讲了这么长，至此全部结束。估计读者都已经晕了，那么，在这里为【看到】傅立叶变换做一个总结，就来总得说说我们从头到尾都干了些啥？参看下面动图

• $e^{2\pi i}$ 表示单位圆，添加自变量即可表示旋转

• 与原函数相乘缠绕到单位圆上

• 为求质心的特征，进行积分计算

一步一步写出傅立叶变换公式的联想链条

• 一个逆时针旋转360°画成的圆 ➜ $e^{2\pi i}$

• 表示运动，需要原函数的自变量，时间 $t$ ➜ $e^{2 \pi i t}$

• 表示旋转速度，需要自变量，频率 $f$ ➜ $e^{2 \pi i f t}$

• 规定变换的采样方向为顺时针，加负号 ➜ $e^{-2 \pi ift}$

• 乘以原函数缠绕到单位圆并记录 ➜ $g(t) e^{-2 \pi ift}$ （此处使用 $g$ 符号标识原函数是为了和频率符号 $f$ 做区分）

• 为了计算质心特征，积分 ➜ $\int_{-\infty}^{+\infty} g(t)e^{-2\pi it \color{red}{f}}dt$

• 自变量为频率 $f$，写出函数表达式 ➜ $\hat g(\color{red}{f} \color{black}{) = \int_{-\infty}^{+\infty} g(t)e^{-2\pi it \color{red}{f}}dt}$

本篇博客回答知乎问题怎样更好的理解，并且记忆泰勒展开式？ （求点赞^_^）

For me, mathematics is a collection of examples; a theorem is a statement about a collection of examples and the purpose of proving theorems is to classify and explain the examples

John B. Conway

对于我而言，数学就是范例的集合——定理是为了描述范例，证明定理是为了分类并解释范例

约翰·B·康威

微积分的本质 - 10 - 泰勒级数

在遇到一个生僻的概念或者公式时，确认它的几种不同的表述形式（马甲）是很重要，也就是定义问题：我们到底要了解的东西是什么 ＆ 怎么称呼：

泰勒公式（也叫 泰勒展开式、泰勒多项式）
泰勒级数

它是微积分学下的一个重要概念，与之有关联的有：如泰勒定理，多元泰勒公式，以拉格朗日型余项为代表的各类余项，审敛法，牛顿差值公式（牛顿级数）（列出为了进行树状知识整合和梳理）

什么是泰勒公式

基本定义

数学定义，公式各个部分代表什么含义先说清楚

$f^{(n)}(a)$ 表示 $f(x)$ 在第 $n$ 阶导数的表达式，带入一个值 $a$ 计算后得到的结果（注意，它是个值）
$\frac{1}{n!}$ 是一个系数（一个值），每一项都不同，第一项 $\frac{1}{1}$，第二项 $\frac{1}{2!}$ …… 依此类推
$(x-a)^n$ 是一个以 $x$ 为自变量的表达式

求和符号去掉展开写即第二行
$R_n(x)$ 是泰勒公式的余项，是 $(x-a)^n$ 的高阶无穷小（此处先不解释，听起来很牛逼，但是跟随例子看完就发现并没有什么玄乎的）

个人粗浅总结，初学者产生记不住的感觉大多数情况下是没有沉下心来想想公式的各部分表示的是什么东西，梳理一下会清晰很多

联想链条

所有的 ＜内容＞➜ 符号都表达【由＜内容＞联想到】（一种牢固记忆的技巧）

联想链条是为了给你一把一个长期记忆的钥匙，很久不用之后，估计只能记住【泰勒公式】四个字了，如何利用这仅有的信息回忆起具体的理解和内容，除了理解透彻，直观，利用图像外，弄一个联想链条也是不错的方法

首先拆字

【公式】 ＜什么公式？＞➜ 【多项式】（Polynomials），把多项式的一般形式写出来，这应该是非常容易理解的概念，即指数不仅仅为2的抛物线的组合

【泰勒】＜谐音“太乐” ≈ 如果所有小数都能近似成整数那不是太快乐了？＞ ➜ 近似，获得一个直观理解

• 泰勒公式通过把【任意函数表达式】转换（重写）为【多项式】形式，是一种极其强大的函数近似工具

为什么说它强大呢？

• 多项式非常【友好】，三易，易计算，易求导，易积分
• 几何感觉和计算感觉都很直观，如抛物线和几次方就是底数自己乘自己乘几次

泰勒公式干的事情就是：使用多项式表达式估计（近似） $f(x)$ 在 $x = a$ 附近的值

那么如何近似呢？使用一个例子来加深理解

怎样理解泰勒公式

我们要干的事情，就是改变多项式函数 $P(x) = c_0 + c_1x + c_2x^2$ 中 $c_0, c_1, c_2$ 的值

（只有三项是为图个方便）去近似余弦函数 $f(x) = cos(x)$ ，【近似过程】参考下面的动图

我们需要做的事情（目的）即寻找一条绿色的曲线（多项式的系数 $c_0, c_1, c_2$），在 $x = 0$ 附近（0为上面提到的 $a$）尽可能的与 $f(x) = cos(x)$ 的图像相似（重合）

函数式角度

那如何才能找到这三个参数呢？最为显而易见的做法就是希望在 $x=0$ 的位置，两个表达式的切线尽量相等，切线即斜率，也就是求导，比较抽象，一步一步来可视化一下

近似过程

• 【确定 $c_0$】$x=0$ 带入公式，令 $cos(x) = 1$ ，同理对 $P(x)$ 可以得到 $c_0=1$

• 【确定 $c_1$】容易观察到，如果对 $P(x)$ 求导就可以把 $c_1$ 前的自变量去掉。并且，$x=0$ 处 $P(x)$ 已经固定为1，为了更进一步的相似，如果我们让 $x=0$ 处的 $f(x)$ 和 $P(x)$ 的切线斜率也相同不就更近似了？（两种思考模式我觉得都可以） 求导之后可以的到 $c_1 = 0$

  

• 【确定 $c_2$】现在我们已经确定两个值，那么绿色曲线就只能如下图一样移动（固定了 $x=0$ 的函数值和 $x=0$ 处的斜率 ），为了更接近相似的目标，我们希望斜率在变化的过程中，速度也是近似的（滑动的白色和黄色直线）。求二次导数，斜率的变化率相等，确定 $c_2 = -\frac{1}{2}$

  

此时得到表达式 $P(x) = 1 - \frac{1}{2}x^2$ ，检测一下近似度如何？$cos(0.1) \approx 1 - \frac{1}{2}(0.1)^2 = 0.995$ 同时计算器 $cos(0.1) = 0.9950042$ ，其实只取前几项的多项式已经在 $x=a$ 附近的近似这一要求上有很好的效果了

为什么这个【近似过程】写的这么详细，是为了在过程中体会两个关键点

为什么使用多项式来近似

因为多项式的求导法则可以控制变量，消去低次项，使得 $x=a$ 未知的 $c_n$ 容易确定，在之前的例子里，如下图所示

$c_0$ 确保了 $x=0$ 时相等，$c_1$ 确保了 $x=0$ 时的斜率相等，$c_2$ 确保了 $x=0$ 时斜率的变化率相等，或者说，随着多项式幂次变高，这种近似就越精确

为什么有个系数 $\frac{1}{n!}$

阶层系数是由一次一次的求导产生的。我们再把项数加两个，参看下图，直观的感受一个 $n!$ 的诞生

首先，低次项会变为0，这样可以很方便的通过计算 $f(x)$ 的 $n$ 次求导的表达式，带入 $x=a$ 即可得到 $c_n$ 的值，阶层其实是多次求导的系数

函数角度总结

其实，某一点处的导数值信息 $\iff$ 那一点附近的函数值信息 这个直观感觉，是很重要的

• 首先，对于 $cos(x)$ 这个具体例子，把 $x=0$ 位置的多阶导数求出，再使用多项式进行近似，使用的项越多，得到的近似就越准确，参看下面动图

  

• 推广到一般函数 $f(x)$ ,下列动图描述了随着项的增加，$x=0$ 附近的越来越准确

  

• 最后，推广到 $x=a$ 的情形，完全推导出泰勒展开式的一般形式，如下列动图所示

  

几何角度

首先定义一个函数表示求下列图像中函数图像中填满部分的面积，函数为 $f(x)$ ，面积函数为 $f_{area}(x)$ ，而围成面积区域的曲线即为面积函数的导数 $\frac{df_{area}}{dx}(x)$ （至于为什么是这样，有一个牛逼的名字叫做，微积分基本定理： $\int_{a}^{b}f(t)dt = F(b)-F(a)$ ，没那么玄乎，在3B1B的另一个视频内讲解的相当直观。博主也可以写那一期的博客，如果要求的读者多的话），如下图所示

定义一个这样的场景是为了计算这样一件事（如下图所示）：假设我们知道了 $f(a)$ 点的面积，往右扩展很小的距离 $dx$ 要算出新部分的面积（左边绿色已知 + 黄色矩形 + 红色三角形），公式会是什么样的呢？

设 $dx$ 开始点为 $a$，终点为 $x$ ，则可以得到

• 【黄色矩形】底边为 $x-a$ ；高为 $\frac{df_{area}}{dx}(a)$ ；
• 【红色三角形】底边为 $x-a$；高的计算稍微麻烦，首先，斜边的斜率是 $\frac{df_{area}}{dx}(x)$ 函数的导数在 $x=a$ 时的函数值（算斜率，求导数即可），而斜率 $k = \frac{y}{x}$ ，所以得到高为 $\frac{d^2f_{area}}{dx^2}(a) \times (x-a)$ （前部分是斜率，后半部分是 $x$ ，需要求的是 $y$ 也是高）
• 【计算总面积】如下图和公式所示

这个公式为啥这么眼熟呢？其实明显就是泰勒展开式的前3项，如果你还要打破沙锅问到底，第4项呢？你可以放大红色三角形，把函数曲线和面积之间的空白部分再次用多个更小的三角形填补，在积分工具的帮助下，可以得到三次项

从几何角度来看，再一次验证了，泰勒公式是近似的 $x=a$ 附近的函数值这一直观理解

余项

我们知道，对泰勒公式来说，并没有办法完全逼近待求函数，所以无论如何到最后都会留一点东西，这剩下的东西不好表达，就全都丢到余项中

可以暂时如此理解，不在此迷惑，如果是专业学生，需要深究，建议参看专业教材深入理解其中玄妙

泰勒级数

完成对【泰勒公式】的理解后，需要对【级数 Series】这个概念进行一个推广，什么是【级数】呢？

在数学中，【级数】就是无限多项的和

在把泰勒展开式，扩展到无限项之后，就会出现【收敛 Converge】和【发散 diverge】的概念

收敛

收敛，即在泰勒展开式被推广到无限项之后，整体式子的值会越来越趋近于一个定值，比如下图的 $\frac{1}{2}$ 和 $e$

发散

与收敛相对应的，即发散，式子无法趋近于一个定值，比如 $ln(x)$ 在 $x=1$ 附近，如下图所示，虚线即为能够让多项式的和收敛的最大取之范围，称为【泰勒级数的收敛半径】

总结

• 泰勒公式干了一件什么事？

使用多项式表达式估计（近似） $f(x)$ 在 $x = a$ 附近的值

• 泰勒公式的导数项如何推倒出来的？

某一点处的导数值信息 $\iff$ 那一点附近的函数值信息

• 泰勒公式如何记永远不会忘？

参照第一条总结，是 $x=a$ 附近，公式 ➜ 多项式，很多项，要用求和写在一起；参照第二条总结，近似信息用的求导；系数就是对 $x=a$ 处求导一次一次放下来；OK，开始写！

并不知道写的对不对，翻到上面Check。OK，很完美，收工！

问题描述

对于微信跳一跳来说，问题描述很直观

问题描述

• 【玩游戏的心态】游戏本身有没有什么小技巧？
  • 特殊的加分技巧有哪些？
  • 如何才能不紧张？
• 【解题目的心态】每一次【跳跃】如何不掉下去？
  • 每一跳，看到目标墩后，需要按多久？
  • 目标墩和小人的距离是多少？

游戏机制

考虑到这是一个【按得时间越久，跳的距离越远的游戏】，也就是说：不摔死才是王道！问题描述已经如此明了，依次解决就好

加分机制

【1】特殊墩。停留2s，可加对应分数

【2】连击跳。连续中心点，+2 +4 …… （是个人都知道）

【3】快速跳。落地之后马上起跳，可以在下一次落地即使也从+1变为+2

按压时间与跳跃距离

直说结论，微信跳一跳的按压时间和跳跃距离是大约线性关系（根据其他大神的验证和精确测试，并不是完美线性关系）

打开声音，在蓄力的过程会有嘟嘟声，两次声音之间0.105秒左右，而每次跳跃的距离可以用尺子量出来。拟合（找一条直线看看是否能正好通过所有的点）后是个直线

写成公式的话为
$$
按压时间 = k \times 目标墩中心和小人的距离
$$
其实只要针对你的手机把这个k拟合出来就好（iOS，非Plus系列，k = 2.045）

设计原则

对于游戏设计来说，一款优秀的【休闲游戏】一定要满足三点

• 核心规则简单
• 容易失误
• 回报和难度成正比 + 随机奖励

所以，跳一跳能火爆，除了好友圈（这里包含微信强大的整合推广能力）之中的攀比心理，更是在这三点都做的相当出色

解决方案

不是每个人都闲着没事做去搞得那么复杂来玩这个游戏，只有两种人会这么做，一种好胜心装逼心爆炸的，另一种就是吃饱了撑着（估计我是两者兼而有之），所以根据现根据前一种人来说，给出的解决方案就是【技巧上】

技巧

游戏技巧当然是利用【比较容易达成】的手段来减少失误的方法，这款游戏考验的核心节奏感，控制力

【节奏感】

大家都知道默数一分钟这个游戏吧

能完美默数60s，并且每一秒差距都不大的同学，在这部分就有很高的天赋了。当然还有学乐器，长时间锻炼的同学也是

【控制力】

也叫手残部分。你的APM（每分钟操作次数）速度，控制自己手的能力都考虑其中。

有个游戏是掉尺子抓住，看谁抓的位置更靠上，控制力包含对手的掌控力+反应速度，在这个游戏能取得很棒成绩的同学，你的得分肯定不会低

当然，所有这两点，都是可以通过不断的锻炼（花时间疯狂跳）来提高（这和花时间练琴才能弹的越来越好是一个道理）。只是有些人提高的快，有些同学可能提高的慢，而且很不幸，这种提升是一个Logistic曲线（有天花板）

天赋这东西就是这样，你在这里不擅长，太正常不过。每个人天赋都在不同的领域，所以放宽心才是王道，别太较真（跳一跳跳出一场轰轰烈烈的人生，我的天）

以下就是一些小技巧

用纸贴住分数

紧张和手不稳是【失误】的最大元凶，所以贴住分数有奇效

建立自己的模型

个人建议自己把距离分为4类

• 很近（人和墩基本贴起来，一看就觉得好近）
• 很远（看起来就远的那种）
• 介于两者之间但是靠很近
• 介于两者之间但是靠很远

在新墩出现的时候，先用0.5秒分一个类

【4类】原则，宁愿多按一点不少按

【1类】原则，蜻蜓点水千万不多

【2 3类】是最容易出问题的类别，如果失误，根据【第二设计原则】，太正常，如果太容易高分，成就感也会被压缩到很小，所以这是必须的，大侠从头来过就好

小墩

对于遇到看起来非常小的墩（小药瓶，天崩地裂）

首先，不要虚，个人虽然没有验证，但是小的目标，感觉能跳上去的阈值也会大一些（或说磁铁or吸附效应），只要按照4分类模型来跳，上垒的可能性还是挺高的

多跳

用时间积累，就和练钢琴是一个套路，身体的肌肉根据你看的图像产生反应，如果已经成为一种自然反应，分数肯定不会低

正常方案

解决这个问题，就是计算目标墩中心和小人的距离，那么目标墩的位置（目标位置），和小人的位置（起跳点位置）就是待求量

但是这些正常方案都需要在每一跳花费一定时间，非大毅力者不可为

听音法

量距离 ➜ 查表 ➜ 专心听 ➜ 数嘟嘟声 ➜ 到次数放

（不做评价，累）优势是如果每次都很准，+32 +64 可能都不是梦想吧？

滑动屏幕法

然后，匀速的速度是 5.1 cm/s

（这个方法，感觉比靠感觉更容易失误）这个方法并没有每次都可以跳到中心的特点，个人感觉这个网站找到的方法有点做负功

程序方案

市面上很多的【外挂】或者说【脚本】基本都是这个方案，还有一些直接截包的可能更加暴力一些

手机和电脑交互方法

电脑手机连接起来，并且手机可以和电脑交换数据（API），比如电脑可以控制按压时间，电脑可以控制手机截图之类的基本交互操作

Android有adb工具，iOS有WebDriverAgent

算法流程图

截图 ➜ 算出小人位置 ➜ 算出目标墩位置 ➜ 计算按压时间 ➜ 利用API操控手机按压 ➜ 跳

其实流程图非常简单，直接单线程就搞定了（没有循环结构和分支结构，都不用用其他软件画了）

主要如何计算小人位置，和计算目标墩位置两部分是关键

多尺度搜索

利用OpenCV，图像处理，可以把所有小人抠图出来和图像进行匹配，最后选取置信度最高的，找出小人位置。代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

def multi_scale_search(pivot, screen, range=0.3, num=10):
    H, W = screen.shape[:2]
    h, w = pivot.shape[:2]

    found = None
    for scale in np.linspace(1-range, 1+range, num)[::-1]:
        resized = cv2.resize(screen, (int(W * scale), int(H * scale)))
        r = W / float(resized.shape[1])
        if resized.shape[0] < h or resized.shape[1] < w:
            break
        res = cv2.matchTemplate(resized, pivot, cv2.TM_CCOEFF_NORMED)

        loc = np.where(res >= res.max())
        pos_h, pos_w = list(zip(*loc))[0]

        if found is None or res.max() > found[-1]:
            found = (pos_h, pos_w, r, res.max())

    if found is None: return (0,0,0,0,0)
    pos_h, pos_w, r, score = found
    start_h, start_w = int(pos_h * r), int(pos_w * r)
    end_h, end_w = int((pos_h + h) * r), int((pos_w + w) * r)
    return [start_h, start_w, end_h, end_w, score]

目标墩也可以使用类似的方法。只是要想办法减小搜索空间，加速。因为目标墩的数量还是比较多的。还可以搜索那个中心的小白点，速度越快越准（主需要等那个白点出现就好）

机器学习方案

为什么题都已经解了，还需要深究呢？这里主要目的是【提高用户体验感】，考虑到繁多的手机种类和尺寸，特别是iOS中截图的图像压缩问题，需要一套更加稳定的算法，机器学习算法就应运而生了

输入

经过裁剪的截图，只保留小人和目标墩（包含关键信息即可，做法使用OpenCV颜色为界，和小人位置为界即可），最终图像大小为 640*720 像素点

输出

两个值，目标墩的位置【x，y】（小人位置使用多尺度匹配搜索效率足够高了）

模型结构

考虑是图像处理。选择卷积网 - CNN，5层，基本规模，训练完成模型体积约700M

训练数据

根据跳一跳截图大约3000章，保证包含所有目标墩的形态，并且使用多尺度算法进行标注（所谓标注就是算出目标墩【x，y】值，并记录，和这幅图匹配起来）

模型增强

第一层网络经过数据训练后误差在10像素以内。为了进一步提升精度，之后，以此点中心，根据原训练图，再截图320*320大小的图片，同时加入像素偏移（噪声，防止过拟合），再次利用另一个CNN来训练计算坐标

Pipeline示意图

最终结果

小于1像素，Inference时间0.5秒左右

Trick

由于微信的反作弊系统，需要添加一些人为随机因素绕过反作弊系统，基本思路

• Target_pos + 正态分布随机数，保证连跳次数最多5-6次
• 间隔时间为>2s的随机数
• 按压位置随机

至此，微信跳一跳算是通关了。倒腾不息，生命不止。游戏中学习，兴趣中学习是我辈福气！

游戏是放松的一种方式，这种休闲游戏的好处就是，上瘾不易，每个人都有自己的天花板，每周刷新后跳跳看看可能会变成常态，总之孔子说的好，过犹不及

【参考文献】

思路借鉴于知乎相关问题下的回答

代码借鉴Prinsplield大神的AI跳一跳项目，只添加绕过反作弊系统的代码

感谢大神们提供的学习资料！

版本信息：更新到7.07b

升级效果

推荐出的英雄

推荐英雄

其中，有质变效果的：

远古冰魄，发条技师，干扰者，谜团，祈求者，光之守卫，莉娜，瘟疫法师，暗夜魔王，帕克，帕格纳，暗影恶魔，暗影萨满，工程师，伐木机，树精卫士，维萨吉，术士，巫医，嗜血狂魔，米拉娜，司夜刺客，不朽尸王

看情况出的英雄

看情况出

无A帐效果

无A帐效果

新版本中加上小小，石鳞剑士，邪影芳灵无A帐效果

在之前的详解：深入浅出看懂AlphaGo中，详细定义的DeepMind团队定义围棋问题的结构，并且深入解读了AlphaGo1.0每下一步都发生了什么事，就在最近，AlphaGo Zero横空出世。个人观点是，如果你看了之前的文章，你就会觉得这是一个水到渠成的事情

另，如果你只对这个事件感兴趣的，而不想了解论文和技术细节，链接奉上，欢迎跳过到最后评论和总结部分（但这部分网上的大牛太多了，知乎答案内最高票对结合围棋的分析很漂亮！建议阅读）

上限置信区间算法（UCT），一种博弈树搜索算法，是AlphaGo中一个重要组成部分：MCTS搜索算法中的核心

法国南巴黎大学的数学家西尔万·热利(SylvainGelly)与巴黎技术学校的王毅早(YizaoWang，音译)将UCT集成到一个他们称之为MoGo的程序中。该程序的胜率竟然比先前最先进的蒙特卡罗扩展算法几乎高出了一倍。

2007年春季，MoGo在大棋盘比赛中也击败了实力稍弱的业余棋手，充分展示了能力。科奇什（UCT算法发明者）预言，10年以后，计算机就能攻克最后的壁垒，终结人类职业棋手对围棋的统治。今年是2017年，AlphaGo系列横空出世。10年，总有着天才的人具有先知般的远见。详见UTC算法

【小发现】看完论文发现，这篇文章的接受时间是2017年4月7号，审核完成时间是2017年9月13号，而在乌镇对阵柯洁（2017年5月23号）用的可能是AlphaGo Master（这里没法证据来证明到底是AlphaGo Zero还是AlphaGo Master）。这个团队也是无情啊，人类再一次感觉被耍了，根据Elo得分，Deepmind团队可能在赛前就透露过吧，即使是Master也有4858分啊，对于一个棋手来说，我感受到的是风萧萧兮易水寒决绝的背影。为柯洁的勇气打Call，当真围棋第一人，天下无双

论文正文内容详细解析

先上干货论文：Mastering the Game of Go without Human Knowledge ，之后会主要以翻译论文为主，在语言上尽量易懂，避免翻译腔

AlphaGo Zero，从本质上来说完全不同于打败樊麾和李世石的版本

• 算法上，自对弈强化学习，完全从随机落子开始，不用人类棋谱。之前使用了大量棋谱学习人类的下棋风格）
• 数据结构上，只有黑子白子两种状态。之前包含这个点的气等相关棋盘信息
• 模型上，使用一个神经网络。之前使用了策略网络（基于深度卷积神经网）学习人类的下棋风格，局面网络（基于左右互搏生成的棋谱，为什么这里需要使用左右互搏是因为现有的数据集不够，没法判断落子胜率这一更难的问题）来计算在当前局面下每一个不同落子的胜率
• 策略上，基于训练好的这个神经网，进行简单的树形搜索。之前会使用蒙特卡洛算法实时演算并且加权得出落子的位置

AlphaGo Zero 的强化学习

问题描述

在开始之前，必须再过一遍如何符号化的定义一个围棋问题

围棋问题，棋盘 19×19=361 个交叉点可供落子，每个点三种状态，白（用1表示），黑（用-1表示），无子（用0表示），用 $\vec s$ 描述此时棋盘的状态，即棋盘的状态向量记为 $ \vec s$ （state首字母）
$$
\vec s = (\underbrace{1,0,-1,\ldots}_{\text{361}})
$$
假设状态 $\vec s$ 下，暂不考虑不能落子的情况， 那么下一步可走的位置空间也是361个。将下一步的落子行动也用一个361维的向量来表示，记为 $\vec a$ （action首字母）
$$
\vec a = (0,\ldots,0,1,0,\ldots)
$$
公式1.2 假设其中1在向量中位置为39，则 $\vec a$ 表示在棋盘3行1列位置落白子，黑白交替进行

有以上定义，我们就把围棋问题转化为。

任意给定一个状态 $\vec s$ ，寻找最优的应对策略 $\vec a$ ，最终可以获得棋盘上的最大地盘

简而言之

看到 $\vec s$ ，脑海中就是一个棋盘，上面有很多黑白子

看到 $\vec a$ ，脑海中就想象一个人潇洒的落子

网络结构

新的网络中，使用了一个参数为 $\theta$ （需要通过训练来不断调整） 的深度神经网络$f_\theta$

• 【网络输入】19×19×170/1值：现在棋盘状态的 $\vec s$ 以及7步历史落子记录。最后一个位置记录黑白，0白1黑，详见
• 【网络输出】两个输出：落子概率（362个输出值）和一个评估值（[-1,1]之间）记为 $f_{\theta}(\mathbf {\vec s}) = (\mathbf p,v)$
  • 【落子概率 $\mathbf p$】 向量表示下一步在每一个可能位置落子的概率，又称先验概率 （加上不下的选择），即 $p_a = Pr(\vec a|\mathbf {\vec s})$ （公式表示在当前输入条件下在每个可能点落子的概率）
  • 【评估值 $v$】 表示现在准备下当前这步棋的选手在输入的这八步历史局面 $\vec s$ 下的胜率（我这里强调局面是因为网络的输入其实包含历史对战过程）
• 【网络结构】基于Residual Network（大名鼎鼎ImageNet冠军ResNet）的卷积网络，包含20或40个Residual Block（残差模块），加入批量归一化Batch normalisation与非线性整流器rectifier non-linearities模块

改进的强化学习算法

自对弈强化学习算法（什么是强化学习，非常建议先看看强化学习的一些基本思想和步骤，有利于理解下面策略、价值的概念，推荐系列笔记）

在每一个状态 $\vec s$ ，利用深度神经网络 $f_\theta$ 预测作为参照执行MCTS搜索（蒙特卡洛搜索树算法），MCTS搜索的输出是每一个状态下在不同位置对应的概率 $\boldsymbol \pi$ （注意这里是一个向量，里面的值是MCTS搜索得出的概率值），一种策略，从人类的眼光来看，就是看到现在局面，选择下在每个不同的落子的点的概率。如下面公式的例子，下在$(1,3)$位置的概率是0.92，有很高概率选这个点作为落子点
$$\boldsymbol \pi_i = (\underbrace{0.01,0.02,0.92,\ldots}_{\text{361}})$$

MCTS搜索得出的落子概率比 $f_\theta$ 输出的仅使用神经网络输出的落子概率 $\mathbf p$ 更强，因此，MCTS可以被视为一个强力的策略改善（policy improvement）过程

使用基于MCTS提升后的策略（policy）来进行落子，然后用自对弈最终对局的胜者 $z$ 作为价值（Value），作为一个强力的策略评估（policy evaluation）过程

并用上述的规则，完成一个通用策略迭代算法去更新神经网络的参数 $\theta$ ，使得神经网络输出的落子概率和评估值，即 $f_{\theta}(\mathbf {\vec s}) = (\mathbf p,v)$ 更加贴近能把这盘棋局赢下的落子方式（使用不断提升的MCST搜索落子策略$\boldsymbol \pi$ 和自对弈的胜者 $z$ 作为调整依据）。并且，在下轮迭代中使用新的参数来进行自对弈

在这里补充强化学习的通用策略迭代（Generalized Policy Iteration）方法

• 从策略 $\pi_0$ 开始

• 策略评估（Policy Evaluation）- 得到策略 $\pi_0$ 的价值 $v_{\pi_0}$ （对于围棋问题，即这一步棋是好棋还是臭棋）

• 策略改善（Policy Improvement）- 根据价值 $v_{\pi_0}$，优化策略为 $\pi_{0+1}$ （即人类学习的过程，加强对棋局的判断能力，做出更好的判断）

• 迭代上面的步骤2和3，直到找到最优价值 $v_*$ ，可以得到最优策略 $\pi_*$

【a图】表示自对弈过程 $s_1,\ldots,s_T$。在每一个位置 $s_t$ ，使用最新的神经网络 $f_\theta$ 执行一次MCTS搜索 $\alpha_\theta$ 。根据搜索得出的概率 $a_t \sim \boldsymbol \pi_i$ 进行落子。终局 $s_T$ 时根据围棋规则计算胜者 $z$
$\pi_i$ 是每一步时执行MCTS搜索得出的结果（柱状图表示概率的高低）

【b图】表示更新神经网络参数过程。使用原始落子状态 $\vec s_t$ 作为输入，得到此棋盘状态 $\vec s_t$ 下下一步所有可能落子位置的概率分布 $\mathbf p_t$ 和当前状态 $\vec s_t$ 下选手的赢棋评估值 $v_t$

以最大化 $\mathbf p_t$ 与 $\pi_t$ 相似度和最小化预测的胜者 $v_t$ 和局终胜者 $z$ 的误差来更新神经网络参数 $\theta$ （详见公式1） ，更新参数 $\theta$ ，下一轮迭代中使用新神经网络进行自我对弈

我们知道，最初的蒙特卡洛树搜索算法是使用随机来进行模拟，在AlphaGo1.0中使用局面函数辅助策略函数作为落子的参考进行模拟。在最新的模型中，蒙特卡洛搜索树使用神经网络 $f_\theta$ 的输出来作为落子的参考（详见下图Figure 2）

每一条边 $(\vec s,\vec a)$ （每个状态下的落子选择）保存的是三个值：先验概率 $P(\vec s,\vec a)$，访问次数 $N(\vec s,\vec a)$，行动价值 $Q(\vec s,\vec a)$。

每次模拟（模拟一盘棋，直到分出胜负）从根状态开始，每次落子最大化上限置信区间 $Q(\vec s,\vec a) + U(\vec s,\vec a)$ 其中 $U(\vec s,\vec a) \propto \frac{P(\vec s,\vec a)}{1 + N(\vec s,\vec a)}$ 直到遇到叶子节点 $s’$

叶子节点（终局）只会被产生一次用于产生先验概率和评估值，符号表示即 $f_\theta(s’) = (P(s’,\cdot), V(s’))$

模拟过程中遍历每条边 $(\vec s, \vec a)$ 时更新记录的统计数据。访问次数加一 $N(\vec s,\vec a) += 1$；更新行动价值为整个模拟过程的平均值，即 $Q(\vec s, \vec a) = \frac {1}{N(\vec s, \vec a)}\Sigma_{\vec s'|\vec s, \vec a \Rightarrow \vec s'}V(\vec s')$ ，$\vec s’|\vec s, \vec a \Rightarrow \vec s’$ 表示在模拟过程中从 $\vec s$ 走到 $\vec s’$的所有落子行动 $\vec a$

【a图】表示模拟过程中遍历时选 $Q+U$ 更大的作为落子点

【b图】叶子节点 $s_L$ 的扩展和评估。使用神经网络对状态 $s_L$ 进行评估，即 $f_\theta(s_L) = (P(s_L,\cdot), V(s_L))$ ，其中 $\mathbf P$ 的值存储在叶子节点扩展的边中

【c图】更新行动价值 $Q$ 等于此时根状态 $\vec s$ 所有子树评估值 $V$ 的平均值

【d图】当MCTS搜索完成后，返回这个状态 $\vec s$ 下每一个位置的落子概率 $\boldsymbol \pi$，成比例于 $N^{1/\tau}$（$N$为访问次数，$\tau$ 为控温常数）

更加具体的详解见：搜索算法

MCTS搜索可以看成一个自对弈过程中决定每一步如何下的依据，根据神经网络的参数 $\theta$ 和根的状态 $\vec s$ 去计算每个状态下落子位置的先验概率，记为 $\boldsymbol \pi = \alpha_\theta(\vec s)$ ，幂指数正比于访问次数 $\pi_{\vec a} \propto N(\vec s, \vec a)^{1/\tau}$，$\tau$ 是温度常数

训练步骤总结

使用MCTS下每一步棋，进行自对弈，强化学习算法（必须了解通用策略迭代的基本方法）的迭代过程中训练神经网络

• 神经网络参数随机初始化 $\theta_0$
• 每一轮迭代 $i \geqslant 1$ ，都自对弈一盘（见Figure-1a）
• 第 $t$ 步：MCTS搜索 $\boldsymbol \pi_t = \alpha_{\theta_{i-1}}(s_t)$ 使用前一次迭代的神经网络 $f_{\theta_{i-1}}$，根据MCTS结构计算出的落子策略 $\boldsymbol \pi_t$ 的联合分布进行【采样】再落子
• 在 $T$ 步 ：双方都选择跳过；搜索时评估值低于投降线；棋盘无地落子。根据胜负得到奖励值Reward $r_T \in \{-1,+1\}$。
• MCTS搜索下至中盘的过程的每一个第 $t$ 步的数据存储为 $\vec s_t,\mathbf \pi_t, z_t$ ，其中 $z_t = \pm r_T$ 表示在第 $t$ 步时的胜者
• 同时，从上一步 $\vec s$ 迭代时自对弈棋局过程中产生的数据 $(\vec s, \boldsymbol \pi, z)$ （$\vec s$ 为训练数据，$\boldsymbol \pi, z$ 为标签）中采样（这里的采样是指选Mini-Batch）来训练网络参数 $\theta_i$，
• 神经网络 $f_{\theta_i}(\vec s) = (\mathbf p, v)$以最大化 $\mathbf p_t$ 与 $\pi_t$ 相似度和最小化预测的胜者 $v_t$ 和局终胜者 $z$ 的误差来更新神经网络参数 $\theta$ ，损失函数公式如下

其中 $c$ 是L2正则化的系数

AlphaGo Zero训练过程中的经验

最开始，使用完全的随机落子训练持续了大概3天。训练过程中，产生490万场自对弈，每次MCTS大约1600次模拟，每一步使用的时间0.4秒。使用了2048个位置的70万个Mini-Batches来进行训练。

训练结果如下，图3

【a图】表示随时间AlphaGo Zero棋力的增长情况，显示了每一个不同的棋手 $\alpha_{\theta_i}$ 在每一次强化学习迭代时的表现，可以看到，它的增长曲线非常平滑，没有很明显的震荡，稳定性很好

【b图】表示的是预测准确率基于不同迭代第$i$轮的 $f_{\theta_i}$

【c图】表示的MSE（平方误差）

在24小时的学习后，无人工因素的强化学习方案就打败了通过模仿人类棋谱的监督学习方法

为了分别评估结构和算法对结构的影响，得到了，下图4

【dual-res】表示 AlphaGo Zero（20个模块），策略头和评估值头由一个网络产生
【sep-res】表示使用20个残差模块，策略头和评估值头被分成两个不同的网络
【dual-conv】表示不用ResNet，使用12层卷积网，同时包括策略头和评估值头
【sep-conv】表示 AlphaGo Lee（击败李世乭的）使用的网络结构，策略头和评估值头被分成两个不同的网络

头的概念详见网络结构

AlphaGo Zero学到的知识

在训练过程中，AlphaGo Zero可以一步步的学习到一些特殊的围棋技巧（定式），如图5

中间的黑色横轴表示的是学习时间

【a图】对应的5张棋谱展现的是不同阶段AlphaGo Zero在自对弈过过程中展现出来的围棋定式上的新发现

【b图】展示在右星位上的定式下法的进化。可以看到训练到50小时，点三三出现了，但再往后训练，b图中的第五种定式高频率出现，在AlphGa Zero看来，这一种形式似乎更加强大

【c图】展现了前80手自对弈的棋谱伴随时间，明显有很大的提升，在第三幅图中，已经展现出了比较明显的围的倾向性

具体频率图见：出现频率随训练时间分布图

AlphaGo Zero的最终实力

之后，最终的AlphaGo Zero 使用40个残差模块，训练接近40天。在训练过程中，产生了2900万盘的自对弈棋谱，使用了310万个Mini-Batches来训练神经网络，每一个Mini-Batch包含了2048个不同的状态。（覆盖的状态数是63亿（$10^{10}$），但和围棋的解空间 $2^{361} \approx 10^{108}$ 相比真的很小，也从侧面反映出，围棋中大部分选择都是冗余的。在一个棋盘局面下，根据先验概率，估计只有15-20种下法是值得考虑的）

被评测不同版本使用计算力的情况，AlphaGo Zero和AlphaGo Master被部署到有4个TPUs的单机上运行（主要用于做模型的输出预测Inference和MCTS搜索），AlphaGo Fan（打败樊麾版本）和AlphaGo Lee（打败李世乭版本） 分布式部署到机器群里，总计有176GPUs和48GPUs（Goolge真有钱）。还加入了raw network，它是每一步的仅仅使用训练好的深度学习神经网的输出 $\mathbf p_a$ 为依据选择最大概率点来落子，不使用MCTS搜索（Raw Network裸用深度神经网络的输出已经十分强大，甚至已经接近了AlphaGo Fan）

下图6展示不同种AlphaGo版本的棋力情况

【a图】随着训练时间棋力的增强曲线

【b图】裸神经网络得分3055，AlphaGo Zero得分5185，AlphaGo Master得分4858，AlphaGo Lee得分3738，AlphaGo Fan得分3144

最终，AlphaGo Zero 与 AlphaGo Master的对战比分为89：11，对局中限制一场比赛在2小时之内（新闻中的零封是对下赢李世乭的AlphaGo Lee）

论文附录内容

我们知道，Nature上的文章一般都是很强的可读性和严谨性，每一篇文章的正文可能只有4-5页，但是附录一般会远长于正文。基本所有你的技术细节疑惑都可以在其中找到结果，这里值列举一些我自己比较感兴趣的点，如果你是专业人士，甚至想复现AlphaGo Zero，读原文更好更精确

围棋领域先验知识

AlphaGo Zero最主要的贡献是证明了没有人类的先验知识机器也可以在性能上超越人类。为了阐释清楚这种贡献来自于何处，我们列举一些AlphaGo Zero使用到的知识，无论是训练过工程中的还是MCTS搜索中的。如果你想把AlphaGo Zero的思路应用的到解决其他游戏问题上，这些内容可能需要被替换

围棋基本规则

无论实在MCTS搜索中的模拟还是自对弈的过程，都依赖游戏最终的胜负规则，并且在落子过程中，根据规则还可以排除一部分不可以落子的点（比如已经落子的点，无法确认在AlphaGo Zero还有气为零的点不能下这个规则，因为不记录气的信息了。但可以写一个函数来判断当前局面 $\vec s$ 下下一步所有可能的落子点，不一定非得计算这个信息，这个过程可以完全多线程）

Tromp-Taylor规则

在AlphaGo Zero中使用的是PSK（Positional Superko）禁全同规则（中国，韩国及日本使用），只要这一手（不包括跳过）会导致再现之前的局面，就禁止。

旋转与镜面

对于围棋来说，几个状态 $\vec s$ 在经过旋转或反射后是完全相同的，这种规律可以用来优化训练数据和MCTS搜索中的子树替换策略。并且因为贴目（黑棋先下优势贴目7目半）规则存在，不同状态 $\vec s$ 换颜色也是相同的。这个规则可以用来使用当前下子的棋手的角度来表示棋盘

除了以上的三个规则，AlphaGo Zero 没有使用其他任何先验知识，它仅仅使用深度神经网络对叶子节点进行评估并选择落子位置。它没有使用任何Rollout Policy(这里指的应该是AlphaGo之前版本的快速走子策略)或者树形规则，MCTS搜索也没有使用其他的标准启发式规则或者先验常识规则去进行增强

整个算法从随机初始化神经网络参数开始。网络结构和超参数选择 见下一节。MCTS搜索的超参数 $c_{puct}$ 由高斯过程优化决定，为了优化自对弈的性能，使用了一个神经网络进行预训练。对于一个大规模网络的训练过程（40个残差模块，40天），使用一个小规模网络（20个残差模块，3天）来反复优化MCTS搜索的超参数 $c_{puct}$。整个训练过程没有任何人工干预

自对弈训练工作流

AlphaGo Zero的工作流由三个模块构成，可以异步多线程进行：

• 深度神经网络参数 $\theta_i$ 根据自对弈数据持续优化
• 持续对棋手 $\alpha_{\theta_i}$ 棋力值进行评估
• 使用表现最好的 $\alpha_{\theta_*}$ 用来产生新的自对弈数据

优化参数

每一个神经网络 $f_{\theta_i}$ 在64个GPU工作节点和19个CPU参数服务器上进行优化。

每个工作节点的批次（Batch）大小是32，每一个mini-batch大小为2048。每一个 mini-batch 的数据从最近50万盘的自对弈棋谱的状态中联合随机采样。

神经网络权重更新使用带有动量（momentum）和学习率退火（learning rate annealing）的随机梯度下降法（SGD），损失函数见公式1

学习率退火比率见下表

动量参数设置为0.9

方差项和交叉项的权重相同，原因是奖励值被归一化到 $r \in [-1,+1]$

L2正则化系数设置为 $c = 10^{-4}$

优化过程每1000个训练步数执行一次，并使用这个新模型来生成下一个Batch的自对弈棋谱

评估器

为了保证生成数据的质量（不至于棋力反而下降），在使用新的神经网络去生成自对弈棋谱前，用现有的最好网络 $f_{\theta_*}$ 来对它进行评估

【评估神经网络 $f_{\theta_i}$ 的方法】使用 $f_{\theta_i}$ 进行MCTS搜索得出的 $\alpha_{\theta_i}$ 的性能（得到 $\alpha_{\theta_i}$ 的MCTS搜索过程中使用 $f_{\theta_i}$ 去估计叶子节点的位置和先验概率，详见MCTS搜索这一节）

每一个评估由400盘对局组成，MCTS搜索使用1600次模拟，将温度参数设为无穷小 $\tau \Rightarrow 0$（目的是为了使用最多访问次数的落子下法去下，追求最强的棋力），如果新的选手 $\alpha_{\theta_i}$ 在这400盘中胜率大于55%，将这个选手更新为最佳选手 $\alpha_{\theta_*}$ ，用来产生下一轮的自对弈棋谱，并且设为下一轮的比较对象

自对弈

通过评估器，现在已经有一个当前的最好棋手 $\alpha_{\theta_*}$，使用它来产生数据。每次迭代中， $\alpha_{\theta_*}$ 自对弈25000盘，其中每一步MCTS搜索模拟1600次（模拟的每次落子大约0.4秒，这里的一次表示的就是MCTS搜索中走到叶子节点，得出胜负结果）

前30步，温度 $\tau = 1$，与MCTS搜索中的访问次数成正比，目的是保证前30步下法的多样性。在之后的棋局中，温度设为无穷小。并在先验概率中加入狄利克雷噪声 $P(\vec s, \vec a) = (1 - \epsilon) p_{\vec a} + \epsilon \eta_{\vec a}$ ，其中 $\eta \sim Dir(0.03)$ 且 $\epsilon = 0.25$。这个噪声保证所有的落子可能都会被尝试，但也可能下出臭棋

投降阈值 $v_{rerign}$ 自动设为错误正类率（如果AlphaGo没有投降可以赢的比例）小于5%，为了测量错误正类(false positives)，在10%的自对弈中关闭投降机制，必须下完

监督学习

为了进行对比，我们还使用监督学习训练了一个参数为 $\theta_{SL}$ 神经网络。神经网络的结构和AlphaGo Zero相同。数据集 $(\vec s, \boldsymbol \pi, z)$ 随机采样自KGS数据集，人类的落子策略位置即设置 $\pi_a = 1$ 。使用同样的超参数和损失函数，但是平方误差的系数为0.01，学习率图参照上表的第二列。其他超参数和上一节相同

比AlphaGo1.0z中使用两种网络，使用这种结构的网络，可以有效的防止过拟合。并且实验也证明这个网络结构的的效果要好于之前的网络

MCTS搜索算法

这一部分详解的AlphaGo Zero的算法核心示意图Figure2

AlphaGo Zero使用的是比AlphaGo1.0中更简单的异步策略价值MCTS搜索算法（APV-MCTS）的变种

搜索树中的节点 $\vec s$ 包含一条边 $(\vec s,\vec a)$ 对应所有可能的落子 $\vec a \in \mathcal A(\vec s)$ ，每一条边中存储一个数据，包含下列公式的四个值
$$
{N(\vec s,\vec a), W(\vec s,\vec a), Q(\vec s,\vec a), P(\vec s,\vec a)}
$$

$N(\vec s,\vec a)$ 表示MCST搜索模拟走到叶子节点的过程中的访问次数
$W(\vec s,\vec a)$ 表示行动价值（由路径上所有的 $v$ 组成）的总和
$Q(\vec s,\vec a)$ 表示行动价值的均值
$P(\vec s,\vec a)$ 表示选择这条边的先验概率（一个单独的值）

多线程（并行）执行多次模拟，每一次迭代过程先重复执行1600次Figure 2中的前3个步骤，计算出一个 $\boldsymbol \pi$ ，根据这个向量下现在的这一步棋

Selcet - Figure2a

MCTS中的选择步骤和之前的版本相似，详见AlphaGo之前的详解文章，这篇博文详细通俗的解读了这个过程。概括来说，假设L步走到叶子节点，当走第 $t < L$ 步时，根据搜索树的统计概率落子
$$\vec a_t = \operatorname*{argmax}_{\vec a}(Q(\vec s_t, \vec a) + U (\vec s_t, \vec a))$$

其中计算 $U (\vec s_t, \vec a)$ 使用PUCT算法的变体

其中 $c_{puct}$ 是一个常数。这种搜索策略落子选择最开始更趋向于高先验概率和低访问次数的，但逐渐的会更加趋向于选择有着更高行动价值的落子

$c_{puct}$ 使用贝叶斯高斯过程优化来确定

Expand and evaluate - Figure 2b

将叶子节点 $\vec s_L$ 加到队列中等待输入至神经网络进行评估， $f_\theta(d_i(\vec s_L)) = (d_i(p), v)$ ，其中 $d_i$ 表示一个1至8的随机数来表示双方向镜面和旋转（从8个不同的方向进行评估，如下图所示，围棋棋型在很多情况如果从视觉角度来提取特征来说是同一个节点，极大的缩小了搜索空间）

队列中8个不同位置组成一个大小为8的mini-batch输入到神经网络中进行评估。整个MCTS搜索线程被锁死直到评估过程完成（这个锁死是保证并行运算间同步）。叶子节点被展开(Expand)，每一条边 $(\vec s_L,\vec a)$被初始化为

这里的 $p_a$ 由将 $\vec s$ 输入神经网络得出 $\mathbf p$ （包括所有落子可能的概率值 $p_a$），然后将神经网络的输出值 $v$ 传回（backed up）

Backup - Figure 2c

沿着扩展到叶子节点的路线回溯将边的统计数据更新（如下列公式所示）

注解：在 $W(\vec s_t, \vec a_t)$ 的更新中，使用了神经网络的输出 $v$，而最后的价值就是策略评估中的这一状态的价值 $Q(\vec s, \vec a)$

使用虚拟损失（virtual loss）确保每一个线程评估不同的节点。实现方法概括为把其他节点减去一个很大的值，避免其他搜索进程走相同的路，详见

Play - Figure 2d

完成MCTS搜索（并行重复1-3步1600次，花费0.4s）后，AlphaGo Zero才从 $\vec s_0$ 状态下走出第一步 $\vec a_0$，与访问次数成幂指数比例

其中 $\tau$ 是一个温度常数用来控制探索等级（level of exploration）。它是热力学玻尔兹曼分布的一种变形。温度较高的时候，分布更加均匀（走子多样性强）；温度降低的时候，分布更加尖锐（多样性弱，追求最强棋力）

搜索树会在接下来的自对弈走子中复用，如果孩子节点和落子的位置吻合，它就成为新的根节点，保留子树的所有统计数据，同时丢弃其他的树。如果根的评价值和它最好孩子的评价值都低于 $v_{resign}$ AlphaGo Zero就认输

MCTS搜索总结

与之前的版本的MCTS相比，AlphaGo Zero最大的不同是没有使用走子网络（Rollout），而是使用一个整合的深度神经网络；叶子节点总会被扩展，而不是动态扩展；每一次MCTS搜索线程需要等待神经网络的评估，之前的版本性能评估（evaluate）和返回（backup）是异步的；没有树形策略

至于很重要的一个关键点：每一次模拟的中的叶子节点L的深度

【个人分析】是由时间来决定，根据论文提到的数据，0.4秒执行1600次模拟，多线程模拟，在时限内能走到的深度有多深就是这个叶子节点。可以类比为AlphaGo 1.0中的局面函数（用来判断某个局面下的胜率的），也就是说不用模拟到终盘，在叶子节点的状态下，使用深度神经网的输出 $v$ 来判断现在落子的棋手的胜率

网络结构

网络输入数据

输入数据的维度 19×19×17，其中存储的两个值0/1，$X_t^i = 1$表示这个交叉点有子，$0$ 表示这个交叉点没有子或是对手的子或 $t<0$。使用 $Y_t$ 来记录对手的落子情况。

从状态 $\vec s$ 开始，记录了倒退回去的15步，双方棋手交替。最后一个19×19的存储了前面16步每一个状态对应的棋子的黑白颜色。1黑0白

【个人理解】为了更加直观的解释，如果是上面的局部棋盘状态 $\vec s$，接下里一步是黑棋落子，走了4步，那么输入数据是什么样的呢？

同理，如果有8步的话，也就是16个对应的 $X$ 和 $Y$ 加一个 $C$ 来表示现在的棋盘状态（注意，这里面包含的历史状态）。这里的数据类型是Boolean，非常高效，并且表达的信息也足够

至于使用八步的原因。个人理解，一方面是为了避免循环劫，另一方面，选择八步也可能是性能和效果权衡的结果（从感知上来说当然信息记录的越多神经网络越强，奥卡姆剃刀定理告诉我们，简单即有效，一味的追求复杂，并不是解决问题的最佳途径）

深度神经网结构

整个残差塔使用单独的卷机模块组成，其中包含了19或39个残差模块，详细结构参数如下图所示

过了深度卷积神经网络后接策略输出与评估值输出，详细结构参数如下图所示

数据集

GoKifu数据集，和KGS数据集

图5更多细节

Figure 5a中每种定式出现的频率图

Figure 5b中每种定式出现的频率图

总结与随想

AlphaGo Zero = 启发式搜索 + 强化学习 + 深度神经网络，你中有我，我中有你，互相对抗，不断自我进化。使用深度神经网络的训练作为策略改善，蒙特卡洛搜索树作为策略评价的强化学习算法

之后提出一些我在看论文时带着的问题，最后给出我仔细看完每一行论文后得出的回答，如有错误，请批评指正！

问题与个人答案

训练好的Alpha Zero在真实对弈时，在面对一个局面时如何决定下在哪个位置？

评估器的落子过程即最终对弈时的落子过程（自对弈中的落子就是真实最终对局时的落子方式）：使用神经网络的输出 $\mathbf p$ 作为先验概率进行MCTS搜索，每步1600次（最后应用的版本可能和每一步的给的时间有关）模拟，前30步采样落子，剩下棋局使用最多访问次数来落子，得到 $\boldsymbol \pi$ ，然后选择落子策略中最大的一个位置落子

AlphaGo Zero的MCTS搜索算法和和上个版本的有些什么区别？

最原始MCTS解析，AlphaGo Lee加上策略函数和局面函数改进后的MCTS解析

对于AlphaGo Zero来说

• 最大的区别在于，模拟过程中依据神经网络的输出 $\mathbf p$ 的概率分布采样落子。采样是关键词，首先采样保证一定的随机特性，不至于下的步数过于集中，其次，如果模拟的盘数足够多，那这一步就会越来越强
• 其次，在返回（Bakcup）部分每一个点的价值（得分），使用了神经网络的输出 $v$。这个值也是策略评估的重要依据

AlphaGo Zero 中的策略迭代法是如何工作的？

策略迭代法（Policy Iteration）是强化学习中的一种算法，简单来说：以某种策略（ $\pi_0$ ）开始，计算当前策略下的价值函数（ $v_{\pi_0}$ ）；然后利用这个价值函数，找到更好的策略（Evaluate和Improve）；接下来再用这个更好的策略继续前行，更新价值函数……这样经过若干轮的计算，如果一切顺利，我们的策略会收敛到最优的策略（ $\pi_*$ ），问题也就得到了解答。

对于AlphaGo Zero来说，详细可见论文，简单总结如下

• 策略评估过程，即使用MCTS搜索每一次模拟的对局胜者，胜者的所有落子（$\vec s$）都获得更好的评估值
• 策略提升过程，即使用MCTS搜索返回的更好策略 $\boldsymbol \pi$
• 迭代过程，即神经网络输出 $\mathbf p$ 和 $v$ 与策略评估和策略提升返回值的对抗（即神经网络的训练过程）

总的来说，有点像一个嵌套过程，MCST算法可以用来解决围棋问题，这个深度神经网络也可以用来解决围棋问题，而AlphaGo Zero将两者融合，你中有我，我中有你，不断对抗，不对自我进化

AlphaGo Zero 最精彩的部分哪部分？

毫无悬念的，我会选择这个漂亮的公式，看懂公式每一项的来历，即产生的过程，就读懂了AlphaGo Zero。这个公式你中有我，我中有你，这是一个完美的对抗，完美的自我进化

第二我觉得很精彩的点子是将深度神经网络作为一个模块嵌入到了强化学习的策略迭代法中。最关键的是，收敛速度快，效果好，解决各种复杂的局面（比如一个关于围棋棋盘的观看角度可以从八个方向来看的细节处理的很好，又如神经网络的输入状态选择了使用历史八步）

随想和评论

量子位汇集各家评论

• 不是无监督学习，带有明显胜负规则的强化学习是强监督的范畴
• 无需担心快速的攻克其他领域，核心还是启发式搜索
• 模型简约漂亮，充满整合哲学的优雅，可怕的是效果和效率也同样极高
• AlphaGo项目在经历了把书读厚的过程后，已经取得了瞩目的成就依旧不满足现状，现通过AlphaGo Zero把书读薄，简约而不简单，大道至简，九九归一，已然位列仙班了

随着AlphaGo Zero的归隐，DeepMind已经正式转移精力到其他的任务上了。期待这个天才的团队还能搞出什么大新闻！

对于围棋这项运动的影响可能是：以后的学围棋手段会发生变化，毕竟世界上能复现AlphaGo Zero的绝对很多，那么AlphaGo Zero的实力那就是棋神的感觉，向AlphaGo Zero直接学习不是更加高效嘛？另，围棋受到的关注也应该涨了一波，是利好

感觉强化学习会越来越热，对于和环境交互这个领域，强化学习更加贴近于人类做决策的学习方式。个人预测，强化学习会在未来会有更多进展！AlphaGo Zero 可能仅仅是一个开头

以上！鞠躬！

在之前的【直观理解】线性代数的本质的笔记中，详细讨论了特征值与特征向量的几何直观意义

起初，研究线性代数，也是因为深入了解矩阵（变换）对机器学习中的很多优美公式的推导和理解有帮助。上篇笔记中，3B1B团队的讲解内容中没有涉及几个线性代数中的概念，且这些概念在做矩阵分解时会被用到。以上一篇笔记中的直观理解为基础（矩阵 = 变换）在这里做一个整理和记录

正交矩阵

可能很多人已经有一个概念：正交（Orthogonal） = 垂直。但我们知道，正交的一定垂直，垂直的不一定正交（比如空间中两个不相交直线垂直）。提及垂直，首先出现你脑海中的特点是什么呢？我想是勾股数 $a^2 + b^2 = c^2$ ， 还有 $\cos (\frac {\pi}{2}) = 1$

那什么是正交矩阵呢？在讲这个概念之前，变换中有一种特殊变换：旋转变换。这种变换除了原点外没有特征向量，特征值恒为1，不对网格进行伸缩。或者说，这个变换保证了新列空间内和原列空间内所有对应向量的长度不变

三维情况下，单位矩阵（对角线为1，其他为0，即基向量构成的矩阵）$\mathbf E = \left [ \begin{smallmatrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0&0&1 \end{smallmatrix} \right ]$ 如下图所示

根据基变换原理，易得旋转变换的矩阵表达式 $\mathbf R = \left [ \begin{smallmatrix} 0&-0.8 &-0.6 \\ 0.8&-0.36&0.48 \\ 0.6&0.48&-0.64 \end{smallmatrix} \right ]$ 计算得特征向量为 $(0,-0.75,1)$，发现这条向量即旋转轴！

此时我们考虑从 $\mathbf R$矩阵下变到 $\mathbf E$的变换矩阵是多少，即求 $\mathbf R$ 矩阵的逆

观察形式大家就可以发现一个有趣的特点 $\mathbf R^{-1} = \mathbf R^T$

正交矩阵有一个几何直观的特点，表示一个旋转变换，并且矩阵的逆和矩阵的转置相等

正定与半正定矩阵

根据特征值和特征向量这篇笔记中的内容，我们知道特征值是对一个变换（矩阵）特性的有力表征，公式 $\mathbf A \mathbf{\vec v} = \lambda \mathbf{\vec v}$ 表示了变换中被留在张成空间内的向量就是特征向量的符号表达，其中 $\vec v$ 是特征向量，$\lambda$ 即特征值

我们对上式进行一些数学恒等变换，左乘 $\vec v^T$，得到

此时我们会发现一些巧合，先来看看正定矩阵的正规定义：若一个 n×n的矩阵 $\mathbf M$ 是正定的，当且仅当队友所有的非零实系数的向量 $\vec v$，都有 $\vec v^T \mathbf M \vec v > 0$

我们暂时不考虑复数情况（在机器学习预见复数域的内容较少），结合上面的二公式，发现保证 $\vec v^T \mathbf M \vec v > 0$ 即使得 $\lambda \vec v^T \vec v>0$，其中 $\vec v^T \vec v$一定大于等于0（由于 $\vec v$ 是一个1×n的向量，转置进行矩阵相乘实际效果计算元素的平方和），所以可以推出即正定矩阵就是使得特征值大于0

再回到正定矩阵的定义公式 $\vec x^T \mathbf M \vec x > 0$，我们已经有深刻的理解 $\mathbf M \vec x$ 表示对向量 $\vec x$ 进行变换，记变换后的向量为 $\vec y = \mathbf M \vec x$ ，则我们可以把正定矩阵的公式写成

这个公式是不是很熟悉呢？它是两个向量的内积，对于内积，有公式：

$\Vert \vec x \Vert \; \Vert \vec y \Vert$ 表示 $\vec x$ 和 $\vec y$的长度，$\theta$ 是它们之间的夹角。根据2-2式，可以得到 $\cos(\theta) > 0$，即它们之间的夹角小于90度

总结：如果说一个矩阵正定，则表示，一个向量经过此矩阵变换后的向量与原向量夹角小于90度

当然，加一个【半】字，是指这个小于变成小于等于

正规矩阵

矩阵中还有一张形状特殊的矩阵，被称为正规矩阵，定义为：如果矩阵 $\mathbf A$ 满足 $\mathbf A^T \mathbf A = \mathbf A \mathbf A^T$

更多的，如果矩阵 $\mathbf U$ 满足 $\mathbf U^T \mathbf U = \mathbf U \mathbf U^T = \mathbf I$，其中 $\mathbf I$ 是单位矩阵，则称矩阵 $\mathbf U$ 为酉矩阵

从变换的角度来看正规矩阵，先做一个变换 $\mathbf A$ 再做一个变换 $\mathbf A^T$。并且交换两个矩阵的位置，最终结果相同

矩阵的转置

什么是转置

在前面的三个描绘矩阵不同矩阵的概念中，多次使用了转置的概念。从矩阵形态的角度看，转置是将 $\mathbf A$ 的所有元素关于一条从第1行第1列元素出发的向右下方45度的射线作镜面翻转（下面的动图更加直观）

那么，从矩阵是表示变换的集合角度如何理解转置呢？

为什么转置

试图从另一个角度来理解其实也是为了回答另一个问题：为什么要定义转置这种操作呢？你可能会说，这就是一个【对角线镜像对称交换的操作】，从形式上来理解对一般人已完全足够。

这里要深究的原因也只是为了克服在学习机器学习的过程中，公式里若出现转置符号，无法完全理解带来的生涩感（俗称强迫症），对博主来说，一个直接动机源于SVD算法

首先，考虑矩阵的列向量有具体的列空间的含义（对应 $\hat {\imath}$ 和 $\hat {\jmath}$ 的变换位置），若进行转置操作，列空间的性质会被完全破坏，或者说，转换成了一个新的列空间

非方阵

考虑矩阵转置的几何含义是无意义的，或者说，对出现过矩阵转置的公式的进一步理解是没有帮助的

特别的，如果是向量形式（1×n的矩阵），转置很多时候出现，是为了进行二次型运算（即平方运算），设 $\mathbf x = \{x_1, x_2,\ldots, x_n\}$ 是一个1×n的矩阵

很多机器学习的教材中这里会是列矩阵，因为要切合列空间的概念。对于机器学习来说，这里的 $x_1$ 代表的数据的特征维度

计算二次型： $\mathbf x \mathbf x^T = x_1^2 + x_2^2 + \ldots + x_n^2$ ，记过为一个数，表示的是距离

方阵

从列空间的概念，转置是一种非常特殊的旋转。这种旋转结合了横向镜面等特性，详细可以参看下图

从这幅图可以看出，如果想从几何变换的角度（类似3b1b的方法）来理解转置相当困难。此时，需要考虑换一种思考角度，性质和数学计算（这可能也是解决一个数学问题最常用的两种手段，性质寻找共性，并推广演绎，数学计算导出同样问题的不同表现形式，并总结规律）

性质找规律

首先先用一个简单的例子，二维可视化，并寻找规律，得到下面图像

观察得到，和旋转有一定的关系的，但是其实这个几何意义已经十分抽象了，为了追根之底，从数学的角度进行一些更有意思的探究

数学计算

为了发掘 $\mathbf A$ 和 $\mathbf A^T$ 之间的关系，我们可以设有转换矩阵 $\mathbf T$，其描述了从 $\mathbf A$ 到 $\mathbf A^T$ 的变换，写成公式为：
$$
\mathbf T \mathbf A = \mathbf A^{T} \tag 1
$$
同时我们假设 $\mathbf A$ 是一个2×2的矩阵，如下所示所示（列的不同为字母的不同a和b，行的不同为小标的1和2）

保证变换不会压缩维度，即 $det(\mathbf A) \neq 0$，利用（1）式，未知数，消元计算后，可以算出 $\mathbf T$，其中 $det(\mathbf A) = a_1b_2 - b_1a_2$

前面的 $\frac{1}{det(\mathbf A)}$ 作为一个常数，保证了 $det(\mathbf A^{T})=det(\mathbf A)$，将后面关键的变换矩阵写成

把 （4）式进行整理，也写成矩阵相乘的形式，得到下式

对于 $\mathbf A$ 的列空间来说，有 $\mathbf a = \left [ \begin{smallmatrix} a_1 \\ a_2 \end{smallmatrix} \right ]$ 和 $\mathbf b = \left [ \begin{smallmatrix} b_1 \\ b_2 \end{smallmatrix} \right ]$ 观察到 $\mathbf T$ 中包含列空间的两个项，把 $\mathbf T’$ 整理得

令 $\mathbf c = \begin{bmatrix}b_{2} \\ -a_{2} \\ \end{bmatrix} $ $\mathbf d = \begin{bmatrix}-b_{1} \\ a_{1} \\ \end{bmatrix} $ ，观察后发现规律：

• $\mathbf c$ 变换到 $\mathbf A^T_{\hat {\jmath}}$ 为逆时针旋转90°
• $\mathbf d$ 变换到 $\mathbf A^T_{\hat {\imath}}$ 为顺时针旋转90°

$\mathbf c$ 和 $\mathbf d$ 组成的列空间设为 $\mathbf C$，写成公式为

将（7）式左乘 $\mathbf A$ 得到下式

再将（8）式所有乘以 $\mathbf A$ 的逆矩阵 $\mathbf A^{-1}$ 得到
$$
\mathbf C = \mathbf A^{-1} det(\mathbf A) \tag{9}
$$
所以，构造的这个 $\mathbf C$ 矩阵和 $\mathbf A$ 矩阵的逆矩阵有关

另外，（4）式，即 $\mathbf T’$ 矩阵还可以被写成

或者可以写成

由 $\mathbf T \mathbf A = \mathbf A^T$ 可得

这时候，可以得出一个结论，矩阵的转置的过程和矩阵的逆是有关系的，是矩阵逆的一个更加复杂的表现形式

有了这个作为基础，考虑一下具有对称性，构造 $\mathbf A \mathbf A^T$，这个复合变换有着很好的对称性和分解性（接下来为了方便，默认非粗体表示的矩阵变换），因为

考虑任何不进行压缩维度变换的矩阵都可以进行特征分解，则有

之后左乘（这里补充一下，所有的左乘操作在几何意义上来说，就是附加了一个新的变换）$A^{-1}$，得到

根据之前（1）式的例子进行计算，发现 $R_{AA^{T}} = (R^{-1})_{AA^{T}}$，并且 $R_{AA^T}$ 首先将空间关于 y 轴对称，之后旋转 $\alpha$ 角度，所以假设定义

利用上面的推导，带入（15）式，得到：

用更加清晰的符号改写（17）式得到

$M_y$ 表示的是关于y轴对称
$R_\alpha$ 表示逆时针旋转 $\alpha$ 度
$\Lambda$ 表示一种伸缩变换

这里的（18式）结论和上面的作图规律，还有（12）式从某种程度上来说有相似的地方

其实应该从矩阵分解的部分来再次思索矩阵转置的意义，可详见什么是PCA,SVD

最终感觉关于转置还是研究的不够透彻，可能需要拔高到另一个层面去理解会更加直观，但是限于水平，只能至此（并不是数学专业的学生）

总结

• $\mathbf A \mathbf A^T$ 的对称特性非常有用
• 正交 = 旋转 = 垂直，并且逆等于转置
• 正规矩阵的定义和转置息息相关，但是从形式上来看，约束条件是逐步变弱的，其实这些特征都是描述了空间一个变换的一些变化模式，比如旋转，伸缩的特殊模式，只需要有一个基本的直观理解，在机器学习领域就已经足够用了

记录工具使用幕布，方便一键生成思维导图，并且快速搜索查找

人工智能AI

机器学习

大数据

总

Hadoop

Web 前端

总

移动性能优化

HTML5开发

Angular 2

Server 后端

架构师

OpenResty

直播技术

CDN技术

DNS排查

云计算

总

容器 Container

微服务 MicroService

微服务架构和实践

智能运维

总

DBA

DevOps

Kubernetes

安全

总

测试

总

移动无线测试

移动开发

iOS开发

Android App 开发

Android ROM 开发

Android 架构师

智能硬件

嵌入式开发

开发语言

总

Golang

Clojure

Python

Haskell

Node.js

Ruby

Java

开发工具

Git

技能清单

CTO技能

在笔记开始之前，想象学习一个事物（概念）的场景：我们需要学习正弦函数，$\sin (x)$，非常不幸的是，你遇到了一本相当装逼的教材，它告诉你，正弦函数是这样的：
$$\sin (x) = x - \frac{x^3}{3!} + \frac{x^5}{5!} + \cdots + (-1)^n\frac{x^{2n+1}}{(2n+1)!} + \cdots$$
的确很厉害的样子，并且，计算器就是这样算 $\sin (x)$，知道了这个的确“挺酷的”。对你来说，你的作业可能就是回家把 $x= \frac{\pi}{6}$ 带到公式里面，发现，好神奇！竟然越算越接近0.5。此时你对$\sin (x)$与三角形之间的几何直观只有一些模糊的概念。这样的学习过程就十分悲催了。为什么呢？

再假设一个场景，接下来，物理课，正弦函数随处可见，下图场景中，其他人能快速的大概估计出这个值是0.7。而刚“学过”正弦函数的你，内心戏可能是这样的：这些人忒diao了吧？你莫不是在玩我？

你可能会觉得这些做物理的人脑子也太强了，我弱爆了。其实，你需要只是一个几何直观的灌输而已，这也从侧面佐证了一个好的老师（这里的好老师真的不是他本身的学术能力有多强，而在于他擅不擅长站在学习者的角度不断的修正教学方法。甚至，模拟学生的学习过程提前预知所需要的基础概念）是有多么重要。

教学不同层次的人：初学，入门，掌握，理解，都是不同的。解释的角度，方式都完全不同。更加不幸的是，为了能更加通用的用理论来描述现实生活中的规律，人类已经做了很多工作，我们常说：越通用，越抽象（越难以理解）。这对于初学者来说堪称一段噩梦

这个例子比较极端，但只为强调一件事：直观理解很重要，或者说，学习方法很重要。好的学习方法即你如何直观的去理解（可能是几何的，或是现实中的具体例子）一个抽象的事物，并层次化的建立知识与知识间的联系，构建并健壮属于自己的知识图谱。个人观点是，这种【学习方法】是最高效的。它唯一的难度在于，需要一定的基础知识打底，一定的量变结合方法论（点拨或领悟）就是质变。换句话说，想躺着学习？不存在的

根据生物学家我们知道，人对具体的事物（动画＞图形＞数字＞未建立直观理解的文字）更敏感，记忆速度更快。这篇笔记的对象3B1B团队生产的内容目的就是从为了帮助人们建立直观概念的角度来教学，在如今中国应试教育风行的大背景下，它会超越你的认知：学习如追番般期待，真不是一个调侃！

我是极度反对现代大学的线性代数课程中（甚至数学类课程）的教学方法的，在计算上（做题）花费了大量时间。而工程中，有计算机，绝不会有任何一个人去笔算矩阵的逆或特征值。如果现在的老师反驳：做计算的目的是为了让你通过大量的联系（重复）去记牢概念，我也一直坚信：学习知识的最快捷径是带有思考的重复，但那是带思考的重复，有一些直观的方法在帮助你理解和记忆上比做题有效率的多

注解，因为这是一篇个人笔记，我个人已经深刻理解的内容，或者我觉得是很基本的内容我会略过或默认。好消息是，我自己也是一个理解力非常捉急的人，所以还是会比较详细的

什么是矩阵？矩阵 = 变换的数字表达

向量究竟是什么

引入一些数作为坐标是一种鲁莽的行为 ——赫尔曼·外尔

The introduction of numbers as coordinates is an act of violence - Hermann Weyl

这部分，讲向量，扎实的读者完全可以跳过

向量的定义 What

对于向量的这个概念，大家一定并不陌生，但是这次让我们从数学，物理，计算机三个角度来看待如何定义这个【向量】这个概念

物理专业角度

• 向量是空间中的箭头
• 决定一个向量的是：它的长度和它所指的方向

计算机专业角度

• 向量是有序的数字列表
• 向量不过是“列表”一个花哨的说法
• 向量的维度等于“列表”的长度

数学专业角度

从数学来说，它的本质就是通用和抽象，所以，数学家希望概括这两种观点

• 向量可以是任何东西，只需要保证：两个向量相加及数字与向量相乘是有意义的即可
• 向量加法和向量乘法贯穿线性代数始终，十分重要

可以通过上图直观的感受到数学家（这个很牛逼的灰色的$\pi$）在想什么，有种【大道】的逼格。左边是物理角度，右边是计算机角度，但是很抱歉，我能用一些抽象的定义和约束让你们变成一个东西

坐标系

把向量至于坐标系中，坐标正负表示方向，原点为起点，可完美把两个不同的角度融合

• 向量加法
  • 物理：首尾相连 Motion
  • 计算机：坐标相加
• 向量乘法
  • 物理：缩放 Scaling
  • 计算机：坐标和比例相乘

线性组合、张成的空间与基

数学需要的不是天赋，而是少量的自由想象，但想象太过自由又会陷入疯狂 ——安古斯·罗杰斯

Mathematics requires a small dose, not of genius, but of an imaginative freedom which, in a larger dose, would be insanity - Angus K. Rodgers

本部分继续加深一个概念，为何向量加法与向量乘法是那么重要，并从始至终贯穿整个线性代数

线性组合

这个概念再好理解不过，空间中不共线的两个不为零向量都可以表示空间中的任意一个向量，写成符号语言就是：$a \mathbf{\vec v} + b \mathbf{\vec w}$

至于为什么被称为“线性”，有一种几何直观：如果你固定其中一个标量，让另一个标量自由变化，所产生的向量终点会描出一条直线

空间的基 Basis

对于我们常见的笛卡尔坐标系，有一个最直观一组基：$\{{\hat {\imath}} ,{\hat {\jmath}} \}$ ，即单位向量：${\hat {\imath}}=(1,0)$ 和$\hat {\jmath} =(0,1)$ ，通过 ${\hat {\imath}}$ 和 ${\hat {\jmath}}$的拉伸与相加可以组成笛卡尔坐标系中的任意一个向量

张成的空间 Span

同理，举一反三的来说，我们可以选择不同的基向量，并且这些基向量构成的空间称为：张成的空间。张成二字比较拗口，可以类比为延展或扩展。直观来看，就是所有动图中的网格。笛卡尔坐标系就是一个由单位坐标$\{{\hat {\imath}} ,{\hat {\jmath}} \}$ 张成的空间

所有可以表示为给定向量（基）线性组合（刚刚讲了这个概念）的向量的集合，被称为给定向量（基）张成的空间

如果你继续思考一下，会发现一个特点：并不是每一组给定向量都可以张成一个空间，若这两个向量共线（2D），共面（3D），它们就只能被限制在一个直线或面中，类似于“降维打击”。通过这个直观的思考可以引出一个概念：线性相关

线性相关

关于什么是线性相关，有两种表达

• 【表达一】你有多个向量，并且可以移除其中一个而不减小张成的空间（即2D共线或3D共面），我们称它们（这些向量）线性相关
• 【表达二】其中一个向量，可以表示为其他向量的线性组合，因为这个向量已经落在其他向量张成的空间之中

如果从统计学角度来说，这些向量之中有冗余。这一堆向量中，我们只需要其中几个（取决于维度）就可以表示其他所有的向量。

向量空间一组基的严格定义

有了这些对名次（概念）的直观理解，来看看数学家们是如何严谨的定义向量空间的一组基：

向量空间的一组基是张成该空间的一个线性无关向量集

用这样的步骤来慢慢导出这个定义，个人感觉，远比在课堂的第一分钟就将这句让你迷惑的话丢给你好的多，抽象的东西只有在慢慢推倒中你才能发现它的精巧之处，非常优雅且迷人

矩阵与线性变换

很遗憾，Matrix（矩阵）是什么是说不清的。你必须得自己亲眼看看 ——墨菲斯

Unfortunately, no one can be told what the Matrix is. You have to see it yourself -Morpheus

矩阵，最直观的理解当然是一个写成方阵的数字 $\left[\begin{smallmatrix} 1&2 \\ 3&4 \end{smallmatrix}\right]$，这几节的核心是为了说明：矩阵其实就是一种向量变换（至于什么是变换下面会讲），并附带一种不用死记硬背的考虑矩阵向量乘法的方法

变换

【变换】本质上是【函数】（左）的一种花哨的说法，它接受输入内容，并输出对应结果，矩阵变换（右），同理，如下图

那既然两者意思相同，为何还要新发明一个词语装逼呢？其实不然，搞学术，不严谨就会出现纰漏。常说编程出现Bug，其实就是不严谨的一种体现，在写Code前，没有考虑到可能性的全集（虽然在一些大型程序中，考虑全集的做法有时候是没必要的，这是一对关于编程困难程度和不出的bug的博弈Trade-off），但是【变换】这个名词和不严谨其实没什么关系……

【变换】的表达方法暗示了我们可以用运动的方法来理解【向量的函数】这一概念，可以用可视化的方法来展现这组【变换】即输入-输出关系

这世界上有非常多优美的变换，如果你将他们编程，并可视化，就能得到下图

线性变换

我们说具有以下两个性质的就是线性变换（直观可视化如下图）：

• 直线在变换后仍然保持为直线，不能有所弯曲
• 原点必须保持固定

一点扩展，如果保持保持直线但原点改变就称为：仿射变换（Affine Transformation）

一句话总结来说是：线性变换是“保持网格线平行且等距分布”的变换

如何用数值描述线性变换

这里需要使用上一节提到的工具，空间的基，也就是单位向量（基向量）：${\hat {\imath}}=(1,0)$ 和$\hat {\jmath} =(0,1)$

你只需要关注两个基向量 $\hat {\imath}$ 和 $\hat {\jmath}$ 变换后的位置即可。例如， $\hat {\imath}$ 变换到 $(3,1)$ 的位置， $\hat {\jmath}$ 变换到$(1,2)$ 的位置，并把 $\hat {\imath}$ 变换后坐标立起来作为方阵的第一列（绿色表示）， $\hat {\jmath}$ 变换后的坐标立起来作为方阵的第二列（红色表示）。

构成了一个矩阵：$\begin{bmatrix} \color{green}3&\color{red}1 \\ \color{green}1&\color{red}2 \end{bmatrix}$，假设我们想要知道目标向量$(-1,2)$进行变换后的位置，那么这个矩阵就是对变换过程最好的描述，一动图胜千言

Step1：绿色 $\hat {\imath}$ （x轴）进行移动（变换）
Step2：红色 $\hat {\jmath}$ （y轴）进行移动（变换）
Step3：目标向量x轴坐标值与 $\hat {\imath}$ 变换后向量进行向量乘法
Step4：目标向量y轴坐标值与 $\hat {\jmath}$ 变换后向量进行向量乘法
Step5：两者进行向量加法，得到线性变换结果

更加一般的情况，我们用变量来代替其中的具体值：绿色代表 $\hat {\imath}$ 变换后的向量，红色代表 $\hat {\jmath}$ 变换后的向量

上面的公式就是我们常说的矩阵乘法公式，现在，不要强行背诵，结合可视化的直观动图，你一辈子都不会忘记的

【线性】的严格定义

在给出一个数学化抽象的解释前，先做一下总结：

• 【线性变换】是操纵空间的一种手段，它保持网格线平行且等距分布，并保持原点不动
• 【矩阵】是描述这种变换的一组数字，或者说一种描述线性变换的语言

在数学上，【线性】的严格定义如下述公式，这些性质，会在之后进行讨论，也可以在这里就进行一些思考，为什么说向量加法和向量乘法贯穿线性代数始终，毕竟是线性代数，很重要的名次就是线性二字

矩阵乘法与线性变换复合

据我的经验，如果丢掉矩阵的话，那些涉及矩阵的证明可以缩短一半 ——埃米尔·阿廷

It is my experience that proofs involving matrices can be shortened by 50% if one throws the matrices out -Emil Artin

复合变换

如果对一个向量先进行一次旋转变换，再进行一次剪切变换（ $\hat {\imath}$ 保持不变第一列为（1,0）， $\hat {\jmath}$ 移动到坐标（1,1）） ，如下图所示

那么如果通过旋转矩阵和剪切矩阵来求得这个符合矩阵呢？为了解决这个问题，我们定义这个过程叫做矩阵的乘法

矩阵乘法

在这里我们发现，矩阵乘法的变换顺序是从右往左读的（这一个常识很重要，你得明白这一点，有基本概念），进一步联系和思考发现，和复合函数的形式，如 $f(g(x))$ ，是一致的

那么如何求解矩阵乘法呢？对线性代数有印象的同学你们现在能马上记起来那个稍显复杂的公式吗？如果有些忘记了，那么，现在，就有一个一辈子也忘不了的直观解释方法：

M1矩阵的第一列表示的是 $\hat {\imath}$ 变换的位置，先把它拿出来，M2矩阵看成对这个变换过的 $\hat {\imath}$ 进行一次变换（按照同样的规则），就如上图所示。同理，针对 $\hat {\jmath}$ 一样的操作过程，就可以得出这个表达式。这里我也不把它写出来了，按照这种思路，并且把上面的动图多看几遍，如果还能忘记，那就要去补一补基本的对几何图形的反应能力了（这也是一种能力，包括三维想象力，心算能力，都和记忆或肌肉一样，不锻炼，是不可能躺着被提高的）

计算规则证明

有了上面的想法，可以自己尝试证明一下，矩阵乘法的交换律是否成立？矩阵乘法的结合律呢？你会发现，原来这么直观，根本不需要动笔算

三维空间

对三维空间内扩展的话，你会发现，显示生活中的每一种形态改变都能用一个3*3的矩阵来表示这个变换，这在机器人，自动化操作领域是非常重要的，因为你可以把现实生活很难描述的动作通过一个矩阵来表示，是一个连接数字和现实的重要桥梁和工具

行列式

计算的目的不在于数字本身，而在于洞察其背后的意义 ——理查德·汉明（没错，是发明汉明码的那个人）

The purpose of computation is insight, not numbers - Richard Hamming

行列式定义的由来

我们注意到，有一些变换在结果上拉伸了整个网格，有一些则是压缩了，那如何度量这种压缩和拉伸呢？或者换一种更容易思考的表达，某一块面积的缩放比例是多少？

其实，根据我们之前讲的基向量，我们只需要知道 $\hat {\imath}$ 和 $\hat {\jmath}$ 组成的面积为1的正方形面积缩放了多少就代表所有的情况。因为线性变换有一个性质：网格线保持平行且等距分布

所以，这个特殊的缩放比例，即线性变换对面积产生改变的比例，就是行列式

特别的，我们可以发现，如果一个矩阵的行列式为0，意味着它把这个空间降维了，并且矩阵的列线性相关

其中，正负表达的是方向，类似于纸的翻面。从数学来说，$\hat {\jmath}$ 起始状态在 $\hat {\imath}$ 的左侧，如果经过变换，变为在右侧，就添加负号。三维情况下，右手定位为正

计算行列式

为了连接行列式的计算公式和几何直观，我们现考虑 $\begin{bmatrix} \color{green}a&\color{red}b \\ \color{green}c&\color{red}d \end{bmatrix}$ 其中的b c 为0，那么，a表示 $\hat {\imath}$ 在x轴缩放比例，d表示 $\hat {\jmath}$ 在y轴缩放比例，ad表示拉伸倍数，同理来说，bc表示的就是压缩倍数，两者的和就是缩放比例。如果你还是对公式念念不忘，那么下面这张图可能可以帮到你

行列式直观理解的好处

在这里，可以思考一下如何证明 $det(M_1M_2) = det(M_1)det(M_2)$ ，你会发现太简单不过了

逆矩阵、列空间与零空间

提出正确的问题比回答它更难 ——格奥尔格·康托尔

To ask the right question is harder than to answer it - Georg Cantor

首先，这一节并不涉及计算的方法，相关名次有：高斯消元法 Gaussian elimination、行阶梯形 Row echelon form。这里着眼的是对抽象的概念建立一个几何直观的理解，计算的任务就交给计算机去做

矩阵的用途

• 描述对空间的操作，3*3矩阵描述的三维变换
• 可以帮助我们解线性方程组（Linear System of equation）

线性方程组

上图就是一个整理好的线性方程组，一般形式 $\mathbf A \mathbf{\vec x} = \mathbf{\vec v}$ ，其中 $\mathbf{\vec x}$ 是待求向量。使用之前的几何直观来翻译个公式即，$\mathbf{\vec x}$ 经过 $\mathbf A$ 矩阵变换后，恰好落在 $\mathbf{\vec v}$ 上，如下图

既然使用了 $\mathbf A$ 这个矩阵变换，那么之前讲解的概念：行列式应用在这里就很有意思了。根据之前提到的，行列式直观来说就是矩阵变换操作面积的缩放比例。我们可以思考，$det(\mathbf A) = 0$ 意味着缩放比例为0，即降维了。很大可能找不到解，唯一的可能性，比如平面压缩成直线，这个直线恰好落在 $\mathbf{\vec v}$ 上才有解。这也是为什么计算行列式的值可以判断方程是否有解的几何直观

接下来思考如何求 $\mathbf{\vec x}$ 。逆向思考，从 $\mathbf{\vec v}$ 出发，进行某一个矩阵变换，恰好得到 $\mathbf{\vec x}$ 。而这个反过来的矩阵变换，就称为 $\mathbf A$ 矩阵的逆矩阵，写成公式是：
$$
\mathbf A^{-1}\mathbf A\mathbf{\vec x} =\mathbf A^{-1} \mathbf{\vec v} \implies \mathbf{\vec x} =\mathbf A^{-1} \mathbf{\vec v}
$$

逆矩阵

所谓逆，就是反过来的意思。根据基向量代表整个空间，已经变换过的 $\hat {\imath}’$ 和 $\hat {\jmath}’$ 如何通过一个矩阵变换，变回 $\hat {\imath}$ 和 $\hat {\jmath}$ ，这个矩阵就是逆矩阵 ，写作 $\mathbf A^{-1}$，直观理解如下图

逆矩阵乘原矩阵等于恒等变换，写作 $\mathbf A \mathbf A^{-1} = \mathbf I$ 。$\mathbf I$ 矩阵表示基向量，对角线元素为1，其余为0（矩阵说对角线，默认为左上方到右下方）

列空间

其实这只是之前一直在提到过的概念，在线性方程组中，这么描述：所有可能得输出向量 $\mathbf A \mathbf{\vec v}$ 构成的集合被称为A的列空间。这么说不太好理解，可以从名称“列空间”入手，矩阵的列是什么呢？我们之前已经多次强调了，就是 $\hat {\imath}$ 和 $\hat {\jmath}$ 变换后的坐标。即矩阵的列表示基向量变换后的坐标（位置），变换后的向量张成的空间就是所有可能得输出向量

简单说即：列张成的空间 = 列空间，即矩阵的列所张成的空间，如下图。

检查一下自己是否完全理解，就思考下面句话为什么这么说：零向量一定在列空间中（列空间很好理解）

秩 Rank

秩这个概念相信很多学习线性代数的同学，因为中文字，秩，本身就不熟（和正则化有点类似），所以秩也就非常难以理解了。秩是秩序，联想为秩序的程度。但是，因为你已经看了这个教程，矩阵的秩在现在你拥有的几何直观下，理解起来，当真的小菜一碟

我们已经建立了一种深刻的认知：矩阵 = 变换，那么变换后空间的维度，就是这个矩阵的秩。更加精确的定义是：列空间的维数（如果你可以焕然大：原来这两句话是一个意思，那么我觉得你对矩阵的理解已经有了质的提高）

零空间

变换后落在原点的向量的集合，称为这个矩阵（再次强调矩阵 = 变换的数字表达）的零空间或核，如果感觉没理解，可以看看下图

【图1】二维压缩到一个直线（一维），有一条直线（一维）的点被压缩到原点
【图2】三维压缩到一个面（二维），有一条直线（一维）的点被压缩到原点
【图3】三维压缩到一条线（一维），有一条直线（二维）的点被压缩到原点

【注意】压缩就是变换，变换就是矩阵，其实说的就是矩阵

满秩 = 列空间 + 零空间

总结

• 从几何角度理解线性方程组的一个高水平概述
• 每个方程组都有一个线性变换与之联系，当逆变换存在时，你就能用这个逆变换求解方程组
• 不存在逆变换时，列空间的概念让我们清楚什么时候存在解
• 零空间的概念有助于我们理解所有可能得解的集合是什么样的

非方阵

在这个小测试里，我让你们求一个2*3矩阵的行列式。让我感到非常可笑的是，你们当中竟然有人尝试去做 ——佚名

On this quiz, I asked you to find the determinant of a 2*3 matrix. Some of you, to my great amusement, actually tried to do this - no name listed

几何意义

首先从一个特例出发，考虑3×2（3行2列）矩阵的几何意义，从列空间我们得知，第一列表示的是 $\hat {\imath}$ 变换后的位置（现在是一个有三个坐标的值，即三维），第二列同理是 $\hat {\jmath}$ 。总结来说，3×2矩阵的几何意义是将二维空间映射到三维空间上

此时从特例到一般化推倒，我们可以得到一个结论：n*m 的几何意义是将m维空间（输入空间）映射到n维空间（输出空间）上

注意这里的输入空间，输出空间的概念，阅读方向同样也是从右向左的（靠右的是输入，靠左的是输出）

非方阵乘法

如果你已经学过线性代数的大学课程，你可能有一些影响，并不是任意两个非方阵都可以进行矩阵乘法，必须满足一些条件，例如，$\mathbf M_1 \mathbf M_2$（非方阵）计算中，假设 $\mathbf M_2$ 为2×3的矩阵，那么 $\mathbf M_1$的列必须等于 $\mathbf M_2$ 的行，否则这个乘法是没法计算的。

当我们有了变换的几何直观后，这个概念只要自己思考推倒一次，也是一辈子都忘不了的

直观解释是：矩阵的行是这个变换的输出空间维数，而列是变换的输入空间维数。矩阵乘法从右向左读，第一个变换的 $\mathbf M_2$ 的输出向量的维度（ $\mathbf M_2$ 的行）必须和第二个变换 $\mathbf M_1$ 的输入向量（ $\mathbf M_1$ 的列）维度相等，才可以计算。也就是说，类似于插头和插座的关系，我只有三头插座，你来一个双头插头肯定没法用的

非方阵行列式

这里有一个很好玩的概念，非方阵的行列式呢？都不是一个维度的变换，如同归零者和咱们谈判一样，你和我谈缩放比例？不存在的

点积与对偶性

卡尔文：你知道吗，我觉数学不是一门科学，而是一种宗教
霍布斯：一种宗教？
卡尔文：是啊。这些公式就像奇迹一般。你取出两个数，把它们相加时，它们神奇地成为了一个全新的数！没人能说清这到底是怎么发生的。你要么完全相信，要么完全不信

什么是点积

个相同维数的向量，或是两个相同长度的数组。求它们的点积，就是将相应坐标配对，求出每一对坐标的乘积，然后将结果相加，一动图胜千言

几何直观来说，$\mathbf{\vec v} \cdot \mathbf{\vec w}$ 可以想象成向量 $\mathbf{\vec w}$ 朝着过原点和向量 $\mathbf{\vec v}$ 的直线上的正交（垂直）投影，然后把投影的长度和向量 $\mathbf{\vec v}$ 的长度乘起来就是点击的值。其中正负号代表方向，两个向量成锐角，大于0；钝角，小于0

点积的顺序

你可能会发现，顺序在线性代数其实是很重要的，而对于 $\mathbf{\vec v} \cdot \mathbf{\vec w}$ 和 $\mathbf{\vec w} \cdot \mathbf{\vec v}$ 它们的结果是相同，为什么呢？

解释的方法为：首先假设 $\mathbf{\vec v}$ 和 $\mathbf{\vec w}$ 长度相同，利用对称轴，两个向量互相的投影相等；接下来如果你缩放其中一个到原来的两倍，对称性被破坏，但是缩放比例没变，最终乘法的结果也没变，一动图胜千言

点积与投影

这个时候问题就来了，这种直观的乘法与加法的组合运算：点积为何和投影长度的乘积有关？这个问题非常有意思，因为回答这个问题的过程用到了十分精彩的直觉和思维方式

首先，需要建立多维空间到一维空间的线性变换（描述为1×n的矩阵，列代表对应的基向量压缩到一维空间的位置），即函数（自变量对应多维空间，$f(x)$ 最后的输出为一维空间，也就是数轴上的点，一个确定的数）的概念。一动图胜千言

你会发现，n×1 表示的是坐标和1×n表示的多维到一维的变换（矩阵）之间有某种联系，即将向量转化为数的线性变换和这个向量本身有着某种关系

接下来，我们想象一个情景，这个被压缩成的一条线（数轴）放置在一个坐标系（二维空间）中，且空间所有向量都经过一个变换被压缩到这个数轴上。记这个数轴的单位向量为 $\mathbf{\vec u}$，一动图胜千言

再然后，我们需要考虑的问题变为，坐标系中的 $\hat {\imath}$ 与 $\hat {\jmath}$ 是如何被压缩到这条直线上的呢（基向量表征整个空间的变换）？即求一个1×2的矩阵内的值，第一列表示 $\hat {\imath}$ 变换后的位置（在这条数轴上），第二列表示 $\hat {\jmath}$ 变换后的位置。可以直接给出结论，这个变换的数值恰好就是 $\mathbf{\vec u}$ 在这个坐标系中的坐标 $(u_x,u_y)$ ，推倒方法使用到了对称性，一动图胜千言

动图中的白色虚线就是对称轴，目的就是确定变换后 $\hat {\imath}$ 与 $\hat {\jmath}$ 的位置，即描述变换的矩阵（再次重复，列表示坐标，行表示变换）。

推倒完毕，把这个过程总结成一个动图

矩阵的向量乘积和点积的计算公式一样，且恰好由压缩这一变换理念，与投影正好联系了起来。关键点，在于压缩变换 = 投影

对偶性

在证明的过程中，有一个很关键的点就是使用了对称轴（对称理念）。在数学中，对偶性定义为：两种数学事物之间自然而又出乎意料的对应关系。刚刚推倒的内容是数学上“对偶性”的一个实例，即无论何时你看到一个二维到一维的变换，空间中会存在为一个向量 $\mathbf{\vec v}$ 与之相关

总结

• 点积是理解投影的有力几何工具
• 方便检验两个向量的指向是否相同
• 更进一步，两个向量点乘，就是将其中一个向量转化为线性变换
• 向量放佛是一个特定变换的概念性记号。对一般人类来说，想象空间中的向量比想象这个空间移动到数轴上更加容易

叉积

每一个维度都很特别 ——杰弗里·拉加里亚斯

从他（格罗滕迪克）和他的作为中，我还学到了一点：不以高难度的证明为傲，因为难度高意味着我们还不理解。理想的情况是能够绘出一幅美景，而其中的证明显而易见

二维情况下的叉积类比

$\mathbf{\vec v}$ 与 $\mathbf{\vec w}$ 张成的平行四边形的面积，即 $\mathbf{\vec v} \times \mathbf{\vec w}$ ，结果方向的确定考虑 $\hat {\imath}$ 和 $\hat {\jmath}$ 的相对位置关系，与其相同，为正；否则，为负

通过这个定义，结合几何直观，我们可以发现几个有趣的结论

• 越接近垂直的 $\mathbf{\vec v}$ 与 $\mathbf{\vec w}$ 构成的面积越大
• 并且叉积的分配律成立

真正的叉积定义

真正的叉积是在三维情况下被定义出来的：通过两个三维向量（$\mathbf{\vec v}$ 与 $\mathbf{\vec w}$ ）产生一个新的三维向量 $\mathbf{\vec p}$ ，向量 $\mathbf{\vec p}$ 的长度就是 $\mathbf{\vec v}$ 和 $\mathbf{\vec w}$ 组成平行四边形的面积 ，向量的方向与平行四边形（所在平面）垂直，并用右手定则确定方向，食指为 $\mathbf{\vec v}$ ，中指为 $\mathbf{\vec w}$ ，大拇指即 $\mathbf{\vec p}$

叉积计算公式

其中 $\hat {\imath}$ $\hat {\jmath}$ $\hat k$ 三个基向量后的数字就是对应向量 $\mathbf{\vec p}$ 的坐标值

第一次学这个计算方法的时候，估计没几个人能想清楚它为什么是这样的形式，甚至老师也说不清，只是告诉学生，我们这么记下来，定义是这样的定义的。但是，既然是直观讲解，必须把这里的来由探明清楚

叉积计算的几何直观

在开始前，先再次加深一次对偶性的概念：每当你看到一个（多维）空间到数轴的线性变换时，它都与那个空间中的唯一一个向量对应。即应用线性变换到某个向量和与这个向量点乘等价

恰好，叉积的运算过程给出了对偶性的一个绝佳的实例：根据 $\mathbf{\vec v}$ 和 $\mathbf{\vec w}$ 定义一个从三维空间到数轴的特定线性变换，找到这个变换的对偶向量，这个对偶向量就是 $\mathbf{\vec v}$ 和 $\mathbf{\vec w}$ 的叉积

首先，我们知道三维情况的，求一个3×3矩阵的行列式，就是求这三个向量张成的平行六面体的体积，然后，把第一列（向量）换成一个自变量，后两列（两向量）记为 $\mathbf{\vec v}$ 和 $\mathbf{\vec w}$ ，那么我们就有

这样形式的函数 $f()$ ，如右图所示，即平行六面体随白色向量 $(x,y,z)$ 的随机游走而不断改变。然后，问题就变成了，我们需要根据 $\mathbf{\vec v}$ 和 $\mathbf{\vec w}$ 找到一个变换（一个矩阵，或者说函数），使得上述等式成立。

并且因为 $f()$ 是线性的，可以利用对偶性，一动图胜千言

对偶性：即应用线性变换到某个向量和与这个向量点乘等价，即我们可以把1×3的变换（矩阵用来描述变换），立起来（转置），并写成点乘的形式。并把这个向量记为 $\mathbf{\vec p}$

其中向量的颜色左右对应，并且行列式的值就是右图中平行四面体的体积，然后，我们就把问题进一步变成了：寻找向量 $\mathbf{\vec p}$ 使得上述等式成立

根据点积的性质得知，当你把一个向量与其他向量点积的几何解释是，把其他向量投影到 $\mathbf{\vec p}$ 上，然后将投影长度与 $\mathbf{\vec p}$ 的长度相乘。而我们知道，对于一个平行六面体来说，体积等于底面积乘以高，高于底面积垂直，所以，作为背投影对象的 $\mathbf{\vec p}$ 必须和 $\mathbf{\vec v}$ 和 $\mathbf{\vec w}$ 构成的平面垂直，方面已经找到

至于长度，可以看到，一个向量与其他向量点积的几何解释是，把其他向量投影到 $\mathbf{\vec p}$ 上，然后将投影长度与 $\mathbf{\vec p}$ 的长度相乘，其中投影长度就是 $(x,y,z)$ 向量的长度，根据公式的形式，可以观察得，向量 $\mathbf{\vec p}$ 的长度作为第二项，只有当长度等于平行四面体面积时，上述公式（图片中的点积=行列式值的公式）才能成立。

至此，又一次利用对偶性发现了一些事物之间自然而又出乎意料的对应关系。通过几何直观来了解计算公式的由来，也是一种加深印象，深刻理解的有效途径

总结

在这里总结一下涉及到的过程，也可以通过阅读看看是否直观的理解每句话来判断掌握程度

• 首先定义了一个三维空间到数轴的线性变换（函数 $f()$ ），它是根据向量 $\mathbf{\vec v}$ 和 $\mathbf{\vec w}$ 来定义的
• 接着通过两种不同的方式来考虑这个变换的对偶向量
  • 这种计算方法引导你在第一列中插入 $\hat {\imath}$ $\hat {\jmath}$ $\hat k$ ，然后计算行列式
  • 在几何直观上，这个对偶向量一定与 $\mathbf{\vec v}$ 和 $\mathbf{\vec w}$ 垂直，并且其长度与这两个向量张成的平行四边形的面积相同

基变换

数学是一门赋予不同事物相同名称的艺术 ——昂利·庞加莱

Mathematics is the art of givinh the same name to different things -Henri Poincare

坐标系与基向量

坐标系指：发生在向量与一组数之间的任意转化，如果假设有一个向量，使用 $\hat {\imath}$ 和 $\hat {\jmath}$ 来描述是 $[\begin{smallmatrix} 3 \\ 2 \end{smallmatrix}]$ ，我们把这种描述称为：我们的语言。如果有另一组基向量，$\hat {\imath}’ = [\begin{smallmatrix} 2 \\ 1 \end{smallmatrix}] $ 和 $\hat {\jmath}’ = [\begin{smallmatrix} -1 \\ 1 \end{smallmatrix}]$ （写成列向量的形式是为了形式上的统一）来描述同样一个向量变成 $[\begin{smallmatrix} \frac{5}{3} \\ \frac{1}{3} \end{smallmatrix}]$ ，我们把这种语言记为：詹妮弗的语言

基变换

我们在之前的解释中已经说明了，在不同的【语言】之间的转化使用矩阵向量乘法，在上面的例子中，转移矩阵是 $\mathbf T = [\begin{smallmatrix} 2 & -1 \\ 1 & 1 \end{smallmatrix}]$ ，矩阵的列表示用我们的语言表达詹妮弗的基向量，称为基变换。

反过来，就是求转移矩阵的逆 $\mathbf T^{-1}$ ，称为基变换矩阵的逆，作用是可以表示从詹妮弗的基向量转换回我们的语言需要做的变换。

如何转化一个矩阵

接下来使用一个具体的例子：变换左旋转90°，在我们的语言中，和詹妮弗的语言分别是如何互相转换的来加深印象

• 左乘基变换矩阵（矩阵的列代表的是用我们的语言描述詹妮弗语言的基向量）：需要被转换的詹妮弗的语言：$[\begin{smallmatrix} -1 \\ 2 \end{smallmatrix}]$ ➜ 使用我们的语言描述来描述同一个向量
• 左乘线性变换矩阵（表示的变化为：左旋转90°）：➜变换的后的向量（还是以我们的语言来描述）
• 左乘基变换矩阵的逆：➜变换后的向量（用詹妮弗的语言来描述）

这三个矩阵合起来就是用詹妮弗语言描述的一个线性变换

总结

表达式 $\mathbf A^{-1} \mathbf M \mathbf A$ 暗示着一种数学上的转移作用

• 中间的 $\mathbf M$ 代表一种你所见的转换（例子中的90°旋转变换）
• 两侧的矩阵 $\mathbf A$ 代表着转移作用（不同坐标系间的基向量转换），即就是视角上的转换
• 矩阵乘积仍然表示着同一个变换，只不过从其他人的角度来看

这给了很多域变换的应用一个直观的理解，把这简单的几行记录清晰，

特征向量与特征值

在这一部分中，你会发现，前面提到的所有几何直观：线性变换，行列式，线性方程组，基变换会穿插其中。不仅给了你一个机会检验之前的理解是否深刻（在这一节，会添加一些超链接，方便你进行复习和定位），更多的，现在，是拼装起来感受成就感的时刻了！

What

首先，我们假设坐标系的一个基变换（对 $\hat {\imath}$ 和 $\hat {\jmath}$ 张成的空间做一个线性变换 ），即 $\hat {\imath}’ = [\begin{smallmatrix} 3\\ 0 \end{smallmatrix}] $ 和 $\hat {\jmath}’ = [\begin{smallmatrix} 1 \\ 2 \end{smallmatrix}]$ 。在变换的过程中，空间内大部分的向量都离开了它所张成的空间（即这个向量原点到终点构成的直线） ，还有一部分向量留在了它所张成的空间，矩阵对它仅仅是拉伸或者压缩而已，如同一个标量。

如上图，是给出例子中，x轴所有向量被伸长为原来的3倍，一个明显留在张成空间内的例子。另一个比较隐藏的，是$(-1,1)$这个向量，其中的任意一个向量被伸长为原来的2倍

• 变换中被留在张成空间内的向量，就是特征向量（上例x轴和$(-1,1)$）
• 其中每个向量被拉伸或抽缩的比例因子，就是特征值（上例3和2）
• 正负表示变换的过程中是否切翻转了方向

Why

三维情况，如果能找到这个不变的向量，即旋转轴（特征值必须为1）

理解线性变换的作用的关键（或者说更好的描述一个变换），更好的方法是求出它的特征向量和特征值

How

从计算角度来看特征值和特征向量，里面包含了很多对以前只是回顾和整合

根据特征向量和特征值的定义，使用数学的方法来表示即
$$
\mathbf A \mathbf{\vec v} = \lambda \mathbf{\vec v}
$$

$\mathbf A$ 是求特征值和特征向量的变换矩阵；$\mathbf{\vec v}$ 是特征向量；$\lambda$ 是特征值；目标是找 $\mathbf{\vec v}$ 和 $\lambda$

至于为何会用这个式子来定义特征向量和特征值呢，我们继续观察这个式子中的 $\lambda \mathbf{\vec v}$ ，考虑到右边是一个矩阵乘法，我们希望左右都是一个矩阵乘法，这样方便等价和计算。观察发现，$\lambda \mathbf{\vec v}$ 就是给 $\mathbf{\vec v}$ 中每一个元素都乘以 $\lambda$ 。对角矩阵 $\mathbf I$ 且对角线元素为 $\lambda$ 的矩阵也能有同样的变换结果，得到下列表达式
$$
\mathbf A \mathbf{\vec v} = (\lambda \mathbf I ) \mathbf{\vec v} \implies (\mathbf A - \lambda \mathbf I ) \mathbf{\vec v} = 0
$$
观察这个等式你会发现：可以把 $\mathbf A - \lambda \mathbf I$ 矩阵看成一个对 $\mathbf{\vec v}$ 矩阵的变换，目的是把 $\mathbf{\vec v}$ 压缩到更低的维度。而空间压缩对应的恰好就是变换矩阵的行列式为0（期待你在品读这句话的时候感受到满满的成就感，实在有难度，再结合下图）

上图显示随 $\lambda$ 可视化的变化情况，从这幅图中，使用的例子是 $[\begin{smallmatrix} 2 & 2 \\ 1 & 3 \end{smallmatrix}]$ ，特征值恰好是1

特征向量的特殊情况

旋转变换

解出特征值能发现答案是 $\pm i$ ，没有特征向量存在，即特征值出现复数的情况一般对应于变换中的某种旋转

剪切变换

Shear变换。x轴不变，只有一个特征值，为1（$(\lambda-1)^2=0$）

伸缩变换

特征值只有一个，但是是空间中所有的向量都是特征向量

特征基

对角矩阵：只有对角线非零的矩阵。解读它的方法是：所有的基向量都是特征向量。因为之前提到过，矩阵的第一列是 $\hat {\imath}$ ，第二列是 $\hat {\jmath}$ ，往后同理。这样就能发现，如果一列只有对应的位置非零，那么这个坐标轴本身就就是特征向量

一组基向量（同样是特征向量）构成的集合被称为一组：特征基

对角矩阵有一个好处是计算方便，多次矩阵乘法非常容易

这时我们就希望利用对角矩阵（基向量为特征向量）的便于计算的特性，利用上一节提到的基向量变换的方法，把特征向量作为基，对每一个矩阵进行变换后再进行计算，最后再左乘变换矩阵的逆求回原矩阵得到结果，如下图所示

但需要说明的是，并不是所有的矩阵都能对角化，比如Shear变换，它的特征向量不够多，不足以张成一个空间

抽象向量空间

线性代数的一切概念，如行列式和特征向量，它们并不受所选坐标系的影响，但是这两者是暗含于空间中的性质