一篇文章入門深度學習框架PyTorch

• 1 Tensor（張量）
• 2 Variable（變量）
• 3 Dataset（數據集）
• 4 nn.Module（模組）
• 5 torch.optim（優化）
• • 一階優化算法
  • 二階優化算法
• 6 模型的保存和加載

1 Tensor（張量）

• PyTorch里面處理的最基本的操作對象就是Tensor，Tensor表示的是一個多維矩陣，比如零維就是一個點，一維就是向量，二維就是一般的矩陣，多維就相當于一個多維數組
• Tensor和Numpy是對應的，可以和Numpy的ndarray互相轉換，唯一不同的是PyTorch可以再GPU上運行，numpy只能在CPU上運行。
• 常用的不同類型的Tensor：32位浮點型torch.FloatTensor，64位浮點型torch.DoubleTensor，16位整型torch.ShortTensor，32位整型torch.IntTensor，64位整型torch.LongTensor

import torch import numpy as np# 定義一個三行兩列給定元素矩陣 a = torch.Tensor([[2, 3], [4, 8], [7, 9]]) # 顯示矩陣元素 print('a is {}'.format(a)) # 顯示矩陣大小 print('a size is {}'.format(a.size()))# torch.tensor默認的是torch.FloatTensor數據類型 b = torch.LongTensor(([[2, 3], [4, 8], [7, 9]])) print('b is {}'.format(b))# 創建一個全是0的空Tensor c = torch.zeros((3, 2)) print('zeros tensor {}'.format(c))# 取一個正太分布作為隨機初始值 d = torch.randn((3, 2)) print('d is {}'.format(d))# 可以像Numpy一樣通過索引的方式取得其中的元素，也可以改變它的值 a[0, 1] = 100 # 將a的第一行與第二列的元素改變為100 print('changed a is {}'.format(a))# Tensor可以和Numpy.ndarray之間相互轉換 numpy_b = b.numpy() # 將b裝換為Numpy的數據類型 print('converse to numpy is \n {}'.format(numpy_b))e = np.array([[2, 3], [4, 5]]) torch_e = torch.from_numpy(e) # 將Numpy轉換為Tensor print('from numpy to torch.Tensor is \n {}'.format(torch_e))f_torch_e = torch_e.float() # 如果需要更改Tensor的數據類型，只需要在轉換后的tensor后面加上需要的類型 print('change data type to float tensor \n {}'.format(f_torch_e))# 如果支持GPU加速，Tensor放到GPU上 if torch.cuda.is_available():a_cuda = a.cuda()print(a_cuda)

• 結果

D:\software\anaconda3\envs\pytorch_gpu\python.exe D:/IDEA/pytorch_gpu/src/demo.py a is tensor([[2., 3.],[4., 8.],[7., 9.]]) a size is torch.Size([3, 2]) b is tensor([[2, 3],[4, 8],[7, 9]]) zeros tensor tensor([[0., 0.],[0., 0.],[0., 0.]]) d is tensor([[-0.3689, -0.8400],[ 1.1293, -0.3011],[-0.4752, 0.5565]]) changed a is tensor([[ 2., 100.],[ 4., 8.],[ 7., 9.]]) converse to numpy is [[2 3][4 8][7 9]] from numpy to torch.Tensor is tensor([[2, 3],[4, 5]], dtype=torch.int32) change data type to float tensor tensor([[2., 3.],[4., 5.]]) tensor([[ 2., 100.],[ 4., 8.],[ 7., 9.]], device='cuda:0')Process finished with exit code 0

2 Variable（變量）

• Variable是神經網絡計算圖里特有的一個概念，提供了自動求導功能，位于torch.autograd.variable，在Numpy里不存在。神經網絡在做運算的時候，需要先構造一個計算圖譜，在里面進行前向傳播和反向傳播。
• Variable和Tensor本質上沒有區別，不過Variable會被放入一個計算圖中，然后進行前向傳播，反向傳播，自動求導。
• Variable屬性結構圖
  
• Variable有三個重要的屬性：data，grad，grad_fn。通過data可以取出Variable里面的Tensor數值，grad_fn表示的是得到這個Variable的操作，比如通過加減還是乘除來得到，grad是這個Variable的反向傳播梯度。
• 自動求導是不需要明確哪個函數對哪個函數求導，直接通過一行代碼對所有的需要梯度的變量進行求導。

