跳到正文
OpenAI News·· 2021-07-28精選AI 評分64

OpenAI 發佈 Triton 1.0:面向神經網絡的開源 GPU 程式設計語言

Introducing Triton: Open-source GPU programming for neural networks

AI 導讀

OpenAI 發佈 Triton 1.0,這是一種用於神經網絡 GPU 程式設計的類 Python 開源語言。它讓沒有 CUDA 經驗的研究人員也能編寫高效 GPU 程式碼;OpenAI 稱,多數情況下這些程式碼可媲美專家所能產出。

推薦理由

Triton 1.0 以類 Python 語言降低神經網絡 GPU 程式設計門檻,讓沒有 CUDA 經驗的研究人員也能編寫高效程式碼,OpenAI 稱多數情況下可媲美專家產出。

正文 · 繁體中文

Introducing Triton Open Source Gpu Programming For Neural Networks

我們現正推出 Triton 1.0,這是一種類似 Python 的開源程式語言,讓沒有 CUDA 經驗的研究人員也能編寫效率極高的 GPU 程式碼,而大多數情況下,成果可媲美專家所能編寫的程式碼。

為何重要

Triton 讓人只需付出相對少的努力,便能達到硬件峰值效能;例如,在不到 25 行程式碼內,就能編寫出效能媲美 cuBLAS 的 FP16 矩陣乘法核心函式——這是許多 GPU 程式設計師做不到的事。我們的研究人員已用它編寫出效率最高可達同等 Torch 實作 2x 的核心函式,而我們期待與社群合作,讓 GPU 程式設計對 所有人都更容易上手。

深度學習領域的新穎研究構想,通常會透過組合使用框架原生運算子的方式實作。這種做法雖然方便,但往往需要建立(及/或移動)大量暫存張量,可能會影響神經網絡在大規模運作時的效能。編寫專用 GPU 核心函式可以緩解這些問題,但由於 GPU 程式設計涉及許多繁複細節,這樣做可能出乎意料地困難。1, 2, 3 而且,儘管近期出現了多種系統4, 5 旨在簡化這個流程,但我們發現這些系統不是過於冗長,就是欠缺彈性,或產生的程式碼效能明顯不及我們手動調校的基準版本。這促使我們擴展並改良 Triton6,這是一種近期推出的語言及編譯器,其原創者目前在 OpenAI 工作。

GPU 程式設計的挑戰

現代 GPU 的架構大致可分為三個主要部分——DRAM、SRAM 和 ALUs——最佳化 CUDA 程式碼時必須將每一部分都納入考慮:

  • 來自 DRAM 的記憶體傳輸必須 合併 成大型交易,以善用現代記憶體 介面的寬闊匯流排。

  • 資料必須先手動暫存至 SRAM,以便之後重用,並妥善管理,以盡量減少共享記憶體在 資料取回時出現的分區衝突。

  • 計算工作必須謹慎分割及排程,無論是在串流多處理器(SMs)之間還是在其內部,藉此提升指令/執行緒層級的平行性,並善用專用 ALUs(例如張量 核心)。

GPU Architecture

GPU 的基本架構。

即使是有多年經驗的資深 CUDA 程式設計師,要考慮所有這些因素也可能相當棘手。Triton 旨在將這些最佳化工作全面自動化,讓開發者能更專注於平行程式碼的高階邏輯。Triton 目標是廣泛適用,因此不會自動在 SM 之間排程工作;一些重要的演算法考量(例如分塊、SM 間同步)則交由開發者自行決定。

CUDA

TRITON

記憶體合併存取

手動

自動

共享記憶體管理

手動

自動

排程(SM 內)

手動

自動

排程(SM 之間)

手動

手動

CUDA 與 Triton 的編譯器最佳化。

程式設計模型

在現有的領域專用語言和 JIT 編譯器之中,Triton 可能與 Numba 最相似:核心函式以裝飾器修飾的 Python 函式定義,並以不同的 program_id值,在一個由所謂的 執行個體組成的網格上並行啟動。不過,如下方程式碼片段所示,相似之處僅止於此:Triton 透過對 區塊進行操作,呈現執行個體內的平行性;區塊是各維度均為二的冪次方的小型陣列,而非採用單指令多執行緒(SIMT)7 執行模型。藉此,Triton 實際上將所有與並行處理 (其發生於 CUDA 執行緒區塊內)相關的問題抽象化(例如記憶體合併存取、共享記憶體同步/衝突、張量核心 排程)。

