URL

• paper: https://arxiv.org/pdf/2008.05711.pdf
• code: https://github.com/real-zhangzhe/lift-splat-shoot (fork from official implementation, adding comments and predictions)

TL;DR

• 本文是 BEV (bird eye view) 的开山之作，通过隐式 2D 深度估计和像素坐标到世界坐标转换，将多张（6张）车周环视图拼接得到一张鸟瞰图。
• 具体实现请看代码，代码中有非常详细的注释。

Algorithm

在 inference 过程中，下半部分的 6 张环视图为输入，上半部分的鸟瞰图为输出（地图和本算法无关）。

Dataset

• 本文使用自动驾驶数据集 nuScense
  • 官网：https://www.nuscenes.org/
  • 数据集介绍论文：https://arxiv.org/pdf/1903.11027.pdf
    
• 输入的 6 张图来自上图的 6 个绿色 camera
• 世界坐标系如图 IMU 所示原点定为 车后轴中心，x 轴正方向为车辆前进方向， y 轴正方向为面向车辆前进方向的左手边，z 轴正方向为竖直向上。

相关知识

• 相机内外参：参考 相机内参与外参
• 体素：
  • 立体像素
  • 在本文中，一个体素表示 x 方向上 0.5m，y 方向上 0.5m，z 方向上 20m 的立方体区域
  • 体素为鸟瞰视角中可区分的最小单元

算法细节

特别细节的看代码

1. 特征提取（Lift）

• 使用 EfficientNet 进行 2D 特征提取 + 隐式深度估计
  • 输入：shape = [4, 6, 3, 128, 352]，分别表示：[batch, cameras, channel, height, width]
  • 输出：shape = [24, 64, 41, 8, 22]，分别表示：[batch * cameras, features, depth, height, width]
    • 使用 64 维向量编码深度（不是直接预测深度，所以被称为隐式深度估计）
    • 深度从 4m ~ 45m，编码精度为 1m，所以有 41 种离散深度，相机坐标系下深度估计的目的是：从像素坐标转化为世界坐标
    • 长宽各下采样 16 倍，减小计算量

2. 像素坐标和相机坐标系下深度到世界坐标的映射（Splat）

• 使用如下参数将像素坐标和相机坐标系下深度映射到世界坐标
  • 相机内参
  • 相机外参
    • 旋转
    • 平移
  • 像素坐标系内变换参数（缩放 + 裁剪（平移））
    • 原图(900, 1600) -> 模型输入图(128, 352) -> 模型预测图(8, 22)
• 体素池化：将属于同一个体素的深度估计向量求和
• 输入：
  • 深度估计：shape = [24, 64, 41, 8, 22]
  • 相机内外参和缩放参数
• 输出：shape = [4, 64, 200, 200]
  • 200 * 200 个体素
    • X 方向上 [-50m, 50m) 0.5m 为一个 bin，200 个 bin
    • Z 方向上 [-50m, 50m) 0.5m 为一个 bin，200 个 bin
    • Y 方向不分 bin
  • 每个体素用 64 维向量编码
• 本质是：
  1. 构造一个 [24 * 41 * 8 * 22, 3] 的查找表，输入为 backbone 输出特征图的每一个 pixel，输出为这个 pixel 对应的世界坐标（这个查找表可由相机内外参和图像缩放系数计算得到）
  2. 将离散的世界坐标点合并，合并规则是属于同一个体素的坐标点则合并

3. 体素编码降维（Shoot）

• 输入：shape = [4, 64, 200, 200]
• 输出：shape = [4, 1, 200, 200]，BEV 图

4. 训练 loss

非常简单粗暴

• 将 GT bbox3d 同样映射到 BEV 空间 [4, 1, 200, 200]，然后做 pixel-wise loss（分割 loss）

Thought

• 代码中 像素坐标和相机坐标系下深度到世界坐标的映射 部分比较难懂，需要较强的相机成像原理 / 图像 2D 转 3D 背景才能看懂

URL

• paper: https://arxiv.org/pdf/2103.14030.pdf
• code: https://github.com/microsoft/Swin-Transformer

TL;DR

• 本文提出一种新型 Transformer 结构使用 Window Multi-head Self-attention (W-MSA) 和 Shifted Window Multi-head Self-attention (SW-MSA) 结构替代原始 Transformer 使用的 Multi-head Self-attention (MSA) 结构。
  • 大大节省了原始 Transformer 的计算复杂度。
  • 在视觉任务中吊打了一众 CNN 和 Transformer。

Algorithm

总体结构

• swin-Transformer 总体按照类似 CNN 的层次化构建方式构建网络结构，分为 4 个 stage，每个 stage 都会将分辨率缩小一倍，channel 数扩大一倍 （like vgg） 。
• Swin Tranformer Block 像大多数 Transformer Block 一样，不改变输入特征 shape，可以看做是一种比较高级（加入了 self-attention）的激活函数。
• 图中 Swin Tranformer Block 都是以连续偶数次出现，因为是一个 W-MSA Transformer Block + 一个 SW-MSA Transformer Block，如右边子图 b 所示。

