_pickle.PicklingError: Can‘t pickle ＜class ‘__main__.MLPmodel‘＞: attribute lookup MLPmodel on __main
报错信息：_pickle.PicklingError: Can't pickle
解决方法：
报错信息的意思是在main里面找不到MLPmodel（文末附源代码）
因为我是在同一个文件A里定义的网络结构(class MLPmodel)，在后面的if __name__ == "__main__"里面使用，故出现上述报错。
※ 将class MLPmodel部分代码剪切粘贴到一个单独的文件B中，在A中import即可解决问题。
下面放出代码：原代码及更改后的代码
原代码：create_net.py
更改后的代码：MLPmodel.py、MLPmodel2.py、create_net_test.py
create_net.py
'''搭建网络：用Module和Sequential两种不同的网络定义方式'''
import torch
import torch.nn as nn # nn模块方便用户对网络中的层的使用
from torch.optim import SGD
import torch.utils.data as Data # Data模块用于对使用数据的预处理
from sklearn.datasets import load_boston # 用于导入数据
from sklearn.preprocessing import StandardScaler # 对数据进行标准化
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
# 使用继承Module的方式定义一个包含层的全连接神经网络
class MLPmodel(nn.Module):
def __init__(self):
super(MLPmodel, self).__init__()
# 定义第一个隐藏层
self.hidden1 = nn.Linear(
in_features=13, # 第一个隐藏层的输入，数据的特征数
out_features=10, # 第一个隐藏层的输出，神经元的数量
bias=True, # 默认会有偏置
)
self.active1 = nn.ReLU()
# 定义第二个隐层
self.hidden2 = nn.Linear(10, 10)
self.active2 = nn.ReLU()
# 定义预测回归层
self.regression = nn.Linear(10, 1)
# 定义网络的前向传播路径
def forward(self, x):
x = self.hidden1(x)
x = self.active1(x)
x = self.hidden2(x)
x = self.active2(x)
output = self.regression(x)
# 输出为output
return output
# 使用定义网络时使用nn.Sequential的形式
class MLPmodel2(nn.Module):
def __init__(self):
super(MLPmodel2, self).__init__()
# 定义隐藏层
# nn.Sequential()可以简化定义网络的结构和前向传播函数
self.hidden = nn.Sequential(
nn.Linear(13, 10),
nn.ReLU(),
nn.Linear(10, 10),
nn.ReLU(),
)
# 预测回归层
self.regression = nn.Linear(10, 1)
# 定义网络的前向传播路径
def forward(self, x):
x = self.hidden(x)
output2 = self.regression(x)
return output2
def init_weights(m):
'''
对不同类型层的参数使用不同的方法进行初始化
:param m: 网络的某一层
:return:
'''
# 如果是卷积层
if type(m) == nn.Conv2d:
torch.nn.init.normal_(m.weight, mean=0, std=0.5)
# UserWarning: nn.init.normal is now deprecated in favor of nn.init.normal_.
# 如果是全连接层
if type(m) == nn.Linear:
torch.nn.init.uniform_(m.weight, a=-0.1, b=0.1)
m.bias.data.fill_(0.01)
if __name__ == '__main__':
# 读取数据
boston_X, boston_y = load_boston(return_X_y=True)
print("boston_X.shape:", boston_X.shape)
plt.figure()
plt.hist(boston_y, bins=20)
plt.show()
# 数据标准化处理
ss = StandardScaler(with_mean=True, with_std=True)
boston_Xs = ss.fit_transform(boston_X)
# 将数据预处理为可以使用pytorch进行批量训练的形式
# 训练集X转化为张量
train_xt = torch.from_numpy(boston_Xs.astype(np.float32))
# 训练集y转化为张量
train_yt = torch.from_numpy(boston_y.astype(np.float32))
# 将训练集转化为张量后，使用TensorDataset将X和y整理到一起
train_data = Data.TensorDataset(train_xt, train_yt)
# 定义一个数据加载器，将训练数据集进行批量处理
train_loader = Data.DataLoader(
dataset=train_data, # 使用的数据集
batch_size=128, # 批处理样本大小
shuffle=True, # 每次迭代前打乱数据
num_workers=1, # 使用两个进程
)
###################### 网络定义与训练方式1 ##################################
# 输出网络结构
mlp1 = MLPmodel()
print(mlp1)
# # 使用网络的apply方法进行权重初始化
# torch.manual_seed(13)
# mlp1.apply(init_weights)
# 对回归模型mlp1进行训练并输出损失函数的变化情况，定义优化器和损失函数
optimizer = SGD(mlp1.parameters(), lr=0.001) # 使用SGD优化方法对网络进行优化，需要优化的参数可以使用mlp1.parameters()获得
loss_function = nn.MSELoss() # 使用MSELoss()函数作为损失函数：最小均方根误差
train_loss_all = [] # 保存每个批次训练的损失函数值，用来可视化
# 进行训练，并保存每次迭代的损失函数值
for epoch in range(30): # 定义了对整个数据集训练的次数
# 对训练数据的加载器进行迭代计算
for step, (b_x, b_y) in enumerate(train_loader): # 利用train_loader中的每一个batch对模型参数进行优化
output = mlp1(b_x).flatten() # MLP在训练本轮batch上的输出，返回值为一个一维数组
train_loss = loss_function(output, b_y)
#
optimizer.zero_grad() # 每个迭代步的梯度初始化为0
train_loss.backward() # 损失的后向传播，计算梯度
optimizer.step() # 使用梯度进行优化
#
train_loss_all.append(train_loss.item())
# train_loss_all里面包括120个点，因为506个样本，128/batch，共4batch；
# 4batch * 30epoch = 120
plt.figure()
plt.plot(train_loss_all, "r-")
plt.title("Train loss per iteration")
plt.show()
###################### 网络定义与训练方式2 ##################################
# 输出网络结构
mlp2 = MLPmodel2()
print(mlp2)
# 使用与mlp1同样的优化方式对mlp2进行训练并输出损失函数的变化情况
###################### PyTorch模型保存和加载方法 ##################################
# 方法一：保存整个模型
# torch.save(mlp1, "model_saved/mlp1.pkl")
# print('1')
# mlp1load = torch.load("model_saved/mlp1.pkl") # 导入保存的模型
# print('2')
# print(mlp1load)
# print(mlp1load.hidden2.weight)
# 方法二：只保存模型的参数
torch.save(mlp1.state_dict(), "model_saved/mlp1_param.pkl")
print('3')
mlp1load_param = torch.load("model_saved/mlp1_param.pkl") # 导入保存的模型的参数
print('4')
print(mlp1load_param)
MLPmodel.py
import torch.nn as nn
# 使用继承Module的方式定义一个包含层的全连接神经网络
class MLPmodel(nn.Module):
def __init__(self):
super(MLPmodel, self).__init__()
# 定义第一个隐藏层
self.hidden1 = nn.Linear(
in_features=13, # 第一个隐藏层的输入，数据的特征数
out_features=10, # 第一个隐藏层的输出，神经元的数量
bias=True, # 默认会有偏置
)
self.active1 = nn.ReLU()
# 定义第二个隐层
self.hidden2 = nn.Linear(10, 10)
self.active2 = nn.ReLU()
# 定义预测回归层
self.regression = nn.Linear(10, 1)
# 定义网络的前向传播路径
def forward(self, x):
x = self.hidden1(x)
x = self.active1(x)
x = self.hidden2(x)
x = self.active2(x)
output = self.regression(x)
# 输出为output
return output
MLPmodel2.py
import torch.nn as nn
# 使用定义网络时使用nn.Sequential的形式
class MLPmodel2(nn.Module):
def __init__(self):
super(MLPmodel2, self).__init__()
# 定义隐藏层
# nn.Sequential()可以简化定义网络的结构和前向传播函数
self.hidden = nn.Sequential(
nn.Linear(13, 10),
nn.ReLU(),
nn.Linear(10, 10),
nn.ReLU(),
)
# 预测回归层
self.regression = nn.Linear(10, 1)
# 定义网络的前向传播路径
def forward(self, x):
x = self.hidden(x)
output2 = self.regression(x)
return output2
create_net_test.py
'''搭建网络：用Module和Sequential两种不同的网络定义方式'''
import torch
import torch.nn as nn # nn模块方便用户对网络中的层的使用
from torch.optim import SGD
import torch.utils.data as Data # Data模块用于对使用数据的预处理
from sklearn.datasets import load_boston # 用于导入数据
from sklearn.preprocessing import StandardScaler # 对数据进行标准化
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from MLPmodel import MLPmodel
from MLPmodel2 import MLPmodel2
def init_weights(m):
'''
对不同类型层的参数使用不同的方法进行初始化
:param m: 网络的某一层
:return:
'''
# 如果是卷积层
if type(m) == nn.Conv2d:
torch.nn.init.normal_(m.weight, mean=0, std=0.5)
# UserWarning: nn.init.normal is now deprecated in favor of nn.init.normal_.
# 如果是全连接层
if type(m) == nn.Linear:
torch.nn.init.uniform_(m.weight, a=-0.1, b=0.1)
m.bias.data.fill_(0.01)
if __name__ == '__main__':
# 读取数据
boston_X, boston_y = load_boston(return_X_y=True)
print("boston_X.shape:", boston_X.shape)
plt.figure()
plt.hist(boston_y, bins=20)
plt.show()
# 数据标准化处理
ss = StandardScaler(with_mean=True, with_std=True)
boston_Xs = ss.fit_transform(boston_X)
# 将数据预处理为可以使用pytorch进行批量训练的形式
# 训练集X转化为张量
train_xt = torch.from_numpy(boston_Xs.astype(np.float32))
# 训练集y转化为张量
train_yt = torch.from_numpy(boston_y.astype(np.float32))
# 将训练集转化为张量后，使用TensorDataset将X和y整理到一起
train_data = Data.TensorDataset(train_xt, train_yt)
# 定义一个数据加载器，将训练数据集进行批量处理
train_loader = Data.DataLoader(
dataset=train_data, # 使用的数据集
batch_size=128, # 批处理样本大小
shuffle=True, # 每次迭代前打乱数据
num_workers=1, # 使用两个进程
)
###################### 网络定义与训练方式1 ##################################
# 输出网络结构
mlp1 = MLPmodel()
print(mlp1)
# # 使用网络的apply方法进行权重初始化
# torch.manual_seed(13)
# mlp1.apply(init_weights)
# 对回归模型mlp1进行训练并输出损失函数的变化情况，定义优化器和损失函数
optimizer = SGD(mlp1.parameters(), lr=0.001) # 使用SGD优化方法对网络进行优化，需要优化的参数可以使用mlp1.parameters()获得
loss_function = nn.MSELoss() # 使用MSELoss()函数作为损失函数：最小均方根误差
train_loss_all = [] # 保存每个批次训练的损失函数值，用来可视化
# 进行训练，并保存每次迭代的损失函数值
for epoch in range(30): # 定义了对整个数据集训练的次数
# 对训练数据的加载器进行迭代计算
for step, (b_x, b_y) in enumerate(train_loader): # 利用train_loader中的每一个batch对模型参数进行优化
output = mlp1(b_x).flatten() # MLP在训练本轮batch上的输出，返回值为一个一维数组
train_loss = loss_function(output, b_y)
#
optimizer.zero_grad() # 每个迭代步的梯度初始化为0
train_loss.backward() # 损失的后向传播，计算梯度
optimizer.step() # 使用梯度进行优化
#
train_loss_all.append(train_loss.item())
# train_loss_all里面包括120个点，因为506个样本，128/batch，共4batch；
# 4batch * 30epoch = 120
plt.figure()
plt.plot(train_loss_all, "r-")
plt.title("Train loss per iteration")
plt.show()
###################### 网络定义与训练方式2 ##################################
# 输出网络结构
mlp2 = MLPmodel2()
print(mlp2)
# 使用与mlp1同样的优化方式对mlp2进行训练并输出损失函数的变化情况
###################### PyTorch模型保存和加载方法 ##################################
# 方法一：保存整个模型
torch.save(mlp1, "model_saved/mlp1.pkl")
print('1')
mlp1load = torch.load("model_saved/mlp1.pkl") # 导入保存的模型
print('2')
print(mlp1load)
print(mlp1load.hidden2.weight)
# 方法二：只保存模型的参数
torch.save(mlp1.state_dict(), "model_saved/mlp1_param.pkl")
print('3')
mlp1load_param = torch.load("model_saved/mlp1_param.pkl") # 导入保存的模型的参数
print('4')
print(mlp1load_param)