雖然這對容易平行化(即逐元素)的計算未必特別有幫助,卻能大幅簡化較複雜 GPU 程式的開發。

以融合 softmax 核心函式為例(如下所示),其中每個執行個體會將給定輸入張量 X_∈R_M_×_N 中不同的一列正規化。這種平行化策略的標準 CUDA 實作可能很難編寫,因為執行緒會同時對 X 的同一列進行歸約,需要明確同步。使用 Triton 後,大部分複雜性都消失了;每個核心函式執行個體會載入目標列,並使用類似 NumPy 的基本運算依序將其正規化。

1

import triton

2

import triton.language as tl

3

4

@triton.jit

5

def softmax(Y, stride_ym, stride_yn, X, stride_xm, stride_xn, M, N):

6

# row index

7

m = tl.program_id(0)

8

# col indices

9

# this specific kernel only works for matrices that

10

# have less than BLOCK_SIZE columns

11

BLOCK_SIZE = 1024

12

n = tl.arange(0, BLOCK_SIZE)

13

# the memory address of all the elements

14

# that we want to load can be computed as follows

15

X = X + m * stride_xm + n * stride_xn

16

# load input data; pad out-of-bounds elements with 0

17

x = tl.load(X, mask=n < N, other=-float('inf'))

18

# compute numerically-stable softmax

19

z = x - tl.max(x, axis=0)

20

num = tl.exp(z)

21

denom = tl.sum(num, axis=0)

22

y = num / denom

23

# write back to Y

24

Y = Y + m * stride_ym + n * stride_yn

25

tl.store(Y, y, mask=n < N)

26

27

import torch

28

# Allocate input/output tensors

29

X = torch.normal(0, 1, size=(583, 931), device='cuda')

30

Y = torch.empty_like(X)

31

# SPMD launch grid

32

grid = (X.shape[0], )

33

# enqueue GPU kernel

34

softmax[grid](Y, Y.stride(0), Y.stride(1),

35

X, X.stride(0), X.stride(1),

36

X.shape[0] , X.shape[1])

請注意,Triton JIT 將 X 和 Y 視為 指標,而非張量;我們認為保留對記憶體存取的低階控制權很重要,以便處理較複雜的資料結構(例如區塊稀疏張量)。

值得注意的是,這個特定的 softmax 實作會在整個正規化過程中將 X 的各列保留在 SRAM 中,適用時可令資料重用最大化(~<32K columns)。這與 PyTorch 內部的 CUDA 程式碼不同;後者使用暫存記憶體,因此更通用,但速度慢得多(如下所示)。重點並非 Triton 天生更優,而是它簡化了專用核心函式的開發;這些函式的速度可能遠高於通用函式庫中的同類實作。

Torch (v1.9) JIT 效能較低,凸顯了從高階張量運算序列自動產生 CUDA 程式碼的難度。

1

@torch.jit.script

2

def softmax(x):

3

x_max = x.max(dim=1)[0]

4

z = x - x_max[:, None]

5

numerator = torch.exp(x)

6

denominator = numerator.sum(dim=1)

7

return numerator / denominator[:, None]

使用 Torch JIT 的融合 softmax。

矩陣乘法

能為逐元素運算和歸約編寫融合核心函式固然重要,但考慮到矩陣乘法任務在神經網絡中的重要性,這還不夠。事實證明,Triton 同樣能很好地處理這些任務,只用 ~25 行 Python 程式碼就可達到峰值效能。另一方面,若以 CUDA 實作類似功能,便要付出 多得多的心力⁠(在新視窗中開啟) 而且甚至可能達到更低的 效能。

1

@triton.jit

2

def matmul(A, B, C, M, N, K, stride_am, stride_ak,

3

stride_bk, stride_bn, stride_cm, stride_cn,

4

**META):

5

# extract metaparameters

6

BLOCK_M, GROUP_M = META['BLOCK_M'], META['GROUP_M']

7

BLOCK_N = META['BLOCK_N']

8

BLOCK_K = META['BLOCK_K']