Patch Partition

• 作用与 ViT 第一步很像：将图片切成若干等大小不重叠的 patch，patch_size = P，然后把每个 patch 从 (P, P, c) 拉成 1 维。
• 本实验中 patch_size = 4，所以一张图被裁切成了 $\frac{H}{4}\times\frac{W}{4}$ 个长度为 4 * 4 * 3 = 48 的向量。

Linear Embedding

• 与一个 shape = (48, C) 的矩阵乘将 48 维映射到 C 维。

与上一步结合可以变成一个 in_channel = 3, out_channel = C, kernel_size = stride = 4 的 Conv2d，官方实现中实际上也是这么做的（ class PatchEmbed ）。

Patch Merging

• 由两步组成，作用是 将分辨率缩小一倍，channel 扩大一倍。
  • 将 $\frac{H}{4}\times\frac{W}{4}\times C$ 的输入使用 bayer2rggb (space2depth with block_size = 2) 变成 $\frac{H}{8}\times\frac{W}{8}\times 4C$ 。
  • 再将 $\frac{H}{8}\times\frac{W}{8}\times 4C$ 与一个 $4C\times 2C$ 的矩阵相乘，输出一个 $\frac{H}{8}\times\frac{W}{8}\times 2C$ 的矩阵。

W-MSA

• 全称为 Windows Multi-head Self-attention，目的是为了减少 Self-attention 计算量。
  • 原始的 MSA 会直接对完整输入计算其 self-attention 结果
  • W-MSA 先将输入拆成大小为 $M\times M$ 且互不重叠的 windows，然后计算每个 window 的 self-attention 结果。
  • 计算公式还是: $Attention(Q, K, V) = softmax(\frac{QK^T}{\sqrt{d_k}})V$
• MSA 和 W-MSA 计算量对比（假设输入特征图 $X \in \mathbb{R}^{H\times W\times C}$，且 $W_q,W_k,W_v \in \mathbb{R}^{C\times C}$，且 Multi-head 的 head 数为 1)：

  • MSA 计算量：

    • X -> Q / K / V 计算量：$\mathbb{R}^{H\times W\times C}\times \mathbb{R}^{C\times C}$ 计算量为 $3HWC^2$ 。

    • $QK^T$ 计算量：$\mathbb{R}^{HW\times C}\times \mathbb{R}^{C\times HW}$ 计算量为 $H^2W^2C$ 。

    • 不考虑 softmax 和 $\frac{..}{\sqrt{d_k}}$ 计算量。

    • softmax 结果 $\times V$ 计算量： $\mathbb{R}^{HW \times HW}\times \mathbb{R}^{HW \times C}$ 计算量为 $H^2W^2C$ 。

    • 因为需要 Multi-head，所以需要将 $\times V$ 之后的矩阵再 $\times W_o$，且 head 数为 1，计算量： $\mathbb{R}^{1*HW \times C}\times \mathbb{R}^{C \times C}$ 计算量为 $HWC^2$ 。

    • 总计算量： $4HWC^2 + 2H^2W^2C$ 。

  • W-MSA 计算量：

    • 上图的 $H\rightarrow M,\ W\rightarrow M$，一共重复 $\frac{HW}{M^2}$ 次，所以总计算量为：

    $(4M^2C^2 + 2M^4C)\times \frac{HW}{M^2}=4HWC^2+2HWM^2C$

  • 相比之下 W-MSA 会比 WSA 计算量少： $2HWC(HW-M^2)$ 。

SW-MSA

• 为了节省计算量 W-MSA 会将输入的完整特征图分 window，每个 window 独立去做 self-attention，这会导致 window 之间的关联性消失，这有悖于 self-attention 会在全图上建立长距离全局相关性依赖的特点。
• 所以，作者引入 SW-MSA 的方案通过 滑窗 解决这一问题。
  
• 滑窗会带来边角处的零碎区域（长或宽小于 window_size 的区域），由于 $H \% M = 0,\ W \% M = 0$ (W-MSA 要求)，所以零碎的区域可以通过调整位置拼成完整 window 。
• 完整的滑窗区域与 W-MSA 一样独立做 Self-attention。
• 由零碎区域拼成的滑窗区域中：

  • 本属于同一零碎区域的位置可以 Self-attention 。

  • 本不属于同一零碎区域的位置在原图上不相邻，不能做 Self-attention 。

  • 具体做法是来自不同区域位置之间的 Self-attention 被 mask 掉 ，只保留来自相同区域的位置间的 Self-attention 。

W-MSA + SW-MSA

