测试使用的是一个liner model，还有更多的问题。pytorch 模型保存只保存可训练参数吗？

save模型

# 导入包import globimport osimport torchimport matplotlib.pyplot as pltimport random#用于数据迭代器生成随机数据# 生成数据集 x1类别0，x2类别1
n_data= torch.ones(50,2)# 数据的基本形态
x1= torch.normal(2 * n_data,1)# shape=(50, 2)
y1= torch.zeros(50)# 类型0 shape=(50, 1)
x2= torch.normal(-2 * n_data,1)# shape=(50, 2)
y2= torch.ones(50)# 类型1 shape=(50, 1)# 注意 x, y 数据的数据形式一定要像下面一样(torch.cat是合并数据)
x= torch.cat((x1, x2),0).type(torch.FloatTensor)
y= torch.cat((y1, y2),0).type(torch.FloatTensor)

# 数据集可视化
plt.scatter(x.data.numpy()[:,0], x.data.numpy()[:,1], c=y.data.numpy(), s=100, lw=0, cmap='RdYlGn')
plt.show()

# 数据读取：
def data_iter(batch_size, x, y):
    num_examples= len(x)
    indices= list(range(num_examples))
    random.shuffle(indices)# 样本的读取顺序是随机的foriin range(0, num_examples, batch_size):
        j= torch.LongTensor(indices[i: min(i + batch_size, num_examples)])#最后一次可能不足一个batch
        yield  x.index_select(0, j), y.index_select(0, j)#############################################################################################################
def saver(model_state_dict, optimizer_state_dict, model_path, epoch,max_to_save=30):
    total_models= glob.glob(model_path +'*')if len(total_models)>= max_to_save:
        total_models.sort()
        os.remove(total_models[0])

    state_dict={}
    state_dict["model_state_dict"]= model_state_dict
    state_dict["optimizer_state_dict"]= optimizer_state_dict

    torch.save(state_dict, model_path +'h' + str(epoch))
    print('models {} save successfully!'.format(model_path +'hahaha' + str(epoch)))################################################################################################################import torch.nn as nnimport torch.optim as optim



class net(nn.Module):
    def __init__(self, **kwargs):
        super(net, self).__init__(**kwargs)
        self.net= nn.Sequential(nn.Linear(2,1), nn.ReLU())

    def forward(self, x):return self.net(x)

def loss(y_hat, y):return(y_hat - y.view(y_hat.size())) **2 /2



def accuracy(y_hat, y):#@save"""计算预测正确的数量。"""cmp= y_hat.type(y.dtype)>0.5# 大于0.5类别1result=cmp.type(y.dtype)
    acc=1-float(((result-y).sum())/ len(y))return acc;

lr=0.03
num_epochs=3# 迭代次数
batch_size=10# 批量大小
model= net()
params=  list(model.parameters())
optimizer= torch.optim.Adam(params, 1e-4)forepochin range(num_epochs):for X, y_trainin data_iter(batch_size, x, y):
        optimizer.zero_grad()
        l= loss(model(X), y_train).sum()# l是有关小批量X和y的损失
        l.backward(retain_graph=True)
        optimizer.step()
        print(l)
    saver(model.state_dict(), optimizer.state_dict(),"./", epoch +1,max_to_save=100)

load模型

# 导入包import globimport osimport torchimport matplotlib.pyplot as pltimport random#用于数据迭代器生成随机数据# 生成数据集 x1类别0，x2类别1
n_data= torch.ones(50,2)# 数据的基本形态
x1= torch.normal(2 * n_data,1)# shape=(50, 2)
y1= torch.zeros(50)# 类型0 shape=(50, 1)
x2= torch.normal(-2 * n_data,1)# shape=(50, 2)
y2= torch.ones(50)# 类型1 shape=(50, 1)# 注意 x, y 数据的数据形式一定要像下面一样(torch.cat是合并数据)
x= torch.cat((x1, x2),0).type(torch.FloatTensor)
y= torch.cat((y1, y2),0).type(torch.FloatTensor)

# 数据集可视化
plt.scatter(x.data.numpy()[:,0], x.data.numpy()[:,1], c=y.data.numpy(), s=100, lw=0, cmap='RdYlGn')
plt.show()

