Python 如何在使用Keras的深度学习中利用多处理和多线程？

我假设大多数框架像keras/tensorflow/。。。自动使用所有CPU核，但实际上似乎并非如此。在深度学习过程中，我只能找到很少的资源来引导我们使用CPU的全部容量。我找到了一本关于

来自多处理导入池的

导入psutil
导入光线

另一方面，基于此，对于在多个流程中使用keras模型，没有上述库的跟踪。有没有更优雅的方法来利用Keras的多处理，因为它在实现中非常流行

• 例如，在学习过程中，如何修改以下简单的RNN实现以实现至少50%的CPU容量

• 我是否应该使用第二个模型作为多任务处理，如我下面评论的LSTM？我的意思是，我们能通过使用更多的CPU容量同时运行多个模型吗

将numpy导入为np
作为pd进口熊猫
将matplotlib.pyplot作为plt导入
从keras.layers.normalization导入批处理normalization
从sklearn.preprocessing导入MinMaxScaler
从sklearn.metrics导入均方误差
从sklearn.metrics导入准确性\u分数
从sklearn.model\u选择导入列车\u测试\u拆分
从keras.layers导入稠密
从keras.layers导入退出
从keras.layers导入LSTM、SimpleRN
从keras.models导入顺序
从keras.optimizers导入Adam、RMSprop
df=pd.read\u csv（“D:\Train.csv”，标题=None）
索引=[i表示列表中的i（范围（1440）），如果i%3==2]
Y_列=df[指数]
df=df.值
#下一步通过回顾预测创造历史
def create_数据集（数据集、数据列、回望=1）：
dataX，dataY=[]，[]
打印（“Len:”，Len（数据集）-回顾-1）
对于范围内的i（len（数据集）-向后看-1）：
a=数据集[i:（i+回顾），：]
dataX.append（a）
追加（数据列车[i+回顾，：]））
返回np.array（dataX），np.array（dataY）
Y_列=np.数组（Y_列）
df=np.数组（df）
回头看=10
trainX，trainY=创建数据集（df，Y\u train，look\u back=look\u back）
#将数据拆分为训练和测试
trainX，testX，trainY，testY=训练测试分割（trainX，trainY，测试大小=0.2，随机播放=假）
#列车外形及试验数据
trainX，testX，trainY，testY=训练测试分割（trainX，trainY，测试大小=0.2，随机播放=假）
打印（“列车尺寸：{}”。格式（trainX.shape））
打印（“列车标签尺寸：{}”。格式（trany.shape））
打印（“测试大小：{}”。格式（testX.shape））
打印（“测试标签大小：{}”。格式（testY.shape））
#列车尺寸：（23、101440）
#列车标签尺寸：（23960）
#测试尺寸：（6、10、1440）
#测试标签尺寸：（6960）
模型n=顺序（）
模型添加（SimpleRNN（单位=1440，输入形状=（trainX.shape[1]，trainX.shape[2]））
型号添加（密度（960））
模型添加（BatchNormalization（））
型号添加（激活（'tanh'））
#编译模型
模型编译（loss='mean'u squared'u error'，优化器='adam'）
回调=[
提前停止（耐心=10，冗长=1），
还原稳定期（因子=0.1，耐心=3，最小值=0.00001，详细度=1）]
#符合模型
历史数据=模型拟合（trainX，trainY，epochs=50，批次大小=20，验证数据=（testX，testY），详细数据=1，回调=回调）
#预测
Y\u列=np.数组（列Y）
Y_test=np.array（testX）
Y\U RNN\U Train\U pred=模型预测（列车X）
Y\u RNN\u Test\u pred=模型预测（testX）
列车均方误差=均方误差（列车Y、Y、N列车pred）
test_MSE=均方误差（testY，Y_RNN_test_pred）
#创建简单的LSTM模型，并将其作为多任务的第二个模型
#模型_LSTM=顺序（）
#模型添加（LSTM（单位=1440，输入形状=（trainX.shape[1]，trainX.shape[2]））
#模型添加（密度（单位=960））
#model_LSTM.add（BatchNormalization（））
#模型添加（激活（'tanh'））
#模型编译（loss='mean'u squared'u error'，优化器='adam'）
#hist_LSTM=model_LSTM.fit（trainX，trainY，epochs=50，batch_size=20，validation_data=（testX，testY），verbose=1，callbacks=callbacks）
#Y\u列=np.数组（列Y）
#Y_test=np.array（testX）
#Y_LSTM_Train_pred=模型预测（trainX）
#Y_LSTM_Test_pred=模型预测（testX）
#列车均方误差=均方误差（列车Y、Y、LSTM、列车pred）
#test_MSE=均方误差（testY，Y_LSTM_test_pred）
#RNN+LSTM的绘图损失
f、 ax=plt.子批次（figsize=（20,15））
plt.子地块（1,2,1）
ax=plt.绘图（历史记录['loss']，标签='Train loss'）
ax=plt.绘图（历史记录['val\u loss'，标签='Test/Validation/Prediction loss'）
plt.xlabel（'Training steps（Epochs=50'））
plt.ylabel（'Sx-Sy和Sxy'的损失（MSE））
plt.标题（“列车和测试数据上的RNN损失”）
plt.legend（）
plt.子地块（1、2、2）
ax=plt.绘图（历史记录['loss']，标签='Train loss'）
ax=plt.绘图（历史记录['val_loss'，label='Test/Validation/Prediction loss'））
plt.xlabel（'Training steps（Epochs=50'））
plt.ylabel（'Sx-Sy和Sxy'的损失（MSE））
plt.title（“列车和测试数据上的LSTM丢失”）
plt.legend（）
plt.子批次调整（顶部=0.80，底部=0.38，左侧=0.12，右侧=0.90，hspace=0.37，wspace=0.28）
#plt.savefig（'All_loss_history_uu.png'））
plt.show（）

注意我不能访问CUDA只是在没有VGA的情况下访问功能强大的服务器。我的目标是利用多处理和多线程的最大CPU容量，而不是30%，这意味着只有一个核心，而我有四核！ 如有任何建议，将不胜感激。我上传了一个格式化的数据集

更新：我的硬件配置如下：

• CPU:AMD A8-7650K Radeon R7 10计算核心4C+6G 3.30 GHz
• 内存：16GB
• OS:Win7
• Python版本3.6.6
• Tensorflow版本1.8.0
• Keras版本2.2.4

---

培训一个型号并没有100%使用您的CPU，这是一件好事！现在我们有空间并行训练多个模型，加快您的整体训练时间

注意：如果是y

import time
import signal
import multiprocessing

def init_worker():
    ''' Add KeyboardInterrupt exception to mutliprocessing workers '''
    signal.signal(signal.SIGINT, signal.SIG_IGN)


def train_model(layer_size):
    '''
    This code is parallelised and runs on each process
    It trains a model with different layer sizes (hyperparameters)
    It saves the model and returns the score (error)
    '''
    import keras
    from keras.models import Sequential
    from keras.layers import Dense

    print(f'Training a model with layer size {layer_size}')

    # build your model here
    model_RNN = Sequential()
    model_RNN.add(Dense(layer_size))

    # fit the model (the bit that takes time!)
    model_RNN.fit(...)

    # lets demonstrate with a sleep timer
    time.sleep(5)

    # save trained model to a file
    model_RNN.save(...)

    # you can also return values eg. the eval score
    return model_RNN.evaluate(...)


num_workers = 4
hyperparams = [800, 960, 1100]

pool = multiprocessing.Pool(num_workers, init_worker)

scores = pool.map(train_model, hyperparams)

print(scores)

Training a model with layer size 800
Training a model with layer size 960
Training a model with layer size 1100
[{'size':960,'score':1.0}, {'size':800,'score':1.2}, {'size':1100,'score':0.7}]

import time
import signal
import numpy as np
import pandas as pd
import multiprocessing
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
from sklearn.metrics import accuracy_score


def init_worker():
    ''' Add KeyboardInterrupt exception to mutliprocessing workers '''
    signal.signal(signal.SIGINT, signal.SIG_IGN)


def train_model(model_type):
    '''
    This code is parallelised and runs on each process
    It trains a model with different layer sizes (hyperparameters)
    It saves the model and returns the score (error)
    '''
    from keras.layers import LSTM, SimpleRNN, Dense, Activation
    from keras.models import Sequential
    from keras.callbacks import EarlyStopping, ReduceLROnPlateau
    from keras.layers.normalization import BatchNormalization

    print(f'Training a model: {model_type}')

    callbacks = [
        EarlyStopping(patience=10, verbose=1),
        ReduceLROnPlateau(factor=0.1, patience=3, min_lr=0.00001, verbose=1),
    ]

    model = Sequential()

    if model_type == 'rnn':
        model.add(SimpleRNN(units=1440, input_shape=(trainX.shape[1], trainX.shape[2])))
    elif model_type == 'lstm':
        model.add(LSTM(units=1440, input_shape=(trainX.shape[1], trainX.shape[2])))

    model.add(Dense(480))
    model.add(BatchNormalization())
    model.add(Activation('tanh'))
    model.compile(loss='mean_squared_error', optimizer='adam')
    model.fit(
        trainX,
        trainY,
        epochs=50,
        batch_size=20,
        validation_data=(testX, testY),
        verbose=1,
        callbacks=callbacks,
    )

    # predict
    Y_Train_pred = model.predict(trainX)
    Y_Test_pred = model.predict(testX)

    train_MSE = mean_squared_error(trainY, Y_Train_pred)
    test_MSE = mean_squared_error(testY, Y_Test_pred)

    # you can also return values eg. the eval score
    return {'type': model_type, 'train_MSE': train_MSE, 'test_MSE': test_MSE}


# Your code
# ---------

df = pd.read_csv("D:\Train.csv", header=None)

index = [i for i in list(range(1440)) if i % 3 == 2]

Y_train = df[index]
df = df.values

# making history by using look-back to prediction next
def create_dataset(dataset, data_train, look_back=1):
    dataX, dataY = [], []
    print("Len:", len(dataset) - look_back - 1)
    for i in range(len(dataset) - look_back - 1):
        a = dataset[i : (i + look_back), :]
        dataX.append(a)
        dataY.append(data_train[i + look_back, :])
    return np.array(dataX), np.array(dataY)


Y_train = np.array(Y_train)
df = np.array(df)

look_back = 10
trainX, trainY = create_dataset(df, Y_train, look_back=look_back)

# Split data into train & test
trainX, testX, trainY, testY = train_test_split(
    trainX, trainY, test_size=0.2, shuffle=False
)

# My Code
# -------

num_workers = 2
model_types = ['rnn', 'lstm']

pool = multiprocessing.Pool(num_workers, init_worker)

scores = pool.map(train_model, model_types)

print(scores)

[{'type': 'rnn', 'train_MSE': 0.06648435491248038, 'test_MSE': 0.062323388902691866}, 
 {'type': 'lstm', 'train_MSE': 0.10114341514420684, 'test_MSE': 0.09998065769499974}]