深度學習
基礎知識和各種網路結構實戰 ...狂肝兩萬字帶你用pytorch搞深度學習！！！
- 深度學習
- 前言
- 一、基本資料：Tensor
- 1.1 Tensor的創建
- 1.2 torch.FloatTensor
- 1.3 torch.IntTensor
- 1.4 torch.randn
- 1.5 torch.range
- 1.6 torch.zeros/ones/empty
- 二、Tensor的運算
- 2.1 torch.abs
- 2.2 torch.add
- 2.3 torch.clamp
- 2.4 torch.div
- 2.5 torch.pow
- 2.6 torch.mm
- 2.7 torch.mv
- 三、神經網路工具箱torch.nn
- 3.1 nn.Module類
- 3.2 搭建簡易神經網路
- 四、torch實作一個完整的神經網路
- 4.1 torch.autograd和Variable
- 4.2 自定義傳播函式
- 4.3 PyTorch 之 torch.nn
- 4.3.1 torch.nn.Sequential
- 4.3.2 torch.nn.Linear
- 4.3.3 torch.nn.ReLU
- 4.3.4 torch.nn.MSELoss
- 4.3.4 torch.nn.L1Loss
- 4.3.5 torch.nn.CrossEntropyLoss
- 4.3.5 使用損失函式的神經網路
- 4.4 PyTorch 之 torch.optim
- 五、搭建神經網路實作手寫資料集
- 5.1 torchvision
- 5.1.1 torchvision.datasets
- 5.1.2 torchvision.models
- 5.1.3 torch.transforms
- 5.1.3.1 torchvision.transforms.Resize
- 5.1.3.2 torchvision.transforms.Scale
- 5.1.3.3 torchvision.transforms.CenterCrop
- 5.1.3.4 torchvision.transforms.RandomCrop
- 5.1.3.5 torchvision.transforms.RandomHorizontalFlip
- 5.1.3.6 torchvision.transforms.RandomVerticalFlip
- 5.1.3.7 torchvision.transforms.ToTensor
- 5.1.3.8 torchvision.transforms.ToPILImage:
- 5.1.4 torch.utils
- 5.2 模型搭建和引數優化
- 5.2.1 torch.nn.Conv2d
- 5.2.2 torch.nn.MaxPool2d
- 5.2.3 torch.nn.Dropout
- 5.3 引數優化
- 5.3.1 模型訓練
- 5.4 模型驗證
- 5.5 完整代碼
- 六、結語
前言
學習深度學習一個好的框架十分的重要，現在主流的就是Pytorch和tf，今天讓我們一起來學習pytorch
一、基本資料：Tensor
Tensor，即張量，是PyTorch中的基本操作物件，可以看做是包含單一資料型別元素的多維矩陣，從使用角度來看，Tensor與NumPy的ndarrays非常類似，相互之間也可以自由轉換，只不過Tensor還支持GPU的加速，
1.1 Tensor的創建
1.2 torch.FloatTensor
torch.FloatTensor用于生成資料型別為浮點型的Tensor，傳遞給torch.FloatTensor的引數可以是串列，也可以是一個維度值，
import torch
a = torch.FloatTensor(2,3)
b = torch.FloatTensor([2,3,4,5])
a,b
得到的結果是：
(tensor([[1.0561e-38, 1.0102e-38, 9.6429e-39],
[8.4490e-39, 9.6429e-39, 9.1837e-39]]),
tensor([2., 3., 4., 5.]))
1.3 torch.IntTensor
torch.IntTensor用于生成資料型別為整型的Tensor,傳遞給傳遞給torch.IntTensor的引數可以是串列，也可以是一個維度值，
import torch
a = torch.FloatTensor(2,3)
b = torch.FloatTensor([2,3,4,5])
a,b
import torch
a = torch.rand(2,3)
a
得到：
tensor([[0.5625, 0.5815, 0.8221],
[0.3589, 0.4180, 0.2158]])
1.4 torch.randn
用于生成資料型別為浮點數且維度指定的隨機Tensor，和在numpy中使用的numpy.randn生成的亂數的方法類似，隨機生成的浮點數的取值滿足均值為0，方差為1的正態分布，
import torch
a = torch.randn(2,3)
a
得到：
tensor([[-0.0067, -0.0707, -0.6682],
[ 0.8141, 1.1436, 0.5963]])
1.5 torch.range
torch.range用于生成資料型別為浮點型且起始范圍和結束范圍的Tensor，所以傳遞給torch.range的引數有三個，分別為起始值，結束值，步長，其中步長用于指定從起始值到結束值得每步的資料間隔，
import torch
a = torch.range(1,20,2)
a
得到：
tensor([ 1., 3., 5., 7., 9., 11., 13., 15., 17., 19.])
1.6 torch.zeros/ones/empty
torch.zeros用于生成資料型別為浮點型且維度指定的Tensor，不過這個浮點型的Tensor中的元素值全部為0，
torch.ones生成全1的陣列，
torch.empty創建一個未被初始化數值的tensor,tensor的大小是由size確定,size: 定義tensor的shape ，這里可以是一個list 也可以是一個tuple
import torch
a = torch.zeros(2,3)
a
得到：
tensor([[0., 0., 0.],
[0., 0., 0.]])
二、Tensor的運算
2.1 torch.abs
將引數傳遞到torch.abs后回傳輸入引數的絕對值作為輸出，輸入引數必須是一個Tensor資料型別的變數，如：
import torch
a = torch.randn(2,3)
a
得到的a是：
tensor([[ 0.0948, 0.0530, -0.0986],
[ 1.8926, -2.0569, 1.6617]])
對a進行abs處理：
b = torch.abs(a)
b
得到：
tensor([[0.0948, 0.0530, 0.0986],
[1.8926, 2.0569, 1.6617]])
2.2 torch.add
將引數傳遞到torch.add后回傳輸入引數的求和結果作為輸出，輸入引數既可以全部是Tensor資料型別的變數，也可以一個是Tensor資料型別的變數，另一個是標量，
import torch
a = torch.randn(2,3)
a
#tensor([[-0.1146, -0.3282, -0.2517],
# [-0.2474, 0.8323, -0.9292]])
b = torch.randn(2,3)
b
#tensor([[ 0.9526, 1.5841, -3.2665],
# [-0.4831, 0.9259, -0.5054]])
c = torch.add(a,b)
c
輸出的c:
tensor([[ 0.8379, 1.2559, -3.5182],
[-0.7305, 1.7582, -1.4346]])
再看一個：
d = torch.randn(2,3)
d
#這里我們得到的d：
#tensor([[ 0.1473, 0.7631, -0.1953],
# [-0.2796, -0.7265, 0.7142]])
我們對d與一個標量10相加：
e = torch.add(d,10)
e
得到：
tensor([[10.1473, 10.7631, 9.8047],
[ 9.7204, 9.2735, 10.7142]])
2.3 torch.clamp
torch.clamp是對輸入引數按照自定義的范圍進行裁剪，最后將引數裁剪的結果作為輸出，所以輸入引數一共有三個，分別是需要進行裁剪的Tensor資料型別的變數、裁剪的上上邊界和裁剪的下邊界，具體的裁剪程序是：使用變數中的每個元素分別和裁剪的上邊界及裁剪的下邊界的值進行比較，如果元素的值小于裁剪的下邊界的值，該元素被重寫成裁剪的下邊界的值；同理，如果元素的值大于裁剪的上邊界的值，該元素就被重寫成裁剪的上邊界的值，我們直接看例子：
a = torch.randn(2,3)
a
#我們得到a為：
#tensor([[-1.4049, 1.0336, 1.2820],
# [ 0.7610, -1.7475, 0.2414]])
我們對b進行clamp操作：
b = torch.clamp(a,-0.1,0.1)
b
#我們得到b為：
#tensor([[-0.1000, 0.1000, 0.1000],
# [ 0.1000, -0.1000, 0.1000]])
2.4 torch.div
torch.div是將引數傳遞到torch.div后回傳輸入引數的求商結果作為輸出，同樣，參與運算的引數可以全部是Tensor資料型別的變數，也可以是Tensor資料型別的變數和標量的組合，具體我們看例子
a = torch.randn(2,3)
a
#我們得到a為：
#tensor([[ 0.6276, 0.6397, -0.0762],
# [-0.4193, -0.5528, 1.5192]])
b = torch.randn(2,3)
b
#我們得到b為：
#tensor([[ 0.9219, 0.2120, 0.1155],
# [ 1.1086, -1.1442, 0.2999]])
對a,b進行div操作
c = torch.div(a,b)
c
#得到c：
#tensor([[ 0.6808, 3.0173, -0.6602],
# [-0.3782, 0.4831, 5.0657]])
2.5 torch.pow
torch.pow：將引數傳遞到torch.pow后回傳輸入引數的求冪結果作為輸出，參與運算的引數可以全部是Tensor資料型別的變數，也可以是Tensor資料型別的變數和標量的組合，
a = torch.randn(2,3)
a
#我們得到a為：
#tensor([[ 0.3896, -0.1475, 0.1104],
# [-0.6908, -0.0472, -1.5310]])
對a進行平方操作
b = torch.pow(a,2)
b
#我們得到b為：
#tensor([[1.5181e-01, 2.1767e-02, 1.2196e-02],
# [4.7722e-01, 2.2276e-03, 2.3441e+00]])
2.6 torch.mm
torch.mm：將引數傳遞到torch.mm后回傳輸入引數的求積結果作為輸出，不過這個求積的方式和之前的torch.mul運算方式不太一樣，torch.mm運用矩陣之間的乘法規則進行計算，所以被傳入的引數會被當作矩陣進行處理，引數的維度自然也要滿足矩陣乘法的前提條件，即前一個矩陣的行數必須和后一個矩陣列數相等
下面我們看實體：
a = torch.randn(2,3)
a
#我們得到a為：
#tensor([[ 0.1057, 0.0104, -0.1547],
# [ 0.5010, -0.0735, 0.4067]])
b = torch.randn(2,3)
b
#我們得到b為：
#tensor([[ 1.1971, -1.4010, 1.1277],
# [-0.3076, 0.9171, 1.9135]])
然后我們用產生的a,b進行矩陣乘法操作：
c = torch.mm(a,b.T)
c
#tensor([[-0.0625, -0.3190],
# [ 1.1613, 0.5567]])
2.7 torch.mv
將引數傳遞到torch.mv后回傳輸入引數的求積結果作為輸出，torch.mv運用矩陣與向量之間的乘法規則進行計算，被傳入的第1個引數代表矩陣，第2個引數代表向量，循序不能顛倒，
下面我們看實體：
a = torch.randn(2,3)
a
#我們得到a為：
#tensor([[ 1.0909, -1.1679, 0.3161],
# [-0.8952, -2.1351, -0.9667]])
b = torch.randn(3)
b
#我們得到b為：
#tensor([-1.4689, 1.6197, 0.7209])
然后我們用產生的a,b進行矩陣乘法操作：
c = torch.mv(a,b)
c
#tensor([-3.2663, -2.8402])
三、神經網路工具箱torch.nn
torch.autograd庫雖然實作了自動求導與梯度反向傳播，但如果我們要完成一個模型的訓練，仍需要手寫引數的自動更新、訓練程序的控制等，還是不夠便利，為此，PyTorch進一步提供了集成度更高的模塊化介面torch.nn，該介面構建于Autograd之上，提供了網路模組、優化器和初始化策略等一系列功能，
3.1 nn.Module類
nn.Module是PyTorch提供的神經網路類，并在類中實作了網路各層的定義及前向計算與反向傳播機制，在實際使用時，如果想要實作某個神經網路，只需繼承nn.Module，在初始化中定義模型結構與引數，在函式forward()中撰寫網路前向程序即可，
1．nn.Parameter函式
2．forward()函式與反向傳播
3．多個Module的嵌套
4．nn.Module與nn.functional庫
5．nn.Sequential()模塊
#這里用torch.nn實作一個MLP
from torch import nn
class MLP(nn.Module):
def __init__(self, in_dim, hid_dim1, hid_dim2, out_dim):
super(MLP, self).__init__()
self.layer = nn.Sequential(
nn.Linear(in_dim, hid_dim1),
nn.ReLU(),
nn.Linear(hid_dim1, hid_dim2),
nn.ReLU(),
nn.Linear(hid_dim2, out_dim),
nn.ReLU()
)
def forward(self, x):
x = self.layer(x)
return x
3.2 搭建簡易神經網路
下面我們用torch搭一個簡易神經網路：
1、我們設定輸入節點為1000，隱藏層的節點為100，輸出層的節點為10
2、輸入100個具有1000個特征的資料，經過隱藏層后變成100個具有10個分類結果的特征，然后將得到的結果后向傳播
import torch
batch_n = 100#一個批次輸入資料的數量
hidden_layer = 100
input_data = 1000#每個資料的特征為1000
output_data = 10
x = torch.randn(batch_n,input_data)
y = torch.randn(batch_n,output_data)
w1 = torch.randn(input_data,hidden_layer)
w2 = torch.randn(hidden_layer,output_data)
epoch_n = 20
lr = 1e-6
for epoch in range(epoch_n):
h1=x.mm(w1)#(100,1000)*(1000,100)-->100*100
print(h1.shape)
h1=h1.clamp(min=0)
y_pred = h1.mm(w2)
loss = (y_pred-y).pow(2).sum()
print("epoch:{},loss:{:.4f}".format(epoch,loss))
grad_y_pred = 2*(y_pred-y)
grad_w2 = h1.t().mm(grad_y_pred)
grad_h = grad_y_pred.clone()
grad_h = grad_h.mm(w2.t())
grad_h.clamp_(min=0)#將小于0的值全部賦值為0，相當于sigmoid
grad_w1 = x.t().mm(grad_h)
w1 = w1 -lr*grad_w1
w2 = w2 -lr*grad_w2
torch.Size([100, 100])
epoch:0,loss:112145.7578
torch.Size([100, 100])
epoch:1,loss:110014.8203
torch.Size([100, 100])
epoch:2,loss:107948.0156
torch.Size([100, 100])
epoch:3,loss:105938.6719
torch.Size([100, 100])
epoch:4,loss:103985.1406
torch.Size([100, 100])
epoch:5,loss:102084.9609
torch.Size([100, 100])
epoch:6,loss:100236.9844
torch.Size([100, 100])
epoch:7,loss:98443.3359
torch.Size([100, 100])
epoch:8,loss:96699.5938
torch.Size([100, 100])
epoch:9,loss:95002.5234
torch.Size([100, 100])
epoch:10,loss:93349.7969
torch.Size([100, 100])
epoch:11,loss:91739.8438
torch.Size([100, 100])
epoch:12,loss:90171.6875
torch.Size([100, 100])
epoch:13,loss:88643.1094
torch.Size([100, 100])
epoch:14,loss:87152.6406
torch.Size([100, 100])
epoch:15,loss:85699.4297
torch.Size([100, 100])
epoch:16,loss:84282.2500
torch.Size([100, 100])
epoch:17,loss:82899.9062
torch.Size([100, 100])
epoch:18,loss:81550.3984
torch.Size([100, 100])
epoch:19,loss:80231.1484
四、torch實作一個完整的神經網路
4.1 torch.autograd和Variable
torch.autograd包的主要功能就是完成神經網路后向傳播中的鏈式求導，手動去寫這些求導程式會導致重復造輪子的現象，
自動梯度的功能程序大致為：先通過輸入的Tensor資料型別的變數在神經網路的前向傳播程序中生成一張計算圖，然后根據這個計算圖和輸出結果精確計算出每一個引數需要更新的梯度，并通過完成后向傳播完成對引數的梯度更新，
完成自動梯度需要用到的torch.autograd包中的Variable類對我們定義的Tensor資料型別變數進行封裝，在封裝后，計算圖中的各個節點就是一個Variable物件，這樣才能應用自動梯度的功能，
下面我們使用autograd實作一個二層結構的神經網路模型
import torch
from torch.autograd import Variable
batch_n = 100#一個批次輸入資料的數量
hidden_layer = 100
input_data = 1000#每個資料的特征為1000
output_data = 10
x = Variable(torch.randn(batch_n,input_data),requires_grad=False)
y = Variable(torch.randn(batch_n,output_data),requires_grad=False)
#用Variable對Tensor資料型別變數進行封裝的操作，requires_grad如果是False，表示該變數在進行自動梯度計算的程序中不會保留梯度值，
w1 = Variable(torch.randn(input_data,hidden_layer),requires_grad=True)
w2 = Variable(torch.randn(hidden_layer,output_data),requires_grad=True)
#學習率和迭代次數
epoch_n=50
lr=1e-6
for epoch in range(epoch_n):
h1=x.mm(w1)#(100,1000)*(1000,100)-->100*100
print(h1.shape)
h1=h1.clamp(min=0)
y_pred = h1.mm(w2)
#y_pred = x.mm(w1).clamp(min=0).mm(w2)
loss = (y_pred-y).pow(2).sum()
print("epoch:{},loss:{:.4f}".format(epoch,loss.data))
# grad_y_pred = 2*(y_pred-y)
# grad_w2 = h1.t().mm(grad_y_pred)
loss.backward()#后向傳播
# grad_h = grad_y_pred.clone()
# grad_h = grad_h.mm(w2.t())
# grad_h.clamp_(min=0)#將小于0的值全部賦值為0，相當于sigmoid
# grad_w1 = x.t().mm(grad_h)
w1.data -= lr*w1.grad.data
w2.data -= lr*w2.grad.data
w1.grad.data.zero_()
w2.grad.data.zero_()
# w1 = w1 -lr*grad_w1
# w2 = w2 -lr*grad_w2
得到結果：
torch.Size([100, 100])
epoch:0,loss:54572212.0000
torch.Size([100, 100])
epoch:1,loss:133787328.0000
torch.Size([100, 100])
epoch:2,loss:491439904.0000
torch.Size([100, 100])
epoch:3,loss:683004416.0000
torch.Size([100, 100])
epoch:4,loss:13681055.0000
torch.Size([100, 100])
epoch:5,loss:8058388.0000
torch.Size([100, 100])
epoch:6,loss:5327059.5000
torch.Size([100, 100])
epoch:7,loss:3777382.5000
torch.Size([100, 100])
epoch:8,loss:2818449.5000
torch.Size([100, 100])
epoch:9,loss:2190285.0000
torch.Size([100, 100])
epoch:10,loss:1760991.0000
torch.Size([100, 100])
epoch:11,loss:1457116.3750
torch.Size([100, 100])
epoch:12,loss:1235850.6250
torch.Size([100, 100])
epoch:13,loss:1069994.0000
torch.Size([100, 100])
epoch:14,loss:942082.4375
torch.Size([100, 100])
epoch:15,loss:841170.6250
torch.Size([100, 100])
epoch:16,loss:759670.1875
torch.Size([100, 100])
epoch:17,loss:692380.5625
torch.Size([100, 100])
epoch:18,loss:635755.0625
torch.Size([100, 100])
epoch:19,loss:587267.1250
torch.Size([100, 100])
epoch:20,loss:545102.0000
torch.Size([100, 100])
epoch:21,loss:508050.6250
torch.Size([100, 100])
epoch:22,loss:475169.9375
torch.Size([100, 100])
epoch:23,loss:445762.8750
torch.Size([100, 100])
epoch:24,loss:419216.2812
torch.Size([100, 100])
epoch:25,loss:395124.9375
torch.Size([100, 100])
epoch:26,loss:373154.8438
torch.Size([100, 100])
epoch:27,loss:352987.6875
torch.Size([100, 100])
epoch:28,loss:334429.0000
torch.Size([100, 100])
epoch:29,loss:317317.7500
torch.Size([100, 100])
epoch:30,loss:301475.8125
torch.Size([100, 100])
epoch:31,loss:286776.8750
torch.Size([100, 100])
epoch:32,loss:273114.4062
torch.Size([100, 100])
epoch:33,loss:260383.6406
torch.Size([100, 100])
epoch:34,loss:248532.8125
torch.Size([100, 100])
epoch:35,loss:237452.3750
torch.Size([100, 100])
epoch:36,loss:227080.5156
torch.Size([100, 100])
epoch:37,loss:217362.9375
torch.Size([100, 100])
epoch:38,loss:208250.5312
torch.Size([100, 100])
epoch:39,loss:199686.1094
torch.Size([100, 100])
epoch:40,loss:191620.0312
torch.Size([100, 100])
epoch:41,loss:184017.4375
torch.Size([100, 100])
epoch:42,loss:176841.0156
torch.Size([100, 100])
epoch:43,loss:170073.1719
torch.Size([100, 100])
epoch:44,loss:163686.5000
torch.Size([100, 100])
epoch:45,loss:157641.5000
torch.Size([100, 100])
epoch:46,loss:151907.0000
torch.Size([100, 100])
epoch:47,loss:146470.1250
torch.Size([100, 100])
epoch:48,loss:141305.3594
torch.Size([100, 100])
epoch:49,loss:136396.7031
4.2 自定義傳播函式
其實除了可以采用自動梯度方法，我們還可以通過構建一個繼承了torch.nn.Module的新類，來完成對前向傳播函式和后向傳播函式的重寫，在這個新類中，我們使用forward作為前向傳播函式的關鍵字，使用backward作為后向傳播函式的關鍵字，下面我們進行自定義傳播函式：
import torch
from torch.autograd import Variable
batch_n = 64#一個批次輸入資料的數量
hidden_layer = 100
input_data = 1000#每個資料的特征為1000
output_data = 10
class Model(torch.nn.Module):#完成類繼承的操作
def __init__(self):
super(Model,self).__init__()#類的初始化
def forward(self,input,w1,w2):
x = torch.mm(input,w1)
x = torch.clamp(x,min = 0)
x = torch.mm(x,w2)
return x
def backward(self):
pass
model = Model()
x = Variable(torch.randn(batch_n,input_data),requires_grad=False)
y = Variable(torch.randn(batch_n,output_data),requires_grad=False)
#用Variable對Tensor資料型別變數進行封裝的操作，requires_grad如果是F，表示該變數在進行自動梯度計算的程序中不會保留梯度值，
w1 = Variable(torch.randn(input_data,hidden_layer),requires_grad=True)
w2 = Variable(torch.randn(hidden_layer,output_data),requires_grad=True)
epoch_n=30
for epoch in range(epoch_n):
y_pred = model(x,w1,w2)
loss = (y_pred-y).pow(2).sum()
print("epoch:{},loss:{:.4f}".format(epoch,loss.data))
loss.backward()
w1.data -= lr*w1.grad.data
w2.data -= lr*w2.grad.data
w1.grad.data.zero_()
w2.grad.data.zero_()
得到結果：
4.3 PyTorch 之 torch.nn
4.3.1 torch.nn.Sequential
torch.nn.Sequential類是torch.nn中的一種序列容器，通過在容器中嵌套各種實作神經網路模型的搭建，最主要的是，引數會按照我們定義好的序列自動傳遞下去，
import torch
from torch.autograd import Variable
batch_n = 100#一個批次輸入資料的數量
hidden_layer = 100
input_data = 1000#每個資料的特征為1000
output_data = 10
x = Variable(torch.randn(batch_n,input_data),requires_grad=False)
y = Variable(torch.randn(batch_n,output_data),requires_grad=False)
#用Variable對Tensor資料型別變數進行封裝的操作，requires_grad如果是F，表示該變數在進行自動梯度計算的程序中不會保留梯度值，
models = torch.nn.Sequential(
torch.nn.Linear(input_data,hidden_layer),
torch.nn.ReLU(),
torch.nn.Linear(hidden_layer,output_data)
)
#torch.nn.Sequential括號內就是我們搭建的神經網路模型的具體結構，Linear完成從隱藏層到輸出層的線性變換，再用ReLU激活函式激活
#torch.nn.Sequential類是torch.nn中的一種序列容器，通過在容器中嵌套各種實作神經網路模型的搭建，
#最主要的是，引數會按照我們定義好的序列自動傳遞下去，
4.3.2 torch.nn.Linear
torch.nn.Linear類用于定義模型的線性層，即完成前面提到的不同的層之間的線性變換， 線性層接受的引數有3個：分別是輸入特征數、輸出特征數、是否使用偏置，默認為True,使用torch.nn.Linear類，會自動生成對應維度的權重引數和偏置，對于生成的權重引數和偏置，我們的模型默認使用一種比之前的簡單隨機方式更好的引數初始化方式，
4.3.3 torch.nn.ReLU
torch.nn.ReLU屬于非線性激活分類，在定義時默認不需要傳入引數，當然，在torch.nn包中還有許多非線性激活函式類可供選擇，比如PReLU、LeaKyReLU、Tanh、Sigmoid、Softmax等，
4.3.4 torch.nn.MSELoss
torch.nn.MSELoss類使用均方誤差函式對損失值進行計算，定義類的物件時不用傳入任何引數，但在使用實體時需要輸入兩個維度一樣的引數方可進行計算，
import torch
from torch.autograd import Variable
loss_f = torch.nn.MSELoss()
x = Variable(torch.randn(100,100))
y = Variable(torch.randn(100,100))
loss = loss_f(x,y)
loss.data
#tensor(1.9529)
4.3.4 torch.nn.L1Loss
torch.nn.L1Loss類使用平均絕對誤差函式對損失值進行計算，定義類的物件時不用傳入任何引數，但在使用實體時需要輸入兩個維度一樣的引數方可進行計算，
import torch
from torch.autograd import Variable
loss_f = torch.nn.L1Loss()
x = Variable(torch.randn(100,100))
y = Variable(torch.randn(100,100))
loss = loss_f(x,y)
loss.data
#tensor(1.1356)
4.3.5 torch.nn.CrossEntropyLoss
torch.nn.CrossEntropyLoss類用于計算交叉熵，定義類的物件時不用傳入任何引數，但在使用實體時需要輸入兩個滿足交叉熵的計算條件的引數，
import torch
from torch.autograd import Variable
loss_f = torch.nn.CrossEntropyLoss()
x = Variable(torch.randn(3,5))
y = Variable(torch.LongTensor(3).random_(5))#3個0-4的亂數字
loss = loss_f(x,y)
loss.data
#tensor(2.3413)
4.3.5 使用損失函式的神經網路
import torch
from torch.autograd import Variable
import torch
from torch.autograd import Variable
loss_fn = torch.nn.MSELoss()
x = Variable(torch.randn(100,100))
y = Variable(torch.randn(100,100))
loss = loss_fn(x,y)
batch_n = 100#一個批次輸入資料的數量
hidden_layer = 100
input_data = 1000#每個資料的特征為1000
output_data = 10
x = Variable(torch.randn(batch_n,input_data),requires_grad=False)
y = Variable(torch.randn(batch_n,output_data),requires_grad=False)
#用Variable對Tensor資料型別變數進行封裝的操作，requires_grad如果是F，表示該變數在進行自動梯度計算的程序中不會保留梯度值，
models = torch.nn.Sequential(
torch.nn.Linear(input_data,hidden_layer),
torch.nn.ReLU(),
torch.nn.Linear(hidden_layer,output_data)
)
#torch.nn.Sequential括號內就是我們搭建的神經網路模型的具體結構，Linear完成從隱藏層到輸出層的線性變換，再用ReLU激活函式激活
#torch.nn.Sequential類是torch.nn中的一種序列容器，通過在容器中嵌套各種實作神經網路模型的搭建，
#最主要的是，引數會按照我們定義好的序列自動傳遞下去，
for epoch in range(epoch_n):
y_pred = models(x)
loss = loss_fn(y_pred,y)
if epoch%1000 == 0:
print("epoch:{},loss:{:.4f}".format(epoch,loss.data))
models.zero_grad()
loss.backward()
for param in models.parameters():
param.data -= param.grad.data*lr
4.4 PyTorch 之 torch.optim
torch.optim包提供非常多的可實作引數自動優化的類，如SGD、AdaGrad、RMSProp、Adam等
使用自動優化的類實作神經網路：
import torch
from torch.autograd import Variable
batch_n = 100#一個批次輸入資料的數量
hidden_layer = 100
input_data = 1000#每個資料的特征為1000
output_data = 10
x = Variable(torch.randn(batch_n,input_data),requires_grad=False)
y = Variable(torch.randn(batch_n,output_data),requires_grad=False)
#用Variable對Tensor資料型別變數進行封裝的操作，requires_grad如果是F，表示該變數在進行自動梯度計算的程序中不會保留梯度值，
models = torch.nn.Sequential(
torch.nn.Linear(input_data,hidden_layer),
torch.nn.ReLU(),
torch.nn.Linear(hidden_layer,output_data)
)
#torch.nn.Sequential括號內就是我們搭建的神經網路模型的具體結構，Linear完成從隱藏層到輸出層的線性變換，再用ReLU激活函式激活
#torch.nn.Sequential類是torch.nn中的一種序列容器，通過在容器中嵌套各種實作神經網路模型的搭建，
#最主要的是，引數會按照我們定義好的序列自動傳遞下去，
# loss_fn = torch.nn.MSELoss()
# x = Variable(torch.randn(100,100))
# y = Variable(torch.randn(100,100))
# loss = loss_fn(x,y)
epoch_n=10000
lr=1e-4
loss_fn = torch.nn.MSELoss()
optimzer = torch.optim.Adam(models.parameters(),lr=lr)
#使用torch.optim.Adam類作為我們模型引數的優化函式，這里輸入的是：被優化的引數和學習率的初始值，
#因為我們需要優化的是模型中的全部引數，所以傳遞的引數是models.parameters()
#進行，模型訓練的代碼如下：
for epoch in range(epoch_n):
y_pred = models(x)
loss = loss_fn(y_pred,y)
print("Epoch:{},Loss:{:.4f}".format(epoch,loss.data))
optimzer.zero_grad()#將模型引數的梯度歸0
loss.backward()
optimzer.step()#使用計算得到的梯度值對各個節點的引數進行梯度更新，
五、搭建神經網路實作手寫資料集
5.1 torchvision
torchvision 是PyTorch中專門用來處理影像的庫，這個包中有四個大類，
torchvision.datasets
torchvision.models
torchvision.transforms
torchvision.utils
5.1.1 torchvision.datasets
torchvision.datasets可以實作對一些資料集的下載和加載如MNIST可以用torchvision.datasets.MNIST COCO、ImageNet、CIFCAR等都可用這個方法下載和載入，
這里用torchvision.datasets加載MNIST資料集：
data_train = datasets.MNIST(root="./data/",
transform=transform,
train = True,
download = True)
data_test = datasets.MNIST(root="./data/",
transform = transform,
train = False)
5.1.2 torchvision.models
torchvision.models 中為我們提供了已經訓練好的模型，讓我們可以加載之后，直接使用，
torchvision.models模塊的 子模塊中包含以下模型結構，如：
AlexNet
VGG
ResNet
SqueezeNet
DenseNet等
我們可以直接使用如下代碼來快速創建一個權重隨機初始化的模型：
import torchvision.models as models
resnet18 = models.resnet18()
alexnet = models.alexnet()
squeezenet = models.squeezenet1_0()
densenet = models.densenet_161()
也可以通過使用 pretrained=True 來加載一個別人預訓練好的模型:
import torchvision.models as models
resnet18 = models.resnet18(pretrained=True)
alexnet = models.alexnet(pretrained=True)
5.1.3 torch.transforms
torch.transforms中有大量資料變換類，如：
5.1.3.1 torchvision.transforms.Resize
用于對載入的圖片資料按照我們需求的大小進行縮放，傳遞的引數可以是一個整型資料，也可以是一個類似于(h,w)的序列，h代表高度，w代表寬度，如果輸入的是整型資料那么h和w都等于這個數，
5.1.3.2 torchvision.transforms.Scale
用于對載入的圖片資料按照我們需求的大小進行縮放，和Resize類似，
5.1.3.3 torchvision.transforms.CenterCrop
用于對載入的圖片以圖片中心為參考點，按照我們需要的大小進行裁剪，傳遞給這個類的引數可以是一個整型資料，也可以是一個類似于(h,w)的序列，
5.1.3.4 torchvision.transforms.RandomCrop
用于對載入的圖片按照我們需要的大小進行隨機裁剪，傳遞給這個類的引數可以是一個整型資料，也可以是一個類似于(h,w)的序列，
5.1.3.5 torchvision.transforms.RandomHorizontalFlip
用于對載入的圖片按隨機概率進行水平翻轉，我們通過傳遞給這個類的自定義隨機概率，如果沒有定義，則使用默認的概率為0.5
5.1.3.6 torchvision.transforms.RandomVerticalFlip
用于對載入的圖片按隨機概率進行垂直翻轉，我們通過傳遞給這個類的自定義隨機概率，如果沒有定義，則使用默認的概率為0.5
5.1.3.7 torchvision.transforms.ToTensor
用于對載入的圖片資料進行型別轉換，將之前構成PIL圖片資料轉換為Tensor資料型別的變數，讓PyTorch能夠對其進行計算和處理，
5.1.3.8 torchvision.transforms.ToPILImage:
用于對Tensor變數的資料轉換成PIL圖片資料，主要為方便圖片顯示，
這里使用transforms對MNIST資料集進行操作：
#torchvision.transforms: 常用的圖片變換，例如裁剪、旋轉等；
transform=transforms.Compose(
[transforms.ToTensor(),#將PILImage轉換為張量
transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))#將[0, 1]歸一化到[-1, 1]
#前面的（0.5，0.5，0.5） 是 R G B 三個通道上的均值， 后面(0.5, 0.5, 0.5)是三個通道的標準差
])
#上述代碼我們可以將transforms.Compose()看作一種容器，它能夠同時對多種資料變換進行組合，
#傳入的引數是一個串列，串列中的元素就是對載入資料進行的變換操作，
5.1.4 torch.utils
關于torchvision.utils我們介紹一種用來對資料進行裝載的類：torch.utils.data.DataLoader和
torch.utils.data.DataLoader類中， dataset引數指定我們載入的資料集的名稱，batch_size引數設定每個包中圖片的數量， shuffle設定為True代表在裝載的程序會將資料隨機打亂順序并進行打包，
data_loader_train=torch.utils.data.DataLoader(dataset=data_train,
batch_size=64,#每個batch載入的圖片數量，默認為1,這里設定為64
shuffle=True,
#num_workers=2#載入訓練資料所需的子任務數
)
data_loader_test=torch.utils.data.DataLoader(dataset=data_test,
batch_size=64,
shuffle=True)
#num_workers=2)
還有torchvision.utils.make_grid將一個批次的圖片構造成網格模式的圖片，
#預覽
#在嘗試過多次之后，發現錯誤并不是這一句引發的，而是因為圖片格式是灰度圖只有一個channel，需要變成RGB圖才可以，所以將其中一行做了修改：
images,labels = next(iter(data_loader_train))
# dataiter = iter(data_loader_train) #隨機從訓練資料中取一些資料
# images, labels = dataiter.next()
img = torchvision.utils.make_grid(images)
img = img.numpy().transpose(1,2,0)
std = [0.5,0.5,0.5]
mean = [0.5,0.5,0.5]
img = img*std+mean
print([labels[i] for i in range(64)])
plt.imshow(img)
這里，iter和next獲取一個批次的圖片資料和其對應的圖片標簽， 再使用torchvision.utils.make_grid將一個批次的圖片構造成網格模式 經過torchvision.utils.make_grid后圖片維度變為channel,h,w三維， 因為要用matplotlib將圖片顯示，我們要使用的資料要是陣列且維度為（height,weight,channel）即色彩通道在最后 因此我們需要用numpy和transpose完成原始資料型別的轉換和資料維度的交換，
5.2 模型搭建和引數優化
實作卷積神經網路模型搭建：
import math
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super(Model, self).__init__()
#構建卷積層之后的全連接層以及分類器
self.conv1 = nn.Sequential(
nn.Conv2d(3,64,kernel_size=3,stride=1,padding=1),
nn.ReLU(),
nn.Conv2d(64,128,kernel_size=3,stride=1,padding=1),
nn.ReLU(),
nn.MaxPool2d(stride=2,kernel_size=2)
)
self.dense = torch.nn.Sequential(
nn.Linear(14*14*128,1024),
nn.ReLU(),
nn.Dropout(p=0.5),
nn.Linear(1024,10)
)
def forward(self,x):
x=self.conv1(x)
x=x.view(-1,14*14*128)
x=self.dense(x)
return x
5.2.1 torch.nn.Conv2d
用于搭建卷積神經網路的卷積層，主要引數是：
輸入通道數、輸出通道數、卷積核大小、卷積核移動步長和paddingde值（用于對邊界像素的填充）
5.2.2 torch.nn.MaxPool2d
實作卷積姐神經網路的最大池化層，主要引數是：
池化視窗的大小，池化視窗移動步長和paddingde值
5.2.3 torch.nn.Dropout
用于防止卷積神經網路在訓練程序中發生過擬合，原理是以一定的隨機概率將卷積神經網路模型的部分引數歸零，以達到減少相鄰兩層神經連接的目的
5.3 引數優化
搭完模型后，我們就可以對模型進行訓練和引數優化了:
model = Model()
cost = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters())
print(model)
5.3.1 模型訓練
n_epochs = 5
for epoch in range(n_epochs):
running_loss = 0.0
running_correct = 0
print("Epoch {}/{}".format(epoch,n_epochs))
print("-"*10)
for data in data_loader_train:
X_train,y_train = data
X_train,y_train = Variable(X_train),Variable(y_train)
outputs = model(X_train)
_,pred=torch.max(outputs.data,1)
optimizer.zero_grad()
loss = cost(outputs,y_train)
loss.backward()
optimizer.step()
running_loss += loss.data
running_correct += torch.sum(pred == y_train.data)
testing_correct = 0
for data in data_loader_test:
X_test,y_test = data
X_test,y_test = Variable(X_test),Variable(y_test)
outputs = model(X_test)
_,pred=torch.max(outputs.data,1)
testing_correct += torch.sum(pred == y_test.data)
print("Loss is:{:4f},Train Accuracy is:{:.4f}%,Test Accuracy is:{:.4f}".format(running_loss/len(data_train),100*running_correct/len(data_train)
,100*testing_correct/len(data_test)))
5.4 模型驗證
為了驗證我們訓練的模型是不是真的已知結果顯示的一樣準確，則最好的方法就是隨機選取一部分測驗集中的圖片，用訓練好的模型進行預測，看看和真實值有多大的偏差，并對結果進行可視化，測驗代碼如下：
data_loader_test = torch.utils.data.DataLoader(dataset=data_test,
batch_size = 4,
shuffle = True)
X_test,y_test = next(iter(data_loader_test))
inputs = Variable(X_test)
pred = model(inputs)
_,pred = torch.max(pred,1)
print("Predict Label is:",[i for i in pred.data])
print("Real Label is:",[i for i in y_test])
img = torchvision.utils.make_grid(X_test)
img = img.numpy().transpose(1,2,0)
std = [0.5,0.5,0.5]
mean = [0.5,0.5,0.5]
img = img*std+mean
plt.imshow(img)
5.5 完整代碼
import torch
import torchvision
from torchvision import datasets,transforms
from torch.autograd import Variable
import numpy as np
import matplotlib.pyplot as plt
#torchvision.transforms: 常用的圖片變換，例如裁剪、旋轉等；
# transform=transforms.Compose(
# [transforms.ToTensor(),#將PILImage轉換為張量
# transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))#將[0, 1]歸一化到[-1, 1]
# #前面的（0.5，0.5，0.5） 是 R G B 三個通道上的均值， 后面(0.5, 0.5, 0.5)是三個通道的標準差
# ])
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Lambda(lambda x: x.repeat(3,1,1)),
transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))
]) # 修改的位置
data_train = datasets.MNIST(root="./data/",
transform=transform,
train = True,
download = True)
data_test = datasets.MNIST(root="./data/",
transform = transform,
train = False)
data_loader_train=torch.utils.data.DataLoader(dataset=data_train,
batch_size=64,#每個batch載入的圖片數量，默認為1,這里設定為64
shuffle=True,
#num_workers=2#載入訓練資料所需的子任務數
)
data_loader_test=torch.utils.data.DataLoader(dataset=data_test,
batch_size=64,
shuffle=True)
#num_workers=2)
#預覽
#在嘗試過多次之后，發現錯誤并不是這一句引發的，而是因為圖片格式是灰度圖只有一個channel，需要變成RGB圖才可以，所以將其中一行做了修改：
images,labels = next(iter(data_loader_train))
# dataiter = iter(data_loader_train) #隨機從訓練資料中取一些資料
# images, labels = dataiter.next()
img = torchvision.utils.make_grid(images)
img = img.numpy().transpose(1,2,0)
std = [0.5,0.5,0.5]
mean = [0.5,0.5,0.5]
img = img*std+mean
print([labels[i] for i in range(64)])
plt.imshow(img)
import math
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super(Model, self).__init__()
#構建卷積層之后的全連接層以及分類器
self.conv1 = nn.Sequential(
nn.Conv2d(3,64,kernel_size=3,stride=1,padding=1),
nn.ReLU(),
nn.Conv2d(64,128,kernel_size=3,stride=1,padding=1),
nn.ReLU(),
nn.MaxPool2d(stride=2,kernel_size=2)
)
self.dense = torch.nn.Sequential(
nn.Linear(14*14*128,1024),
nn.ReLU(),
nn.Dropout(p=0.5),
nn.Linear(1024,10)
)
def forward(self,x):
x=self.conv1(x)
x=x.view(-1,14*14*128)
x=self.dense(x)
return x
model = Model()
cost = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters())
print(model)
n_epochs = 5
for epoch in range(n_epochs):
running_loss = 0.0
running_correct = 0
print("Epoch {}/{}".format(epoch,n_epochs))
print("-"*10)
for data in data_loader_train:
X_train,y_train = data
X_train,y_train = Variable(X_train),Variable(y_train)
outputs = model(X_train)
_,pred=torch.max(outputs.data,1)
optimizer.zero_grad()
loss = cost(outputs,y_train)
loss.backward()
optimizer.step()
running_loss += loss.data
running_correct += torch.sum(pred == y_train.data)
testing_correct = 0
for data in data_loader_test:
X_test,y_test = data
X_test,y_test = Variable(X_test),Variable(y_test)
outputs = model(X_test)
_,pred=torch.max(outputs.data,1)
testing_correct += torch.sum(pred == y_test.data)
print("Loss is:{:4f},Train Accuracy is:{:.4f}%,Test Accuracy is:{:.4f}".format(running_loss/len(data_train),100*running_correct/len(data_train)
,100*testing_correct/len(data_test)))
data_loader_test = torch.utils.data.DataLoader(dataset=data_test,
batch_size = 4,
shuffle = True)
X_test,y_test = next(iter(data_loader_test))
inputs = Variable(X_test)
pred = model(inputs)
_,pred = torch.max(pred,1)
print("Predict Label is:",[i for i in pred.data])
print("Real Label is:",[i for i in y_test])
img = torchvision.utils.make_grid(X_test)
img = img.numpy().transpose(1,2,0)
std = [0.5,0.5,0.5]
mean = [0.5,0.5,0.5]
img = img*std+mean
plt.imshow(img)
六、結語
關于pytorch的一個學習總結，代碼檔案我也會上傳到github，期待大家和我交流，留言或者私信，一起學習，一起進步！
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/297750.html
標籤：AI
上一篇：HCNP Routing&Switching之OSPF LSA更新規則和路由匯總
下一篇：研一新生職務選擇建議