• 如网络结构图子图 b 所示，W-MSA 连接 SW-MSA 之后，数学表示：
  $\hat{z}^l=W-MSA(LN(z^{l-1})) + z^{l-1}$
  $z^l=MLP(LN(\hat z^l)) + \hat z^l$
  $\hat z^{l+1} = SW-MSA(LN(z^l))+z^l$
  $z^{l+1} = MLP(LN(\hat z^{l+1}))+\hat z^{l+1}$

Relative Position Bias

• 对 Self-attention 加上 相对位置偏置 bias 之后，精度提升巨大。
• 原始 Self-attention： $Attention(Q, K, V) = softmax(\frac{QK^T}{\sqrt{d_k}})V$ 。
• Relative Position Bias Self-attention： $Attention(Q, K, V) = softmax(\frac{QK^T}{\sqrt{d_k}} + Bias)V$ 。
  

Through

• 质疑了很多人都没有质疑的点，例如给 Self-attention 加上相对位置偏置。
• 本质是对 Tranformer 的一种很 work 的加速方法。
• 但 Shift window 逻辑比较复杂，没有经典模型该有的简约美，盲猜之后会被更 make sense 的结构替代。

Python 闭包 (closure)

闭包定义

• 闭包: 在一些语言中，在函数中可以（嵌套）定义另一个函数时，如果内部的函数引用了外部的函数的变量，则可能产生闭包。闭包可以用来在一个函数与一组“私有”变量之间创建关联关系。在给定函数被多次调用的过程中，这些私有变量能够保持其持久性。
• 支持将函数当成对象使用的编程语言，一般都支持闭包。比如 Python, JavaScript。

闭包的示例

• 代码

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

  def function_1(arg_1): def function_2(arg_2): return arg_1 * arg_2 return function_2 times_8 = function_1(8) out = times_8(9) print(f"times_8(9) = {out}") # 闭包中的 cell print(f"times_8.__closure__ = {times_8.__closure__}") # 闭包中的 cell 对象的内容 print("times_8.__closure__.cell_contents:") for i in times_8.__closure__: print(i.cell_contents)

• 输出

  1 2 3 4

  times_8(9) = 72 times_8.__closure__ = (<cell at 0x7ff39d4d2a30: int object at 0x5642a56c5e20>,) times_8.__closure__.cell_contents: 8

闭包的用处

1. 可以读取函数内部的变量

• 如上面给出的例子

2. 让这些变量的值始终保持在内存中

• 例如一个棋盘游戏，棋子每次可以选择上下左右方向中的一个，在此方向上移动距离 step，使用闭包实现代码如下：

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

  def create(pos=[0, 0]): def go(direction, step): new_x = pos[0] + direction[0] * step new_y = pos[1] + direction[1] * step pos[0] = new_x pos[1] = new_y return pos return go player = create() print(player([1, 0], 10)) print(player([0, 1], 20)) print(player([-1, 0], 10))

• 输出

  1 2 3

  [10, 0] [10, 20] [0, 20]

棋子每次更新后的位置都会存储在闭包中。

3. 用于装饰器

• 可以读取函数内部的变量 和 让这些变量的值始终保持在内存中 都可以使用 Python 的类实现，但 装饰器 是闭包的一个典型用处。

装饰器 (Decorators)

装饰器的定义

• 装饰器: 由闭包的概念引申而来，是一种 增加函数或类功能的方法，它可以快速地给不同的函数或类传入相同的功能。

函数装饰器的示例

• 代码

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

  import time def count_time(some_fun): def wrapper(): t1 = time.time() some_fun() print(f"运行时间为: {round(time.time() - t1, 2)} s") return wrapper # 装饰器语法糖 @count_time def function_1(): time.sleep(1) print("run function_1") function_1() # 不使用语法糖的方法 def function_2(): time.sleep(1) print("run function_2") new_function = count_time(function_2) new_function()

• 输出

  1 2 3 4

  run function_1 运行时间为: 1.0 s run function_2 运行时间为: 1.0 s

类别装饰器示例

• 代码

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

  import time class Timer: def __init__(self, func) -> None: self.func = func def __call__(self, *args, **kwargs): start = time.time() ret = self.func(*args, **kwargs) print(f"Time: {time.time()-start}") return ret # 使用装饰器语法糖实现 @Timer def add_1(a, b): time.sleep(1) print(f"{a} + {b} = {a+b}") add_1(2, 3) # 不使用装饰器语法糖实现 def add_2(a, b): time.sleep(1) print(f"{a} + {b} = {a+b}") new_add_2 = Timer(add_2) new_add_2(2, 3)

• 输出

  1 2 3 4

  2 + 3 = 5 Time: 1.0011768341064453 2 + 3 = 5 Time: 1.001098394393921

URL

• https://arxiv.org/pdf/2106.08295.pdf

TL;DR

• 本文用比较简洁的方式给出了神经网络的通用量化方法，是量化领域的必读论文。

Algorithm

1. 量化基础知识

