AMD社製GPUとTensorFlow1.3を用いた領域認識(Semantic Segmentation)

Introduction

SourceYoloV2(Object Detection)FCN(Semantic Segmentation)

Deep Learningにおける領域認識(Semantic Segmentation)ではよく話にでるネットワークとして、U-Net(2015)、FCN(2015)、PSPNet(2017)があります。今回はAMD社製 Radeon GPUを用いてそれらを動かしてみたいと思います。

使用するフレームワークは、AMD TensorFlow1.3, ROCm1.7.137を使用します。※2018年4月16日現在の最新バージョン
hellochick ← 台湾人開発者のリポジトリからソースをお借りします。

https://github.com/hellochick/semantic-segmentation-tensorflow




Setup TensorFlow 1.3 on AMD Radeon GPU

最近、HIP-TensorFlow1.0.1から1.3へアップデートされ、同時に名前がのHIPという部分が取れてリポジトリも別になりました。同時に、旧HIP-TensorFlowのリポジトリが見えなくなっています。旧HIP−TensorFlowはこちらのリポジトリですがすでにリンク切れになっています。HIPって何?TensorFlowとは別物なの?という声も多かったので個人的には歓迎です。
https://github.com/ROCmSoftwarePlatform/hiptensorflow

一方で、新しいTensorFlowはなんと呼べば良いかわからないので、今回はAMD TensorFlowという風に呼びたいと思います。
https://github.com/ROCmSoftwarePlatform/tensorflow

以下のコマンドにて、Python3上にAMD TensorFlow1.3を簡単に構築できます。なおOpenCV3.3.0、ビデオコーデック、CythonやPillowイメージ等々も含まれます。

1
curl -sL http://install.aieatr.com/setup_rocm_tensorflow_p3

[Ubuntu16.04用]




Semantic Segmentation

1
git clone https://github.com/hellochick/semantic-segmentation-tensorflow

gitリポジトリのReadmeに書いてある、FCNの学習済みモデルを持ってきます。
Google Drive - FCN(fcn.npy)

semantic-segmentation-tensorflow/model/fcn.npy
として設置します。

PSPNetの場合は、
semantic-segmentation-tensorflow/model/pspnet50.npy

ICNetの場合は、
semantic-segmentation-tensorflow/model/cityscapes/icnet.npy
として、cityspaces以下に設置します。


実行

semantic-segmentation-tensorflow/input以下にテスト用の画像が含まれますので、それをFCNモデルと一緒に指定して実行します。

1
python3 inference.py --model fcn --img-path input/indoor_1.jpg

以下に出力されます。
semantic-segmentation-tensorflow/output/fcn_indoor_1.jpg

リアルタイム性の強いICNetにしたければ、

1
python3 inference.py --model icnet --img-path input/indoor_1.jpg

とするだけです。

カメラから読み取ったものをリアルタイムに処理する場合は、model.load(path)の中身を書き換える必要があるので、semantic-segmentation-tensorflow/tools.pyファイルを開いて、

1
2
3
4
5
6
7
8
9
10
11
def load_img(img_path):
if os.path.isfile(img_path):
print('successful load img: {0}'.format(img_path))
else:
print('not found file: {0}'.format(img_path))
sys.exit(0)

filename = img_path.split('/')[-1]
img = misc.imread(img_path, mode='RGB')

return img, filename

を以下に修正すれば、numpy形式が受け取れるようになります。

1
2
3
4
5
6
7
8
9
10
11
12
13
def load_img(img_path):
if type(np.array(img_path)).__module__ == np.__name__:
return img_path, "np"
if os.path.isfile(img_path):
print('successful load img: {0}'.format(img_path))
else:
print('not found file: {0}'.format(img_path))
sys.exit(0)

filename = img_path.split('/')[-1]
img = misc.imread(img_path, mode='RGB')

return img, filename

以下のソースをmain.pyにして実行すれば、カメラからリアルタイムに出力する事ができます。
Cameraデバイス、デスクトップ環境、OpenCV3.3.0が揃っている必要があります。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
import tensorflow as tf
from model import FCN8s, PSPNet50, ICNet, ENet
import cv2
import time
import sys
import numpy as np

# Parameters
model_name = 'icnet'
camera_num = 0
model_table = {}
model_table['icnet'] = {"module":ICNet, "path":"model/icnet.npy"}
model_table['fcn'] = {"module":FCN8s, "path":"model/fcn.npy"}
model_table['pspnet'] = {"module":PSPNet50, "path":"model/pspnet50.npy"}
if len(sys.argv) == 2: model_name = sys.argv[1]

print("Open TensorFlow session and initialize")
sess = tf.Session()
init = tf.global_variables_initializer()
sess.run(init)


print("Selected model => " + model_name)
param = model_table[model_name]
model = param['module']()
model.load(param['path'], sess)

print("Start camera")
cap = cv2.VideoCapture(camera_num)
print("Initialized capture device.")
while cap.isOpened():
check, frame = cap.read()
print(check)
if check:
left = frame.copy()
right = frame.copy()

model.read_input(left)
print("Input")
left = model.forward(sess)[0]
print("Forward")

left = cv2.resize(left,(frame.shape[1],frame.shape[0]))
left += left
left += right
left /= 3
left = cv2.resize(left,(2*left.shape[1],2*left.shape[0]))
left = np.array(left, dtype = 'uint8')
cv2.imshow(model_name,left)
cv2.waitKey(1)
print("Show")

SemanticSegmentationの場合は、教師データを作るのが地獄ですが、ObjectDetectionよりもネットワークはシンプルなものが多くて助かります。

SourceYoloV2(Object Detection)FCN(Semantic Segmentation)
SourceYoloV2(Object Detection)FCN(Semantic Segmentation)
SourceYoloV2(Object Detection)FCN(Semantic Segmentation)

