如何在单个GPU上运行多个keras程序？

Question

我正在一个python项目中，我需要为每个数据集构建多个Keras模型。在这里，当我运行Keras模型时，程序正在使用10％的GPU（GTX 1050ti）。

我的问题是我可以100％使用我的GPU来减少时间吗？还是可以在同一GPU上运行多个程序？

我试图在单个GPU上运行多个程序，但它不是并行运行，例如，当我运行单个python程序时，每个时期要花5秒，而如果我每个时期运行2个程序，则持续时间会增加到10秒，是运行多个程序的最佳方法是什么。

提前致谢！！

Answer 1

不确定是否有适当的方法来执行此操作，但是看来，这种“ gambiarra”可能效果很好。

制作一个将两个或多个模型并行连接在一起的模型。唯一的缺点是：并行训练和预测它们时，需要相同数量的输入样本。

如何与功能性API模型并行使用两个模型：

input1 = Input(inputShapeOfModel1)
input2 = Input(inputShapeOfModel2)

output1 = model1(input1)
output2 = model2(input2) #it could be model1 again, using model1 twice in parallel. 

parallelModel = Model([input1,input2], [output1,output2])

您可以使用此模型进行训练和预测，并传递并行输入和输出数据：

parallelModel.fit([x_train1, x_train2], [y_train1, y_train2], ...)

工作测试代码：

from keras.layers import *
from keras.models import Model, Sequential
import numpy as np

#simulating two "existing" models
model1 = Sequential()
model2 = Sequential()

#creating "existing" model 1
model1.add(Conv2D(10,3,activation='tanh', input_shape=(20,20,3)))
model1.add(Flatten())
model1.add(Dense(1,activation='sigmoid'))

#creating "existing" model 2
model2.add(Dense(20, input_shape=(2,)))
model2.add(Dense(3))


#part containing the proposed answer: joining the two models in parallel
inp1 = Input((20,20,3))
inp2 = Input((2,))

out1 = model1(inp1)
out2 = model2(inp2)

model = Model([inp1,inp2],[out1,out2])


#treat the new model as any other model
model.compile(optimizer='adam', loss='mse')

#dummy input data x and y, for models 1 and 2
x1 = np.ones((30,20,20,3))
y1 = np.ones((30,1))
x2 = np.ones((30,2))
y2 = np.ones((30,3))

#training the model and predicting
model.fit([x1,x2],[y1,y2], epochs = 50)
ypred1,ypred2 = model.predict([x1,x2])

print(ypred1.shape)
print(ypred2.shape)

先进的解决方案-分组数据以提高速度并匹配样品量

由于此方法将在两个模型之间同步批处理，​​因此仍有更多空间可以进行优化。因此，如果一个模型比另一个模型快得多，则快速模型将调整为慢速模型的速度。

另外，如果批次数量不同，则需要单独训练/预测一些剩余数据。

如果您将输入数据分组并在带有Lambda层的模型中使用一些自定义重塑，则可以在这些限制中解决这些问题，在Lambda层中，您可以在开始时重塑批次尺寸，然后在结束时进行重塑。

例如，如果x1有300个样本并且x2有600个样本，则可以调整输入和输出的形状：

x2 = x2.reshape((300,2,....))
y2 = y2.reshape((300,2,....))

在之前和之后model2，您可以使用：

#before
Lambda(lambda x: K.reshape(x,(-1,....))) #transforms in the inner's model input shape

#after
Lambda(lambda x: K.reshape(x, (-1,2,....))) #transforms in the grouped shape for output

....原始输入和输出形状在哪里（不考虑batch_size）。

然后，您需要考虑最好的方法是：分组数据同步数据大小，或分组数据同步速度。

（与下一个解决方案相比，优点是：您可以轻松地按任意数字分组，例如2、5、10、200 .....）

先进的解决方案-多次使用同一模型，以双倍速度

您也可以并行使用同一模型两次，例如在此代码中。这可能会使其速度提高一倍。

from keras.layers import *
from keras.models import Model, Sequential
#import keras.backend as K
import numpy as np
#import tensorflow as tf


#simulating two "existing" models
model1 = Sequential()
model2 = Sequential()

#model 1
model1.add(Conv2D(10,3,activation='tanh', input_shape=(20,20,3)))
model1.add(Flatten())
model1.add(Dense(1,activation='sigmoid'))

#model 2
model2.add(Dense(20, input_shape=(2,)))
model2.add(Dense(3))

#joining the models
inp1 = Input((20,20,3))

#two inputs for model 2 (the model we want to run twice as fast)
inp2 = Input((2,))
inp3 = Input((2,))

out1 = model1(inp1)
out2 = model2(inp2) #use model 2 once
out3 = model2(inp3) #use model 2 twice

model = Model([inp1,inp2,inp3],[out1,out2,out3])

model.compile(optimizer='adam', loss='mse')

#dummy data - remember to have two inputs for model 2, not repeated
x1 = np.ones((30,20,20,3))
y1 = np.ones((30,1))
x2 = np.ones((30,2)) #first input for model 2
y2 = np.ones((30,3)) #first output for model 2
x3 = np.zeros((30,2)) #second input for model 2
y3 = np.zeros((30,3)) #second output for model 2

model.fit([x1,x2,x3],[y1,y2,y3], epochs = 50)
ypred1,ypred2,ypred3 = model.predict([x1,x2,x3])

print(ypred1.shape)
print(ypred2.shape)
print(ypred3.shape)

与以前的解决方案相比，优点是：操作数据和自定义整形的麻烦更少。