导包

import torch.multiprocessing as mp
import torch
import torch.nn as nn
import torch.utils.data as Data

这里使用torch.multiprocessing构造多进程，与python的多进程神似

准备训练数据（同单进程）

这里使用随机数生成训练数据，就不用下载什么数据了

def get_train_data():"""得到训练数据，这里使用随机数生成训练数据，由此导致最终结果并不好"""def get_tensor_from_pd(dataframe_series) -> torch.Tensor:return torch.tensor(data=dataframe_series.values)import numpy as npimport pandas as pdfrom sklearn import preprocessing# 生成训练数据x并做归一化后，构造成dataframe格式，再转换为tensor格式df = pd.DataFrame(data=preprocessing.MinMaxScaler().fit_transform(np.random.randint(0, 10, size=(2000, 300))))y = pd.Series(list(range(2000)))return get_tensor_from_pd(df).float(), get_tensor_from_pd(y).float()

构造模型（同单进程）

这里使用一个LSTM的AutoEncoder，可以换成任何你想要训练的模型哈~，多进程与模型是什么无关

class LstmFcAutoEncoder(nn.Module):def __init__(self, input_layer=300, hidden_layer=100, batch_size=20):super(LstmFcAutoEncoder, self).__init__()self.input_layer = input_layerself.hidden_layer = hidden_layerself.batch_size = batch_sizeself.encoder_lstm = nn.LSTM(self.input_layer, self.hidden_layer, batch_first=True)self.encoder_fc = nn.Linear(self.hidden_layer, self.hidden_layer)self.decoder_lstm = nn.LSTM(self.hidden_layer, self.input_layer, batch_first=True)self.decoder_fc = nn.Linear(self.hidden_layer, self.hidden_layer)self.relu = nn.ReLU()def forward(self, input_x):input_x = input_x.view(len(input_x), 1, -1)# encoderencoder_lstm, (n, c) = self.encoder_lstm(input_x,# shape: (n_layers, batch, hidden_size)(torch.zeros(1, self.batch_size, self.hidden_layer),torch.zeros(1, self.batch_size, self.hidden_layer)))encoder_fc = self.encoder_fc(encoder_lstm)encoder_out = self.relu(encoder_fc)# decoderdecoder_fc = self.relu(self.decoder_fc(encoder_out))decoder_lstm, (n, c) = self.decoder_lstm(decoder_fc,(torch.zeros(1, 20, self.input_layer),torch.zeros(1, 20, self.input_layer)))return decoder_lstm.squeeze()

构造训练代码（同单进程）

由于多个进程之间是隔离的，因此除了模型参数会共享，其余都不共享：损失函数、优化器、迭代次数不共享

def train(model, data_loader, loss_function, optimizer, epochs):for i in range(epochs):for seq, labels in data_loader:optimizer.zero_grad()y_pred = model(seq).squeeze()  # 压缩维度：得到输出，并将维度为1的去除single_loss = loss_function(y_pred, seq)single_loss.backward()optimizer.step()

开始训练（这里设置多进程！）

if __name__ == '__main__':model = LstmFcAutoEncoder()x, y = get_train_data()