References


GPU EATER - AMD GPU-based Deep Learning Cloud


Benchmarks on MATRIX MULTIPLICATION | TitanV TensorCore (FP16=>FP32)

Introduction

This is continued from the last article.
I’ll be writing about benchmarks for the multiplications of matrices, including for the TensorCore (FP16=>FP32), which was first incorporated in the Volta.


Matrix Multiplication with TensorCore


NVIDIA TitanV’s TensorCore (FP16=>FP32) and other FP32 benchmarks.
I used the same setup as before: Ubuntu16.04 incorporating Python3.5+390.30, CUDA9.0, cuDNN7, and TensorFlow1.6.

https://devblogs.nvidia.com/programming-tensor-cores-cuda-9/
*It’s not really ideal to make comparisons against FP32 where they should be made against FP16, and give exaggerated descriptions the way they do on NVIDIA’s official site, but please note that this graph does make comparisons between FP32 and TensorCore (FP16).




Considerations

If you look at the graph, you’ll see that there is a bottleneck somewhere in the calculated number of elements in the matrices and the GPU calculation memory, creating spikes in places. Therefore, it would appear that when using Tensor Core, there are rules for “fast numbers of elements” and “slow numbers of elements.”

Incidentally, TensorCore uses a method called Mixed-Precision, a special core that is engineered to maintain precision by taking 16-bit floating point inputs (FP16) and accumulating the result into 32-bit floating point (FP32). If Deep Learning calculations were carried out using only FP16, the lack of precision would result in numerical failures. It appears that applying FP32 to the part where precision failures would occur makes it possible to maintain the efficient computing speeds of FP16, and carry out calculations efficiently while preventing precision failure.

Therefore, we need to remember that these are figures for “FP16” rather than”FP32” to avoid confusion . Or, given that this is not purely FP16, perhaps this should be described in a particular way such as FP16=>FP32.

According to materials provided by NVIDIA, there are no real issues with learning even if TensorCore(FP16=>FP32) is used for all layers, as it uses not only FP16 but augments any numerical failures with FP32. However, there may be cases where it is necessary to use regular FP32 rather than TensorCore, such as for calculations or particular models that require precision, and calculations for updates. Therefore, for operational purposes, FP32 should be used if one is not sure if a numerical failure may occur within the model. When conducting learning at FP32 precision in the cloud, you have the choice of continuing to use Tesla, which is not cost effective as it costs 10 times as much, or downgrading to Pascal or using Vega56/64/FrontierEdition as more cost effective methods.


(*These are figures for FP32 only)

The benchmarks for the multiplication of matrices were almost exactly as predicted, more or less matching the official Flops benchmarks, so I was able to achieve figures that made sense. However, Flops benchmarks are not really relevant for DeepLearning, and it is difficult to achieve differences of over five times in the same way as for simple Flops benchmarks. NVIDIA itself measured benchmarks for ResNet-50 using P100 and V100 (TensorCore), and from what I can see of the materials, they only achieved a difference of 3.7 times, so expectations need to be kept in check.


The reason I am using so much red text this time is because I didn’t realize that the official figure of “120TFlops” was a benchmark for FP16, and as I couldn’t achieve any real speeds with FP32 when I actually used it, for a while I mistakenly thought that the driver was either old or had not been implemented. In addition, some blog articles by the general public, as well as slide shares and media, had misunderstood and erroneously put down 120TFlops for FP32, causing even more confusion, so I have used a lot of red text.


The official figures as published

Tesla V100 PCleTesla V100 SXM2TitanV
FP647 TFLOPS7.8 TFLOPS? TFLOPS
FP3214 TFLOPS15.7 TFLOPS? TFLOPS
FP16=>FP32112 TFLOPS125 TFLOPS110 TFLOPS

The reason that there is almost no difference in speed between the Tesla and GeForce/Titan products, as with the previous generation, is because there is almost no difference in actual speeds for the V100 series and the TitanV for the Volta generation. In addition, the sensory speeds for gaming experiences using TitanV were not as fast as expected, and were almost the same as the default settings for the overclocked version of the 1080Ti. This would appear to be because TensorCore is not used in gaming, and even if it were used, the massive numbers of linear algebraic computations would tend to create bottlenecks in the overheads of shader pipelines, number of draw calls, or texture fetch.



The world’s first AMD GPU-based Deep Learning Cloud.

GPU EATER https://gpueater.com

References

Benchmarks on MATRIX MULTIPLICATION | TitanV TensorCore (FP16=>FP32)

Introduction

前回からの続きです。
行列の掛け算についてVolta世代から入ったTensorCore(FP16=>FP32)を含むベンチマークについて記述していきます。


Matrix Multiplication with TensorCore


TitanVのTensorCore(FP16=>FP32)とその他はFP32のベンチマーク。
動作環境は前回同様、Ubuntu16.04にPython3.5+390.30,CUDA9.0,cuDNN7,TensorFlow1.6を入れています。

https://devblogs.nvidia.com/programming-tensor-cores-cuda-9/
*NVIDIAの公式に書いてあるような、本来FP16と比較するべき部分をFP32と比較、誇張した記述の仕方はあまりよくないのですが、このグラフもあえてFP32とTensorCore(FP16)を比較したグラフですので注意が必要です。




考察

グラフを見ると計算上の行列の要素数とGPUの計算用メモリのどこかがネックになりところどころスパイク状に尖っています。
この事から、TensorCoreを使用する場合は”速い要素数”と”遅い要素数”のルールがあると考えられます。

ちなみに、TensorCoreはMixed-Precisionと呼ばれる方式で、入力が16bit浮動小数点(FP16)、途中計算から32bit浮動小数点(FP32)にすることで精度を崩さないように工夫した特殊コアになります。DeepLearning計算を全てFP16にしてしまうと精度が足らず数値破綻を起こします。これを精度破綻が起こる部分にFP32を適応したことでFP16での効率的な演算速度を維持しながら、精度破綻を防いで効率よく計算を行う事が可能なるということのようです。