1.1 硬件背景

• 一个 $y=Wx+b$ 实际上是由 乘法器 和 累加器 组合而成的，实际的计算过程如下：
  

卷积实际上也是通过 image to column 操作变成 $y=Wx+b$ 操作

• 常见的 int8 量化会将上述过程变成如下过程：
  

weight 和 input 都被量化为 int8 ，同时保留各自的量化 scale，乘法操作是整形乘法器（更快），累加器是 int32 类型，最后再量化为 int8 放到 OCM 上

1.2 均匀仿射量化

• 均匀仿射量化也被称为 非对称量化，由三个量化参数定义：
  • 比例因子 scale
  • 零点 zero_point
  • 比特宽度 bits
• 非对称量化：
  • for unsigned integers: $X_{int} = clamp(\lfloor\frac{X}{s}\rceil+z;0,2^b-1)$
  • for signed integers: $X_{int} = clamp(\lfloor\frac{X}{s}\rceil+z;-2^{b-1},2^{b-1}-1)$
  • 这里的 $\lfloor\rceil$ 表示 round 运算
• 对称量化是非对称量化的简化版本，是将零点 zero_point 固定为 0
• 对称量化：
  • for unsigned integers: $X_{int} = clamp(\lfloor\frac{X}{s}\rceil;0,2^b-1)$
  • for signed integers: $X_{int} = clamp(\lfloor\frac{X}{s}\rceil;-2^{b-1},2^{b-1}-1)$
• 对称量化和非对称量化的含义：
  
  
• 2 的指数幂量化：
  • 限制 $s=2^{-k}$
  • 优势：scale 过程变成了硬件移位，对硬件更友好。
  • 劣势：会使得 round 和 clip 误差的权衡变难。
• 量化颗粒度：
  • per-tensor: 硬件更友好，但限制了量化的自由度。
  • per-channel: 反之。

1.3 量化模拟

• 量化模拟是指在浮点计算设备上模拟定点计算设备的过程，通常用于训练。
  

左边是定点计算过程，右边是用浮点设备模型定点计算的过程

• 为了减少数据搬运和不必要的量化步骤，通常会做：
  • batch norm 折叠：batch norm 在推理时是静态的，因此可以和前面的 conv 等层合并。
  • 激活函数融合：在实际的硬件解决方案中，通常会在非线性操作（如 ReLU）之后直接进行量化，而不是先将激活写入内存然后再加载回计算核心。

1.4 实践考量

• 对称量化和非对称量化：
  • 对称量化：zero-point == 0
  • 非对称量化：zero-point != 0
• 为了方便计算，通常情况下，会将权重设置为对称量化（$z_w=0$），将特征设置为非对称量化（$z_x\ne 0$）
  • 原因分析：
    • $W=S_w(W_{int} - Z_w)$
    • $X=S_x(X_{int} - Z_x)$
    • $WX=S_wS_x(W_{int} - Z_w)(X_{int} - Z_x)\\=S_wS_xW_{int}X_{int}-S_wS_xZ_wX_{int}-S_wS_xZ_xW_{int}+S_wS_xZ_wZ_x$
    • 在推理阶段：$S_w,\ S_x,\ Z_w,\ Z_x,\ W_{int}$ 已知，因此：
      • 等式的第三项和第四项可提前算出，无需推理耗时。
      • 第一项和第二项由于关联动态输入 $X_{int}$，因此需要额外耗时；但是如果设置 $Z_w=0$，则第二项恒等于0，可节省计算量。

2. 训练后量化（PTQ，post-training quantization）

• 训练后量化是指用 float32 精度训练的模型直接转成量化模型，无需任何数据和训练。

2.1 量化范围的设置

• 最大最小值法（min-max）：$q_{min}=minV,\ \ q_{max}=maxV$，$V$ 是待量化 tensor
• 均方差法（MSE）：$\argmin_{q_{min},q_{max}}||V-\hat{V}(q_{min}, q_{max})||^2_F$
• 交叉熵法（cross entropy）：$\argmin_{q_{min},q_{max}}=H(softmax(V),softmax(\hat{V}(q_{min},q_{max})))$，其中 $H$ 表示 cross entropy function
• 批量归一化法（BN based）：$q_{min}=min(\beta-\alpha\gamma),\ \ q_{max}=max(\beta+\alpha\gamma)$，其中 $\beta,\ \gamma$ 分布表示 batch norm 学到的 per channel 的 shift 和 scale，$\alpha>0$ 是超参数
• 组合法（comparsion）：以上方法的自由组合
  
  

使用不同量化方法分别量化 weight 和 activation 后的精度

2.2 跨层均衡（Cross-Layer Equalization）

• 这是一种 通过修改模型权重 来改善神经网络量化性能的技术，CLE 的目的是减少网络中不同 channel 之间由于量化引起的性能不平衡，这种问题在 depth-wise conv layer 中尤其容易出现。
  