from torch.autograd.variable import *# Create Variable # requires_grad表示是否對變量求梯度 x = Variable(torch.Tensor([1]), requires_grad=True) w = Variable(torch.Tensor([2]), requires_grad=True) b = Variable(torch.Tensor([3]), requires_grad=True)# Build a Computational graph y = w * x + b # y=2*x+3# Compute gradients 自動求導 # 對于標量求導，參數可以不寫 y.backward() # same as y.backward(torch.FloatTensor([1]))# print out the gradients print(x.grad) print(w.grad) print(b.grad)

• 運行結果

D:\software\anaconda3\envs\pytorch_gpu\python.exe D:/IDEA/pytorch_gpu/src/demo.py tensor([2.]) tensor([1.]) tensor([1.])Process finished with exit code 0

• 上面是標量的求導，也可以做矩陣的求導

from torch.autograd.variable import * import torchx = torch.randn(3) x = Variable(x, requires_grad=True) y = x * 2 print(y) # 矩陣求導 y.backward(torch.FloatTensor([1, 0.1, 0.01])) print(x.grad)

• 運行結果

D:\software\anaconda3\envs\pytorch_gpu\python.exe D:/IDEA/pytorch_gpu/src/demo.py tensor([-0.4075, -1.0235, -2.4338], grad_fn=<MulBackward0>) tensor([2.0000, 0.2000, 0.0200])Process finished with exit code 0

3 Dataset（數據集）

• 在處理任何機器學習問題之前都需要數據讀取并進行預處理。torch.utils.data.Dataset是代表這一數據的抽象類，可以自己定義數據類型集成和重寫這個抽象類。

import torch from torch.utils.data import Dataset import pandas as pdclass myDataset(Dataset):def __init__(self, csv_file, txt_file, root_dir, other_file):self.csv_data = pd.read_csv(csv_file)with open(txt_file, 'r') as f:data_list = f.readlines();self.txt_data = data_listself.root_dir = root_dirdef __len__(self):return len(self.csv_data)def __getitem__(self, item):data = (self.csv_data[item], self.txt_data[item])return data

• 通過上面的方式，可以定義需要的數據類，通過迭代的方式取得每一個數據，但是很難實現取batch，shuffle或者多線程取數據，可以通過torch.utils.data.DataLoader

import torch from torch.utils.data import Dataset, DataLoader import pandas as pd from torch.utils.data._utils.collate import default_collateclass myDataset(Dataset):def __init__(self, csv_file, txt_file, root_dir, other_file):self.csv_data = pd.read_csv(csv_file)with open(txt_file, 'r') as f:data_list = f.readlines()self.txt_data = data_listself.root_dir = root_dirdef __len__(self):return len(self.csv_data)def __getitem__(self, item):data = (self.csv_data[item], self.txt_data[item])return datadataiter = DataLoader(myDataset, batch_size=32, shuffle=True, collate_fn=default_collate)

4 nn.Module（模組）

• 在PyTorch里面編寫神經網絡，所有的層結構和損失函數都來自于torch.nn，所有的模型構建都繼承自nn.Module基類。

import torch.nn as nnclass net_name(nn.Module):def __init__(self, other_arguments):super(net_name, self).__init__()self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size)# other network layersdef forward(self, x):x = self.conv1(x)return x

• 這樣就建立了一個計算圖，并且這個結構可以復用多次，每次調用就相當于用該計算圖定義的相同參數做一次前向傳播，這得益于PyTorch的自動求導功能，所以我們不需要自己編寫反向傳播，而所有的網絡層都由nn這個包得到，如線性層nn.Linear.
• 定義完模型之后，需要通過nn這個包定義損失函數，常見的損失函數有均方誤差、多分類的交叉熵、二分類的交叉熵.

criterion = nn.CrossEntropyLoss() loss = criterion(output, target)

5 torch.optim（優化）

• 在機器學習或者深度學習中，需要通過修改參數使得損失函數最小化或者最大化，優化算法就是一種調整模型參數更新的策略。

一階優化算法

• 一階優化算法使用各個參數的梯度值來更新參數，最常用的一階優化算法是梯度下降。梯度就是導數的多變量表達式，函數的梯度形成了一個向量場，同時也是一個方向，這個方向上的方向導數最大，且等于梯度。梯度下降的功能是通過尋找最小值，控制方差，更新模型參數，最終使模型收斂，網絡的參數更新公式是：