9

# programs are grouped together to improve L2 hit rate

10

_pid_m = tl.program_id(0)

11

_pid_n = tl.program_id(1)

12

pid_m = _pid_m // GROUP_M

13

pid_n = (_pid_n * GROUP_M) + (_pid_m % GROUP_M)

14

# rm (resp. rn) denotes a range of indices

15

# for rows (resp. col) of C

16

rm = pid_m * BLOCK_M + tl.arange(0, BLOCK_M)

17

rn = pid_n * BLOCK_N + tl.arange(0, BLOCK_N)

18

# rk denotes a range of indices for columns

19

# (resp. rows) of A (resp. B)

20

rk = tl.arange(0, BLOCK_K)

21

# the memory addresses of elements in the first block of

22

# A and B can be computed using numpy-style broadcasting

23

A = A + (rm[:, None] * stride_am + rk[None, :] * stride_ak)

24

B = B + (rk [:, None] * stride_bk + rn[None, :] * stride_bn)

25

# initialize and iteratively update accumulator

26

acc = tl.zeros((BLOCK_M, BLOCK_N), dtype=tl.float32)

27

for k in range(K, 0, -BLOCK_K):

28

a = tl.load(A)

29

b = tl.load(B)

30

# block level matrix multiplication

31

acc += tl.dot(a, b)

32

# increment pointers so that the next blocks of A and B

33

# are loaded during the next iteration

34

A += BLOCK_K * stride_ak

35

B += BLOCK_K * stride_bk

36

# fuse leaky ReLU if desired

37

# acc = tl.where(acc >= 0, acc, alpha * acc)

38

# write back result

39

C = C + (rm[:, None] * stride_cm + rn[None, :] * stride_cn)

40

mask = (rm[:, None] < M) & (rn[None, :] < N)

41

tl.store(C, acc, mask=mask)

Triton 中的矩陣乘法。

手寫矩陣乘法核心函式的一項重要優點,是可以按需要自訂,以配合對輸入(例如切片)和輸出(例如 Leaky ReLU)進行的融合轉換。若沒有 Triton 這類系統,對矩陣乘法核心函式作出較複雜的修改,對不具備高超 GPU 程式設計專業知識的開發者而言便遙不可及。

高階系統架構

Triton 的良好效能源自以 Triton-IR 為核心的模組化系統架構;Triton-IR 是一種以 LLVM 為基礎的中介表示法,其中多維數值區塊是一級公民。

這個 @triton.jit 裝飾器會遍歷所提供 Python 函式的抽象語法樹(AST),並使用常用的 SSA 建構演算法即時產生 Triton-IR。8 隨後,我們的編譯器後端會簡化、最佳化並自動平行化生成的 IR 程式碼,再將其轉換成高品質的 LLVM-IR,最終轉為 PTX,以便在較新的 NVIDIA GPU 上執行。目前尚未支援 CPU 和 AMD GPU,但我們歡迎社群貢獻,協助克服這項限制。

編譯器後端

我們發現,透過 Triton-IR 採用區塊化程式表示法,可讓我們的編譯器自動執行各種重要的程式最佳化。例如,檢視計算密集型區塊層級運算(例如 tl.dot)的運算元,即可自動將資料暫存到共享記憶體,並使用標準的活躍性分析技術進行配置和同步。

另一方面,Triton 程式也能有效自動平行化:(1) 透過同時執行不同核心函式執行個體,在 SM 之間平行處理;(2) 分析每個區塊層級運算的迭代空間,並將其適當分割至不同 SIMD 單元,以在 SM 內平行處理,如下所示。

貢獻

如果你有興趣加入我們的團隊,並參與 Triton 與 GPU 核心函式的開發, 我們 正在招聘⁠!

參考資料

  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8

    Braun, M., Buchwald, S., Hack, S., Leißa, R., Mallon, C., & Zwinkau, A. (2013, March). Simple and efficient construction of static single assignment form⁠(在新視窗中開啟)。收錄於 International Conference on Compiler Construction (第 102-122 頁)。Springer, Berlin, Heidelberg.

作者

Philippe Tillet

鳴謝

Da Yan (HKUST), DeepSpeed (Microsoft), Anthropic

來源:OpenAI News · openai.com