ですので、“FP32”ではなく”FP16”の指標だ、という部分を勘違いしないように注意が必要です。
もしくは、純粋なFP16でもありませんので、FP16=>FP32という風に特殊な記法で記述するべきかもしれません。

NVIDIAの資料によると、FP16のみではなく数値破綻部分をFP32で補填するので全ての層に対してTensorCore(FP16=>FP32)を使用しても大凡は学習においても問題がないとのこと。ただし、精度が必要な計算や特定のモデル、更新時の計算については、TensorCoreではなく通常のFP32を使わなければならないケースもあるということで、モデル内部での数値破綻が発生するかわからない場合はFP32を使用するといった運用になります。もし、クラウド上でFP32の精度の学習を行う場合は、10倍ほどの値段の費用対効果が悪いTeslaを継続して使用するか、世代をPascalに落として使うか、Vega56/64/FrontierEditionを使用するのが費用対効果が良い方法となります。


(*こちらはFP32のみ指標になります。)

今回のベンチマークも行列の掛け算においてもほぼ、予測したとおりの結果となっており、公式で言われてるFlops指標と大凡一致し、違和感の無い指標が取れています。しかし、DeepLearningに於いてはFlops指標はあまり参考にならず、単純なFlops指標のように5倍以上等の差をつけるのは難しく、NVIDIAが自らP100とV100(TensorCore)で計測したResNet-50のベンチも資料を見る限り、3.7倍しか差が開かないという結果が出ていますので過剰な期待は注意が必要です。


今回、赤い文字を多く使っているのは、公式の”120TFlopsという数値はFP16の指標”だとは知らず、実際使ってみた時にFP32で全く速度が出ないことから、ドライバが古いか実装がされていないのだろうとしばらく勘違いをしていたからです。また、一般のブログ記事、スライドシェアやメディアによってはFP32の部分を120TFlopsと誤記されていたことから勘違いから勘違いを引き起こしてしまい混乱していたので、今回は赤文字を多く使用しました。


アナウンスされている公式値

Tesla V100 PCleTesla V100 SXM2TitanV
FP647 TFLOPS7.8 TFLOPS? TFLOPS
FP3214 TFLOPS15.7 TFLOPS? TFLOPS
FP16=>FP32112 TFLOPS125 TFLOPS110 TFLOPS

前世代同様、TeslaとGeForce/Titan製品の速度が殆んど変わらないのは、Volta世代も同じくV100シリーズとTitanVの実質の速度もあまり変わりません。また、TitanVでのGamingの体感速度は期待するほど早くならず、1080Tiのオーバークロック版のデフォルトとほぼ変わりませんでした。GamingにおいてはTensorCoreは使われず、使ったとしても大量の線形代数演算より、シェーダーパイプライン上のオーバーヘッドやドローコール回数、テクスチャフェッチの方がボトルネックになりやすいからだと考えられます。



世界初のAMD GPU搭載の Deep Learning クラウド

GPU EATER https://gpueater.com

References

Keras VGG-19 on PlaidML (Japanese)

HIP-TensorFlowより速いと噂のPlaidMLを動かしてみた。

Introduction

HIP-TensorFlowはTensorFlowをCUDAシミュレーションを行って実現されたライブラリですが、その動作スピードはまだ開発の途中であるか、古いTensorFlowをもとに作られているため、DeepLearingの計算においては最新のNVIDIA+TensorFlowの組み合わせに対して速度差があります。また、RX580と上位GPUであるVega56、Vega64と変わらないスピードであることから、Vegaシリーズの能力が発揮出来ていないという部分からもまだ未成熟のライブラリです。(2018/03/13)

PlaidMLはそれを補うことが出来るライブラリの一つだと言われており、TensorFlowの代わりにKerasのバックエンド化が出来ることが特徴です。




HIP-TensorFlowとPaidMLのライブラリスタック



HIP-TensorFlowPlaidML

Keras or something


TensorFlow


MIOpen(CUDA simulation layer)


ROCm(GPU computing driver)


AMD-GPU driver


OS


Native GPU




Keras or something


PlaidML


PlaidML


ROCm or AMDGPUPRO or CUDASDK


AMD-GPU driver/NVIDIA-GPU driver


OS


Native GPU




ライブラリスタックからもわかるように、PlaidMLはKerasのバックエンドとしての役割を担います。Kerasのバックエンド層には他の候補として、GoogleのTensorFlow、MicrosoftのCNTK、モントリオール大学のTheanoなどが有名です。




Installation

PlaidMLを弊社のAMD Ubuntu16.04インスタンスに入れていきます。
まずはAMDGPUのドライバをインストールします。この場合、ROCmをベースとしますので簡単です。

1
2
3
4
5
wget -qO - http://repo.radeon.com/rocm/apt/debian/rocm.gpg.key | sudo apt-key add -
sudo sh -c 'echo deb [arch=amd64] http://repo.radeon.com/rocm/apt/debian/ xenial main > /etc/apt/sources.list.d/rocm.list'
sudo apt update
sudo apt install -y libnuma-dev rocm-dkms rocm-opencl-dev
sudo usermod -a -G video $LOGNAME

