直接使用
會出現當更新model2時，model1的權重也會更新，這和自己的初始目的不同。
經評論指出可以使用：
model2=copy.deepcopy(model1)
來實現深拷貝，手上沒有pytorch環境，具體還沒測試過，誰測試過可以和我說下有沒有用。
原方法：
所有要使用模型復制可以使用如下方法。
torch.save(model, "net_params.pkl")
model5=Cnn(3,10)
model5=torch.load('net_params.pkl')
這樣編寫不會影響原始模型的權重
補充：pytorch模型訓練流程中遇到的一些坑(持續更新)
要訓練一個模型，主要分成幾個部分，如下。
數據預處理
入門的話肯定是拿 MNIST 手寫數據集先練習。
pytorch 中有幫助我們制作數據生成器的模塊，其中有 Dataset、TensorDataset、DataLoader 等類可以來創建數據入口。
之前在 tensorflow 中可以用 dataset.from_generator() 的形式，pytorch 中也類似，目前我了解到的有兩種方法可以實現。
第一種就繼承 pytorch 定義的 dataset，改寫其中的方法即可。如下，就獲得了一個 DataLoader 生成器。
class MyDataset(Dataset):
def __init__(self, data, labels):
self.data = data
self.labels = labels
def __getitem__(self, index):
return self.data[index], self.labels[index]
def __len__(self):
return len(self.labels)
train_dataset = MyDataset(train_data, train_label)
train_loader = DataLoader(dataset = train_dataset,
batch_size = 1,
shuffle = True)
第二種就是轉換，先把我們準備好的數據轉化成 pytorch 的變量(或者是 Tensor)，然后傳入 TensorDataset，再構造 DataLoader。
X = torch.from_numpy(train_data).float()
Y = torch.from_numpy(train_label).float()
train_dataset = TensorDataset(X, Y)
train_loader = DataLoader(dataset = train_dataset,
batch_size = 1,
shuffle = True)
#num_workers = 2)
模型定義
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 6, 3)
self.conv2 = nn.Conv2d(6 ,16, 3)
self.fc1 = nn.Linear(400, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
def forward(self, x):
relu = F.relu(self.conv1(x))
x = F.max_pool2d(relu, (2, 2))
x = F.max_pool2d(F.relu(self.conv2(x)), 2)
x = x.view(-1, self.num_flat_features(x))
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
def num_flat_features(self, x):
size = x.size()[1:] #除了batch_size之外的維度
num_features = 1
for s in size:
num_features *= s
return num_features
訓練模型那么肯定要先定義一個網絡結構，如上定義一個前向傳播網絡。里面包含了卷積層、全連接層、最大池化層和 relu 非線性激活層(名字我自己取的)以及一個 view 展開，把一個多維的特征圖平展成一維的。
其中nn.Conv2d(in_channels, out_channels, kernel_size)，第一個參數是輸入的深度，第二是輸出的深度，第三是卷積核的尺寸。
F.max_pool2d(input, (pool_size, pool_size))，第二個參數是池話
nn.Linear(in_features, out_features)
x.view是平展的操作，不過實際上相當于 numpy 的 reshape，需要計算轉換后的尺寸。
損失函數定義
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
模型定義完之后，意味著給出輸入，就可以得到輸出的結果。那么就來比較 outputs 和 targets 之間的區別，那么就需要用到損失函數來描述。
訓練網絡
for epoch in range(2): # loop over the dataset multiple times
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
# get the inputs; data is a list of [inputs, labels]
inputs, labels = data
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item()
if i % 2000 == 1999: # print every 2000 mini-batches
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 2000))
running_loss = 0.0
print('Finished Training')
以上的代碼是官方教程中給出來的，我們要做的就是學習他的思路。
1.首先是 epoch 的數量為 2，每個 epoch 都會歷遍一次整個訓練集。在每個 epoch 內累積統計 running_loss，每 2000 個 batch 數據計算一次損失的平均值，然后 print 再重新將 running_loss 置為 0。
2.然后分 mini-batch 進行訓練，在每個計算每個 mini-batch 的損失之前，都會將優化器 optimizer 中的梯度清空，防止不同 mini-batch 的梯度被累加到一起。更新分成兩步：第一步計算損失函數，然后把總的損失分配到各個層中，即 loss.backward()，然后就使用優化器更新權重，即 optimizer.step()。
保存模型
PATH = '...'
torch.save(net.state_dict(), PATH)
爬坑總結
總的來說流程就是上面那幾步，但自己做的時候就遇到了挺多問題，最主要是對于其中張量傳播過程中的要求不清楚，導致出了不少錯誤。
首先是輸入的數據，pytorch 默認圖片的 batch 數據的結構是（BATCH_SIZE, CHANNELS, IMG_H, IMG_W），所以要在生成數據時做一些調整，滿足這種 BCHW 的規則。
會經常出現一些某個矩陣或者張量要求的數據，例如 “RuntimeError: Expected object of scalar type Double but got scalar type Float for argument #2 ‘mat2'” 等錯誤信息。
可以使用 x.double()，y.float()，z.long() 等方式轉換成他要求的格式。
RuntimeError: multi-target not supported。這個錯誤出現在損失函數那個地方，對于分類問題肯定是優先考慮交叉熵。
criterion = nn.CrossEntropyLoss()
loss = criterion(outputs, labels.long())#報錯的地方
當我batch-size=1時這個地方不會報錯，但是當batch-size>1時就會報錯。
查了別人的代碼，大家基本都是和官方教程里面寫的一樣，使用官方的 mnist 數據接口，代碼如下。一開始我是不愿意的，因為那樣子意味著可能數據格式被封裝起來看不見，但是自己折騰成本比較高，所以還是試了，真香！
train_dataset = datasets.MNIST(root='./data/',
train=True,
transform=transforms.ToTensor(),
download=True)
train_loader = DataLoader(dataset = train_dataset,
batch_size = 4,
shuffle = True)
打印了一下從生成器中獲得數據，看一下 size，發現果然和我自己寫的不同。當 batch_size=4 時，數據 data.size() 都是4*1*28*28，這個是相同的；但是 labels.size() 是不同的，我寫的是 one_hot 向量所以是 4*10，但它的是 4。
直接打印 labels 看看，果然，是單個指，例如 tensor([3, 2, 6, 2]) 這樣。
不過模型的 outputs 依然是 4*10，看來是 nn.CrossEntropyLoss() 這個函數自己會做計算，所以他才會報錯說 multi-target not supported，因為 lables.size() 不對，原本只有一個數字，但現在是10個數字，相當于被分配了10個屬性，自然就報錯啦。
所以稍微修改了自己寫的生成器之后，就沒問題了。
不過，如果想要更自由的調用數據，還是需要對對象進行一些方法的重載，使用 pytoch 定義的 DataLoader，用 enumerate，就會把所有的數據歷遍一次，如果使用 iter() 得到一個可迭代對象之后 next()，并不可以像 tensorflow 那樣子生成訓練數據。
例如說，如果使用如上的形式，DataLoader 得到的是一個生成器，python 中的生成器對象主要有 __next__ 和 __iter__ 等魔術方法決定。
__iter__ 方法使得實例可以如下調用，可以得到一個可迭代對象，iterable，但是如果不加也沒關系，因為更重要的是 __next__ 類方法。
如下自己寫了 __next__ 方法之后就可以看到，原本會出現越界的現象不見了，可以循環的歷遍數據，當然也可以想被注釋的那部分一樣，拋出 StopIteration 來終止。
a = A()
a_iter = iter(a)
class A():
def __init__(self):
self.list = [1,2,3]
self.index = 0
#def __getitem__(self, index):
# return self.list[i]
#def __iter__(self):
# return self
def __next__(self):
#for i in range():
if self.index >= len(self.list):
#raise StopIteration
self.index = self.index%len(self.list)
result = self.list[self.index]
self.index += 1
return result
b = A()
for i in range(20):
print(next(b))
以上為個人經驗，希望能給大家一個參考，也希望大家多多支持腳本之家。如有錯誤或未考慮完全的地方，望不吝賜教。
您可能感興趣的文章:- pytorch 狀態字典:state_dict使用詳解
- 解決pytorch 保存模型遇到的問題
- 解決pytorch 的state_dict()拷貝問題
