GPU上如何优化卷积

本文将演示如何在TVM中编写高性能卷积实现。我们以平方大小的输入张量和滤波器为例,假设卷积的输入是大批量的。在本例中,使用不同的布局来存储数据,以实现更好的数据局部性。缓冲区布局为HWCN,代表高度、宽度、通道、批次。

Preparation and Algorithm

对于256个通道和14 x 14维的输入张量,使用固定大小。批量大小是256。卷积滤波器包含512个尺寸为3 x 3的滤波器。使用步幅大小1和填充大小1进行卷积。下面的代码定义了TVM中的卷积算法。

import numpy as np

import tvm

from tvm import te

# The sizes of inputs and filters

batch = 256

in_channel = 256

out_channel = 512

in_size = 14

kernel = 3

pad = 1

stride = 1

# Algorithm

A = te.placeholder((in_size, in_size, in_channel, batch), name="A")

W = te.placeholder((kernel, kernel, in_channel, out_channel), name="W")

out_size = (in_size - kernel + 2 * pad) // stride + 1

# Pad input

Apad = te.compute(

(in_size + 2 * pad, in_size + 2 * pad, in_channel, batch),

lambda yy, xx, cc, nn: tvm.tir.if_then_else(

tvm.tir.all(yy >= pad, yy - pad < in_size, xx >= pad, xx - pad < in_size),

A[yy - pad, xx - pad, cc, nn],

tvm.tir.const(0.0, "float32"),

),

name="Apad",

)

# Create reduction variables

rc = te.reduce_axis((0, in_channel), name="rc")

ry = te.reduce_axis((0, kernel), name="ry")

rx = te.reduce_axis((0, kernel), name="rx")

# Compute the convolution

B = te.compute(

(out_size, out_size, out_channel, batch),

lambda yy, xx, ff, nn: te.sum(

Apad[yy * stride + ry, xx * stride + rx, rc, nn] * W[ry, rx, rc, ff], axis=[ry, rx, rc]

),

name="B",

)

Memory Hierarchy

首先指定缓冲区的内存层次结构。下图显示了GPU内存层次结构。与CPU内存层次结构的一个重要区别是GPU提供了一个称为共享内存的缓存缓冲区,由程序员管理。因此,如何最大限度地利用共享内存中的数据是实现GPU内核高性能的关键。

在本例中,将Apad和W加载到缓冲区AA和WW中,存储在共享内存中。这些缓冲区将由同一线程块内的所有线程共享,以计算卷积。然后每个线程将自己的部分从共享缓冲区加载到本地寄存器AL和WL中。BL是输出B的本地缓存,它也存储在线程本地寄存器中。

# Designate the memory hierarchy

s = te.create_schedule(B.op)

s[Apad].compute_inline()  # compute Apad inline

AA = s.cache_read(Apad, "shared", [B])

WW = s.cache_read(W, "shared", [B])

AL = s.cache_read(AA, "local", [B])

WL = s.cache_read(WW, "local", [B])

BL = s.cache_write(B, "local")

Blocking

下面的代码将工作负载分成线程块和单个线程。我们遵循矩阵乘法中的分块方案。如下图所示,给定一个像素坐标(y,x),线程块负责计算输出通道和批处理的块系数x块系数(64x64)的区域。由于共享内存空间的限制,我们每次只从Apad和B加载stepx块系数(8x64)数据到共享内存中的缓冲区。

# tile consts

tile = 8

num_thread = 8

block_factor = tile * num_thread

step = 8

vthread = 2

# Get the GPU thread indices

block_x = te.thread_axis("blockIdx.x")

block_y = te.thread_axis("blockIdx.y")

block_z = te.thread_axis("blockIdx.z")

thread_x = te.thread_axis((0, num_thread), "threadIdx.x")

thread_y = te.thread_axis((0, num_thread), "threadIdx.y")

thread_xz = te.thread_axis((0, vthread), "vthread", name="vx")

thread_yz = te.thread_axis((0, vthread), "vthread", name="vy")

# Split the workloads

hi, wi, fi, ni = s[B].op.axis

bz = s[B].fuse(hi, wi)

by, fi = s[B].split(fi, factor=block_factor)

bx, ni = s[B].split(ni, factor=block_factor)

# Bind the iteration variables to GPU thread indices

s[B].bind(bz, block_z)

s[B].bind(by, block_y)

s[B].bind(bx, block_x)

Virtual Thread Split

进一步将工作负载从一个线程块分割到各个线程。为了避免冲突,将8个线程分成4个部分,然后使用8个线程分成4个部分。因此,如下图所示,每个线程计算4个跨距网格,其中每个网格的大小为4 x 4。

