tensorflowを利用するGPUクラウドサーバの利用方法について

Question

tensorflowを動かすGPUクラウドサーバ性能について質問させて頂きます。
AWSのGPUインスタンスを利用して性能を見ていますが、GPUコア数の高いインスタンスを利用しても処理時間が上がりません。
なぜ、インスタンスでGPU数を多くしても処理速度に変化がないのか理解できていませんが、一つのGPUしか利用できていないかとも考えています。
利用方法についてご意見、アドバイスなども含めてご教授ください。

●AWS-g4dn.2xlarge
1 2019-12-21 21:20:45.724076
1 0 2019-12-21 21:20:45.725365
1 1000 2019-12-21 21:22:10.905428
1 2000 2019-12-21 21:27:49.926334
1 3000 2019-12-21 21:37:48.248926【17分】

●AWS-g4dn.8xlarge
1 2019-12-21 23:23:20.350477
1 0 2019-12-21 23:23:20.351867
1 1000 2019-12-21 23:24:44.001723
1 2000 2019-12-21 23:30:19.057467
1 3000 2019-12-21 23:40:09.601611【17分】

●AWS-p2.xlarge
1 2019-12-21 22:02:09.613107
1 0 2019-12-21 22:02:09.615015
1 1000 2019-12-21 22:03:37.300308
1 2000 2019-12-21 22:09:24.594682
1 3000 2019-12-21 22:19:36.657834【17分】

●プログラムについて
プログラムは以下のような物をJupiterNotebookで動かしています。

# -*- coding: utf-8 -*-
import math
import numpy as np
import datetime
import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPooling2D
import matplotlib.pyplot as plt

# 過去半日分の履歴で計算 (1分足データなので、60*12 = 720/半日)
#n = 1 * 60 * 3
n = 160 #16の10倍

# keras用のパラメータ
batch_size = 5000  # 1000データ単位に学習
epochs = 3
# 0:温度以上, 1:温度以上変動なし, 2:温度以下の３クラス
n_classes = 3
# 何分までに
inMinG = 15

datafile = '../jupyter_files/xdata/srcCreate.txt'
testfile = '../jupyter_files/xdata/tstCreate.txt'
savefile = '../jupyter_files/x_ai.hdf5'
        
class xDataGenerator(object):
    def __init__(self, datafile, l_n):
        self.l_n = l_n
        self.reset()
        # データ[温度,湿度,照度,臭度]の4値分足データのCSV形式
        # 上記４値の3部屋分のデータ、+ 4個の[建物,曜日,月日,時分]　= 16項目 を2時間40分[n=160]
        # 常に最新160個のデータを保存
        self.xparam = np.zeros(l_n*4*4)
        # LabelEncode(classをint型に変換)するためのdict
        with open(datafile) as f:
            self.srcd = f.readlines()

    def reset(self):
        self.xdatas = np.empty((0, 1, self.l_n, 4*4), int)
        self.ylabels = np.array([], int)

    def flow_from_datafile(self, batch_size, datalen):
        ######
        # 何分までに
        inMin = 15
        # 期待温度
        goodVal = 100
        # 反対温度
        badVal = 50

        while True:
            # 読み込んだファイルの行数
            for i in range( ( datalen - inMin ) ):
                # 末尾に新しいデータをいれる（160行の最新データにする）
                self.srcd[i] = self.srcd[i].strip()
                spltDataArr = self.srcd[i].split(",")
                if(len(spltDataArr) != 16):
                    continue
                self.xparam = np.append(self.xparam[16:], spltDataArr)

                # l_n個以上になるとAIに学習させる（720個分で学習させる）
                if ( i >= self.l_n ):

                    # inMin分以内にlosscut(pips)以内にhopeVal(pips)が取れるか判定（クラス分）
                    curClass = 1 # 初期値は中間
                    curVal = 0
                    maxVal = 0
                    minVal = 0
                    for j in range( i, (i + inMin) ):
                        spltCheckArr = self.srcd[j].split(",")
                        if (j == i):
                            curVal = int(spltCheckArr[7])
                            maxVal = int(spltCheckArr[5])
                            minVal = int(spltCheckArr[6])
                            lastRate = int(spltCheckArr[7])
                        else:
                            lastRate = int(spltCheckArr[7])
                            if ( maxVal < int(spltCheckArr[5]) ):
                                maxVal = int(spltCheckArr[5])
                            if ( minVal > int(spltCheckArr[6]) ):
                                minVal = int(spltCheckArr[6])

                    # クラス判定 最終値が期待温度を上下で超えているか（反対向けは単体温度以内）で判定
                    if ( (lastRate - curVal) > goodVal ):
                        if ( (curVal - minVal) < badVal ):
                            curClass = 0
                    elif ( (curVal - lastRate) > goodVal ):
                        if ( (maxVal - curVal) < badVal ):
                            curClass = 2

                    # 学習用データの格納
                    self.xdatas = np.append(self.xdatas, self.xparam.reshape(1, 1, self.l_n, 4*4), axis=0)
                    self.ylabels = np.append(self.ylabels, curClass)

                    # batch_sizeに達すれば一度学習する
                    if ( len(self.ylabels) == batch_size or i == (datalen - inMin - 1) ):
                        print ("")
                        print (i,(datalen - inMin - 1),len(self.ylabels),datalen,"shape0:",self.xparam.shape[0],
                               self.xdatas.shape[0],self.xdatas.shape[1],self.xdatas.shape[2],self.xdatas.shape[3])
                        # 現在の日付と日時
                        nowdate = datetime.datetime.now()
                        print(":::", len(self.ylabels), nowdate)
                        # ターゲットyをkeras用の形式に変換
                        #y_keras = keras.utils.to_categorical(self.ylabels, 3)
                        y_keras = np.asarray(keras.utils.to_categorical(self.ylabels, 3))
                        # データ返答
                        #yield self.xdatas, self.ylabels
                        inputs = np.asarray(self.xdatas)
                        #targets = np.asarray(self.ylabels)
                        self.reset()
                        yield inputs, y_keras