OpenCLのコマンド
/opt/rocm/opencl/bin/x86_64/clinfo
にて確認してください。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
root@C-639ab3c2-c201-401e-9cc2-08dc90fef661-1:~# /opt/rocm/opencl/bin/x86_64/clinfo
Number of platforms: 1
Platform Profile: FULL_PROFILE
Platform Version: OpenCL 2.1 AMD-APP.internal (2545.0)
Platform Name: AMD Accelerated Parallel Processing
Platform Vendor: Advanced Micro Devices, Inc.
Platform Extensions: cl_khr_icd cl_amd_object_metadata cl_amd_event_callback
Platform Name: AMD Accelerated Parallel Processing
Number of devices: 1
Device Type: CL_DEVICE_TYPE_GPU
Vendor ID: 1002h
Board name: Device 6861
Device Topology: PCI[ B#5, D#0, F#0 ]
Max compute units: 64
Max work items dimensions: 3
Max work items[0]: 1024
Max work items[1]: 1024
Max work items[2]: 1024
Max work group size: 256
Preferred vector width char: 4
Preferred vector width short: 2
Preferred vector width int: 1
Preferred vector width long: 1
Preferred vector width float: 1
Preferred vector width double: 1
Native vector width char: 4
Native vector width short: 2
Native vector width int: 1
Native vector width long: 1
Native vector width float: 1
Native vector width double: 1
Max clock frequency: 1500Mhz
Address bits: 64
Max memory allocation: 14588628172
Image support: Yes
Max number of images read arguments: 128
Max number of images write arguments: 8
Max image 2D width: 16384
Max image 2D height: 16384
Max image 3D width: 2048
Max image 3D height: 2048
Max image 3D depth: 2048
Max samplers within kernel: 26721
Max size of kernel argument: 1024
Alignment (bits) of base address: 1024
Minimum alignment (bytes) for any datatype: 128
Single precision floating point capability
Denorms: Yes
Quiet NaNs: Yes
Round to nearest even: Yes
Round to zero: Yes
Round to +ve and infinity: Yes
IEEE754-2008 fused multiply-add: Yes
Cache type: Read/Write
Cache line size: 64
Cache size: 16384
Global memory size: 17163091968
Constant buffer size: 14588628172
Max number of constant args: 8
Local memory type: Scratchpad
Local memory size: 65536
Max pipe arguments: 16
Max pipe active reservations: 16
Max pipe packet size: 1703726284
Max global variable size: 14588628172
Max global variable preferred total size: 17163091968
Max read/write image args: 64
Max on device events: 0
Queue on device max size: 0
Max on device queues: 0
Queue on device preferred size: 0
SVM capabilities:
Coarse grain buffer: Yes
Fine grain buffer: Yes
Fine grain system: No
Atomics: No
Preferred platform atomic alignment: 0
Preferred global atomic alignment: 0
Preferred local atomic alignment: 0
Kernel Preferred work group size multiple: 64
Error correction support: 0
Unified memory for Host and Device: 0
Profiling timer resolution: 1
Device endianess: Little
Available: Yes
Compiler available: Yes
Execution capabilities:
Execute OpenCL kernels: Yes
Execute native function: No
Queue on Host properties:
Out-of-Order: No
Profiling : Yes
Queue on Device properties:
Out-of-Order: No
Profiling : No
Platform ID: 0x7f16fc2423f0
Name: gfx900
Vendor: Advanced Micro Devices, Inc.
Device OpenCL C version: OpenCL C 2.0
Driver version: 2545.0 (HSA1.1,LC)
Profile: FULL_PROFILE
Version: OpenCL 1.2
Extensions: cl_khr_fp64 cl_khr_global_int32_base_atomics cl_khr_global_int32_extended_atomics cl_khr_local_int32_base_atomics cl_khr_local_int32_extended_atomics cl_khr_int64_base_atomics cl_khr_int64_extended_atomics cl_khr_3d_image_writes cl_khr_byte_addressable_store cl_khr_fp16 cl_khr_gl_sharing cl_amd_device_attribute_query cl_amd_media_ops cl_amd_media_ops2 cl_khr_subgroups cl_khr_depth_images cl_amd_copy_buffer_p2p

次にPlaidMLです。
公式の方法はこちらになりますが、今回は弊社のAMDGPUインスタンスとROCmを使いますので、以下のコマンドのみでOKです。
公式:https://github.com/plaidml/plaidml

1
2
3
4
sudo add-apt-repository universe && sudo apt update
sudo apt install python-pip
sudo pip install -U plaidml-keras h5py
plaidml-setup

以上で動作環境は整います。

VGG19を公式に従って動かします。
以下の公式のコードをvgg.pyという名前で保存してください。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#!/usr/bin/env python
import numpy as np
import time

# Install the plaidml backend
import plaidml.keras
plaidml.keras.install_backend()

import keras
import keras.applications as kapp
from keras.datasets import cifar10

(x_train, y_train_cats), (x_test, y_test_cats) = cifar10.load_data()
batch_size = 8
x_train = x_train[:batch_size]
x_train = np.repeat(np.repeat(x_train, 7, axis=1), 7, axis=2)
model = kapp.VGG19()
model.compile(optimizer='sgd', loss='categorical_crossentropy',
metrics=['accuracy'])

print("Running initial batch (compiling tile program)")
y = model.predict(x=x_train, batch_size=batch_size)

# Now start the clock and run 10 batches
print("Timing inference...")
start = time.time()
for i in range(10):
y = model.predict(x=x_train, batch_size=batch_size)
print("Ran in {} seconds".format(time.time() - start))

動作確認を行います。

1
2
3
4
5
6
7
8
9
10
11
12
root@C-639ab3c2-c201-401e-9cc2-08dc90fef661-1:~/vgg# python vgg.py
/usr/local/lib/python2.7/dist-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.
from ._conv import register_converters as _register_converters
Downloading data from http://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz
170491904/170498071 [============================>.] - ETA: 0sINFO:plaidml:Opening device "gfx900.0"
Downloading data from https://github.com/fchollet/deep-learning-models/releases/download/v0.1/vgg19_weights_tf_dim_ordering_tf_kernels.h5
574627840/574710816 [============================>.] - ETA: 0sRunning initial batch (compiling tile program)
INFO:plaidml:Analyzing Ops: 44 of 195 operations complete
INFO:plaidml:Analyzing Ops: 100 of 195 operations complete
INFO:plaidml:Analyzing Ops: 162 of 195 operations complete
Timing inference...
Ran in 0.758494853973 seconds

予想していたよりも簡単にインストールすることが出来、動作も問題ないようです。
KerasはDeepLearning業界ではよく使われるライブラリで、github上にも多くのKerasをベースとした最新のコードが大量にありますのでPlaidMLのようなクロスプラットフォームなライブラリは非常に重宝します。

vertex.aiさんGreatJOB!です。





世界初のAMD GPU搭載の Deep Learning クラウド

GPU EATER https://gpueater.com

References


VGG-19 on Keras/PlaidML backend

PLAIDML, which is rumored to be faster than HIP-TENSORFLOW

Introduction

Hello!

HIP-TensorFlow is a library implemented by performing an CUDA simulation of TensorFlow, but since its execution speed is still under development or based on the old TensorFlow, there is a speed difference when compared against the latest NVIDIA + TensorFlow in the DeepLearning. Also, since it works at the same speed for RX 580 as for superior GPUs like Vega 56 and Vega 64, it is still an immature library in that it cannot demonstrate the potential of the Vega series.(Mar/13th/2018)

However, PlaidML is the library that can compensate for it, and is characterized by the fact that it can be used as a backend for Keras instead of TensorFlow.




HIP-TENSORFLOW and PAIDML library stack



HIP-TensorFlowPlaidML

Keras or something


TensorFlow


MIOpen(CUDA simulation layer)


ROCm(GPU computing driver)


AMD-GPU driver


OS


Native GPU




Keras or something


PlaidML


PlaidML


ROCm or AMDGPUPRO or CUDASDK


AMD-GPU driver/NVIDIA-GPU driver


OS


Native GPU




As can seen from the library stack, PlaidML is used as Keras’ backend. Other well-known backend options for Keras include Google’ s TensorFlow, Microsoft ‘s CNTK, Université de Montréal’s Theano, etc.




Installation

We will install PlaidML into our AMD GPU-based Ubuntu 16.04 instance.
First of all we install it on the AMD GPU driver. In this case, it is simple because it is ROCm based.

1
2
3
4
5
wget -qO - http://repo.radeon.com/rocm/apt/debian/rocm.gpg.key | sudo apt-key add -
sudo sh -c 'echo deb [arch=amd64] http://repo.radeon.com/rocm/apt/debian/ xenial main > /etc/apt/sources.list.d/rocm.list'
sudo apt update
sudo apt install -y libnuma-dev rocm-dkms rocm-opencl-dev
sudo usermod -a -G video $LOGNAME

Please run the following OpenCL-based command to confirm.
/opt/rocm/opencl/bin/x86_64/clinfo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
root@C-639ab3c2-c201-401e-9cc2-08dc90fef661-1:~# /opt/rocm/opencl/bin/x86_64/clinfo
Number of platforms: 1
Platform Profile: FULL_PROFILE
Platform Version: OpenCL 2.1 AMD-APP.internal (2545.0)
Platform Name: AMD Accelerated Parallel Processing
Platform Vendor: Advanced Micro Devices, Inc.
Platform Extensions: cl_khr_icd cl_amd_object_metadata cl_amd_event_callback
Platform Name: AMD Accelerated Parallel Processing
Number of devices: 1
Device Type: CL_DEVICE_TYPE_GPU
Vendor ID: 1002h
Board name: Device 6861
Device Topology: PCI[ B#5, D#0, F#0 ]
Max compute units: 64
Max work items dimensions: 3
Max work items[0]: 1024
Max work items[1]: 1024
Max work items[2]: 1024
Max work group size: 256
Preferred vector width char: 4
Preferred vector width short: 2
Preferred vector width int: 1
Preferred vector width long: 1
Preferred vector width float: 1
Preferred vector width double: 1
Native vector width char: 4
Native vector width short: 2
Native vector width int: 1
Native vector width long: 1
Native vector width float: 1
Native vector width double: 1
Max clock frequency: 1500Mhz
Address bits: 64
Max memory allocation: 14588628172
Image support: Yes
Max number of images read arguments: 128
Max number of images write arguments: 8
Max image 2D width: 16384
Max image 2D height: 16384
Max image 3D width: 2048
Max image 3D height: 2048
Max image 3D depth: 2048
Max samplers within kernel: 26721
Max size of kernel argument: 1024
Alignment (bits) of base address: 1024
Minimum alignment (bytes) for any datatype: 128
Single precision floating point capability
Denorms: Yes
Quiet NaNs: Yes
Round to nearest even: Yes
Round to zero: Yes
Round to +ve and infinity: Yes
IEEE754-2008 fused multiply-add: Yes
Cache type: Read/Write
Cache line size: 64
Cache size: 16384
Global memory size: 17163091968
Constant buffer size: 14588628172
Max number of constant args: 8
Local memory type: Scratchpad
Local memory size: 65536
Max pipe arguments: 16
Max pipe active reservations: 16
Max pipe packet size: 1703726284
Max global variable size: 14588628172
Max global variable preferred total size: 17163091968
Max read/write image args: 64
Max on device events: 0
Queue on device max size: 0
Max on device queues: 0
Queue on device preferred size: 0
SVM capabilities:
Coarse grain buffer: Yes
Fine grain buffer: Yes
Fine grain system: No
Atomics: No
Preferred platform atomic alignment: 0
Preferred global atomic alignment: 0
Preferred local atomic alignment: 0
Kernel Preferred work group size multiple: 64
Error correction support: 0
Unified memory for Host and Device: 0
Profiling timer resolution: 1
Device endianess: Little
Available: Yes
Compiler available: Yes
Execution capabilities:
Execute OpenCL kernels: Yes
Execute native function: No
Queue on Host properties:
Out-of-Order: No
Profiling : Yes
Queue on Device properties:
Out-of-Order: No
Profiling : No
Platform ID: 0x7f16fc2423f0
Name: gfx900
Vendor: Advanced Micro Devices, Inc.
Device OpenCL C version: OpenCL C 2.0
Driver version: 2545.0 (HSA1.1,LC)
Profile: FULL_PROFILE
Version: OpenCL 1.2
Extensions: cl_khr_fp64 cl_khr_global_int32_base_atomics cl_khr_global_int32_extended_atomics cl_khr_local_int32_base_atomics cl_khr_local_int32_extended_atomics cl_khr_int64_base_atomics cl_khr_int64_extended_atomics cl_khr_3d_image_writes cl_khr_byte_addressable_store cl_khr_fp16 cl_khr_gl_sharing cl_amd_device_attribute_query cl_amd_media_ops cl_amd_media_ops2 cl_khr_subgroups cl_khr_depth_images cl_amd_copy_buffer_p2p

Next installation is PlaidML.

The official installation method is set forth in the following url.
https://github.com/plaidml/plaidml

But this time, we will use our comany’s AMD GPU instance and ROCm, so please run the following commands.

1
2
3
4
sudo add-apt-repository universe && sudo apt update
sudo apt install python-pip
sudo pip install -U plaidml-keras h5py
plaidml-setup

Now, installation is completed.

We will execute VGG-19 according to the official methodology.
Please save the following official code as vgg.py.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#!/usr/bin/env python
import numpy as np
import time

# Install the plaidml backend
import plaidml.keras
plaidml.keras.install_backend()

import keras
import keras.applications as kapp
from keras.datasets import cifar10

(x_train, y_train_cats), (x_test, y_test_cats) = cifar10.load_data()
batch_size = 8
x_train = x_train[:batch_size]
x_train = np.repeat(np.repeat(x_train, 7, axis=1), 7, axis=2)
model = kapp.VGG19()
model.compile(optimizer='sgd', loss='categorical_crossentropy',
metrics=['accuracy'])

print("Running initial batch (compiling tile program)")
y = model.predict(x=x_train, batch_size=batch_size)

# Now start the clock and run 10 batches
print("Timing inference...")
start = time.time()
for i in range(10):
y = model.predict(x=x_train, batch_size=batch_size)
print("Ran in {} seconds".format(time.time() - start))

We will confirm the status.

1
2
3
4
5
6
7
8
9
10
11
12
root@C-639ab3c2-c201-401e-9cc2-08dc90fef661-1:~/vgg# python vgg.py
/usr/local/lib/python2.7/dist-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.
from ._conv import register_converters as _register_converters
Downloading data from http://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz
170491904/170498071 [============================>.] - ETA: 0sINFO:plaidml:Opening device "gfx900.0"
Downloading data from https://github.com/fchollet/deep-learning-models/releases/download/v0.1/vgg19_weights_tf_dim_ordering_tf_kernels.h5
574627840/574710816 [============================>.] - ETA: 0sRunning initial batch (compiling tile program)
INFO:plaidml:Analyzing Ops: 44 of 195 operations complete
INFO:plaidml:Analyzing Ops: 100 of 195 operations complete
INFO:plaidml:Analyzing Ops: 162 of 195 operations complete
Timing inference...
Ran in 0.758494853973 seconds

It seems that it can be installed more easily than expected and there are no problems with the operation. Keras is a library commonly used in the DeepLearning, and since github also has a lot of the latest Keras-based code, cross-platform libraries like PlaidML are very handy.

GreatJOB, vertex.ai!


The world’s first AMD GPU-based Deep Learning Cloud.

GPU EATER https://gpueater.com




References


Benchmarks on MATRIX MULTIPLICATION | A comparison between AMD Vega and NVIDIA GeForce series

Introduction

ACUBE Corp. graciously allowed us to borrow a Radeon Pro WX9100, so we have decided to make a report on the card and a record of the results here on our company blog. We would like to extend our heartfelt gratitude to ACUBE Corp. for this opportunity.

This report focuses on the Radeon Pro WX9100 card and makes comparisons with the Radeon RX560/580 and RadeonVega56/64/Frontier Edition from the same manufacturer, as well as with the GeForce series from NVIDIA.

Our original goal was simply to compare a number of variables as they pertain to Deep Learning in GPU cloud computing, including the card’s power consumption, stability, durability and heat treatment performance, cost-effectiveness, library operation assessment, as well as inference and learning speeds, and consider implementing this card for our own use. However, we felt that it would be a good idea to show the capabilities of this GPU to a wider audience and thus decided to write this article.


MATRIX MULTIPLICATION

*Calculations for the TitanX(M) only were interrupted mid-way, so we have inserted the final values mechanically.


Calculated Metrics

The calculated metrics we used to measure learning speeds were the foundation for general neural networks—the important factor of matrix multiplication speed via the ρ(φiωji + βj) calculation, as well as CIFAR10, often used in global competitions and benchmarks, using TensorFlow formulas.
We will post only the matrix multiplications for this article.

Refer to this link for more information on matrix multiplication:
https://github.com/yaroslavvb/stuff/blob/master/matmul_benchmark_seq.py


Operating Environments

For AMD:
Ubuntu 16.04.3 x64
HIP-TensorFlow 1.0.1
Python 2.7
Driver: ROCm 1.7, AMDGPUPRO 17.50

For NVIDIA:
Ubuntu 16.04.3 x64
TensorFlow r1.6
Python 3.5
Driver: 390.30, CUDA9.0, cuDNN7

The method for setting up HIP-TensorFlow1.0.1 on Python 3.5 was unclear, so we used Python 2.7. Furthermore, as we judged there to be no difference between Python 2.7 and 3.5 due to the fact that CPU capability is basically unnecessary as a metric for benchmarks, we used Python 3.5 and TensorFlow’s newest version (r1.6) for the NVIDIA cards. Also, because we have made it possible to use TensorCore FP16 with CIFAR10 for the Titan V, please be aware that it is difficult to say that everything was run under exactly the same conditions.

We used the newest version of the ROCm driver (17.50) for the Radeon cards and the 390.30 driver providing full support for Titan V as well as CUDA9.0 + cuDNN7 for the NVIDIA cards. This configuration seems to give an advantage to the NVIDIA cards, but, as support speed for HIP-TensorFlow is not very fast, there is nothing we could do concerning this point.


Discussion

As far as matrix multiplication goes, the results we found were almost exactly as we had predicted. They match with the FLOPS metric laid out in the formulas, and we were able to produce metrics that didn’t seem strange at all. TensorCore (FP16) is not used for calculating 32-bit floating point representation for the Titan V, and it couldn’t reach 110TFLOPS at all, making it slightly faster than the 1080Ti if we use FPS32 as the metric here. We also feel that it should be pointed out that the AMD cards are fighting on even ground with NVIDIA’s cards. This means that, based on the FP32 metric with solidly assembled libraries, there is hardly any difference between NVIDIA and AMD. However, as the difference between the two becomes apparent in the CIFAR10 results which we will post in a future article, we can see that a slight tune-up will be necessary, such as making improvements to HIP-TensorFlow or using Vertex.AI’s PlaidML.


References

MATRIX MULTIPLICATION ベンチマーク | AMD Vega and NVIDIA GeForce シリーズ比較 (Japanese)

Introduction

株式会社ACUBE様より、Radeon Pro WX9100をお貸しして頂きましたので、そのレポートと共に弊社ブログへの結果を記載することに致しました。ご協力頂いた、ACUBE様に心より御礼を申し上げます。

このレポートは、Radeon Pro WX9100 製品を主軸に、同社 RadeonRX560/580, RadeonVega56/64/Frontier Edition, 他 NVIDIA 製品で、GeForceシリーズを比較したものになります。

元々の目的は、GPU クラウドコンピューティングにおける DeepLearning において、推論及び学習スピード、ライブラリの動作評価、費用対効果、耐久性及び熱処理効率、安定性、消費電力量、等などを比較し、導入を検討することですが、もっと多くの方々にGPUの能力について知って貰いたいがため記事に書くことにしました。


Matrix Multiplication


*TitanX(M)のみ途中で計測が途切れたので最後の値を機械的に入れています。

計算指標

計算指標としては、一般ニューラルネットワークにおける基礎、ρ(φiωji + βj)の計算で重要な行列 x 行列の速度、及び世界コンペティションやベンチマークでよく使用される CIFAR10 を TensorFlow の公式を使用し 、学習スピードを計測するものとしました。
今回の記事は、”行列計算”のみ掲載します。

行列の掛け算については、
https://github.com/yaroslavvb/stuff/blob/master/matmul_benchmark_seq.py
を参照。

動作環境

AMD側
Ubuntu 16.04.3 x64
HIP-TensorFlow 1.0.1
Python 2.7
Driver: ROCm 1.7, AMDGPUPRO 17.50

NVIDIA側
Ubuntu 16.04.3 x64
TensorFlow r1.6
Python 3.5
Driver: 390.30, CUDA9.0, cuDNN7

HIP-TensorFlow1.0.1 については Python3.5 でのセットアップ方法が不明なため、 Python2.7 を使用しました。また、今ベンチマークにおける指標については CPU 能力は基本不要で、Python2.7/3.5 は変わらないと判断したため、NVIDIA 側は Python3.5+TensorFlow 最新(r1.6)を利用。また、TitanV のCIFAR10においては”TensorCore FP16”を利用できるようにしているため、完全に同じ条件とは言い難いことに注意。

ドライバは Radeon 側は ROCm ベースの最新(17.50)、 NVIDIA 側は 390.30 の完全 TitanV 対応しているドライバ及び、CUDA9.0+cuDNN7 を使用。NVIDIA側に肩を持つような構成になっていますが、HIP-TensorFlowのサポートスピードが早くないため、これは仕方がありません。

考察

行列の掛け算においてはほぼ、予測したとおりの結果となっており、公式で言われてるFlops指標と一致し、違和感の無い指標が取れています。TitanVについては32bit浮動小数点での計算においては、TensorCore(FP16)が使われず、公式の110TFlopsには全く届かないため、FP32を指標とするならば、1080Tiより少し早い程度になります。また、AMD製品もNVIDIA製品に負けず劣らず健闘しているところも注目すべき点でしょう。この事からライブラリをしっかりと組めればFP32指標では、NVIDIAとAMD双方において大きい差分は無いことを意味しますが、実際に後日記述するCIFAR10での差が明確に開くため、HIP-TensorFlowを改善するか、Vertex.aiのPlaidMLを使用すると言ったチューンナップが必用だということが分かっています。

Wednesday, March 1, 2018, 米国AMD社製GPUベースのDeep Learningクラウドをローンチ (Japanese)

米国AMD社製GPUベースのDeep Learningクラウドをローンチ

第二弾 NVIDIA社製GPUを搭載したビギナー、予測・推論向けの低価格クラウドを発表

2018年3月1日:米国スタートアップ Pegara, Inc.(読み:ペガラインク、本社:米国デラウェア州、共同創業者兼CEO:市原 俊亮)は、米国AMD社製GPUベースのDeep Learningクラウドを同社クラウドサービスであるGPU EATER( https://gpueater.com/ )を通じて正式に提供開始します。また、第二弾としてNVIDIA社製GPUを搭載した予測・推論およびビギナー向けの低価格クラウドを2018年4月1日から開始することを発表し、本日より先行予約を受付開始します。

Amazon Web Services(以降、AWS)を始めとする大手クラウド各社はDeep Learningの需要増加に伴いNVIDIA社製GPUを搭載したインスタンスを複数プラン提供しておりますが、これらのインスタンスをDeep Learningの予測・推論に利用する場合、同インスタンスを無停止稼働させなくてはないため、AWSを利用する場合、インスタンスあたり月額5万円以上(*1)を支払う必要があります。小規模な研究施設や大学、中小企業で働く研究者・開発者が利用するにはリーズナブルな金額とは言えません。

一方で、当社実施の検証では画像認識や物体認識におけるDeep Learningの予測・推論においてはGPUがボトルネックとなることは少なく、CPUやWeb APIの実装がボトルネックとなりやすいことがわかっております。したがって、多くの場合において高価なCPUとGPUを多く搭載するマシンよりも、中程度のCPUと低スペックのGPUを組み合わせたマシンを複数台利用することにより費用対効果を高めることが可能と判断しました。

これらの検証結果をもとにDeep Learningの研究者・開発者らと意見交換を重ねた結果、安価な予測・推論の実行に関する課題の存在を確認できたため、この度商品化を決断するに至りました。

また、安価な予測・推論の実行環境は、初心者がDeep Learningを学ぶ環境としても最適です。AWSを利用して学習する場合、学習を終了したタイミングでインスタンスを停止することを前提としておりますが、停止を忘れることが原因により高額を支払ったという学習者の声があとを絶ちません。低価格クラウドはこれらのミスにより受ける経済的な損失と停止するための手間をなくすことが可能となります。

料金は初期費用なしの1ヶ月あたり7,500円程度を予定しております。GPUは、NVIDIA社製のQuadro P400、P1000、P4000の3種類から選択可能、OSはUbuntu又はCentOS、SSDを搭載したインスタンスとなります。

先行予約のお申し込み、お問い合わせは、日本国内における販売およびサポートを行うペガラジャパン合同会社までお問い合わせください。

今後、Pegaraでは、エンタープライズ向けサービスや、GPUだけではなくFPGA・ASICなど種類の異なるデバイスを組み合わせて構築したコンピューティングリソースのクラウド提供を予定しております。

■Pegara, Inc.について
会社名  : Pegara, Inc.
所在地  : 4000 Barranca parkway, suite 250, Irvine, CA 92604 U.S.
共同創業者: CEO 市原 俊亮、CTO 中塚 晶仁
設立   : 2015年9月21日
URL    : http://www.pegara.com/
事業内容 : Deep Learningの研究開発、
       クラウドホスティングエンジンの開発

■ペガラジャパン合同会社について
会社名 : ペガラジャパン合同会社
所在地 : 千葉県浦安市海楽2-32-11
代表社員: 市原 俊亮
設立  : 2017年12月1日
URL   : http://jp.pegara.com/
事業内容: 日本国内におけるPegara, Inc.社製品の販売、
      サポート、セミナー、コンサルテーション

*1 NVIDIA Tesla K80搭載インスタンスをAWSにおいてオンデマンド利用した場合の金額

Wednesday, March 7, 2018, The World's First AMD GPU-based Cloud Instances for Deep Learning

IRVINE, CALIF. (PRWEB) MARCH 06, 2018

California startup Pegara, Inc. launched the world’s first set of deep learning instances based on GPUs from American chip maker AMD through its “GPU EATER” heterogeneous cloud computing service.

Although much of today’s deep learning research is conducted using GPUs (graphics processing units) from NVIDIA, in conjunction with libraries it provides, such as CUDA and cuDNN, the revision of the company’s EULA (End User License Agreement) content for its consumer graphics drivers around December 2017 has raised strong voices of concern among researchers and developers at domestic and overseas universities and enterprises about potential termination of research projects and delays in their practical application.

To date, many researchers and developers have used consumer products from NVIDIA for their projects. This is because performance comparisons of learning models commonly used in deep learning research show almost no differences in performance between enterprise and consumer GPUs. Going forward, however, the usage of NVIDIA products for such applications will require the purchase of enterprise products, with price tags maximum 10 times the level of their consumer equivalents, or use cloud instances with such products installed.

Given this situation, we believe the promotion of deep learning research and development using products from AMD, whose GPU market share is second only to NVIDIA, is essential to the continued health of the deep learning development movement. In particular, we have conducted a wide variety of operational tests using AMD GPUs for applications such as AlexNet, VGG, GoogLeNet, Inception v3, CNN/DCNN, RNN, LSTM, MLP, GAN, DCGAN and RCNN and have procured consumer GPUs from AMD and used them to develop ultra-lightweight proprietary cloud management systems.

Usage fees will start at $0.341 US per hour with no startup fee charged. Users may select their desired GPUs among AMD’s Radeon(TM) Vega Frontier Edition, Radeon RX Vega 56 and Radeon RX 580, and available operating systems include Ubuntu and CentOS. All storage is provided on SSD hardware. No additional IOPS and disk volume fees are charged. For details, please refer to the GPUEater website.

website: https://gpueater.com/

Sales/support-related inquiries: info(at)pegara(dot)com
Media/interview-related inquiries: press(at)pegara(dot)com
Investment/other inquiries: contact(at)pegara(dot)com

In the future, Pegara plans to offer enterprise services as well as computing resource cloud services built to feature not only GPUs but a variety of other processor types as well, such FPGAs and ASICs.

About Pegara, Inc.
Company name: Pegara, Inc.
Address: 4000 Barranca Pkwy, Suite 250, Irvine, CA 92604, U.S.
Co-founders: CEO Shunsuke Ichihara, CTO Akihito Nakatsuka
Established: September 21st, 2015
Website: http://www.pegara.com
Field of business: Deep learning research and development, cloud hosting engine development