# 数据读取：
def data_iter(batch_size, x, y):
    num_examples= len(x)
    indices= list(range(num_examples))
    random.shuffle(indices)# 样本的读取顺序是随机的foriin range(0, num_examples, batch_size):
        j= torch.LongTensor(indices[i: min(i + batch_size, num_examples)])#最后一次可能不足一个batch
        yield  x.index_select(0, j), y.index_select(0, j)#############################################################################################################
def saver(model_state_dict, optimizer_state_dict, model_path, epoch,max_to_save=30):
    total_models= glob.glob(model_path +'*')if len(total_models)>= max_to_save:
        total_models.sort()
        os.remove(total_models[0])

    state_dict={}
    state_dict["model_state_dict"]= model_state_dict
    state_dict["optimizer_state_dict"]= optimizer_state_dict

    torch.save(state_dict, model_path +'h' + str(epoch))
    print('models {} save successfully!'.format(model_path +'hahaha' + str(epoch)))################################################################################################################import torch.nn as nnimport torch.optim as optim



class net(nn.Module):
    def __init__(self, **kwargs):
        super(net, self).__init__(**kwargs)
        self.net= nn.Sequential(nn.Linear(2,1), nn.ReLU())

    def forward(self, x):return self.net(x)

def loss(y_hat, y):return(y_hat - y.view(y_hat.size())) **2 /2



def accuracy(y_hat, y):#@save"""计算预测正确的数量。"""cmp= y_hat.type(y.dtype)>0.5# 大于0.5类别1result=cmp.type(y.dtype)
    acc=1-float(((result-y).sum())/ len(y))return acc;

lr=0.03
num_epochs=3# 迭代次数
batch_size=10# 批量大小
model= net()
params=  list(model.parameters())
optimizer= torch.optim.Adam(params, 1e-4)# for epoch in range(num_epochs):#     for X, y_train in data_iter(batch_size, x, y):#         optimizer.zero_grad()#         l = loss(model(X), y_train).sum()  # l是有关小批量X和y的损失#         l.backward(retain_graph=True)#         optimizer.step()#         print(l)#     saver(model.state_dict(), optimizer.state_dict(), "./", epoch + 1,  max_to_save=100)




def loader(model_path):
    state_dict= torch.load(model_path)
    model_state_dict= state_dict["model_state_dict"]
    optimizer_state_dict= state_dict["optimizer_state_dict"]return model_state_dict, optimizer_state_dict

model_state_dict, optimizer_state_dict= loader("h1")
model.load_state_dict(model_state_dict)
optimizer.load_state_dict(optimizer_state_dict)

print('pretrained models loaded!')

pytorch 模型保存只保存可训练参数吗？是

class net(nn.Module):
    def __init__(self, **kwargs):
        super(net, self).__init__(**kwargs)
        self.net= nn.Sequential(nn.Linear(2,1), nn.ReLU())
        self.notrain= torch.rand((64,64),dtype=torch.float)

    def forward(self, x):return self.net(x)

解决方案

• 直接更改.data

class net(nn.Module):
    def __init__(self, **kwargs):
        super(net, self).__init__(**kwargs)
        self.net= nn.Sequential(nn.Linear(2,1), nn.ReLU())# self.notrain = torch.rand((64, 64), dtype=torch.float)
        self.notrain= torch.nn.Parameter(torch.ones(64,64))

    def forward(self, x):return self.net(x)

forepochin range(num_epochs):for X, y_trainin data_iter(batch_size, x, y):
        optimizer.zero_grad()
        l= loss(model(X), y_train).sum()# l是有关小批量X和y的损失
        l.backward(retain_graph=True)
        optimizer.step()
        print(l)
        model.notrain.data= model.notrain.data+2
    saver(model.state_dict(), optimizer.state_dict(),"./", epoch +1,max_to_save=100)

TypeError: cannot assign ‘torch.cuda.FloatTensor’ as parameter ‘***’ (torch.nn.Parameter or None expected)

• self.weight = self.weight.detach()会报以上的错误，可以考虑使用

1. 在网络传播中detach(这种方法一般效率低)
2. 推荐注册为buffer，或者直接self.weight = torch.nn.Parameter(Tensor data, requires_grad = False)
3. model.*** = torch.nn.Parameter(torch.load("./SAVEPE.pt"))

参考与更多

PyTorch DataLoader的bug ：随机mask或者对数据的随机挑选产生的bug