tyz, fi = s[B].split(fi, nparts=vthread)  # virtual thread split

txz, ni = s[B].split(ni, nparts=vthread)  # virtual thread split

ty, fi = s[B].split(fi, nparts=num_thread)

tx, ni = s[B].split(ni, nparts=num_thread)

s[B].reorder(bz, by, bx, tyz, txz, ty, tx, fi, ni)

s[B].bind(tyz, thread_yz)

s[B].bind(txz, thread_xz)

s[B].bind(ty, thread_y)

s[B].bind(tx, thread_x)

Cooperative Fetching

如前所述,每个时间步都需要将步骤x块因子数据从GPU全局内存传输到共享内存。为了减少每个线程的内存传输,下面的代码允许同一线程块中的线程协同从全局内存中获取相关数据。

# Schedule BL local write

s[BL].compute_at(s[B], tx)

yi, xi, fi, ni = s[BL].op.axis

ry, rx, rc = s[BL].op.reduce_axis

rco, rci = s[BL].split(rc, factor=step)

s[BL].reorder(rco, ry, rx, rci, fi, ni)

# Attach computation to iteration variables

s[AA].compute_at(s[BL], rx)

s[WW].compute_at(s[BL], rx)

s[AL].compute_at(s[BL], rci)

s[WL].compute_at(s[BL], rci)

# Schedule for A's shared memory load

yi, xi, ci, ni = s[AA].op.axis

ty, ci = s[AA].split(ci, nparts=num_thread)

tx, ni = s[AA].split(ni, nparts=num_thread)

_, ni = s[AA].split(ni, factor=4)

s[AA].reorder(ty, tx, yi, xi, ci, ni)

s[AA].bind(ty, thread_y)

s[AA].bind(tx, thread_x)

s[AA].vectorize(ni)  # vectorize memory load

# Schedule for W's shared memory load

yi, xi, ci, fi = s[WW].op.axis

ty, ci = s[WW].split(ci, nparts=num_thread)

tx, fi = s[WW].split(fi, nparts=num_thread)

_, fi = s[WW].split(fi, factor=4)

s[WW].reorder(ty, tx, yi, xi, ci, fi)

s[WW].bind(ty, thread_y)

s[WW].bind(tx, thread_x)

s[WW].vectorize(fi)  # vectorize memory load

Generate CUDA Kernel

最后利用TVM生成并编译了CUDA内核,并对卷积延迟进行了评估。

func = tvm.build(s, [A, W, B], "cuda")

ctx = tvm.gpu(0)

a_np = np.random.uniform(size=(in_size, in_size, in_channel, batch)).astype(A.dtype)

w_np = np.random.uniform(size=(kernel, kernel, in_channel, out_channel)).astype(W.dtype)

a = tvm.nd.array(a_np, ctx)

w = tvm.nd.array(w_np, ctx)

b = tvm.nd.array(np.zeros((out_size, out_size, out_channel, batch), dtype=B.dtype), ctx)

func(a, w, b)

evaluator = func.time_evaluator(func.entry_name, ctx, number=1)

print("Convolution: %f ms" % (evaluator(a, w, b).mean * 1e3))

Out:

Convolution: 53.197723 ms

https://tvm.apache.org/docs/tutorials/optimize/opt_conv_cuda.html

