01.srt

1
00:00:00,000 --> 00:00:04,560
[字幕生成：BLACK 字幕校对：志宇]

2
00:00:05,320 --> 00:00:06,360
哈喽大家好

3
00:00:06,360 --> 00:00:07,480
我是ZOMI

4
00:00:07,480 --> 00:00:09,520
今天开辟一个新的内容

5
00:00:09,520 --> 00:00:11,280
叫做AI编译器

6
00:00:11,280 --> 00:00:13,600
AI编译器这个内容其实很无聊

7
00:00:13,600 --> 00:00:14,400
哦不

8
00:00:14,400 --> 00:00:16,560
其实它很有意思很有趣

9
00:00:17,000 --> 00:00:19,640
也是非常具有技术含量的

10
00:00:20,320 --> 00:00:21,760
那在这一个系列里面

11
00:00:21,920 --> 00:00:23,800
讲讲一些基本的介绍

12
00:00:23,800 --> 00:00:25,560
首先来了解一下

13
00:00:25,560 --> 00:00:26,960
编译器和解析器

14
00:00:26,960 --> 00:00:27,840
到底是什么

15
00:00:27,840 --> 00:00:29,000
有什么区别

16
00:00:29,360 --> 00:00:30,400
接着看看

17
00:00:30,400 --> 00:00:32,840
JIT和AOT的编译的方式

18
00:00:32,840 --> 00:00:33,800
有什么不一样

19
00:00:34,320 --> 00:00:35,240
在结束之前

20
00:00:35,360 --> 00:00:37,080
看看在编译器里面

21
00:00:37,080 --> 00:00:38,760
很重要的两个小概念

22
00:00:38,760 --> 00:00:39,480
一个是Path

23
00:00:39,480 --> 00:00:40,480
一个是IR

24
00:00:41,160 --> 00:00:42,280
有了对编译器

25
00:00:42,280 --> 00:00:43,560
一个最基础的了解之后

26
00:00:43,560 --> 00:00:45,840
来看看传统的编译器

27
00:00:46,360 --> 00:00:48,000
聊到传统的编译器

28
00:00:48,000 --> 00:00:49,360
很有意思的一个点

29
00:00:49,360 --> 00:00:51,360
就是还是去看看LIS

30
00:00:51,360 --> 00:00:53,040
看看它的发展趋势

31
00:00:53,800 --> 00:00:55,760
接着以两个业界

32
00:00:55,760 --> 00:00:57,280
比较著名的

33
00:00:57,520 --> 00:00:59,600
编译器来去展开一下

34
00:00:59,600 --> 00:01:01,080
去深入的了解

35
00:01:01,080 --> 00:01:03,160
传统编译器到底是什么

36
00:01:03,160 --> 00:01:05,160
那第一个就是GCC

37
00:01:05,160 --> 00:01:06,640
经常用C++写代码

38
00:01:06,640 --> 00:01:08,160
到时候不是经常用到吗

39
00:01:08,160 --> 00:01:11,160
那第二个就是LLVM

40
00:01:11,720 --> 00:01:13,040
如果你跟我一样

41
00:01:13,040 --> 00:01:14,400
用的是苹果电脑

42
00:01:14,400 --> 00:01:17,800
你可能会对这个LLVM特别熟悉

43
00:01:17,800 --> 00:01:19,000
每次编译的时候

44
00:01:19,000 --> 00:01:20,280
都离不开它

45
00:01:21,280 --> 00:01:23,600
第三点就是这个系列的

46
00:01:23,600 --> 00:01:25,200
重点AI编译器

47
00:01:25,200 --> 00:01:25,920
那当然了

48
00:01:25,920 --> 00:01:26,680
这一节课里面

49
00:01:26,680 --> 00:01:28,840
AI编译器只是占了三分之一

50
00:01:28,840 --> 00:01:31,480
但是接下来后面的系列

51
00:01:31,480 --> 00:01:32,720
所有的内容

52
00:01:32,720 --> 00:01:34,360
都是围绕AI编译器

53
00:01:35,160 --> 00:01:36,760
第一个还是去看看

54
00:01:36,760 --> 00:01:38,520
有意思的一些故事

55
00:01:38,520 --> 00:01:40,560
AI编译器的一个发展

56
00:01:41,760 --> 00:01:43,080
接着去看看

57
00:01:43,080 --> 00:01:45,160
AI编译器的一个通用的架构

