专栏首页AutoML(自动机器学习)GAMES201:高级物理引擎实战指南-Lecture 1 Taichi编程语言介绍

GAMES201:高级物理引擎实战指南-Lecture 1 Taichi编程语言介绍

常用链接(上面的论坛帖子里也有)

  • GAMES 的主页 games-cn.org 【201相关链接在:导航栏/在线课程/GAMES201】
  • Taichi 论坛 forum.taichi.graphics/c/games201/ ; 记得在 GAMES201的版块发帖,其余板块用的是英文
  • 课程课件 github.com/taichi-dev/games201/releases
  • Taichi 主页 github.com/taichi-dev/taichi
  • Taichi 中文文档 taichi.readthedocs.io/zh_CN/latest
  • 直播地址 webinar.games-cn.org

Taichi是基于python开发的高性能图形编程语言,为了解决python速度较慢的问题,特别设计了编译器,进一步提高了图形编程应用的生产力和可移植性。按Boss胡的说法是你只要装好了Taichi,别人的代码你copy过来基本上就可以直接用了,而不像OpenGL的一些你还得安装很多其他依赖库才能跑代码。

Taichi还有如下特点:

  • 数据导向、并行性,megakernels
  • 将数据结构和计算解耦
  • Access spatially sparse tensors as if they are dense
  • 支持可微编程

下面对Taichi做正式介绍。

1. 安装Taichi

python3 -m pip install taichi

2. 初始化

在执行任何Taichi操作之前都需要使用对Taichi做初始化操作,例如:

import taichi as ti
ti.init(arch=ti.cuda)

上面的arch参数可以制定如下几种backend:

  • ti.cpu(默认值)
  • ti.x64/arm/cuda/opengl/metal
  • ti.gpu

3. 数据类型

Taichi先支持如下几种

  • Signed integers: ti.i8 / i16 / i32 / i164
  • Unsigned integers: ti.u8 / u16 / u32 / u64
  • Float-point numbers: ti.f32 / f64

ti.i32ti.f32是最常用的数据类型,目前的布尔类型使用ti.i32表示。

4. Tensors

Tensor也就是张量,它是Taichi里的第一公民(first-citizen)。其实在Pytorch和TensorFlow其实也用了这个概念,不过在Taichi有丢丢不一样:

  • Tensor其实是一个多维的数组(arrays)
  • Tensor里的一个元素可以是标量(scalar),向量(vector),也可以是一个矩阵(matrix),但是在Pytorch和TensorFlow里,一个tensor里每一个元素就只是一个标量,这个在下面的代码示例可以体会到区别。
  • Tensor里的元素只能通过a[i,j,k]这样的语法来访问,像a[i][j][k]这样我通过实验发现貌似只能访问tensor某个元素内的某个子元素,具体看下面的例子
  • 越界访问是未定义的行为
  • (高级功能)Tensor可以使空间稀疏的

举例子:

import taichi as ti
ti.init()
a = ti.var(dt=ti.f32, shape=(4,3))
b = ti.Vector(3, dt=ti.f32, shape=(2,2))
c = ti.Matrix(2,2, dt=ti.f32, shape=(4,3))

loss = ti.var(dt=ti.f32, shape=())

a[2,2] = 1
print(f"a[2,2]={a[2,2]}")

b[1,1] = [0,2,4]
print(f"b[1,1]={b[1,1][0],b[1,1][1],b[1,1][2]}")

loss[None] = 3
print(f"loss[None] = {loss[None]}")

>>>
a[2,2]=1.0
b[1,1]=(0.0, 2.0, 4.0)
loss[None] = 3.0

上面的变量a你不要把它理解成是一个标量,其实它是一个tensor,只不过它的每一个元素是标量而已。具体来说a的维度是

4\times3

,然后我们可以用a[2,2]来对指定位置赋值;

同理b也是一个大小为

2\times2

的tensor,只不过它的每一个元素是一个长度为3的vector。上面代码中通过b[1,1]=[0,2,4]来对[1,1]位置上的向量元素赋值,那么最后如何访问这个向量呢?如上面的代码所示,首先使用a[i,j]来定位到向量元素,然后再像a[0]来访问向量里某个具体的元素。

变量c是一个大小为

4\times3

的tensor,其中的每一个元素是一个大小为

2\times2

的矩阵。

变量loss是一个只有一个元素的tensor,即0d的tensor,所以shape=(),另外需要注意的是在访问loss的值(读/写)时需要loss[None]=0,因为我们都知道python语法里如果直接直接loss=0,那么这个loss就不再是原来的loss了。