$$\theta =\theta ?\eta ?\frac{?J(\theta )}{?\theta }$$

二階優化算法

• 二階優化算法使用了二階導數（也叫做Hessian方法）來最小化和最大化損失函數，主要基于牛頓法。但是由于二階導數計算成本很高，所以這種方法并沒有廣泛使用。
• torch.optim是一個實現各種優化算法的包，大多數常見的算法都能通過這個包來調用，比如隨機梯度下降，以及添加動量的隨機梯度下降，自適應學習率等。在調用的時候將需要優化的參數傳入，這些參數必須是Variable，然后傳入一些基本的設定，如學習率和動量。

6 模型的保存和加載

• 在PyTorch里面使用torch.save來保存模型的結構和參數，有兩種保存方式：

（1）保存整個模型的結構信息和參數信息，保存的對象是Model

# save方法：第一個參數是保存對象，第二個參數是保存路徑及名稱 torch.save(model,'./model.pth')

（2）保存模型的參數，保存的對象是模型的狀態：model.state_dict()

# save方法：第一個參數是保存對象，第二個參數是保存路徑及名稱 torch.save(model.state_dict(),'./model_state.pth')

• 加載模型有兩種方式，對應于保存模型的方式，map_location=device 更換設備

（1）加載完整的模型結構和參數信息，在網絡較大的時候，加載的時間較長，同時存儲空間較大。

load_model=torch.load(‘model.pth', map_location=device)

（2）加載模型參數信息，需要先導入模型的結構，然后加載模型參數

model=YourModelClass() model.load_state_dic(torch.load('model_state.pth', map_location=device)) # -*- coding: utf-8 -*- # Import Package import torch import torch.nn as nn from torchvision import transforms,datasets from torch.utils.data import DataLoader import torch.nn.functional as F import torch.optim as optim# Prepare Dataset batch_size=64 transform=transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.1307,),(0.3081,)) ]) train_dataset=datasets.MNIST(root='./dataset/',train=True,download=True,transform=transform ) train_loader=DataLoader(train_dataset,shuffle=True,batch_size=batch_size ) test_dataset=datasets.MNIST(root='./dataset/',train=False,download=True,transform=transform ) test_loader=DataLoader(train_dataset,shuffle=False,batch_size=batch_size )# Design Model class Net(nn.Module):def __init__(self):super(Net, self).__init__()self.l1=nn.Linear(784,512)self.l2=nn.Linear(512,256)self.l3=nn.Linear(256,128)self.l4=nn.Linear(128,64)self.l5=nn.Linear(64,10)def forward(self,x):x=x.view(-1,784)x=F.relu(self.l1(x))x=F.relu(self.l2(x))x=F.relu(self.l3(x))x=F.relu(self.l4(x))return self.l5(x) model=Net()# Construct Loss and Optimizer criterion=nn.CrossEntropyLoss() optimizer=optim.SGD(model.parameters(),lr=0.01,momentum=0.5)# Train and Test def train(epoch):running_loss=0.0for batch_idx,data in enumerate(train_loader,0):inputs,target=dataoptimizer.zero_grad()outputs=model(inputs)loss=criterion(outputs,target)loss.backward()optimizer.step()running_loss+=loss.item()if (batch_idx+1)%300==0:print('[%d, %5d] loss: %.3f'%(epoch+1,batch_idx+1,running_loss/300))running_loss=0 def test(test_model):correct=0total=0with torch.no_grad():for data in test_loader:images,labels=dataoutputs=test_model(images)_,predicted=torch.max(outputs.data,dim=1)total+=labels.size(0)correct+=(predicted==labels).sum().item()print("Accuracy on test set: %d %%"%(100*correct/total))for epoch in range(3):train(epoch) # 保存模型(包括模型結構和參數) torch.save(model,'model_structure_parameter.pth')# 加載保存模型(包括模型結構和參數) test_model=torch.load('model_structure_parameter.pth') test(test_model)for epoch in range(3):train(epoch) # 保存模型(包括模型參數) torch.save(model.state_dict(),'model__parameter.pth')# 加載保存模型(包括模型參數) test_model=Net() test_model.load_state_dict(torch.load('model__parameter.pth')) test(test_model)

總結

以上是生活随笔為你收集整理的一篇文章入门深度学习框架PyTorch的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。