58
00:01:45,160 --> 00:01:47,280
虽然AI编译器还是快速的发展

59
00:01:47,280 --> 00:01:49,760
但是基本架构已经定型了

60
00:01:49,760 --> 00:01:52,560
可能里面会有非常多的细节去补充

61
00:01:52,560 --> 00:01:54,600
那最后来去看看

62
00:01:54,640 --> 00:01:57,280
AI编译器和传统编译器

63
00:01:57,280 --> 00:01:58,360
有什么区别

64
00:01:58,360 --> 00:01:59,400
它的difference

65
00:01:59,400 --> 00:02:00,800
还有它的challenging

66
00:02:00,800 --> 00:02:03,400
还有未来的发展的一些趋势

67
00:02:03,400 --> 00:02:05,480
这个也是我现在非常关心的

68
00:02:06,200 --> 00:02:10,560
随着公司的芯片硬件越来越多

69
00:02:10,560 --> 00:02:12,440
如果把AI编译器做好了

70
00:02:12,440 --> 00:02:15,080
其实可以接上非常多的人力工作

71
00:02:17,680 --> 00:02:19,240
在正式开始之前

72
00:02:19,240 --> 00:02:20,880
我想抛出两个问题

73
00:02:20,880 --> 00:02:21,720
那第一个就是

74
00:02:21,720 --> 00:02:23,760
为什么需要编译器

75
00:02:23,800 --> 00:02:26,000
编译器能够给解决什么问题呢

76
00:02:26,800 --> 00:02:28,040
第二个点就是

77
00:02:28,040 --> 00:02:30,480
AI框架和AI编译器之间

78
00:02:30,480 --> 00:02:32,240
到底有什么关系呢

79
00:02:32,240 --> 00:02:34,280
AI框架就是AI编译器吗

80
00:02:34,280 --> 00:02:36,760
还是AI框架不是AI编译器呢

81
00:02:36,760 --> 00:02:38,520
它们之间的一个gap

82
00:02:38,520 --> 00:02:40,920
两者之间的边界到底在哪里了

83
00:02:41,680 --> 00:02:42,800
带着这两个问题

84
00:02:42,800 --> 00:02:44,160
继续往下展开

85
00:02:45,600 --> 00:02:46,960
首先第一个概念就是

86
00:02:46,960 --> 00:02:49,680
搞清楚编译器和解析器

87
00:02:49,680 --> 00:02:52,000
编译器传统叫做compiler

88
00:02:52,960 --> 00:02:55,160
解析器叫做interpreter

89
00:02:55,800 --> 00:02:57,720
现在打开一个YouTube的视频

90
00:02:57,720 --> 00:02:58,640
来去了解一下

91
00:02:58,640 --> 00:03:01,200
编译器和解析器之间的区别

92
00:03:22,000 --> 00:03:23,600
将在这段视频中看到的

93
00:03:24,800 --> 00:03:26,240
在开始之前

94
00:03:26,240 --> 00:03:29,680
你应该知道两个重要的词语

95
00:03:29,680 --> 00:03:31,760
之后会使用的

96
00:03:31,760 --> 00:03:33,160
这些词语叫做

97
00:03:33,160 --> 00:03:36,000
高级语言和低级语言

98
00:03:37,040 --> 00:03:39,280
如果你已经知道这些词语的意思

99
00:03:39,280 --> 00:03:41,480
你可以跳过屏幕上的一分钟

100
00:03:44,960 --> 00:03:45,840
不幸的是

101
00:03:45,840 --> 00:03:48,240
设备只能够理解binary

102
00:03:48,240 --> 00:03:50,760
也就是0和1

103
00:03:50,800 --> 00:03:52,160
binary这个词语

104
00:03:52,160 --> 00:03:53,640
是机器语言

105
00:03:53,640 --> 00:03:56,480
它被认为是一个低级语言

106
00:03:56,480 --> 00:03:59,360
因为它比人类

107
00:03:59,360 --> 00:04:00,760
能够理解

108
00:04:02,960 --> 00:04:05,240
因为人类几乎无法

109
00:04:05,240 --> 00:04:09,000
用0和1来写标语

110
00:04:09,000 --> 00:04:12,080
其他互联语语言就出现了

111
00:04:12,080 --> 00:04:14,600
现在人类使用的语言

112
00:04:14,600 --> 00:04:17,120
用来写标语都很接近英语

113
00:04:17,120 --> 00:04:18,920
例如