mobilenetv2 第一个 depth-wise conv 层的 per output channel weight range

• 想要实现跨层均衡的模型，需要激活函数满足交换律，即：$f(sx)=sf(x)$，常见的 ReLU 和 PReLU 都满足。
  
• CLE 原理：
  • $y=f(W_2(W_1x+b_1)+b_2)\\=f(SW_2(S^{-1}W_1x+S^{-1}b_1)+b_2)\\=f(\hat{W_2}(\hat{W_1}x+\hat{b_1})+b_2)$
  • 其中：
    • $\hat{W_1}=S^{-1}W_1$
    • $\hat{b_1}=S^{-1}b_1$
    • $\hat{W_2}=SW_2$
    • $S_i=\frac{\sqrt {r_i^1r_i^2}}{r_i^2}$，其中 $r_i^j$ 表示 j tensor 的 i channel
• abosrbing high bias 是一种 解决模型中过大 bias 的技术，原理是：
  • $y=W_2h+b_2\\=W_2(f(W_1x+b_1))+b_2\\=W_2(f(W_1x+b_1)+c-c)+b_2\\=W_2(f(W_1x+\hat{b_1})+c)+b_2\\=W_2(f(W_1x+\hat{b_1}))+\hat{b_2}\\=W_2\hat{h}+\hat{b_2}$
  • 其中：
    • $\hat{b_2}=b_2+W_2c$
    • $\hat{h}=h-c$
    • $\hat{b_1}=b_1-c$
    • $c_i=max(0, min_x(W_{1i}x+b_{1i}))$

WIP

URL

https://mlc.ai/zh/chapter_tensor_program/index.html

元张量函数

• 元张量函数 表示机器学习模型计算中的单个单元计算。
  • 一个机器学习编译过程可以有选择地转换元张量函数的实现。

张量程序

• 张量程序 是一个表示元张量函数的有效抽象。
  • 关键成分包括: 多维数组，循环嵌套，计算语句。
  • 程序变换可以被用于加速张量程序的执行。
  • 张量程序中额外的结构能够为程序变换提供更多的信息。

TensorIR: 张量程序抽象案例研究

• TensorIR 是标准机器学习编译框架 Apache TVM 中使用的张量程序抽象。

目标

• 使用 TensorIR 张量程序抽象 ReLU(A @ B) 张量函数。
• 数学表示：
  • $Y_{i,j}=\sum_k A_{i,k}\times B_{k,j}$
  • $C_{i,j}=ReLU(Y_{i,j})=max(Y_{i,j}, 0)$

不同实现方法

使用 Numpy 实现

1
2
3
4
5

dtype = "float32"
a_np = np.random.rand(128, 128).astype(dtype)
b_np = np.random.rand(128, 128).astype(dtype)
# a @ b is equivalent to np.matmul(a, b)
c_mm_relu = np.maximum(a_np @ b_np, 0)

使用 Low Level Numpy 实现

Low Level Numpy 是指只使用 Numpy 的数据结构而不调用 Numpy 的 API

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

# Use low level numpy to implement matmal ReLU
def lnumpy_mm_relu(A: np.ndarray, B: np.ndarray, C: np.ndarray):
    Y = np.empty((128, 128), dtype="float32")
    for i in range(128):
        for j in range(128):
            for k in range(128):
                if k == 0:
                    Y[i, j] = 0
                Y[i, j] = Y[i, j] + A[i, k] * B[k, j]
    for i in range(128):
        for j in range(128):
            C[i, j] = max(Y[i, j], 0)

使用 TensorIR 实现

TensorIR 是 TVMScript 中的一种 Python 方言

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

import tvm
from tvm.ir.module import IRModule
from tvm.script import tir as T
@tvm.script.ir_module
class MyModule:
    @T.prim_func
    def mm_relu(A: T.Buffer[(128, 128), "float32"],
                B: T.Buffer[(128, 128), "float32"],
                C: T.Buffer[(128, 128), "float32"]):
        T.func_attr({"global_symbol": "mm_relu", "tir.noalias": True})
        Y = T.alloc_buffer((128, 128), dtype="float32")
        for i, j, k in T.grid(128, 128, 128):
            with T.block("Y"):
                vi = T.axis.spatial(128, i)
                vj = T.axis.spatial(128, j)
                vk = T.axis.reduce(128, k)
                with T.init():
                    Y[vi, vj] = T.float32(0)
                Y[vi, vj] = Y[vi, vj] + A[vi, vk] * B[vk, vj]
        for i, j in T.grid(128, 128):
            with T.block("C"):
                vi = T.axis.spatial(128, i)
                vj = T.axis.spatial(128, j)
                C[vi, vj] = T.max(Y[vi, vj], T.float32(0))

TensorIR 代码与 Low Level Numpy 代码对比

函数参数

1
2
3
4
5
6
7
8