GPU上如何优化卷积的更多相关文章

  1. TVM 优化 ARM GPU 上的移动深度学习

    TVM 优化 ARM GPU 上的移动深度学习 随着深度学习的巨大成功,将深度神经网络部署到移动设备的需求正在迅速增长.与桌面平台上所做的类似,在移动设备中使用 GPU 既有利于推理速度,也有利于能源 ...

  2. TVM在ARM GPU上优化移动深度学习

    TVM在ARM GPU上优化移动深度学习 随着深度学习的巨大成功,将深度神经网络部署到移动设备的需求正在迅速增长.与在台式机平台上所做的类似,在移动设备中使用GPU可以提高推理速度和能源效率.但是,大 ...

  3. TensorFlow之CNN:运用Batch Norm、Dropout和早停优化卷积神经网络

    学卷积神经网络的理论的时候,我觉得自己看懂了,可是到了用代码来搭建一个卷积神经网络时,我发现自己有太多模糊的地方.这次还是基于MINIST数据集搭建一个卷积神经网络,首先给出一个基本的模型,然后再用B ...

  4. 如何使用TensorCores优化卷积

    如何使用TensorCores优化卷积 本文将演示如何在TVM中使用TensorCores编写高性能的卷积计划.假设卷积的输入有大量数据.首先介绍如何在GPU上优化卷积. TensorCore简介 每 ...

  5. 在配有英特尔® Iris™ 显卡的系统上通过优化对 Just Cause 3 进行增强

    高端 PC 继续通过高性能显卡驱动桌面游戏. 一流的"梦想机器"基于第六代智能 英特尔® 酷睿™ 处理器i7-6700K等 CPU,通常与高端独立显卡配合使用以运行要求最严苛的游戏 ...

  6. 深入剖析GPU Early Z优化

    最近在公司群里同事发了一个UE4关于Mask材质的优化,比如在场景中有大面积的草和树的时候,可以在很大程度上提高效率.这其中的原理就是利用了GPU的特性Early Z,但是它的做法跟我最开始的理解有些 ...

  7. GPU上的图像和信号处理

    GPU上的图像和信号处理 NVIDIA Performance Primitives(NPP)库提供GPU加速的图像,视频和信号处理功能,其执行速度比仅CPU实施快30倍.拥有5000多个用于图像和信 ...

  8. NVIDIA GPU上的Tensor线性代数

    NVIDIA GPU上的Tensor线性代数 cuTENSOR库是同类中第一个GPU加速的张量线性代数库,提供张量收缩,归约和逐元素运算.cuTENSOR用于加速在深度学习训练和推理,计算机视觉,量子 ...

  9. NVIDIA GPU上的直接线性求解器

    NVIDIA GPU上的直接线性求解器 NVIDIA cuSOLVER库提供了密集且稀疏的直接线性求解器和本征求解器的集合,它们为计算机视觉,CFD,计算化学和线性优化应用程序提供了显着的加速.cuS ...

随机推荐

  1. 【Jwt】JSON Web Token

    一.什么是JSON Web Token: 首先要明确的是JSON Web Token:是一个开放标准,这个标准定义了一种用于简洁,自包含的用于通信双方之间以JSON对象的形式安全传递信息的方法 而我们 ...

  2. 【python】Leetcode每日一题-颠倒二进制位

    [python]Leetcode每日一题-颠倒二进制位 [题目描述] 颠倒给定的 32 位无符号整数的二进制位. 示例1: 输入: 00000010100101000001111010011100 输 ...

  3. Mac 右键强化工具-超级右键

    App Store 功能介绍 1.新建文件 默认支持新建:TXT/RTF/XML/Word/Excel/PPT/WPS文字/WPS表格/WPS演示/Pages/Numbers/keynote/Ai/P ...

  4. STL实现的底层数据结构简介

    STL实现的底层数据结构简介 C++ STL 的实现: 1.vector  底层数据结构为数组 ,支持快速随机访问 2.list    底层数据结构为双向链表,支持快速增删 3.deque   底层数 ...

  5. Handle详解

    首先通过一个函数启动一个服务器,只提供一个方法并返回Hello World!,当你在浏览器输入http://127.0.0.1:8080,就会看到Hello World. 对于http.ListenA ...

  6. 从零搭建springboot服务01-初始搭建、内嵌swagger

    愿历尽千帆,归来仍是少年 1.基础springBoot框架 编辑工具:IDEA.jdk1.8.tomcat8.maven3.3.9 编码格式:UTF-8 参考文献:https://www.cnblog ...

  7. 在Visual Studio 中使用git——浏览版本库(七)

    在Visual Studio 中使用git--什么是Git(一) 在Visual Studio 中使用git--给Visual Studio安装 git插件(二) 在Visual Studio 中使用 ...

  8. [算法] O(n^2)排序算法的效率比较

    选择.插入排序 main.cpp 1 #include <iostream> 3 #include "SortTestHelper.h" 4 5 using names ...

  9. tail -fn 1000 test.log | grep '关键字' 按照时间段 sed -n '/2014-12-17 16:17:20/,/2014-12-17 16:17:36/p' test.log /var/log/wtmp 该日志文件永久记录每个用户登录、注销及系统的启动、停机的事件

    Linux 6种日志查看方法,不会看日志会被鄙视的 2020-02-11阅读 7.3K0   作为一名后端程序员,和Linux打交道的地方很多,不会看Linux日志,非常容易受到来自同事和面试官的嘲讽 ...

  10. Linux查看登录日志 last命令 查看当前登录用户

    Linux查看登录日志 linux 发布于 31 分钟前   lastlog 打印系统账号最近一次的登录记录情况,解析的是/var/log/lastlog文件,它是一个data file类型的文件,文 ...