114
00:04:18,960 --> 00:04:19,800
Python

115
00:04:19,800 --> 00:04:20,480
C

116
00:04:20,480 --> 00:04:22,120
和Java

117
00:04:22,120 --> 00:04:24,400
这些语言被称为高级语言

118
00:04:24,400 --> 00:04:27,480
因为它们比机器语言

119
00:04:27,480 --> 00:04:29,200
更接近人类的理解

120
00:04:31,400 --> 00:04:33,160
但是你可能已经认出

121
00:04:33,160 --> 00:04:35,520
这仍然是个问题

122
00:04:35,520 --> 00:04:38,480
机器语言只能够理解低级语言

123
00:04:38,480 --> 00:04:41,200
而人类却能够提供高级语言

124
00:04:41,200 --> 00:04:43,560
这怎么能够解决呢

125
00:04:43,560 --> 00:04:45,080
为了解决这些问题

126
00:04:45,080 --> 00:04:47,560
需要一个翻译者

127
00:04:47,560 --> 00:04:48,920
正是

128
00:04:48,920 --> 00:04:51,880
这就是使用的翻译者和翻译者

129
00:04:53,880 --> 00:04:55,800
现在,经过这次小旅程

130
00:04:55,800 --> 00:04:58,200
让回到开始的地方

131
00:04:58,200 --> 00:04:59,960
正如之前提到的

132
00:04:59,960 --> 00:05:03,240
翻译者和翻译者都操作为翻译者

133
00:05:03,240 --> 00:05:06,120
从高级语言到低级语言

134
00:05:06,120 --> 00:05:07,200
现在让来看看

135
00:05:07,200 --> 00:05:09,280
哪一位翻译者会做哪一件事

136
00:05:11,760 --> 00:05:12,800
翻译者

137
00:05:12,800 --> 00:05:14,600
把你写的整个程序

138
00:05:14,600 --> 00:05:16,160
翻译到高级语言

139
00:05:16,160 --> 00:05:20,760
然后把整个程序翻译到机器语言

140
00:05:22,280 --> 00:05:24,080
经过这次过程

141
00:05:24,080 --> 00:05:26,440
一个可运行的文件就会准备好运行

142
00:05:27,800 --> 00:05:30,640
翻译有时候需要很多时间

143
00:05:30,640 --> 00:05:32,040
但经过这些过程

144
00:05:32,040 --> 00:05:33,640
运行就变得很快

145
00:05:34,760 --> 00:05:35,760
不幸的是

146
00:05:35,760 --> 00:05:37,040
任何程序中的错误

147
00:05:37,040 --> 00:05:39,600
都会完全阻止它从工作

148
00:05:39,600 --> 00:05:42,560
错误会在组合的结尾显示出来

149
00:05:43,280 --> 00:05:44,360
翻译者

150
00:05:44,360 --> 00:05:46,680
把每一个程序的指示

151
00:05:46,680 --> 00:05:48,320
翻译到机器语言

152
00:05:48,320 --> 00:05:50,080
然后自行运行

153
00:05:52,680 --> 00:05:55,720
翻译程序运行之前的运行步骤

154
00:05:55,720 --> 00:05:56,520
很快

155
00:05:56,520 --> 00:05:58,520
因为程序会立刻开始

156
00:05:58,520 --> 00:06:00,440
但运行会运行得很慢

157
00:06:01,280 --> 00:06:03,240
翻译者的优点是

158
00:06:03,240 --> 00:06:04,920
程序会完全运行

159
00:06:04,920 --> 00:06:06,840
直到出现错误

160
00:06:07,760 --> 00:06:09,200
错误会在

161
00:06:09,400 --> 00:06:10,480
或QO

162
00:06:11,240 --> 00:06:13,240
中的每个指示之后

163
00:06:13,240 --> 00:06:15,920
都会显示出错误

164
00:06:17,960 --> 00:06:19,160
现在让看看

165
00:06:19,160 --> 00:06:22,400
真实的翻译者和翻译者的例子

166
00:06:23,160 --> 00:06:24,920
在第一个例子中

167
00:06:24,920 --> 00:06:26,320
将看到

168
00:06:26,320 --> 00:06:27,440
翻译者创建的

169
00:06:27,440 --> 00:06:30,040
可运行的中间文件

170
00:06:31,120 --> 00:06:32,000
在这个例子中

171
00:06:32,000 --> 00:06:33,520
有一个C语言程序