# TensorIR
def mm_relu(A: T.Buffer[(128, 128), "float32"],
            B: T.Buffer[(128, 128), "float32"],
            C: T.Buffer[(128, 128), "float32"]):
    ...
# numpy
def lnumpy_mm_relu(A: np.ndarray, B: np.ndarray, C: np.ndarray):
    ...

buffer

1
2
3
4

# TensorIR
Y = T.alloc_buffer((128, 128), dtype="float32")
# numpy
Y = np.empty((128, 128), dtype="float32")

循环

1
2
3
4
5
6

# TensorIR
for i, j, k in T.grid(128, 128, 128):
# numpy
for i in range(128):
    for j in range(128):
        for k in range(128):

计算块

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

# TensorIR
with T.block("Y"):
    vi = T.axis.spatial(128, i)
    vj = T.axis.spatial(128, j)
    vk = T.axis.reduce(128, k)
    with T.init():
        Y[vi, vj] = T.float32(0)
    Y[vi, vj] = Y[vi, vj] + A[vi, vk] * B[vk, vj]
# coressponding numpy code
vi, vj, vk = i, j, k
if vk == 0:
    Y[vi, vj] = 0
Y[vi, vj] = Y[vi, vj] + A[vi, vk] * B[vk, vj]

块（Block） 是 TensorIR 中的基本计算单位。

• 值得注意的是，对于一组固定的 vi 和 vj，计算块在 Y 的空间位置 (Y[vi, vj]) 处生成一个点值，该点值独立于 Y 中的其他位置（具有不同的vi, vj 值的位置）。我们可以称 vi、vj 为 空间轴，因为它们直接对应于块写入的缓冲区空间区域的开始。 涉及归约的轴（vk）被命名为 归约轴。
• 空间轴上的每个点都独立于其他点。

1
2
3
4
5
6

vi = T.axis.spatial(128, i)
vj = T.axis.spatial(128, j)
vk = T.axis.reduce(128, k)
# 使用语法糖可等价写成如下形式
# SSR means the properties of each axes are "spatial", "spatial", "reduce"
vi, vj, vk = T.axis.remap("SSR", [i, j, k])

函数属性

1

T.func_attr({"global_symbol": "mm_relu", "tir.noalias": True})

其中：

• global_symbol 对应函数名。
• tir.noalias 是一个属性，表示所有的缓冲存储器不重叠。

装饰器

• @tvm.script.ir_module 表示被装饰的类是一个 IRModule。
• @T.prim_func 表示被装饰的函数是一个张量函数。

URL

https://mlc.ai/zh/chapter_introduction/index.html

什么是机器学习编译

• 机器学习编译 (machine learning compilation, MLC) 是指，将机器学习算法从开发阶段，通过变换和优化算法，使其变成部署状态。
  

机器学习的痛点之一是：训练框架繁多/部署终端种类繁多，开发与部署存在 gap 。

• 开发形式 是指我们在开发机器学习模型时使用的形式。典型的开发形式包括用 PyTorch、TensorFlow 或 JAX 等通用框架编写的模型描述，以及与之相关的权重。
• 部署形式 是指执行机器学习应用程序所需的形式。它通常涉及机器学习模型的每个步骤的支撑代码、管理资源（例如内存）的控制器，以及与应用程序开发环境的接口（例如用于 android 应用程序的 java API）。
• 机器学习编译的目标
  • 集成与最小化依赖
  • 利用硬件加速
  • 通用优化

机器学习编译的关键要素

• 张量
• 张量函数
• 抽象：做什么
• 实现：怎么做
  

绿色节点表示张量，白色节点表示张量函数

机器学习编译过程中的张量函数变换过程

抽象和实现

总结

• 机器学习编译的目标
  • 集成与最小化依赖
  • 利用硬件加速
  • 通用优化
• 为什么学习机器学习编译
  • 构建机器学习部署解决方案
  • 深入了解现有机器学习框架
  • 为新兴硬件建立软件栈
• 机器学习编译的关键要素
  • 张量和张量函数
  • 抽象和实现是值得思考的工具

需求弹性

• 弹性：衡量需求量或供给量对其某种决定因素的变动的反应程度的指标。
• 需求价格弹性（Price elasticity of demand）：衡量一种物品需求量对其价格变动反应程度的指标，用需求量变动百分比除以价格变动百分比来计算。

需求价格弹性的决定因素

• 相似替代品的可获得性
• 必需品和奢侈品：必需品往往缺乏弹性，奢侈品往往富有弹性。
• 市场的定义：任何一个市场的需求弹性都取决于我们如何划定市场的边界，狭窄定义的市场比宽泛定义的市场的弹性更大，例如：香草冰淇淋的弹性很大，但冰淇淋的弹性较小。
• 时间范围：物品的需求往往在长期内更富有弹性。

需求价格弹性的计算

