之前铺垫了神经网络的基础知识，这里使用编程工具Pytorch进行一个实战讲解。首先变成一个看得见、摸得着的程序和代码，然后再说后续怎么使用GPU/NPU硬件去优化。
本文主要参考ZOMI酱《AI系统》：chenzomi12.github.io/01Introduct…
1. Pytorch介绍
参考：zhuanlan.zhihu.com/p/101799677
当前深度学习的框架有很多，其中较为出名的是Google的TensorFlow、Facebook的PyTorch，还有就是百度的paddlepaddle。今天我们拿比较简单的PyTorch来进行入门的学习。
PyTorch是一个基于Torch的Python开源机器学习库，用于自然语言处理等应用程序。 它主要由Facebook的人工智能研究小组开发。
PyTorch是一个Python包，提供两个高级功能： 具有强大的GPU加速的张量计算（如NumPy） 包含自动求导系统的的深度神经网络 * 您可以重用您最喜欢的Python包，如NumPy、SciPy和Cython，以便在需要时扩展PyTorch。 PyTorch的安装十分简单，根据PyTorch官网，对系统选择和安装方式等灵活选择即可。这里以anaconda为例，Windows10 下 Anaconda和 PyCharm 的详细的安装教程（图文并茂），简单的说一下步骤和要点。
国内安装anaconda建议使用中科大镜像，快的不是一点半点。目前中科大、清华镜像都已经关闭。直接通过prompt下载很慢，并且经常会出现HTTPERROR导致下载失败。所以可以提前下载好压缩包，然后离线下载，这样就不容易出现下载到一半下载失败令人苦恼的情况。
1.1 安装Pytorch
Anaconda安装完成后，开始创建环境，这里以win10 系统为例。打开Anaconda Prompt：
# pytorch为环境名，这里创建python3.6版。
conda create - n pytorch python = 3.6
# 切换到pytorch环境
activate pytorch
# ***以下为1.0版本安装***
# 安装GPU版本，根据cuda版本选择cuda80，cuda92，如果cuda是9.0版，则不需要
# 直接conda install pytorch -c pytorch即可
# win下查看cuda版本命令nvcc -V
conda install pytorch cuda92 - c pytorch
# cpu版本使用
conda install pytorch-cpu -c pytorch
# torchvision 是torch提供的计算机视觉工具包，后面介绍
pip install torchvision
# *** 官方更新了1.01 所以安装方式也有小的变更
# torchversion提供了conda的安装包，可以用conda直接安装了
# cuda支持也升级到了10.0
# 安装方式如下：
# cpu版本
conda install pytorch - cpu torchvision - cpu - c pytorch
# GPU版
conda install pytorch torchvision cudatoolkit = 10.0 - c pytorch
# cudatoolkit后跟着相应的cuda版本
# 目前测试 8.0、9.0、9.1、9.2、10.0都可安装成功
验证输入python 进入
import torch
torch.__version__
# 得到结果'1.1.0'
1.2 配置 Jupyter Notebook
新建的环境是没有安装ipykernel的，所以无法注册到Jupyter Notebook中，所以先要准备下环境：
# 安装ipykernel
conda install ipykernel
# 写入环境
python -m ipykernel install --name pytorch --display-name "Pytorch for Deeplearning"
下一步就是定制 Jupyter Notebook：
# 切换回基础环境
activate base
# 创建jupyter notebook配置文件
jupyter notebook --generate-config
## 这里会显示创建jupyter_notebook_config.py的具体位置
打开文件，修改
c.NotebookApp.notebook_dir = '' 默认目录位置
c.NotebookApp.iopub_data_rate_limit = 100000000 这个改大一些否则有可能报错
1.3 测试
至此 Pytorch 的开发环境安装完成，可以在开始菜单中打开Jupyter Notebook，在New 菜单中创建文件时选择Pytorch for Deeplearning，创建PyTorch的相关开发环境了
2. MNIST数据集
MNIST是一个非常有名的手写体数字识别数据集，训练样本：共60000个，其中55000个用于训练，另外5000个用于验证；测试样本：共10000个。MNIST数据集每张图片是单通道的，大小为28x28.
Pytorch支持自动下载这个数据集，在Jupyter Notebook里面输入下面的代码： In [1]:
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
import time
from matplotlib import pyplot as plt
上面先加载需要用到的库，然后就是处理数据集，如下： In [2]:
pipline_train = transforms.Compose([
#随机旋转图片
transforms.RandomHorizontalFlip(),
#将图片尺寸resize到32x32
transforms.Resize((32,32)),
#将图片转化为Tensor格式
transforms.ToTensor(),
#正则化(当模型出现过拟合的情况时，用来降低模型的复杂度)
transforms.Normalize((0.1307,),(0.3081,))
])
pipline_test = transforms.Compose([
#将图片尺寸resize到32x32
transforms.Resize((32,32)),
transforms.ToTensor(),
transforms.Normalize((0.1307,),(0.3081,))
])
#下载数据集
train_set = datasets.MNIST(root="./data", train=True, download=True, transform=pipline_train)
test_set = datasets.MNIST(root="./data", train=False, download=True, transform=pipline_test)
#加载数据集
trainloader = torch.utils.data.DataLoader(train_set, batch_size=64, shuffle=True)
testloader = torch.utils.data.DataLoader(test_set, batch_size=32, shuffle=False)
这里要解释一下Pytorch MNIST数据集标准化为什么是transforms.Normalize((0.1307,), (0.3081,))？
标准化（Normalization） 是神经网络对数据的一种经常性操作。标准化处理指的是：样本减去它的均值，再除以它的标准差，最终样本将呈现均值为0方差为1的数据分布。
神经网络模型偏爱标准化数据，原因是均值为0方差为1的数据在sigmoid、tanh经过激活函数后求导得到的导数很大，反之原始数据不仅分布不均（噪声大）而且数值通常都很大（本例中数值范围是0~255），激活函数后求导得到的导数则接近与0，这也被称为梯度消失。前文已经分析，神经网络是根据函数对权值求导的导数来调整权值，导数越大，调整幅度越大，越快逼近目标函数，反之，导数越小，调整幅度越小，所以说，数据的标准化有利于加快神经网络的训练。
除此之外，还需要保持train_set、val_set和test_set标准化系数的一致性。标准化系数就是计算要用到的均值和标准差，在本例中是((0.1307,), (0.3081,))，均值是0.1307，标准差是0.3081，这些系数都是数据集提供方计算好的数据。不同数据集就有不同的标准化系数，例如([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])就是ImageNet dataset的标准化系数（RGB三个通道对应三组系数），当需要将imagenet预训练的参数迁移到另一神经网络时，被迁移的神经网络就需要使用imagenet的系数，否则预训练不仅无法起到应有的作用甚至还会帮倒忙，
例如，我们想要用神经网络来识别夜空中的星星，因为黑色是夜空的主旋律，从像素上看黑色就是数据集的均值，标准化操作时，所有图像会减去均值（黑色），如此Imagenet预训练的神经网络很难识别出这些数据是夜空图像！
3. LeNet-5神经网络实现手写字符算法
3.1 训练过程
首先就要对MNIST书籍进行训练，就是前向传播的过程。回忆下之前讲的神经学习知识：
- Loss就是损失函数，就是预测值跟真实值的差距，要让这个损失函数越小，模型就越好。
- 预测值是根据算法f得来的，算法f例如这里的LeNet5，其由参数θ和输入x决定，那我们可以调节的就是这个参数θ
训练过程就是找这个参数θ让损失函数最小，需要用到梯度下降等高数的方法。
模型定义： LeNet5 网络模型包含有卷积（Conv2D）层，最大池化层（MaxPool2D），全连接（Linear）层。
3.1.1搭建LeNet-5神经网络结构，并定义前向传播的过程
此为核心算法，
In [3]:
class LeNet(nn.Module):
def __init__(self):
super(LeNet, self).__init__()
self.conv1 = nn.Conv2d(1, 6, 5) # 输入通道1（灰度图），输出通道6，卷积核5x5
self.relu = nn.ReLU() # ReLU激活函数
self.maxpool1 = nn.MaxPool2d(2, 2) # 池化层：窗口2x2，步长2
self.conv2 = nn.Conv2d(6, 16, 5) # 输入通道6，输出通道16，卷积核5x5
self.maxpool2 = nn.MaxPool2d(2, 2)
self.fc1 = nn.Linear(16*5*5, 120) # 全连接层：经过两次卷积核池化后，输入维度16*5*5，原本是32*32的图片，输出120
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10) # 输出10类（如MNIST数字0-9）
def forward(self, x):
x = self.conv1(x)
x = self.relu(x)
x = self.maxpool1(x)
x = self.conv2(x) #卷积
x = self.maxpool2(x) #池化
x = x.view(-1, 16*5*5) # 展平多维特征图为一维向量
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
output = F.log_softmax(x, dim=1) # 对数Softmax，适用于NLLLoss损失函数
return output
- 卷积→激活→池化：重复两次，逐步压缩空间维度并增强特征抽象能力。
- 展平操作：将
16x5x5特征图转换为16*5*5=400维向量，输入全连接层。 - 分类输出：通过
log_softmax计算对数概率，优化时需搭配NLLLoss损失函数
3.1.2 将定义好的网络结构搭载到GPU/CPU，并定义优化器
In [4]:
#创建模型，部署gpu
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = LeNet().to(device)
#定义优化器
optimizer = optim.Adam(model.parameters(), lr=0.001)
3.1.3 定义训练过程
训练过程： 遍历一个批大小（Batch Size）的数据，设置计算的 NPU/GPU 资源数量，执行前向传播计算，计算损失值（Loss），通过反向传播实现优化器计算，从而更新权重。
In [5]:
def train_runner(model, device, trainloader, optimizer, epoch):
#训练模型, 启用 BatchNormalization 和 Dropout, 将BatchNormalization和Dropout置为True
model.train()
total = 0
correct =0.0
#enumerate迭代已加载的数据集,同时获取数据和数据下标
for i, data in enumerate(trainloader, 0):
inputs, labels = data
#把模型部署到device上
inputs, labels = inputs.to(device), labels.to(device)
#初始化梯度
optimizer.zero_grad()
#保存训练结果
outputs = model(inputs)
#计算损失和
#多分类情况通常使用cross_entropy(交叉熵损失函数), 而对于二分类问题, 通常使用sigmod
loss = F.cross_entropy(outputs, labels)
#获取最大概率的预测结果
#dim=1表示返回每一行的最大值对应的列下标
predict = outputs.argmax(dim=1)
total += labels.size(0)
correct += (predict == labels).sum().item()
#反向传播
loss.backward()
#更新参数
optimizer.step()
if i % 1000 == 0:
#loss.item()表示当前loss的数值
print("Train Epoch{} \t Loss: {:.6f}, accuracy: {:.6f}%".format(epoch, loss.item(), 100*(correct/total)))
Loss.append(loss.item())
Accuracy.append(correct/total)
return loss.item(), correct/total
3.1.4 定义测试过程
In [6]:
def test_runner(model, device, testloader):
#模型验证, 必须要写, 否则只要有输入数据, 即使不训练, 它也会改变权值
#因为调用eval()将不启用 BatchNormalization 和 Dropout, BatchNormalization和Dropout置为False
model.eval()
#统计模型正确率, 设置初始值
correct = 0.0
test_loss = 0.0
total = 0
#torch.no_grad将不会计算梯度, 也不会进行反向传播
with torch.no_grad():
for data, label in testloader:
data, label = data.to(device), label.to(device)
output = model(data)
test_loss += F.cross_entropy(output, label).item()
predict = output.argmax(dim=1)
#计算正确数量
total += label.size(0)
correct += (predict == label).sum().item()
#计算损失值
print("test_avarage_loss: {:.6f}, accuracy: {:.6f}%".format(test_loss/total, 100*(correct/total)))
3.1.5 运行
In [7]:
#调用
epoch = 5
Loss = []
Accuracy = []
for epoch in range(1, epoch+1):
print("start_time",time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())))
loss, acc = train_runner(model, device, trainloader, optimizer, epoch)
Loss.append(loss)
Accuracy.append(acc)
test_runner(model, device, testloader)
print("end_time: ",time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())),'\n')
print('Finished Training')
plt.subplot(2,1,1)
plt.plot(Loss)
plt.title('Loss')
plt.show()
plt.subplot(2,1,2)
plt.plot(Accuracy)
plt.title('Accuracy')
plt.show()
start_time 2021-11-27 22:15:09
Train Epoch1 Loss: 2.312757, accuracy: 12.500000%
test_avarage_loss: 0.003749, accuracy: 96.100000%
end_time: 2021-11-27 22:15:45
start_time 2021-11-27 22:15:45
Train Epoch2 Loss: 0.069703, accuracy: 100.000000%
test_avarage_loss: 0.002672, accuracy: 97.300000%
end_time: 2021-11-27 22:16:20
start_time 2021-11-27 22:16:20
Train Epoch3 Loss: 0.025734, accuracy: 100.000000%
test_avarage_loss: 0.002858, accuracy: 97.130000%
end_time: 2021-11-27 22:16:55
start_time 2021-11-27 22:16:55
Train Epoch4 Loss: 0.155763, accuracy: 93.750000%
test_avarage_loss: 0.002237, accuracy: 97.670000%
end_time: 2021-11-27 22:17:31
start_time 2021-11-27 22:17:31
Train Epoch5 Loss: 0.020248, accuracy: 100.000000%
test_avarage_loss: 0.002280, accuracy: 97.720000%
end_time: 2021-11-27 22:18:07
Finished Training
3.1.6 保存模型
In [8]:
print(model)
torch.save(model, './models/model-mnist.pth') #保存模型
LeNet(
(conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))
(relu): ReLU()
(maxpool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
(maxpool2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(fc1): Linear(in_features=400, out_features=120, bias=True)
(fc2): Linear(in_features=120, out_features=84, bias=True)
(fc3): Linear(in_features=84, out_features=10, bias=True)
)
C:\Users\Administrator.conda\envs\pytorch\lib\site-packages\torch\serialization.py:360: UserWarning: Couldn't retrieve source code for container of type LeNet. It won't be checked for correctness upon loading.
"type " + obj.__name__ + ". It won't be checked "
3.2 推理过程
利用刚刚训练的模型进行手写图片的测试。
In [9]:
import cv2
if __name__ == '__main__':
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = torch.load('./models/model-mnist.pth') #加载模型
model = model.to(device)
model.eval() #把模型转为test模式
#读取要预测的图片
img = cv2.imread("./images/test_mnist.jpg")
img=cv2.resize(img,dsize=(32,32),interpolation=cv2.INTER_NEAREST)
plt.imshow(img,cmap="gray") # 显示图片
plt.axis('off') # 不显示坐标轴
plt.show()
# 导入图片，图片扩展后为[1，1，32，32]
trans = transforms.Compose(
[
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)#图片转为灰度图，因为mnist数据集都是灰度图
img = trans(img)
img = img.to(device)
img = img.unsqueeze(0) #图片扩展多一维,因为输入到保存的模型中是4维的[batch_size,通道,长，宽]，而普通图片只有三维，[通道,长，宽]
# 预测
#output = model(img)
#predict = output.argmax(dim=1)
#print(predict.item())
# 预测
output = model(img)
prob = F.softmax(output,dim=1) #prob是10个分类的概率
print("概率：",prob)
value, predicted = torch.max(output.data, 1)
predict = output.argmax(dim=1)
print("预测类别：",predict.item())
概率： tensor([[2.0888e-07, 1.1599e-07, 6.1852e-05, 1.5797e-04, 1.4975e-09, 9.9977e-01,
1.9271e-06, 3.1589e-06, 1.2186e-07, 4.3405e-07]],
grad_fn=<SoftmaxBackward>)
预测类别： 5
4. 算子介绍
参考：chenzomi12.github.io/01Introduct…
上面是整个神经网络的实战，其实核心的部分都被Pytorch的库给实现了，例如：
import torch
class LeNet(nn.Module):
def __init__(self):
super(LeNet, self).__init__()
...
self.conv2 = nn.Conv2d(3, 2, 5) #卷积算法参数定义
...
def forward(self, x):
out = self.conv1(x) #卷积算法
...
我们在PC上执行这个conv1卷积算法，可以使用GPU进行加速。那么这个算法内部是怎么运行呢？
首先卷积运算之前讲过，每次选取输入数据一层的一个窗口（和卷积核一样的宽高），然后和对应的卷积核（5×5 卷积核代表高 5 维宽 5 维的矩阵）进行 矩阵内积（Dot Product） 运算，最后将所有的计算结果与偏置项 b 相加后输出。
首先一次沿着行进行滑动一定的步长 Step，再进行下次矩阵内积计算，直到滑到边界后再沿着一定步长跳到下一列重复刚才的滑动窗口。最终把每一步的结果组合成输出矩阵，即产生特征图（Feature Map）。
图中输入张量形状（Tensor Shape）为 3×32×32（3 代表通道数，32 代表张量高度和宽度），经过 2×3×5×5 的卷积（2 代表输出通道数，3 代表输入通道数，5 代表卷积核高度和宽度）后，输出张量形状为 2×28×28（2 代表通道，28 代表高度和宽度）。
示例的卷积计算，最终在程序上表达为多层嵌套循环，为简化计算过程，循环展开中没有呈现维度（Dimension）的形状推导（Shape Inference）。以 Conv2D 转换为如下 7 层循环进行 Kerenl 计算的代码：
# 批尺寸维度 batch_size
for n in range(batch_size):
# 输出张量通道维度 output_channel
for oc in range(output_channel):
# 输入张量通道维度 input_channel
for ic in range(input_channel):
# 输出张量高度维度 out_height
for h in range(out_height):
# 输出张量宽度维度 out_width
for w in range(out_width):
# 卷积核高度维度 filter_height
for fh in range(filter_height):
# 卷积核宽度维度 filter_width
for fw in range(filter_width):
# 乘加（Multiply Add）运算
output[h, w, oc] += input[h + fw, w + fh, ic]\
* kernel[fw, fh, c, oc]
其实Conv2D就可以成为一个算子，在软件硬化的NPU开发中，算子就是软件硬件化的基本单位。当前AI发展的一个核心技术就是把这些嵌套且是矩阵的软件运行，使用硬件来实现，这个就是NPU出现的意义和AI科技进步的一个核心。
算子：深度学习算法由一个个计算单元组成，称这些计算单元为算子（Operator，Op）。AI 框架中对张量计算的种类有很多，比如加法、乘法、矩阵相乘、矩阵转置等，这些计算被称为算子（Operator）。
为了更加方便的描述计算图中的算子，现在来对算子这一概念进行定义：
数学上定义的算子：一个函数空间到函数空间上的映射 O：X→X，对任何函数进行某一项操作都可以认为是一个算子。
- 狭义的算子（Kernel） ：对张量 Tensor 执行的基本操作集合，包括四则运算，数学函数，甚至是对张量元数据的修改，如维度压缩（Squeeze），维度修改（reshape）等。
- 广义的算子（Function） ：AI 框架中对算子模块的具体实现，涉及到调度模块，Kernel 模块，求导模块以及代码自动生成模块。
对于神经网络模型而言，算子是网络模型中涉及到的计算函数。在 PyTorch 中，算子对应层中的计算逻辑，例如：卷积层（Convolution Layer）中的卷积算法，是一个算子；全连接层（Fully-connected Layer，FC layer）中的权值求和过程，也是一个算子。
AI算法计算过程中有很多有趣的问题：
- 硬件加速： 通用矩阵乘是计算机视觉和自然语言处理模型中的主要的计算方式，同时 NPU/GPU，如 TPU 脉动阵列的矩阵乘单元等其他专用人工智能芯片 ASIC 是否会针对矩阵乘作为底层支持？（第二章 AI 芯片体系结构相关内容）
- 片上内存：其中参与计算的输入、权重和输出张量能否完全放入 NPU/GPU 缓存（L1、L2、Cache）？如果不能放入则需要通过循环块（Loop Tile）编译优化进行切片。（第二章 AI 芯片体系结构相关内容）
- 局部性：循环执行的主要计算语句是否有局部性可以利用？空间局部性（缓存线内相邻的空间是否会被连续访问）以及时间局部性（同一块内存多久后还会被继续访问），这样我们可以通过预估后，尽可能的通过编译调度循环执行。（第三章 AI 编译器相关内容）
- 内存管理与扩展（Scale Out） ：AI 系统工程师或者 AI 编译器会提前计算每一层的输出（Output）、输入（Input）和内核（Kernel）张量大小，进而评估需要多少计算资源、内存管理策略设计，以及换入换出策略等。（第三章 AI 编译器相关内容）
- 运行时调度：当算子与算子在运行时按一定调度次序执行，框架如何进行运行时管理？（第四章推理引擎相关内容）
- 算法变换：从算法来说，当前多层循环的执行效率无疑是很低的，是否可以转换为更加易于优化和高效的矩阵计算？（第四章推理引擎相关内容）
- 编程方式：通过哪种编程方式可以让神经网络模型的程序开发更快？如何才能减少或者降低算法工程师的开发难度，让其更加聚焦 AI 算法的创新？（第五章 AI 框架相关内容）
怎么在NPU上部署AI算法？
之前我们使用的Python语言在PyTorch实现了AI算法，那就是把Python编译成二进制程序给了CPU或者GPU执行。
一个核心就是Python写的算子拆分出来，然后编译的时候用硬件去实现。对于新开发的算子，GPU就需要使用CUDA语言把这个算子给写出来，NPU上也差不多的操作。
5. AI编译器介绍
参考：chenzomi12.github.io/01Introduct…
AI 框架充分赋能深度学习领域，为 AI 算法的开发者提供了极大便利。早期的 AI 框架主要应用于学术界，如 Theano、torch 等，随着深度学习的快速发展以及在工业界的不断拓展，不断有新的 AI 框架被提出以满足不同场景的应用。
但是随着 AI 技术应用的全面发展，各厂家根据自身业务场景的需求，在 AI 硬件和算法上不断优化和探索，AI 系统的体系结构越来越复杂，更多新的 AI 加速芯片被提出来，其设计变得更加多样化，AI 框架运行的硬件环境和算法也趋于更多样和复杂，单一 AI 框架已经无法满足和平衡所有特性。所以，为了提供不同框架和硬件体系结构之间的迁移性，ONNX 等中间 IR 被提出，其定义了表示神经网络模型的统一格式，以促进不同 AI 框架之间的模型转换。
为了实现硬件的多样性，需要将神经网络模型计算映射到不同架构的硬件中执行。在通用硬件上，高度优化的线性代数库为神经网络模型计算提供了基础加速库。此外，大多数硬件供应商还发布了专属的神经网络模型计算优化库，如：MKL-DNN 和 cuDNN 等，但基于基础加速库的优化往往落后于深度学习算法模型的更新，且大多数情况下需要针对不同的平台进行定制化的开发。
为了解决多硬件平台上的性能优化的问题，多种 AI 编译器被提出并得到了普及和应用，比如：TVM ，Glow，XLA 和 Jittor 等。AI 编译器以神经网络模型作为输入，将 AI 计算任务通过一层或多层中间表达 IR 进行翻译和优化，最后转化为目标硬件上可执行的代码，与传统的编译器（LLVM）类似，AI 编译器也采用前端、中间表示和后端分层设计的方式。
目前，业界主流的芯片公司和大型互联网公司等都在 AI 编译器进行了大量的投入来推进相关技术的发展。与传统编译器相比，AI 编译器是一个领域特定的编译器，有四个明显的特征：
- Python 为主前端语言
与传统编译器不同，AI 编译器通常不需要 Lexer/Parser，而是基于前端高级编程语言（如 Python）的 AST 将神经网络模型解析并构造为计算图 IR，侧重于保留 shape、layout 等张量计算特征信息，当然部分编译器还能保留控制流的信息。其中 Python 主要是以动态解释器为执行方式。
- 多层 IR 设计
多层 IR 设计，为的是满足易用性与高性能这两种类型需求：1）为了让开发者使用方便，AI 框架会尽量对张量的计算进行抽象封装成具体的 API 或者函数，算法开发者只要关注神网络模型定义上的逻辑意义模型和算子；2）在底层算子性能优化时，可以打破算子的边界，从更细粒度的循环调度等维度，结合不同的硬件特点完成优化。
- 面向神经网络优化
面向神经网络模型特殊的数据类型进行定义。AI 领域，网络模型层的具体计算被抽象成张量的计算，这就意味着 AI 编译器中主要处理的数据类型也是张量。而在反向传播过程中，是深度学习最为具有有代表的特性，基于计算图构建的网络模型，需要具有自动微分功能。
- DSA 芯片架构支持
AI 训练和推理对性能和时延都非常敏感，所以大量使用专用的 AI 加速芯片进行计算，而 AI 编译器其实是以 DSA 架构的 AI 加速芯片作为为中心的编译器，这也是区别于通用编译器的一个特征。
如果没有 AI 框架、AI 编译器和算子库的支持，算法工程师进行简单的神经网络模型设计与开发都会举步维艰，所以应该看到 AI 算法本身飞速发展的同时，也要看到底层系统对提升整个算法研发的生产力起到了不可或缺的作用。