172
00:06:33,520 --> 00:06:35,720
将尝试翻译它

173
00:06:35,720 --> 00:06:37,600
看看会发生什么

174
00:06:39,200 --> 00:06:42,320
翻译者创建了一个中间文件

175
00:06:42,320 --> 00:06:43,520
试试看

176
00:06:47,520 --> 00:06:50,680
这个文件有一个.exe的延迟

177
00:06:50,680 --> 00:06:51,720
意味着

178
00:06:51,720 --> 00:06:53,720
它是一个可运行的文件

179
00:06:55,040 --> 00:06:56,240
在这个例子中

180
00:06:56,240 --> 00:06:58,720
使用了Python 3.9翻译者

181
00:06:58,720 --> 00:07:00,640
想要使用Python 3.9

182
00:07:00,640 --> 00:07:01,680
来运行

183
00:07:01,680 --> 00:07:02,960
但是需要用到

184
00:07:02,960 --> 00:07:04,720
Python 3.9的翻译程序

185
00:07:04,720 --> 00:07:05,840
来运行

186
00:07:05,840 --> 00:07:07,280
所以需要用到

187
00:07:07,280 --> 00:07:09,120
Python 3.9的翻译程序

188
00:07:09,120 --> 00:07:10,680
来创建一个程序文件

189
00:07:10,680 --> 00:07:12,360
看看会发生什么

190
00:07:13,880 --> 00:07:14,960
如您所见

191
00:07:14,960 --> 00:07:16,160
测试文件创建了

192
00:07:16,160 --> 00:07:18,680
没有任何其他中间文件

193
00:07:18,680 --> 00:07:21,600
这些文件有一个.py的延迟

194
00:07:21,600 --> 00:07:22,200
意味着

195
00:07:22,200 --> 00:07:24,760
它是由翻译者直接打开的

196
00:07:26,480 --> 00:07:27,960
在另一个例子中

197
00:07:27,960 --> 00:07:28,640
将看到

198
00:07:28,640 --> 00:07:30,360
如何展示错误

199
00:07:30,360 --> 00:07:31,360
这将显示

200
00:07:31,360 --> 00:07:32,480
刚才提到的

201
00:07:32,480 --> 00:07:34,560
可运行方式

202
00:07:34,560 --> 00:07:35,400
在这里使用

203
00:07:35,400 --> 00:07:36,760
新的网络组合

204
00:07:36,760 --> 00:07:37,360
它们两个方式

205
00:07:37,360 --> 00:07:38,480
来运行

206
00:07:38,480 --> 00:07:39,720
一步一步

207
00:07:39,720 --> 00:07:40,720
为了简单化

208
00:07:40,720 --> 00:07:42,120
使用.f功能

209
00:07:42,120 --> 00:07:43,920
它在屏幕上展示

210
00:07:43,920 --> 00:07:46,200
翻译中的文字

211
00:07:46,200 --> 00:07:47,160
让做出错误

212
00:07:47,160 --> 00:07:48,560
来看看结果

213
00:07:50,880 --> 00:07:52,080
如您所见

214
00:07:52,080 --> 00:07:53,280
编辑停止了

215
00:07:53,280 --> 00:07:54,160
由于错误

216
00:07:54,160 --> 00:07:56,080
结果无法展示

217
00:07:57,040 --> 00:07:58,120
在这个情况下

218
00:07:58,120 --> 00:07:58,680
使用了

219
00:07:58,680 --> 00:08:00,040
Pash翻译者

220
00:08:00,040 --> 00:08:01,440
而这个Echo功能

221
00:08:01,440 --> 00:08:03,800
是同样的.f

222
00:08:03,800 --> 00:08:05,000
让做出错误

223
00:08:05,000 --> 00:08:06,520
来看看结果

224
00:08:08,360 --> 00:08:09,600
在这个情况下

225
00:08:09,600 --> 00:08:10,200
您可以看到

226
00:08:10,200 --> 00:08:11,520
编辑停止了

227
00:08:11,520 --> 00:08:12,760
第一个表格

228
00:08:12,760 --> 00:08:14,640
并给予第二个表格的错误

229
00:08:14,640 --> 00:08:15,480
这就显示了

230
00:08:15,480 --> 00:08:17,120
编辑停止的方式

231
00:08:17,800 --> 00:08:19,600
看完刚才YouTube的视频

232
00:08:19,600 --> 00:08:20,800
其实大致了解了