$Price\ elasticity\ of\ demand=\frac{Demand\ change\ Percentage}{Price\ change\ percentage}\ \ \ ,(change\ percentage >= 0)$
假设某种物品存在如下两个需求价格统计点：

• A：价格 4 / 需求量 120
• B：价格 6 / 需求量 80
  则需求价格弹性计算可知：
• $A -> B\ Price\ elasticity\ of\ demand = \frac{(120 - 80)/120}{(6 - 4)/4}=\frac{2}{3}$
• $B -> A\ Price\ elasticity\ of\ demand = \frac{(120 - 80)/80}{(6 - 4)/6}=1.5$
  可以看出 A -> B 的需求价格弹性和 B -> A 的需求价格弹性不一致，因此提出中点法。

中点法：一个计算变动百分比和需求价格弹性更好的方法
$Price\ elasticity\ of\ demand = \frac{(Q_2-Q_1)/[(Q_2+Q_1)/2]}{(P_2-P_1)/[(P_2+P_1)/2]}$

• A -> B 的中点 C：价格 5 / 需求量 100
• 因此 $A \rightarrow B\ and\ B \rightarrow A\ Price\ elasticity\ of\ demand = \frac{(120-80)/100}{(6-4)/5} = 1$

各种需求价格曲线

总收益

• 总收益：一种物品的买者支付从而卖者得到的量，用该物品的价格乘以销售量来计算。
  

可以由上图中阴影部分表示

• 当需求富有弹性（价格弹性大于 1 ）时，价格和总收益反方向变动；价格上升，总收益减少。
• 当需求缺乏弹性（价格弹性小于 1 ）时，价格和总收益同方向变动；价格上升，总收益增加。
• 如果需求是单位弹性的（价格弹性等于 1 ）时，价格变动，总收益保持不变。

其他需求弹性

• 需求收入弹性：衡量一种物品需求量对消费者收入变化反应程度的指标；用需求量变动百分比除以收入变动百分比来计算。
• 需求交叉价格弹性：衡量一种物品需求量对另一种物品价格变动的反应程度的指标；用第一种物品的需求量变动百分比除以第二种物品的价格变动百分比来计算。

供给弹性

市场与竞争

• 市场：由某种物品或服务的买者与卖者组成的一个群体。
• 竞争市场：由许多买者与卖者，以至于每个人对市场价格的影响微乎其微的市场。

需求

• 需求量：买者愿意并且能够购买的一种商品的数量。
• 需求定理：认为在其他条件不变时，一种物品的价格上升，对该物品的需求量减少的观点。
• 需求表：表示一种物品的价格和需求量之间关系的表格（离散）。
• 需求曲线：表示一种物品的价格和需求量之间关系的曲线（连续）。
  市场需求是个人需求之和，一个市场的需求量是所有买者在每一价格水平下需求量的总和。
  
• 需求增加：使每一种价格水平下的需求量都增加的任何变动，都会使 需求曲线向右移动，我们称之为需求增加。
• 需求减少：使每一种价格水平下的需求量都减少的任何变动，都会使 需求曲线向左移动，我们称之为需求减少。

影响需求的因素

• 价格
• 收入
  • 正常物品：在其他条件相同时，收入增加引起需求量增加 的物品。
  • 低档物品：在其他条件相同时，收入增加引起需求量减少 的物品。
• 相关物品的价格
  • 替代品：一种物品需求量 上升 引起另一种物品需求量 上升 的两种物品。
  • 互补品：一种物品需求量 上升 引起另一种物品需求量 下降 的两种物品。
• 爱好
• 预期
• 买者的数量

其中，除了 “价格” 因素是将需求沿着需求曲线移动之外，其余的因素都会使得需求曲线移动。

供给

• 供给量：卖者愿意并且能够出售的一种商品的数量。
• 供给定理：认为在其他条件不变时，一种物品的价格上升，对该物品的供给量增加的观点。
• 供给表：表示一种物品的价格和供给量之间关系的表格（离散）。
• 供给曲线：表示一种物品的价格和供给量之间关系的曲线（连续）。
  市场供给是个人供给之和，一个市场的供给量是所有卖者在每一价格水平下供给量的总和。
  
• 供给增加：使每一种价格水平下的供给量都增加的任何变动，都会使 需求曲线向右移动，我们称之为供给增加。
• 供给减少：使每一种价格水平下的供给量都减少的任何变动，都会使 供给曲线向左移动，我们称之为供给减少。

影响供给的因素

• 价格
• 投入品价格
• 技术
• 预期
• 卖者的数量

其中，除了 “价格” 因素是将需求沿着供给曲线移动之外，其余的因素都会使得供给曲线移动。

供给与需求的组合

• 均衡：市场价格达到使供给量与需求量相等的水平时的状态。
• 均衡价格：使供给与需求达到均衡状态的价格。
• 均衡数量：均衡价格下的供给量与需求量。
  