5. Kernels

在Taichi里,kernel简单理解就是用来计算的东西。Taichi的kernel语言是compiled, statically-typed, lexically-scoped,parallel and differentiable

你必须使用@ti.kernel对函数装饰后才能使用taichi的kernel功能。而且kernel的参数和返回值必须带有类型提示,例如

@ti.kernel
def hello(i: ti.i32):
	a = 40
	print("Hello world!", a+i)

hello(2) # "Hello world! 42"
@ti.kernel
def calc(c: ti.i32): -> ti.i32
	c += 1
	return c

6. Functions

taichi里的functions可以被kernel或者其他的function调用,但是function不能调用kernel,kernel不能调用kernel。一个比较方便理解的方法就是ti.func类似于cuda编程里的local function,而ti.kernel则是global function。

例子:

@ti.func
def triple(x):
	return x * 3

@ti.kernel
def triple_array(a):
	for i in range(10):
		a[i] = triple(a[i])

7. 数学函数

7.1 scalar math

7.2 Matrices and linear algebra

8. for-loops

Taichi里有两种loop:

  • Range-for loops:这个其实和python里的for循环没什么区别,Range-for loops可以内嵌;
  • Struct-for loops:因为Taichi支持稀疏化张量,而这个for循环就是为了解决稀疏张量的读取问题。

8.1 range-for loops

For循环里的最外层在taichi kernel里会自动并行化。例如下面第一个例子中的for循环会自动并行化,而第二个例子中由于有一个if判断语句,所以后面的for循环就不是并行化的了。

@ti.kernel
def foo():
	for i in range(10): # Parallelized :-)
	...
	
@ti.kernel
def bar(k: ti.i32):
	if k > 42:
		for i in range(10): # Serial :-(
			...

8.2 Struct-for loops

import taichi as ti

ti.init(arch=ti.gpu)

n = 320

pixels = ti.var(dt=ti.f32, shape=(n * 2, n))

@ti.kernel
def paint(t: ti.f32):
	for i, j in pixels:# Parallized over all pixels
		pixels[i, j] = i * 0.001 + j * 0.002 + t
paint(0.3)

Struct-for loops会遍历如下所有的tensor坐标:(0, 0), (0, 1), (0, 2), ..., (0, 319), (1, 0), ..., (639, 319)

9. 原子操作(Atomic operations)

在Taichi中,augmented assignments (比如 x[i] += 1) 会自动使用原子操作。

看下面的例子:

@ti.kernel
def sum():
	for i in x:
		# Approach 1: OK
		total[None] += x[i]
		
		# Approach 2: OK
		ti.atomic_add(total[None], x[i])
		
		# Approach 3: Wrong result (the operation is not atomic.)
		total[None] = total[None] + x[i]

可以看到上面三种操作里只有前两种是对的,最后一种是会有潜在问题的,因为它首先会先读取total[None],然后再做加法操作,但是很有可能你在读取的时候已经有其他的县城对这个作了修改,换句话说第三种方式不是原子操作,所以是有问题的。

10. Taichi-scope v.s. Python-scope

Taichi-scope: 任何使用ti.kerneltf.func装饰都属于taichi scope,该scope内的代码会使用Taichi编译器编译,然后可以运行在并行设备上。

Python-scope: taichi-scope以外的就是python scope

import taichi as ti
ti.init()
a=ti.var(dt=ti.f32,shape=(42,63)) # A tensor of 42x63 scalars
b=ti.Vector(3,dt=ti.f32,shape=4)#A tensor of 4x 3D vectors
C=ti.Matrix(2,2,dt=ti.f32,shape=(3,5)) # A tensor of 3x5 2x2 matrices
@ti.kernel
def foo():
	a[3,4]=1
	print('a[3,4]=',a[3,4])
	#”a[3,4]=1.000000”
	
	b[2]=[6,7,8]
	print('b[0]=',b[0],',b[2]=',b[2])
	#”b[0]=[[0.000000],[0.000000],[0.000000]],b[2]=[[6.000000],[7.000000],[8.000000]]”
	
	C[2,1][0,1]=1
	print('C[2,1]=',C[2,1])
	#C[2,1]=[[0.000000,1.000000],[0.000000,0.000000]]
foo()

11. Taichi 程序的阶段(phase)