233
00:08:20,800 --> 00:08:22,000
解析器和编译器的

234
00:08:22,000 --> 00:08:23,640
一个简单的差异

235
00:08:23,640 --> 00:08:25,280
现在来汇总一下

236
00:08:25,920 --> 00:08:26,840
首先看看

237
00:08:26,840 --> 00:08:28,160
左边的解析器

238
00:08:28,400 --> 00:08:30,000
解析器其实是不产生

239
00:08:30,000 --> 00:08:31,440
任何中间的代码的

240
00:08:31,440 --> 00:08:32,880
而编译器是产生一个

241
00:08:32,880 --> 00:08:34,440
中间的目标代码

242
00:08:35,040 --> 00:08:37,000
解析器在解析程序的时候

243
00:08:37,120 --> 00:08:39,000
是一行一行解析的

244
00:08:39,200 --> 00:08:40,160
在编译器里面

245
00:08:40,520 --> 00:08:42,600
它首先把程序进行编译

246
00:08:42,600 --> 00:08:44,160
编译成一个二进制的包

247
00:08:44,160 --> 00:08:45,920
然后机器再去执行

248
00:08:46,200 --> 00:08:47,320
二进制的包

249
00:08:47,920 --> 00:08:49,160
所以在编译器里面

250
00:08:49,360 --> 00:08:50,960
程序的执行和编译

251
00:08:50,960 --> 00:08:52,560
是分开两个步骤的

252
00:08:52,920 --> 00:08:54,880
解析器是由于一边执行

253
00:08:54,880 --> 00:08:55,800
一边运算的

254
00:08:55,800 --> 00:08:57,120
所以它的运算速率

255
00:08:57,120 --> 00:08:59,360
自然就会慢

256
00:08:59,360 --> 00:09:00,120
而编译器

257
00:09:00,560 --> 00:09:01,600
我已经编译完

258
00:09:01,720 --> 00:09:02,640
形成一个包了

259
00:09:02,640 --> 00:09:04,160
最后程序在执行的

260
00:09:04,160 --> 00:09:05,760
所以它的执行效率

261
00:09:05,760 --> 00:09:06,960
是非常的快的

262
00:09:07,520 --> 00:09:08,400
在报错方面

263
00:09:08,560 --> 00:09:10,200
解析器是一条一条语句

264
00:09:10,200 --> 00:09:11,320
去读取的

265
00:09:11,320 --> 00:09:11,880
所以说

266
00:09:12,920 --> 00:09:13,760
它遇到错误

267
00:09:13,760 --> 00:09:14,800
就会马上报错

268
00:09:14,800 --> 00:09:15,760
修正了错误

269
00:09:15,760 --> 00:09:17,440
才能够进行下一行

270
00:09:17,440 --> 00:09:18,200
而编译器

271
00:09:18,360 --> 00:09:19,600
在编译的过程当中

272
00:09:19,600 --> 00:09:21,480
显示所有的错误和警告

273
00:09:22,360 --> 00:09:23,720
如果不修正这些错误

274
00:09:23,880 --> 00:09:25,800
一行代码都执行不了

275
00:09:29,880 --> 00:09:32,120
接下来引入两个新的概念

276
00:09:32,120 --> 00:09:33,480
一个是JIT

277
00:09:33,480 --> 00:09:35,000
一个是AOT

278
00:09:35,560 --> 00:09:37,880
实际上程序有两种运行方式

279
00:09:37,880 --> 00:09:39,160
一种是静态编译

280
00:09:39,160 --> 00:09:41,200
另外一种是动态解析

281
00:09:41,560 --> 00:09:42,320
静态编译

282
00:09:42,520 --> 00:09:44,360
主要是指程序在执行之前

283
00:09:44,600 --> 00:09:46,640
全部都被编译成为机器码

284
00:09:46,840 --> 00:09:48,640
这种叫做静态编译

285
00:09:48,640 --> 00:09:50,000
就是AOT

286
00:09:50,000 --> 00:09:51,080
提前编译

287
00:09:51,080 --> 00:09:52,960
另外一种就是一边编译

288
00:09:53,120 --> 00:09:53,880
一边运行

289
00:09:54,000 --> 00:09:54,640
这种方式

290
00:09:54,760 --> 00:09:55,840
叫做JIT

291
00:09:55,840 --> 00:09:56,920
Just in time

