深度學習之入門Pytorch（1）------基礎

目錄：

1. Pytorch數據類型：Tensor與Storage

   • 創建張量
   • tensor與numpy數組之間的轉換
   • 索引、連接、切片等
   • Tensor操作【add，數學運算，轉置等】
   • GPU加速

2. 自動求導：torch.autograd

   • autograd
   • Variable

3. 讀取數據集:torch.utils.data

   • 抽象類：torch.utils.data.Dataset
   • 采用batch、shuffle或者多線程：torch.utils.data.DataLoader

4. 神經網絡的構建：nn.Module（模組）

   • 參數：torch.nn.Parameter()
   • 容器：基類、時序
   • 卷積層
   • 池化層
   • 標准化層
   • 循環層
   • 激活層：torch.nn.ReLU和torch.nn.functional.relu的效果一樣
   • Linear層
   • Dropout層
   • 稀疏層
   • 距離函數
   • 損失函數

5. 神經網絡的優化：torch.optim

   • 構建優化器
   • 設置單獨參數
   • 單步優化

6. 模型的保存和加載：torch.save

 

一、Pytorch數據類型

1、Tensor張量：torch.Tensor是一種包含單一數據類型元素的多維矩陣。

（1）創建張量------float型、long型、全0張量、隨機正態分布張量

• • float型和long型

 

• • 全0張量和正態分布

（2）Tensor和numpy之間的轉換：

通過a.numpy()，就能將Tensor a轉換成numpy數據類型，同時使用torch.from_numpy()就能將numpy轉換成tensor，如果需要更改tensor的數據類型，只需要在轉換后面加上需要的類型，如想將a的類型轉換成float，只需a.float()就可以了。

（3）Tensor的索引、切片、連接、換位：

• 連接：torch.cat(inputs, dimension=0) → Tensor【dimension=0按行連接】

>>> x = torch.randn(2, 3)
>>> x

 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
[torch.FloatTensor of size 2x3]

>>> torch.cat((x, x, x), 0)

 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
[torch.FloatTensor of size 6x3]

>>> torch.cat((x, x, x), 1)

 0.5983 -0.0341  2.4918  0.5983 -0.0341  2.4918  0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735  1.5981 -0.5265 -0.8735  1.5981 -0.5265 -0.8735
[torch.FloatTensor of size 2x9]

• 分塊：torch.chunk(tensor, chunks, dim=0)   【tensor (Tensor) 表示待分塊的輸入張量，chunks (int) 表示 分塊的個數，dim (int) 表示 沿着此維度進行分塊】
• 聚合：torch.gather(input, dim, index, out=None) → Tensor
• 切片：torch.index_select(input, dim, index, out=None) → Tensor 【input (Tensor) – 輸入張量，dim (int) – 索引的軸，index (LongTensor) – 包含索引下標的一維張量，out (Tensor, optional) – 目標張量】

>>> x = torch.randn(3, 4)
>>> x

 1.2045  2.4084  0.4001  1.1372
 0.5596  1.5677  0.6219 -0.7954
 1.3635 -1.2313 -0.5414 -1.8478
[torch.FloatTensor of size 3x4]

>>> indices = torch.LongTensor([0, 2])
>>> torch.index_select(x, 0, indices)

 1.2045  2.4084  0.4001  1.1372
 1.3635 -1.2313 -0.5414 -1.8478
[torch.FloatTensor of size 2x4]

>>> torch.index_select(x, 1, indices)

 1.2045  0.4001
 0.5596  0.6219
 1.3635 -0.5414
[torch.FloatTensor of size 3x2]

• 返回非零元素的索引：torch.nonzero
• 切分：torch.split
• 轉置：torch.transpose，torch.t【只轉置0，1維】
• 壓縮：torch.squeeze【將輸入張量形狀中的1 去除並返回。】

• 擴充：torch.unsqueeze()【對數據維度進行擴充，給指定位置加上維數為1的維度】

 

（4）Tensor操作：加法【+，add】，轉置，索引，數學運算，線性代數，隨機數等。

參考：https://pytorch-cn.readthedocs.io/zh/latest/

（5）GPU加速：

如果電腦支持GPU加速，可以Tensor放到GPU上。首先通過torch.cuda.is_available()判斷一下是否支持GPU，如果想把tensor a放到GPU上，只需a.cuda()就可將tensor a放到GPU上。

 

 

 2、Storage數據類型：torch.Storage

一個torch.Storage是一個單一數據類型的連續一維數組。

二、自動求導：torch.autograd

1、autograd包提供了自動求導的功能

在底層，每個原始 autograd 操作符實際上是在 Tensors 上操作的兩個函數。forward 函數從輸入張量來計算輸出張量。backward函數接收輸出向量關於某個標量的梯度，然后計算輸入張量關於關於同一個標量的梯度。

2、Variable（變量）：torch.autofrad.Variable

 變量和張量本質上沒有什么區別，不過變量會被放入計算圖中，進行前向傳播和后向傳播，自動求導。

 Variable 在 torch.autograd.Variable 中, 如果 a 是一個張量，使用 Variable(a) 可將其變為 Variable。