一个Taichi代码可以分成如下几个阶段:

  1. 初始化: ti.init()
  2. tensor分配:ti.var, ti.Vector, ti.Matrix
  3. 计算(启动kernels, 获取python-scope的tensors)
  4. 可选: 重启Taichi系统ti.reset(),包括了清除内存、销毁所有变量和kernels

目前版本中一旦启动kernel或者访问python-scope下的某个tensor后,就不能再allocate tensor。

import taichi as ti
ti.init()

n=320
pixels=ti.var(dt=ti.f32,shape=(n*2,n))

@ti.func
def complex_sqr(z):
    return ti.Vector([z[0]**2-z[1]**2,z[1]*z[0]*2])
    
@ti.kernel
def paint(t:ti.f32):
    for i,j in pixels:#Parallized over all pixels
        c=ti.Vector([-0.8,ti.cos(t)*0.2])
        z=ti.Vector([i/n-1,j/n-0.5])*2
        iterations=0
        while z.norm()<20 and iterations<50:
            z=complex_sqr(z)+c
            iterations+=1
        pixels[i,j]=1-iterations*0.02

gui=ti.GUI("JuliaSet",res=(n*2,n))
for i in range(1000000):
    paint(i*0.03)
    gui.set_image(pixels)
    gui.show()

亲测有效:

12. debug mode

使用ti.init(debug=True, arch=ti.cpu)可以帮助检查诸如访问越界等问题。

import taichi as ti
ti.init(debug=True, arch=ti.cpu)
a = ti.var(ti.i32, shape=(10))
b = ti.var(ti.i32, shape=(10))
@ti.kernel
def shift():
	for i in range(10):
		a[i] = b[i + 1] # Runtime error in debug mode
		shift()

MARSGGBO♥原创 如有意合作或学术讨论欢迎私戳联系~ 邮箱:marsggbo@foxmail.com 2020-06-02 15:41:06

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 操作系统 页式存储 页与块之间的关系详解

    操作系统 页式存储 页与块之间的关系详解 操作系统 页式存储 页 块 逻辑地址 物理地址 块号 页号 以下这些概念在刚开始学的时候简直要逼疯我了,因为不同书籍不...

    marsggbo
  • Linux下如何删除指定路径下所有的__pycache__文件夹?

    上面的代码意思是在 . (当前目录) 下搜索 名字是__pycache__ 且 类型是 d(directory),之后运行rm -rf {} \;命令, 括号会...

    marsggbo
  • DeepLearning.ai学习笔记(二)改善深层神经网络:超参数调试、正则化以及优化--Week1深度学习的实用层面

    更多笔记请火速前往 DeepLearning.ai学习笔记汇总 本周我们将学习如何配置训练/验证/测试集,如何分析方差&偏差,如何处理高偏差、高方差或者二者...

    marsggbo
  • Ripple区块链对接PHP开发包【瑞波币/XRP】

    XrpTool可以帮助PHP应用快速接入瑞波/Ripple区块链, 即支持部署自有Ripple节点的应用场景,也支持利用公开的Ripple节点广播离线裸交易的轻...

    用户1408045
  • Python 爬虫入门—— IP代理使用

    简单的说,代理就是换个身份。网络中的身份之一就是IP。比如,我们身在墙内,想要访问google、u2b、fb等,直接访问是404,所以要换个不会被墙的IP,比如...

    用户7678152
  • 深入 char * ,char ** ,char a[ ] ,char *a[] 内核

    http://blog.csdn.net/daiyutage/article/details/8604720

    bear_fish
  • 在viewPager里使用高德地图

    因为viewpager的预加载机制,使得联网应用会多出内存以及网络的使用量,同时,在viewpager下使用高德地图,也会因此出现各种莫名其妙的问题,因此,需要...

    用户1665735
  • Android设计模式应用-代理模式

    其实每个模式名称就表明了该模式的作用,代理模式就是多一个代理类出来,替原对象进行一些操作,比如我们在租房子的时候回去找中介,为什么呢?因为 你对该地区房屋的信息...

    wust小吴
  • 大数据工作流Oozie

    因为工作需要用到oozie,但是网上的资料越看越迷茫,经过很大的努力,终于折腾清楚了,这里,做一个总结,帮助后来者更好地进行入门,当然,粗鄙之言,难免疏漏...

    凹谷
  • 【收藏】国内4G/5G频段划分完整版

    https://pan.baidu.com/s/1I16pl9AgnHndADWz1-BgUw

    鲜枣课堂

扫码关注云+社区

领取腾讯云代金券