292
00:09:56,920 --> 00:09:58,000
即时编译

293
00:09:58,000 --> 00:09:58,760
就刚刚好

294
00:09:58,760 --> 00:09:59,840
来得非常巧

295
00:10:00,960 --> 00:10:02,720
又到了汇总的一个表

296
00:10:02,720 --> 00:10:03,200
这个表

297
00:10:03,280 --> 00:10:04,200
可以看到

298
00:10:04,200 --> 00:10:05,640
Just in time有优点

299
00:10:05,640 --> 00:10:06,560
也有缺点

300
00:10:06,560 --> 00:10:07,680
然后ahead of time

301
00:10:07,680 --> 00:10:09,320
也有它自己的优缺点

302
00:10:10,320 --> 00:10:12,360
我在里面挑几个比较重要的

303
00:10:12,360 --> 00:10:14,760
跟大家一起去分享和汇报一下

304
00:10:14,880 --> 00:10:15,840
JIT的优点

305
00:10:16,040 --> 00:10:16,840
就是

306
00:10:16,920 --> 00:10:18,920
可以根据当前硬件的情况下

307
00:10:19,040 --> 00:10:21,400
实时编译成为最优的指令

308
00:10:21,880 --> 00:10:22,560
而这一点

309
00:10:23,400 --> 00:10:26,600
刚好是对应到AOT的缺点里面

310
00:10:27,080 --> 00:10:29,360
AOT是提前已经编译好了一个包

311
00:10:29,360 --> 00:10:30,560
然后再去执行的

312
00:10:30,760 --> 00:10:32,080
执行在哪些硬件

313
00:10:32,080 --> 00:10:33,360
它是不关心的

314
00:10:33,480 --> 00:10:35,200
第二点就是根据进程当中

315
00:10:35,200 --> 00:10:36,720
内存的实际情况

316
00:10:36,720 --> 00:10:38,800
来去调整内存空间

317
00:10:39,280 --> 00:10:41,240
JIT的缺点也比较明显

318
00:10:41,720 --> 00:10:42,400
编译的时候

319
00:10:42,600 --> 00:10:44,440
要占用运行的时间

320
00:10:45,120 --> 00:10:47,160
所以需要在运行时

321
00:10:47,160 --> 00:10:48,440
还有编译时间

322
00:10:48,640 --> 00:10:49,760
做一个权衡

323
00:10:50,120 --> 00:10:51,000
JIT的缺点

324
00:10:51,200 --> 00:10:53,520
刚好对应是AOT的一个优点

325
00:10:53,520 --> 00:10:55,160
就是程序在运行之前

326
00:10:55,320 --> 00:10:56,400
已经编译好了

327
00:10:56,840 --> 00:10:57,800
可以有效的避免

328
00:10:57,960 --> 00:10:58,800
在运行的时候

329
00:10:58,800 --> 00:11:00,400
增加编译性能

330
00:11:00,400 --> 00:11:01,760
还有内存开销

331
00:11:01,920 --> 00:11:03,320
直接跑起来就行了

332
00:11:04,160 --> 00:11:05,440
既然可以直接跑起来

333
00:11:05,440 --> 00:11:06,440
肯定会显著的

334
00:11:06,440 --> 00:11:07,920
加快程序的运行效率

335
00:11:08,200 --> 00:11:09,280
但是它的缺点

336
00:11:09,440 --> 00:11:11,400
刚好对应到JIT的优点

337
00:11:11,400 --> 00:11:12,480
刚才已经讲了

338
00:11:12,480 --> 00:11:13,720
这边就不再罗列

339
00:11:15,840 --> 00:11:18,000
这时候带来一个新的问题

340
00:11:18,000 --> 00:11:20,480
就是AOT和AIT的边界在哪

341
00:11:20,800 --> 00:11:22,160
什么时候用JIT

342
00:11:22,160 --> 00:11:23,800
什么时候用AOT

343
00:11:24,120 --> 00:11:25,360
什么时候用编译

344
00:11:25,360 --> 00:11:27,360
什么时候用解析

345
00:11:29,200 --> 00:11:30,800
现在以神经网络

346
00:11:30,800 --> 00:11:32,320
作为一个实际的例子

347
00:11:32,320 --> 00:11:33,640
在训练的过程当中

348
00:11:33,880 --> 00:11:35,800
像我这样的调参侠

349
00:11:35,800 --> 00:11:37,640
就会去写一堆