• 过剩：供给量大于需求量的状态。
• 短缺：需求量大于供给量的状态。
• 供求定理：认为任何一种物品的价格都会自发调整，使该物品的供给与需求达到平衡的观点。

分析均衡变动的三个步骤

1. 确定该事件是使供给曲线移动还是需求曲线移动（或者使两者都移动）
2. 确定曲线的移动方向
3. 用供求图说明这种移动如何改变均衡价格和均衡数量
   

• 需求供给变化笛卡尔积表
  

一个现代经济寓言

• 根据 “人们面临权衡取舍” 原理可知，生产者生产存在生产可能性边界，上图蓝色的直线表示生产可能性边界。
• Frank 每 8 小时可生产 8 oz 肉或者 32 oz 土豆。
• Ruby 每 8 小时可生产 24 oz 肉或者 48 oz 土豆。
• 没有贸易时，Frank 按照点 A 进行生产，每天可收货 4 oz 肉和 16 oz 土豆，Ruby 按照点 B 进行生产，每天可收货 12 oz 肉和 24 oz 土豆。
  
  
  
• 当存在贸易时，Frank 只生产土豆，每天可获得 32 oz 土豆；Ruby 每天生产 18 oz 肉和 12 oz 土豆。
• Frank 使用 15 oz 土豆换取 Ruby 5 oz 肉，则 Frank 每天可收货 5 oz 肉和 17 oz 土豆；Ruby 每天可收货 13 oz 肉和 27 oz 土豆。
• “贸易可以使每个人情况变得更好”，Frank 和 Ruby 通过贸易都变得更好。
  
  

比较优势：专业化的动力

• 贸易使每个人都变得更好的原因：专业化
• 专业化的动力：比较优势
• 绝对优势和比较优势：
  • 绝对优势 ：一个生产者比另一个生产者更少的投入生产某种商品的能力。Ruby 在生产土豆和肉的方面相较于 Frank 都有绝对优势。
  • 比较优势：一个生产者以低于另一个生产者的 机会成本 生产某种物品的能力。由下表可知，Ruby 在生产肉方面相较于 Frank 有比较优势，Frank 在生产土豆方面相较于 Ruby 有相对优势。

  机会成本：为了得到某种东西所必须放弃的东西。
  
  贸易可以使参与贸易的每个人都获益，因为它使人们可以专门从事他们具有比较优势的活动。
  对于在贸易中获益的双方而言，贸易的价格一般在两种机会成本之间。

• 由此根据上表可知：Ruby 和 Frank 肉的贸易应该在 2 ~ 4 oz 土豆之间。

作为科学家的经济学家

• 科学方法：观察、理论和进一步观察
• 假设的作用：假设可以使复杂的世界简单化，从而使解释这个世界变得更为容易。
• 经济模型：经济学家使用经济模型来解释经济行为。
  

循环流量图模型: 上图阐述了企业和家庭相互交易的经济行为，绿色箭头表示货币流向，红色箭头表示商品和服务流向。

• 生产可能性边界：表示在可能的生产要素与生产技术既定时，一个经济所能生产的产品数量的各种组合的图形。
• 上图 生产边界模型 中的任何一点都表示电脑和汽车的产量组合。阴影部分是可以达到的生产效率。
• F、A、B、E 都是以可以达到的最高效率生产产量。
• D 是低效率的生产方式。由于某种原因（例如：大规模失业），该经济的产量小于他可以获得的资源中所能得到的最大产量。
• C 是无法达到的生产效率。
  
  上图表示由于某种原因（例如：电脑生产技术的升级），导致生产可能性边界向上移动。
  最终导致的结果是：电脑和汽车的产量都可以提高。

• 微观经济学：研究家庭和企业如何做出决策，以及它们如何在市场上相互交易的学科。
• 宏观经济学：研究整体经济现象，包括通货膨胀、失业和经济增长的学科。

作为政策顾问的经济学家

• 实证表述：试图描述世界是什么样子的观点。
• 规范表述：试图描述世界应该是什么样子的观点。
  例如：

“最低工资法引起了失业” 是一句实证表述。
“政府应该提高最低工资” 是一句规范表述。

• 凯恩斯的观点：经济学家和政治哲学家的思想，无论正确与否，实际上都要比一般所想象的更有力量。事实上，这个世界就是由他们统治的。那些自认为能够免受经济学家思想影响的实干家往往只是某些已故经济学家的俘虏。那些当权狂人信奉的其实也不过是若干年前某些末流学者的狂妄思想。

经济学家意见分歧的原因

有两个基本原因：

• 实证分析角度：经济学家可能对世界如何运行的不同实证理论哪一种正确有着不同的看法。
• 规范分析角度：经济学家可能有不同的价值观，因此对政策应该努力实现的目标有不同的规范观点。
  具体来说有三种可能的原因：
• 科学判断不同
• 价值观不同
• 感觉与现实