Variable 中有三個重要組成性質：data, grad, grad_fn. 通過 data 可以取出 Variable 中的 tensor 數值，grad_fn 得到這個 Variable 的操作.比如通過加減還是乘除得到的， grad 是 Variable 反向傳播的梯度.【通過以下代碼y.backward()實現】

 

三、讀取數據集：torch.utils.data

• Dataset是一個包裝類，用來將數據包裝為Dataset類，然后傳入DataLoader中，我們再使用DataLoader這個類來更加快捷的對數據進行操作。
• DataLoader是一個比較重要的類，它為我們提供的常用操作有：batch_size(每個batch的大小), shuffle(是否進行shuffle操作), num_workers(加載數據的時候使用幾個子進程)

1、抽象類：torch.utils.data.Dataset

可以自己定義數據類繼承和重寫這個抽象類，只需定義__len__和__getitem__這兩個函數。

from torch.utils.data import Dataset import pandas as pd class 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, 't') as f: data_list = f.readlines() self.txt_data = data_list self.root_dir = root_dir def __len__(self): return len(self.csv_data) def __getitem__(self, idx): data = (self.csv_data[idx], self.txt_data[idx]) return data

2、采用batch、shuffle或者多線程：torch.utils.data.DataLoader

采用torch.utils.data.DataLoader定義一個新的迭代器，collate_fn表示如何取樣本

dataiter = DataLoader(myDataset, batch_size=2, shuffle=True, collate_fn=default_collate) 

torchvision類中的ImageFolder是讀取圖片的類。

 

四、神經網絡的構建：nn.Module（模組）

激勵函數的選擇，如果層數較少的神經網絡，激勵函數有多種選擇，在圖像卷積神經網絡中，激勵函數選擇ReLu，在循環神經網絡中，選擇ReL或者Tanh。

所有的層結構和損失函數都來自於torch.nn，所有的模型構建都是從這個基類nn.Module繼承的。

 1、參數：torch.nn.Parameter()

Variable的一種，常被用於模塊參數(module parameter)。

2、容器：

• 所有網絡的基類：torch.nn.Module

• 時序容器：torch.nn.Sequential(* args)

3、卷積層：

• torch.nn.Conv1d：一維卷積層
• torch.nn.Conv2d：二維卷積層
• torch.nn.Conv3d：三維卷積層
• torch.nn.ConvTranspose1d：一維解卷積操作
• torch.nn.ConvTranspose2d：二維解卷積操作
• torch.nn.ConvTranspose3d：三維解卷積操作

4、池化層：

• torch.nn.MaxPool1d：1維最大池化
• torch.nn.MaxPool2d：2維最大池化
• torch.nn.MaxPool3d：3維最大池化
• torch.nn.MaxUnpool1d：MaxPool1d的逆過程
• torch.nn.MaxUnpool2d：MaxPool2d的逆過程
• torch.nn.MaxUnpool3d：MaxPool3d的逆過程
• torch.nn.AvgPool1d、torch.nn.AvgPool2d、torch.nn.AvgPool3d：均值池化

5、激活層：

• torch.nn.ReLU

>>> m = nn.ReLU()
>>> input = autograd.Variable(torch.randn(2))
>>> print(input)
>>> print(m(input))

• torch.nn.Sigmoid
• torch.nn.Tanh
• torch.nn.Softmax

6、標准化層：

• torch.nn.BatchNorm1d、torch.nn.BatchNorm2d、torch.nn.BatchNorm3d

7、循環層：

• torch.nn.RNN：多層RNN

rnn = nn.RNN(10, 20, 2)
input = Variable(torch.randn(5, 3, 10))
h0 = Variable(torch.randn(2, 3, 20))  #初始狀態
output, hn = rnn(input, h0)

• torch.nn.LSTM：多層LSTM

lstm = nn.LSTM(10, 20, 2)
input = Variable(torch.randn(5, 3, 10))
h0 = Variable(torch.randn(2, 3, 20))  #初始化狀態
c0 = Variable(torch.randn(2, 3, 20))  #初始化細胞狀態
output, hn = lstm(input, (h0, c0))

• torch.nn.GRU：多層GRU

 rnn = nn.GRU(10, 20, 2)
 input = Variable(torch.randn(5, 3, 10))
 h0 = Variable(torch.randn(2, 3, 20))
 output, hn = rnn(input, h0)

• torch.nn.RNNCell、torch.nn.LSTMCell、torch.nn.GRUCell：一個RNN、LSTM、GRU單元

8、Linear層：回歸

• torch.nn.Linear(in_features, out_features, bias=True)

>>> m = nn.Linear(20, 30)
>>> input = autograd.Variable(torch.randn(128, 20))
>>> output = m(input)
>>> print(output.size())

9、Dropout 層：

• torch.nn.Dropout(p=0.5, inplace=False)
  