350
00:11:38,080 --> 00:11:39,320
神经网络的代码

351
00:11:39,320 --> 00:11:40,000
写完之后

352
00:11:40,480 --> 00:11:41,400
AI框架

353
00:11:41,600 --> 00:11:43,480
就会对神经网络的代码

354
00:11:43,480 --> 00:11:44,440
进行编译

355
00:11:44,600 --> 00:11:45,360
编译完之后

356
00:11:45,360 --> 00:11:47,920
就变成一堆机器码

357
00:11:47,920 --> 00:11:49,840
机器码会丢给NPU

358
00:11:49,840 --> 00:11:51,120
GPU CPU

359
00:11:51,120 --> 00:11:52,720
去执行运算

360
00:11:52,960 --> 00:11:54,080
不断的训练

361
00:11:54,080 --> 00:11:55,840
直到网络收敛为止

362
00:11:55,840 --> 00:11:57,520
然后就把收敛完的

363
00:11:57,520 --> 00:11:59,160
网络模型丢出来

364
00:12:01,120 --> 00:12:03,280
像我这样的调参侠又过来了

365
00:12:03,280 --> 00:12:05,200
首先写了一堆代码

366
00:12:05,200 --> 00:12:06,640
然后用AI框架

367
00:12:06,640 --> 00:12:07,840
编译成一些机器码

368
00:12:08,040 --> 00:12:09,360
机器码经过训练之后

369
00:12:09,960 --> 00:12:12,360
就输出一个神经网络模型

370
00:12:12,360 --> 00:12:13,560
这个神经网络模型

371
00:12:13,680 --> 00:12:14,800
会保存在

372
00:12:14,800 --> 00:12:17,200
SSD的这些硬盘里面

373
00:12:17,200 --> 00:12:19,280
等真正需要用到的时候

374
00:12:19,600 --> 00:12:20,440
就把

375
00:12:20,720 --> 00:12:23,480
刚才保存下来的神经网络的模型

376
00:12:23,480 --> 00:12:25,840
丢给NPU去执行运算的

377
00:12:26,280 --> 00:12:27,800
这种离线推理的方式

378
00:12:27,960 --> 00:12:29,840
一般会用到AOT

379
00:12:31,400 --> 00:12:32,240
在结束之前

380
00:12:32,400 --> 00:12:33,640
还有两个概念

381
00:12:33,640 --> 00:12:35,520
一个是编译器里面的Path

382
00:12:35,520 --> 00:12:37,640
一个是编译器里面的IR

383
00:12:37,640 --> 00:12:39,280
这两个概念比较好理解

384
00:12:39,280 --> 00:12:40,960
首先看看Path的定义

385
00:12:41,320 --> 00:12:42,080
Path的定义

386
00:12:42,320 --> 00:12:43,800
主要是对源程序的

387
00:12:43,800 --> 00:12:46,280
一次完整的扫描或者处理

388
00:12:46,640 --> 00:12:47,920
像我这样的调参侠

389
00:12:48,040 --> 00:12:49,320
去写了类似于Python

390
00:12:49,320 --> 00:12:50,840
这样的高级语言的代码

391
00:12:50,840 --> 00:12:51,880
写完这些代码

392
00:12:51,880 --> 00:12:53,560
机器是不能够识别的

393
00:12:53,560 --> 00:12:56,320
所以程序会对我刚才写的一堆代码

394
00:12:56,320 --> 00:12:57,760
进行一次扫描

395
00:12:57,760 --> 00:12:58,960
做一些语法分析

396
00:12:58,960 --> 00:12:59,880
词法分析

397
00:12:59,880 --> 00:13:00,840
语句分析

398
00:13:00,840 --> 00:13:01,760
分析完之后

399
00:13:01,920 --> 00:13:03,520
再给下一次处理

400
00:13:03,840 --> 00:13:04,760
像刚才这种

401
00:13:04,760 --> 00:13:06,840
对源程序一次完整的扫描

402
00:13:06,840 --> 00:13:09,200
对我刚刚写的代码进行扫描

403
00:13:09,400 --> 00:13:11,720
这个过程叫做一个Path

404
00:13:13,160 --> 00:13:14,000
在编译器里面

405
00:13:14,160 --> 00:13:15,840
可能会有非常多的Path

406
00:13:15,840 --> 00:13:16,560
不同的Path

407
00:13:16,560 --> 00:13:17,600
做不同的扫描