这里将data构造为DataLoader，当然不构造也可以

    train_loader = Data.DataLoader(dataset=Data.TensorDataset(x, y),  # 封装进Data.TensorDataset()类的数据，可以为任意维度batch_size=20,  # 每块的大小shuffle=True,  # 要不要打乱数据 (打乱比较好)num_workers=3,  # 多进程（multiprocess）来读数据)

    # 常规训练三件套loss_function = nn.MSELoss()  # lossoptimizer = torch.optim.Adam(model.parameters(), lr=0.001)  # 优化器epochs = 150

开始多进程的设置：

    # 多进程开始num_processes = 4  # 设置4个进程# NOTE: this is required for the ``fork`` method to workmodel.share_memory()processes = []for rank in range(num_processes):# 4 个进程，每个进程epoch为150，也就是说其实迭代了 4*150 = 600 次 !!!p = mp.Process(target=train, args=(model, train_loader, loss_function, optimizer, epochs))p.start()processes.append(p)for p in processes:p.join()

如果需要尽情压榨cpu的效率，可以修改为：

    from multiprocessing import cpu_countnum_processes = cpu_count()

验证多进程下参数的有效性

打开控制台看cpu是否多进程（当然是啦）
验证参数：在调试时打断点（建议打到61行：optimizer.step()），用一个进程迭代几轮，然后看其他每个进程的模型的参数：
```
print(model.encoder_fc.state_dict()) # 看model的encoder_fc层的参数
```

完整的代码

import torch.multiprocessing as mpimport torch
import torch.nn as nn
import torch.utils.data as Datadef get_train_data():"""得到训练数据，这里使用随机数生成训练数据，由此导致最终结果并不好"""def get_tensor_from_pd(dataframe_series) -> torch.Tensor:return torch.tensor(data=dataframe_series.values)import numpy as npimport pandas as pdfrom sklearn import preprocessing# 生成训练数据x并做归一化后，构造成dataframe格式，再转换为tensor格式df = pd.DataFrame(data=preprocessing.MinMaxScaler().fit_transform(np.random.randint(0, 10, size=(2000, 300))))y = pd.Series(list(range(2000)))return get_tensor_from_pd(df).float(), get_tensor_from_pd(y).float()class LstmFcAutoEncoder(nn.Module):def __init__(self, input_layer=300, hidden_layer=100, batch_size=20):super(LstmFcAutoEncoder, self).__init__()self.input_layer = input_layerself.hidden_layer = hidden_layerself.batch_size = batch_sizeself.encoder_lstm = nn.LSTM(self.input_layer, self.hidden_layer, batch_first=True)self.encoder_fc = nn.Linear(self.hidden_layer, self.hidden_layer)self.decoder_lstm = nn.LSTM(self.hidden_layer, self.input_layer, batch_first=True)self.decoder_fc = nn.Linear(self.hidden_layer, self.hidden_layer)self.relu = nn.ReLU()def forward(self, input_x):input_x = input_x.view(len(input_x), 1, -1)# encoderencoder_lstm, (n, c) = self.encoder_lstm(input_x,# shape: (n_layers, batch, hidden_size)(torch.zeros(1, self.batch_size, self.hidden_layer),torch.zeros(1, self.batch_size, self.hidden_layer)))encoder_fc = self.encoder_fc(encoder_lstm)encoder_out = self.relu(encoder_fc)# decoderdecoder_fc = self.relu(self.decoder_fc(encoder_out))decoder_lstm, (n, c) = self.decoder_lstm(decoder_fc,(torch.zeros(1, 20, self.input_layer),torch.zeros(1, 20, self.input_layer)))return decoder_lstm.squeeze()def train(model, data_loader, loss_function, optimizer, epochs):for i in range(epochs):for seq, labels in data_loader:optimizer.zero_grad()y_pred = model(seq).squeeze()  # 压缩维度：得到输出，并将维度为1的去除single_loss = loss_function(y_pred, seq)single_loss.backward()optimizer.step()if __name__ == '__main__':model = LstmFcAutoEncoder()x, y = get_train_data()train_loader = Data.DataLoader(dataset=Data.TensorDataset(x, y),  # 封装进Data.TensorDataset()类的数据，可以为任意维度batch_size=20,  # 每块的大小shuffle=True,  # 要不要打乱数据 (打乱比较好)num_workers=3,  # 多进程（multiprocess）来读数据)# 常规训练三件套loss_function = nn.MSELoss()  # lossoptimizer = torch.optim.Adam(model.parameters(), lr=0.001)  # 优化器epochs = 150# 多进程开始# from multiprocessing import cpu_count## num_processes = cpu_count()num_processes = 4  # 4个进程# NOTE: this is required for the ``fork`` method to workmodel.share_memory()processes = []for rank in range(num_processes):# 4 个进程，每个进程epoch为150，也就是说其实迭代了 4*150 = 600 次 !!!p = mp.Process(target=train, args=(model, train_loader, loss_function, optimizer, epochs))p.start()processes.append(p)for p in processes:p.join()

pytorch 使用 CPU 多进程多核训练模型相关推荐

多CPU，多核，多进程，多线程以及进程和线程的简单理解以及区别
当面临这些问题的时候,有两个关键词无法绕开,那就是并行和并发. 首先,要先了解几个概念: 1.进程是程序的一次执行. 2.进程是资源分配的基本单位. 3.一个进程可以包括多个线程. 4.在单CPU计算 ...
多CPU 多核CPU | 多进程多线程 | 并行并发
文章目录区分多CPU && 多核CPU CPU缓存并行 && 并发多CPU && 多核CPU | 多进程 && 多线程 | 并行 ...
CPU，多核，多线程，并发，并行，计算效率
计算机原理:CPU.并发.并行.多核.多线程.多进程 0.计算机工作流程 0.0 基础概念:计算机组成 0.1 CPU(Central Processing Unit) (1)控制单元 (2)运算单元 ...
关于 CPU 的多核和超线程技术
1. 关于 CPU 的多核和超线程技术 CPU 的物理个数由主板上的插槽数量决定,每个 CPU 可以有多核心,每核心可能会有多线程. 多核 CPU 的每核(每核都是一个小芯片),在 OS 看来都是一个 ...
CPU单核多核区别【转载】
CPU个数.CPU核心数.CPU线程数我们在选购电脑的时候,CPU是一个需要考虑到核心因素,因为它决定了电脑的性能等级.CPU从早期的单核,发展到现在的双核,多核.CPU除了核心数之外,还有线程数之 ...
多线程与单核cpu，多核cpu概念
1.多线程在单核和多核CPU上的执行效率问题的讨论 a1: 多线程在单cpu中其实也是顺序执行的,不过系统可以帮你切换那个执行而已,其实并没有快(反而慢) 多个cpu的话就可以在两个cpu中同时执 ...
对多线程程序，单核cpu与多核cpu如何工作相关的探讨
对多线程程序,单核cpu与多核cpu如何工作相关的探讨我们程序员在编码的时候,涉及到技术方案时,往往会忽略掉代码对性能方面的影响,或者没有足够的敏感度来帮助自己判断自己的技术方案对系统性能造成的影响 ...
对于多线程程序，单核cpu与多核cpu是怎么工作的
此文中的大部分资料来自于网络上,我只是觉得把有道理的整理一下,方便以后查阅. 1.多线程在单核和多核CPU上的执行效率问题的讨论 a1: 多线程在单cpu中其实也是顺序执行的,不过系统可以帮你切换那个 ...
单核CPU与多核CPU工作原理
单核CPU与多核CPU工作原理今天要介绍一下单核CPU和单核(超时间轴)CPU以及多核CPU的工作原理一.单核CPU 起源: CPU的起源是1971年英特尔公司推出,由此正式宣告计算机的诞生,可以 ...

pytorch 使用 CPU 多进程多核训练模型

文章目录

导包