# 現在の日付と日時
nowdate = datetime.datetime.now()
print(1, nowdate)

# データXをCNN用の形式に変換 （X.shape[0]はデータ[行]数）
#X = X.reshape(X.shape[0], n,4,4) #既にこの形で入力しているのでreshape不要
#input_shape = (n,4,4)
input_shape = (1,n,4*4)
#input_shape = (n,16)

# 畳み込みニューラルネットワークを定義
model = Sequential()
model.add(Conv2D(filters=32, kernel_size=(3,3), activation='relu', input_shape=input_shape))
model.add(Conv2D(filters=64, kernel_size=(3,3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(units=128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(units=n_classes, activation='softmax'))

# モデルのコンパイル
model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.Adadelta(), metrics=['accuracy'])

train_datagen = xDataGenerator(datafile,n)
srcdlen = len(open(datafile).readlines())
test_datagen = xDataGenerator(testfile,n)
tstdlen = len(open(testfile).readlines())

# steps_per_epochはその名のとおり、1epochのstep数で、基本はデータ数 / バッチサイズ = int(srcdlen / batchsize)
history = model.fit_generator(
    generator=train_datagen.flow_from_datafile(batch_size, srcdlen),
    steps_per_epoch=int(np.ceil(srcdlen / batch_size)),
    #steps_per_epoch=int(np.floor(srcdlen / batch_size)),
    epochs=epochs,
    verbose=1)
    #validation_data=test_datagen.flow_from_datafile(batch_size, tstdlen),
    #validation_steps=int(np.ceil(tstdlen / batch_size)))
    
    
# 学習結果を保存
model.save(savefile)

#現在の日付と日時
nowdate = datetime.datetime.now()
print(3, nowdate)

# 損失関数のグラフの軸ラベルを設定
plt.xlabel('time step')
plt.ylabel('loss')

# グラフ縦軸の範囲を0以上と定める
plt.ylim(0, max(np.r_[history.history['val_loss'], history.history['loss']]))

# 損失関数の時間変化を描画
val_loss, = plt.plot(history.history['val_loss'], c='#56B4E9')
loss, = plt.plot(history.history['loss'], c='#E69F00')

# グラフの凡例（はんれい）を追加
plt.legend([loss, val_loss], ['loss', 'val_loss'])

# 描画したグラフを表示
plt.show()

Answer 1

インスタンスでGPU数を多くしても処理速度に変化がないのか理解できていませんが、一つのGPUしか利用できていないかとも考えています。

複数の GPU を利用する場合は、複数の GPU を利用するためのコードを書く必要があります。
DNN の分散学習の方法としてはモデルパラレルとデータパラレルがあります。
とくにそのようなコードを書いてない場合は GPU が複数認識されていたとしても、GPU1枚での学習になります。

分散学習のあれこれ～データパラレルからモデルパラレルまで～

TensorFlow ではやったことがないですが、データパラレルならかんたんにやるような仕組みが用意されているのではないでしょうか

Comments

[yamayamak]

ありがとうございます。
複数GPUを利用するようにプログラム修正が必要なのがわかったので調査してみます。