408
00:13:17,600 --> 00:13:18,480
不同的处理

409
00:13:19,000 --> 00:13:21,120
最后变成一个Low Level的Language

410
00:13:21,120 --> 00:13:23,160
或者叫做Low Level的IR

411
00:13:23,960 --> 00:13:25,600
这时候引入了IR

412
00:13:25,600 --> 00:13:27,920
下面来看看IR的具体作用

413
00:13:28,400 --> 00:13:29,400
IR的详写

414
00:13:29,600 --> 00:13:31,600
主要是叫做中间表达

415
00:13:32,040 --> 00:13:32,800
中间表达

416
00:13:33,080 --> 00:13:34,760
它可以是个数据结构

417
00:13:35,360 --> 00:13:38,560
它也可以是一段你定义好的代码

418
00:13:39,240 --> 00:13:41,880
现在把刚才IR的一个图拿出来

419
00:13:41,880 --> 00:13:44,880
首先输入的是一些高级的语言

420
00:13:44,880 --> 00:13:47,160
输出是一些低级的语言

421
00:13:47,520 --> 00:13:49,240
在做高级语言的处理的时候

422
00:13:49,360 --> 00:13:52,760
会有非常多不同的处理步骤

423
00:13:53,080 --> 00:13:54,160
其中一个处理步骤

424
00:13:54,320 --> 00:13:56,360
我需要输入一个原始的代码

425
00:13:56,360 --> 00:13:58,280
然后输出一个目标的代码

426
00:13:58,800 --> 00:13:59,640
在这个parts里面

427
00:13:59,840 --> 00:14:01,800
需要对输入的代码

428
00:14:01,800 --> 00:14:02,840
做一些修改

429
00:14:03,160 --> 00:14:04,480
但是修改完之后

430
00:14:04,680 --> 00:14:06,200
它还不是机器码

431
00:14:06,560 --> 00:14:08,120
中间产生的表达

432
00:14:08,120 --> 00:14:10,600
或者中间的数据结构和中间的代码

433
00:14:10,600 --> 00:14:11,920
叫做IR

434
00:14:11,920 --> 00:14:14,000
就是所谓的中间表示

435
00:14:14,880 --> 00:14:15,880
所以大部分程序

436
00:14:16,360 --> 00:14:17,680
包括我进入生成之前

437
00:14:17,840 --> 00:14:20,360
我接触的更多的就是高级的语言

438
00:14:20,360 --> 00:14:21,920
Python C++ Java

439
00:14:22,320 --> 00:14:23,480
然后我了解到的

440
00:14:23,480 --> 00:14:25,000
就是我要在硬件上面跑

441
00:14:25,520 --> 00:14:27,440
肯定需要机器码二进字码

442
00:14:28,200 --> 00:14:30,960
而高级语言转换到机器码之间

443
00:14:31,520 --> 00:14:33,800
它大部分都是用IR来去表示的

444
00:14:34,080 --> 00:14:36,320
这里面就没有一种明确的语言

445
00:14:36,320 --> 00:14:39,400
所以都统一叫做IR中间表达

446
00:14:42,080 --> 00:14:43,560
在接下来的章节里面

447
00:14:43,800 --> 00:14:45,480
会详细的去介绍

448
00:14:45,760 --> 00:14:47,360
traditional compiler

449
00:14:47,720 --> 00:14:49,960
就是传统的编译器有什么不一样

450
00:14:50,240 --> 00:14:51,480
它有什么发展的历程

451
00:14:51,760 --> 00:14:53,720
现在最火的传统编译器有哪些

452
00:14:54,120 --> 00:14:56,800
还有最重要的就是AI编译器

453
00:14:57,080 --> 00:14:59,280
针对现在有越来越多的AI框架

454
00:14:59,280 --> 00:14:59,960
AI模型

455
00:14:59,960 --> 00:15:00,560
AI算法

456
00:15:00,560 --> 00:15:01,480
还有AI硬件

457
00:15:01,840 --> 00:15:04,760
AI编译器能够帮助解决什么问题吗

458
00:15:05,600 --> 00:15:07,400
一键三连我尽快更新

459
00:15:07,880 --> 00:15:09,440
卷的不行了

460
00:15:09,440 --> 00:15:10,880
记得一键三连加关注

461
00:15:11,400 --> 00:15:14,240
所有的内容都会开源在下面这条链接里面

462
00:15:14,960 --> 00:15:15,560
摆了个掰