>>> m = nn.Dropout(p=0.2)
>>> input = autograd.Variable(torch.randn(20, 16))
>>> output = m(input)

• torch.nn.Dropout2d(p=0.5, inplace=False)：通常輸入是conv2d模塊。
  
• torch.nn.Dropout3d(p=0.5, inplace=False)

10、稀疏層：一個保存了固定字典和大小的簡單查找表。

• torch.nn.Embedding

11、距離函數：

• torch.nn.PairwiseDistance(p=2, eps=1e-06)：批計算向量v1, v2之間的距離：

>>> pdist = nn.PairwiseDistance(2)
>>> input1 = autograd.Variable(torch.randn(100, 128))
>>> input2 = autograd.Variable(torch.randn(100, 128))
>>> output = pdist(input1, input2)

12、損失函數：

• torch.nn.L1Loss：衡量輸入x(模型預測輸出)和目標y之間差的絕對值的平均值的標准。
• torch.nn.MSELoss：創建一個衡量輸入x(模型預測輸出)和目標y之間均方誤差標准。
• torch.nn.CrossEntropyLoss：此標准將LogSoftMax和NLLLoss集成到一個類中。
• torch.nn.HingeEmbeddingLoss：這個loss通常用來測量兩個輸入是否相似
• torch.nn.MultiLabelMarginLoss：計算多標簽分類的 hinge loss(margin-based loss) ，計算loss時需要兩個輸入

 定義完模型, 來定義損失函數, 常見的損失函數都定義在 nn 中.比如均方誤差、多分類的交叉熵以及二分類的交叉熵等， 這樣我們就能求得輸出和真是目標之間的損失函數.如：

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

五、神經網絡的優化：torch.optim

為了使用torch.optim，你需要構建一個optimizer對象。這個對象能夠保持當前參數狀態並基於計算得到的梯度進行參數更新。

1、構建optimizer：

• torch.optim.SGD

需要給它一個包含了需要優化的參數（必須都是Variable對象）的iterable。然后，你可以設置optimizer的參 數選項，比如學習率，權重衰減，等等。

optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9) 

以上學習率為0.01，動量是0.9的隨機梯度下降，在優化之前需要先將梯度歸零，即optimizer.zeros()，然后通過loss.backward()反向傳播，自動求導得到每個參數的梯度，最后只需要optimizer.step()就可以通過梯度做一步參數更新。

2、為每個參數單獨設置選項

Optimizer也支持為每個參數單獨設置選項。若想這么做，不要直接傳入Variable的iterable，而是傳入dict的iterable。每一個dict都分別定 義了一組參數，並且包含一個param鍵，這個鍵對應參數的列表。其他的鍵應該optimizer所接受的其他參數的關鍵字相匹配，並且會被用於對這組參數的 優化。

當我們想指定每一層的學習率時，這是非常有用的：

optim.SGD([
                {'params': model.base.parameters()},
                {'params': model.classifier.parameters(), 'lr': 1e-3}
            ], lr=1e-2, momentum=0.9)

這意味着model.base的參數將會使用1e-2的學習率，model.classifier的參數將會使用1e-3的學習率，並且0.9的momentum將會被用於所 有的參數。

3、進行單次優化

所有的optimizer都實現了step()方法，這個方法會更新所有的參數。它能按兩種方式來使用：

• optimizer.step()：一旦梯度被如backward()之類的函數計算好后，我們就可以調用這個函數。例如：

for input, target in dataset:
    optimizer.zero_grad()
    output = model(input)
    loss = loss_fn(output, target)
    loss.backward()
    optimizer.step()

• optimizer.step(closure)：一些優化算法例如Conjugate Gradient和LBFGS需要重復多次計算函數，因此你需要傳入一個閉包去允許它們重新計算你的模型。這個閉包應當清空梯度， 計算損失，然后返回。

for input, target in dataset:
    def closure():
        optimizer.zero_grad()
        output = model(input)
        loss = loss_fn(output, target)
        loss.backward()
        return loss
    optimizer.step(closure)

 

六、模型的保存和加載：

• 在 Pytorch 中使用 torch.save 來保存模型的結構和參數,有兩種方式

          1. 保存整個模型的結構信息和參數信息, 保存的對象是模型 model ，可以是pth方式，也可以是pkl的方式。即取名為my_model.pkl名稱。
          2. 保存模型的參數, 保存的對象是模型的狀態 model.state_dict()
       save 的第一個參數是保存的對象, 第二個是保存的路徑及名稱

torch.save(model, './model.pth') # 方式1 torch.save(model.state_dict(), './model_state.pth') # 方式2

   

• 加載模型對應兩種保存方式也有兩種

          1. 加載完整的模型結構和參數信息, 使用 load_model = torch.load(‘model.pth’) 在網絡較大的時候記載時間教程, 存儲空間較大
          2. 加載模型參數信息, 需要先導入模型的結構, 然后通過 model.load_state_dict(torch.load(‘model_state.pth’)) 來導入.

 

 

參考：https://blog.csdn.net/broken_promise/article/details/81174760