Pytorch 入門筆記

• 1. Pytorch下載與安裝
• 2. Pytorch的使用教程
• • 2.1 Pytorch設計理念及其基本操作
  • 2.2 使用torch.nn搭建神經(jīng)網(wǎng)絡
  • 2.3 創(chuàng)建屬于自己的Dataset和DataLoader
  • • 2.3.1 編寫Dataset類
    • 2.3.2 編寫Transform類
    • 2.3.3 將Transform融合到Dataset中去
    • 2.3.4 編寫DataLoader類
  • 2.4 使用Tensorboard來可視化訓練過程
  • • 2.4.1 Images可視化
    • 2.4.2 Graph可視化
    • 2.4.3 訓練中的Loss，Accuracy可視化
  • 2.5 Pytorch實現(xiàn)DQN算法
  • 2.6 Pytorch實現(xiàn)Policy Gradient算法

1. Pytorch下載與安裝

在Pytorch官網(wǎng)進行官方提供的下載方法：Pytorch官網(wǎng)，打開官網(wǎng)后選擇對應的操作系統(tǒng)和cuda版本。如果需要安裝GPU版本的Pytorch則需要下載對應CUDA版本的Torch版本，例如我裝的是CUDA 10.1，Python版本是3.7。

查看已安裝CUDA、cuDNN版本的方法：
Windows:
訪問文件夾 C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA 看該目錄下文件夾名稱，如果是v10.0則代表10.0版本的CUDA；
訪問C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v9.0\include\cudnn.h來查看cuDNN的版本。
Linux:
使用命令 cat /usr/local/cuda/version.txt 查看cuda版本；
使用命令 cat /usr/local/cuda/include/cudnn.h | grep CUDNN_MAJOR -A 2 查看cuDNN版本。

如果沒有安裝cuda和cuDNN，則需要先安裝這兩樣東西，再裝Pytorch。先安裝cuda，進入cuda官網(wǎng)，根據(jù)自己的操作系統(tǒng)選擇對應版本（version 一欄代表的是你Windows的操作系統(tǒng)版本）：

下載exe（local）安裝程序，之后一路選擇默認安裝路徑就好了。安裝完成后再cmd窗口內輸入：nvcc -V，若看到以下信息證明cuda安裝成功：

cuda安裝好了之后下載對應的cnDNN，進入cuDNN安裝鏈接，這里需要先注冊一個Nvidia的賬號并登錄才能進行下一步，登錄后看到以下網(wǎng)址：

根據(jù)安裝的cuda版本選擇對應的cuDNN的版本即可，比如我們演示的是cuda 10.2版本，這里就選擇對應的7.6.5版本的cuDNN就好。下載好后是個壓縮文件，解壓后得到3個文件夾：bin，include，x64，將這三個文件下的內容分別拷貝到安裝的cuda目錄對應的bin，include，x64文件夾下即可，cuda的默認安裝路徑如下：

完成了cuda和cuDNN的安裝后，我們就可以回到Pytorch的安裝中去了，看文章最開始的那張圖，找到對應的版本后，復制圖片最下方的pip命令在cmd窗口執(zhí)行即可開始進行安裝：
pip install torch===1.3.1 torchvision===0.4.2 -f https://download.pytorch.org/whl/torch_stable.html -i https://pypi.tuna.tsinghua.edu.cn/simple
這里使用了清華源來加速下載，等待一段時間后，Pytorch就安裝完畢了。

2. Pytorch的使用教程

2.1 Pytorch設計理念及其基本操作

Pytorch在設計的時候最大的亮點是在于，其可以替代Numpy庫，numpy庫中的array運算是依賴于將數(shù)組編譯成機器碼再到CPU運行進行加速的。而Torch是將array（在Pytorch里面叫Tensor）變成GPU上的變量進行運算的，因此在進行大規(guī)模運算是Torch能更快速。

• Tensor的運算

Tensor的定義和運算都和np.array()差不多，很多操作都是一樣的，下面是一些基本操作的介紹：

import torch""" 創(chuàng)建 Tensor 的方法 """ x = torch.tensor([3, 3]) # 創(chuàng)建一個值為[3, 3]的Tensor x = torch.empty(5, 3) # 5x3空矩陣 x = torch.ones(3, 3) # 值全為1的3x3矩陣 y = torch.randn_like(x, dtype=torch.long) # 創(chuàng)建一個和x一樣shape的隨機矩陣，并將每一個數(shù)字dtype變成long""" Tensor 的屬性 """ print(x.size()) # 相當于np.array中的.shape屬性，x.size()本質是一個tuple，可以使用tuple的全部屬性""" Resize Tensor """ x = torch.tensor([[1, 2], [3, 4]]) y = x.view(-1, 4) # y = ([1, 2, 3, 4]), 和np.reshape()是一樣的""" Tensor 和 Numpy 的互相轉換 """ x_np = np.arrary([1, 1]) x_tensor = torch.from_numpy(x_np) # 從numpy轉換到tensor x_np_2 = x_tensor.numpy() # 從tensor轉換到numpy""" CPU 到 GPU 的轉換 """ if torch.cuda.is_available():device = torch.device("cuda")x = torch.ones(5, 3)x_dev = x.to(device) # CPU tensor 轉 GPU tensorx_host= x_dev.to("cpu", torch.doule) # GPU tensor 轉 CPU tensor

• 自動求導機制

torch.Tensor這個對象擁有自動求導的功能，每個Tensor在被計算的時候都會自動記錄這些運算過程，在最后計算梯度的時候就能夠追蹤的這些計算過程快速的進行梯度計算。如果要打開計算追蹤這個功能需要將Tensor.requires_grad這個屬性設置為True（默認是False的），當該追蹤計算功能打開后，只需要調用.backward()就能夠進行自動的梯度求導了。
在我們訓練的時候通常會為Tenosor打開.requires_grad屬性，但在訓練好一個模型后，我們在使用這個模型的時候，這時候我們就不需要計算梯度了（因為不會再做反向傳播了），這時候我們就可以關閉.requires_grad這個屬性來減少運算時間。使用with torch.no_grad():來關閉Tensor的計算追蹤功能：

with torch.no_grad(): # 整個過程中x, y, z三個tensor均不會開啟計算追蹤torch.add(x, y, out=z) # 將tensor x和tensor y相加后放入到tensor z中

2.2 使用torch.nn搭建神經(jīng)網(wǎng)絡

在Pytorch中，搭建一個神經(jīng)網(wǎng)絡需要自己寫一個類，該類需要繼承自torch.nn.Module類，nn.Module主要包含以下兩個特點：

nn.Module類中已經(jīng)預先定義好了多種類型的Layer（例如：Conv2D，Linear等），使用時直接調用即可。

nn.Module中包含一個forward(input)方法，該方法接收一個input輸入，并return一個output值，通常這個forward()方法都需要用戶自己來實現(xiàn)，構建從輸入到輸出的網(wǎng)絡結構。

通常訓練一個網(wǎng)絡模型的流程如下：

首先定義所有的網(wǎng)絡架構，模型一共有幾層，每一層的類型是什么（Convolution？Linear？），可學習的參數(shù)有哪些（weight + bias）。

遍歷所有的數(shù)據(jù)集，輸入一個 input，通過 forward() 過程計算得到一個 output。

比較 output 和 label 的值，計算出 loss。

根據(jù)梯度和 Loss 計算網(wǎng)絡模型中所有可學習參數(shù)的梯度信息。

進行參數(shù)更新， 更新公式通常為：weight = weight - learning_rate * gradient

我們使用 torch.nn 來搭建一個卷積神經(jīng)網(wǎng)絡用于識別 32*32 的單通道灰度圖。首先，我們先來理一下整個網(wǎng)絡的結構：

1. Convolutional2D Shape Change
$I_w$代表輸入圖層的width，$O_w$代表經(jīng)過Conv2D層后圖層的width，$F_w$代表卷積核Filter的width，$S_w$代表在width上橫跨的步長，$P_w$代表在width方向上的padding值，則有以下公式（Height方向上同理）：$$O_w=\frac{I_w?F_w+2P_w}{S_w}+1$$
2. Maxpooling Shape Change
$I_w$代表輸入圖層的width，$O_w$代表經(jīng)過Maxpooling2D層后圖層的width，$M_w$代表池化層的width，$S_w$代表在width上橫跨的步長（通常是等于池化層的寬度的），則有以下公式（Height方向上同理）：$$O_w=\frac{I_w?M_w}{S_w}+1$$

因此，整個網(wǎng)絡架構如下：

根據(jù)上述網(wǎng)絡設計編寫代碼，搭建一個神經(jīng)網(wǎng)絡需要編寫：

自己寫一個類 net（名字自取）繼承自torch.nn.Module()

利用 torch.nn 中的 Layers 構建自己的Layer

實現(xiàn) net 類中的 forward() 方法

以下是代碼實現(xiàn)：

import torch import torch.nn as nn import torch.nn.functional as Fclass Net(nn.Module):def __init__(self):super(Net, self).__init__()self.Conv1 = nn.Conv2d(1, 6, 3) # params (input_channal_num, out_channal_num, filter_size)self.Conv2 = nn.Conv2d(6, 16, 3)self.fc1 = nn.Linear(6*6*16, 120)self.fc2 = nn.Linear(120, 80)self.fc3 = nn.Linear(80, 10) # predict 10 classesdef forward(self, x):x = F.max_pool2d(F.relu(self.Conv1(x)), 2)x = F.max_pool2d(F.relu(self.Conv2(x)), 2)x = x.view(-1, self.get_flatten_num(x))x = F.relu(self.fc1(x))x = F.relu(self.fc2(x))x = F.relu(self.fc3(x))return xdef get_flatten_num(x):features_num = x[1:] # drop out the batch size (which is x[0])flatten_num = 1for feature_num in features_num:flatten_num *= feature_numreturn flatten_numnet = Net() print(net)

這樣我們就定義好了一個神經(jīng)網(wǎng)絡，打印一下這個神經(jīng)網(wǎng)絡可以看到：

這樣一來，整個前向傳播就寫完了，現(xiàn)在我們來寫反向傳播的過程，首先我們需要計算 Loss 再反向梯度傳播，下圖是一個簡單的反向傳播示意圖：

Input 層有兩個神經(jīng)元，hidden layer 也有兩個神經(jīng)元，最終 output 層有兩個神經(jīng)元。target 代表 Label 數(shù)據(jù)。假設我們網(wǎng)絡內不存再bias，只有 weight 是需要學習的，那么我們需要根據(jù) target 和神經(jīng)網(wǎng)絡的 output 之間的誤差值（Loss）來修改 weight 值，以達到學習的效果。在這里我們以$w_5$這個學習參數(shù)為例，通過反向鏈式求導來計算它的梯度：Loss 是指兩個 output 值與 target 之間的 MSE Error。對$w_5$進行反向求導，由于從$h_1$到$o1$是先經(jīng)過$Linear$層（FC層）再經(jīng)過一個$sigmoid$層，再輸出到$o_1$的。因此從$o_1$到$h_1$的反向求導需要先對$sigmoid$這個計算過程求導，再對$Linear$計算過程求導，這就是為什么上圖中會先對$O{s}_1$求導，再對$O_1$求導。

我們計算隨機生成一個 target 讓其與我們的 output 進行 Loss 計算：

net.zero_grad() # 先清空網(wǎng)絡中的梯度變量中的值target = torch.rand(1, 10) # 隨機生成target標簽 criterion = nn.MSELoss() loss = criterion(target, out) # 計算loss值 loss.backward() # 反向求導函數(shù)

這時，我們已經(jīng)計算出所有的梯度了，現(xiàn)在需要我們去 update 這些 weights 的值，最簡單的更新的方式是使用 SGD 的方法，即 $weight=weight?gradient?learnin{g}_{r}ate$，除此之外還有 Adam，RMSProp等等，Pytorch 將這些更新的算法稱作“優(yōu)化器”（optimizer）封裝在了函數(shù)里，我們只需要調用就可以了：

import torch.optim as optimoptimizer = optim.SGD(net.parameters(), lr=0.01)# 每一輪訓練的時候 optimizer.zero_grad() # 一定要記得清空優(yōu)化器中的上一輪梯度信息 output = net(input) loss = criterion(output, target) loss.backward() optimizer.step() # 更新梯度信息

至此我們已經(jīng)完成了 Pytorch 的安裝并使用 torch 搭建了一個前向神經(jīng)網(wǎng)絡以及反向傳播的全過程。

2.3 創(chuàng)建屬于自己的Dataset和DataLoader

現(xiàn)在我們已經(jīng)成功搭建了一個CNN網(wǎng)絡了，問題是我們的CNN網(wǎng)絡只能接收數(shù)字類型的 Input，而我們往往數(shù)據(jù)集都是圖片類型的，因此為了將圖片數(shù)據(jù)轉換為神經(jīng)網(wǎng)絡能夠接收的數(shù)字類型，我們需要寫 Dataset 類和 DataLoader 類，這兩個類的作用分別為：

Dataset 類的作用
Dataset 用于讀取對應路徑的數(shù)據(jù)集（比如說某個特定文件夾下的圖片）并轉換成神經(jīng)網(wǎng)絡能夠接收的數(shù)據(jù)類型，舉例來說，我們要用人臉識別數(shù)據(jù)集做訓練，那么我們就需要編寫一個 FaceDataset() 來把人臉的圖片轉換向量數(shù)據(jù)。

DataLoader 類的作用
往往在我們訓練神經(jīng)網(wǎng)絡時都會使用到 mini-batch 的方法，一次讀取多個樣本而不是只讀一個樣本，那么如何從數(shù)據(jù)集中去采樣一個batch的數(shù)據(jù)樣本就是 DataLoader 要實現(xiàn)的功能了。

我們使用 Face Landmark 的數(shù)據(jù)集來舉例，下載一個 Landmark 數(shù)據(jù)集，這個數(shù)據(jù)集中包含【人臉圖片】和【Landmark】兩個數(shù)據(jù)，Landmark 是指人臉上的68個特征點（不清楚的可以查查dlib這個庫）。如下圖所示：

Landmark 就是指紅色的68個點，在數(shù)據(jù)集中存放的是這68個點的（x，y）坐標。

2.3.1 編寫Dataset類

我們現(xiàn)在來寫一個 FaceLandmarksDataset() 類用于讀取數(shù)據(jù)中的【人臉圖片】和【Landmark】信息，對于 FaceLandmarksDataset() 這個類我們繼承自 torch 的 Dataset 類，并且實現(xiàn)三個方法：__init__, __len__, __getitem__。

• __len__ 方法用于返回這個 Dataset 的數(shù)據(jù)集長度共有多少個。
• __getitem__ 可以讓你在調用 dataset[i] 的時候直接調用這個方法，非常方便。

import os import torch import pandas as pd from skimage import io, transform import numpy as np import matplotlib.pyplot as plt from torch.utils.data import Dataset, DataLoader from torchvision import transforms, utils# Create a Dataset Class to transform the image data to array dataclass FaceLandmarksDataset(Dataset):def __init__(self, root, transform=None):self.root = root # root 是指你存放數(shù)據(jù)集的路徑self.transform = transform # transform 是數(shù)據(jù)預處理的方法，后面會講，這里先跳過data = pd.read_csv(os.path.join(root, "face_landmarks.csv"))self.image_names = data.iloc[:, 0].as_matrix() # 數(shù)據(jù)集的第一列是圖片的名字self.land_marks = data.iloc[:, 1:].as_matrix() # 數(shù)據(jù)集的后面列全是landmarksdef __len__(self):return len(self.image_names)def __getitem__(self, idx):assert isinstance(idx, int), "Idx must be int."land_marks = self.land_marks[idx, :].reshape(-1, 2)image_name = self.image_names[idx]image = io.imread(os.path.join(self.root, image_name))sample = {"image": image, "landmarks": land_marks} # 定義sample的數(shù)據(jù)結構是個字典{人臉圖片（np.array），landmarks（np.array）}if self.transform:sample = self.transform(sample)return sample

這樣我們就寫好了一個讀取自己數(shù)據(jù)集的 Dataset 類，現(xiàn)在來嘗試使用這個類：

def show_landmarks(sample, ax):print(sample["image"].shape)ax.imshow(sample["image"])ax.scatter(sample["landmarks"][:, 0], sample["landmarks"][:, 1])face_dataset = FaceLandmarksDataset("./faces") # 實例化 for i in range(5):sample = face_dataset[i] # 這里會調用類中的 __getitem__()方法ax = plt.subplot(1, 5, i+1)ax.set_title("Sample #" + str(i+1))show_landmarks(sample, ax)plt.show()

結果如下所示，畫出了五張人臉以及他們對應的 landmark 點：

2.3.2 編寫Transform類

為什么會有 Transform 類？這是因為在很多時候我們并不是把原圖傳入神經(jīng)網(wǎng)絡，在輸入數(shù)據(jù)之前會對原數(shù)據(jù)進行一些列的預處理（preprocessing），例如：數(shù)據(jù)集中的圖片不會全部都是相同尺寸的，但大多神經(jīng)網(wǎng)絡都需要輸入圖片的尺寸是固定的，因此我們需要對數(shù)據(jù)集中的做預處理，resize 或是 crop 以保證輸入數(shù)據(jù)的尺寸是符合神經(jīng)網(wǎng)絡要求的。Transform 類就是用于做數(shù)據(jù)預處理而設計的類，我們一共設計三個類來組成 Transform 類：Rescale()， RandomCrop()，ToTensor()：

• Rescale類：這個類用于對圖片進行 resize。
• RandomCrop類：這個用于對圖片進行裁剪，且是任意位置隨機裁剪。
• ToTensor類：這個類用于將 np 數(shù)組格式轉換成 torch 中 tensor 的格式，圖片的 np 數(shù)組是 [height, width, channel]，而 torch 中圖片的 tensor 格式是 [channel, height, width]。

這些類中都要實現(xiàn) __call__ 方法，call 方法可以使得這些類在被實例化的時候就調用 __call__ 函數(shù)下的方法。

class Rescale(object):def __init__(self, output_size):assert isinstance(output_size, (list, tuple)), "output size must be tuple or list."self.output_size = output_sizedef __call__(self, sample):image, land_marks = sample["image"], sample["landmarks"]h, w = image.shape[:2]new_h, new_w = self.output_sizeimg = transform.resize(image, (int(new_w), int(new_h)))land_marks = land_marks * [new_w / w, new_h / h]return {'image': img, "landmarks": land_marks}class RandomCrop(object):def __init__(self, output_size):assert isinstance(output_size, (int, tuple)), "output size must be int or tuple."if isinstance(output_size, int):self.output_size = [output_size, output_size]else:assert len(output_size) == 2, "output size tuple's length must be 2."self.output_size = output_sizedef __call__(self, sample):image, land_marks = sample["image"], sample["landmarks"]h, w = image.shape[:2]crop_h, crop_w = self.output_sizetop = np.random.randint(0, h - crop_h)left = np.random.randint(0, w - crop_w)image = image[top:top+crop_h, left:left+crop_w]land_marks -= [left, top]return {"image":image, "landmarks":land_marks}class ToTensor(object):def __call__(self, sample):image, land_marks = sample["image"], sample["landmarks"]image = image.transpose((2, 0, 1))return {"image":image, "landmarks":land_marks}

這樣我們就實現(xiàn)好了這三個功能的類，接下來我們將這三個方法合成一個方法，可以依次按順序對一個 sample 做這三個操作。通過 torchvision.transforms() 來融合這三個方法。

scale = Rescale((256, 256)) # 單實現(xiàn) Resacle 處理 random_crop = RandomCrop(128) # 單實現(xiàn) RandomCrop 處理 compose = transforms.Compose([Rescale((256, 256)), RandomCrop(224)]) # 對一個sample先Rescale再RandomCropsample = face_dataset[66]for i, tsfm in enumerate([scale, random_crop, compose]): # 同時展示Rescale、RandomCrop和先Resacle再RandomCrop的效果transformed_data = tsfm(sample)ax = plt.subplot(1, 3, i+1)ax.set_title(type(tsfm).__name__)show_landmarks(transformed_data, ax) plt.show()

效果如下，Compose 是指結合了前兩種方法，先 resize 后再隨機 Crop 后的樣子：

2.3.3 將Transform融合到Dataset中去

前面提到，Transform 的作用是做數(shù)據(jù)預處理的，因此我們期望每次從 Dataset 中讀取數(shù)據(jù)的時候，這些數(shù)據(jù)都被預處理一次，因此我們可以把 Transform 融合到 Dataset 中去，還記得我們在寫 Dataset 的時候有留一個參數(shù) transform 嗎？我們現(xiàn)在可以傳進去就好了：

transformed_dataset = FaceLandmarksDataset(root='./faces',transform=transforms.Compose([Rescale((256, 256)),RandomCrop(224), ToTensor()]))

這樣我們就寫好了一個帶有 Transform 的 Dataset 了。

2.3.4 編寫DataLoader類

在有了 Dataset 類后，我們就可以開始編寫 DataLoader 類了，Dataloader 主要是從Dataset 中去 sample 一個batch 的數(shù)據(jù)。我們可以直接使用 Pytorch 提供的 Dataloader 類：

dl = torch.utils.data.DataLoader(transformed_dataset, batch_size=4, shuffle=True, num_workers=4) # windows下num_workers參數(shù)要等于0，不然會報錯

這樣就可以從我們的 Dataset 中取一個batch 的數(shù)據(jù)了，下面我們來看看怎么用 dataloader 取出 batch data：

def show_landmark_batch(sample_batch):images_batch, landmarks_batch = sample_batch["image"], sample_batch["landmarks"]batch_size = len(images_batch)im_size = images_batch.size(2)grid = utils.make_grid(images_batch)plt.imshow(grid.numpy().transpose(1, 2, 0))grid_border_size = 2for i in range(batch_size):plt.scatter(landmarks_batch[i, :, 0].numpy() + i * im_size + (i + 1) * grid_border_size, landmarks_batch[i, :, 1].numpy() + grid_border_size, s=10)plt.title("Batched Samples")for i_batch, sample_batch in enumerate(dl): # dataloader是一個迭代器，迭代一次取出一個batch的sampleif i_batch == 0:show_landmark_batch(sample_batch)plt.show()

可視化結果如下：

2.4 使用Tensorboard來可視化訓練過程

Tensorboard 無疑是一個非常好用且直觀的神經(jīng)網(wǎng)絡訓練可視化利器，Pytorch 中也集成了使用 Tensorboard 方法，建立一個SummaryWriter() 類即可完成各種類型的可視化，下面我們就一起嘗試使用 Tensorboard 來做可視化。

2.4.1 Images可視化

有時候我們拿到的只是圖片信息的向量信息（例如MNIST數(shù)據(jù)集），我們想查看這些圖片到底長什么樣，這時候我們可以往 Tensorboard 中添加圖片數(shù)據(jù)信息來可視化這些圖片，首先我們先建立一個 writer 對象。

from torch.utils.tensorboard SummaryWriter writer = SummaryWriter("run/experience_1") # 將log信息都保存在run/experience_1的目錄下

這樣我們就建立好了一個 writer 對象，之后的所有操作都通過 writer 對象來完成。

import matplotlib.pyplot as plt import numpy as np import torch import torchvision import torchvision.transforms as transforms import torch.nn as nn import torch.nn.functional as F import torch.optim as optimtransform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))]) trainset = torchvision.datasets.FashionMNIST('./data', download=True, train=True, transform=transform) # 加載數(shù)據(jù)集 testset = torchvision.datasets.FashionMNIST('./data', download=True, train=False, transform=transform) # 加載數(shù)據(jù)集 trainloader = torch.utils.data.DataLoader(trainset, batch_size=4, shuffle=True) testloader = torch.utils.data.DataLoader(testset, batch_size=4, shuffle=True)classes = ('T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat','Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle Boot')dataiter = iter(trainloader) images, labels = dataiter.next() img_grid = torchvision.utils.make_grid(images) # 獲取一個batch的數(shù)據(jù)并將4張圖片合并成一張圖片writer.add_image("four_fashion_samples", img_grid) # 將圖片數(shù)據(jù)添加到 Tensorboard->（圖片名稱，圖片數(shù)據(jù)）

這時候我們前往“run”文件夾存放的目錄，在終端中輸入tensorboard --logdir=run來開啟Tensorboard：

打開后如下所示，可以看到在 Images 這一欄已經(jīng)顯示了我們剛才添加進去的圖片信息：

2.4.2 Graph可視化

如果我們想更清楚的看到我們建立的神經(jīng)網(wǎng)絡模型長什么樣，我們可以使用writer.add_graph()方法來將模型添加入 Tensorboard：

class Net(nn.Module):def __init__(self):super(Net, self).__init__()self.conv1 = nn.Conv2d(1, 6, 5)self.pool = nn.MaxPool2d(2, 2)self.conv2 = nn.Conv2d(6, 16, 5)self.fc1 = nn.Linear(16 * 4 * 4, 120)self.fc2 = nn.Linear(120, 84)self.fc3 = nn.Linear(84, 10)def forward(self, x):x = self.pool(F.relu(self.conv1(x)))x = self.pool(F.relu(self.conv2(x)))x = x.view(-1, 16 * 4 * 4)x = F.relu(self.fc1(x))x = F.relu(self.fc2(x))x = self.fc3(x)return xnet = Net() # 實例化CNN網(wǎng)絡 criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) writer.add_graph(net, images) # 將網(wǎng)絡添加入Tensorboard->(神經(jīng)網(wǎng)絡對象，隨機傳一組Input)

之后，我們可以在 Tensorboard 的Graphs這一欄看到我們整個神經(jīng)網(wǎng)絡的架構：

2.4.3 訓練中的Loss，Accuracy可視化

在模型訓練過程中，我們想實時的監(jiān)測 Loss，Accuracy 等值的變化，我們可以通過writer.add_scalar()方法往 Tensorboard 中加入監(jiān)測變量：

running_loss = 0.0 right_num = 0 for epoch in range(1): # loop over the dataset multiple timesfor i, data in enumerate(trainloader, 0):# get the inputs; data is a list of [inputs, labels]inputs, labels = data# zero the parameter gradientsoptimizer.zero_grad()# forward + backward + optimizeoutputs = net(inputs)loss = criterion(outputs, labels)loss.backward()optimizer.step()_, preds_tensor = torch.max(outputs, 1)right_num += (preds_tensor.numpy() == labels.numpy()).sum()running_loss += loss.item()if i % 1000 == 999: # 每1000步更新一次running_loss /= 1000accaracy = right_num / 4000writer.add_scalar('training/loss', running_loss, epoch * len(trainloader) + i) # 添加Loss監(jiān)測變量->(變量名稱，變量值，step)writer.add_scalar('training/accaracy', accaracy, epoch * len(trainloader) + i) # 添加Accuracy監(jiān)測變量->(變量名稱，變量值，step)print("[%d] Loss: %.4f Acc: %.2f" % (i, running_loss, accaracy))running_loss = 0.0right_num = 0print('Finished Training')

在訓練過程中，在Scalars一欄可以監(jiān)測“Loss”和“Accuracy”的變化情況（Tensorboard默認每30s刷新一次），訓練結果如下所示：

2.5 Pytorch實現(xiàn)DQN算法

Deep Reinforcement Learning 結合了深度學習和增強學習，使得增強學習能有更好的效用。這次我們使用Pytorch來實現(xiàn)一個DQN，學會玩 CartPole-v0 的立桿游戲。DQN 一共分為target network 和 evaluate network，我們在 DQN 類中會實現(xiàn)這兩個網(wǎng)絡。在更新 evaluate network 時，我們使用$q_{eval}$ 和 $r_t+\gamma ?q_{next}$ 之間的差作為 Loss 值來更新網(wǎng)絡，其中 $q_{eval}$ 來自evaluate network，$q_{next}$來自target network。DQN架構圖和 net 示意圖如下所示：（這里默認已經(jīng)有DQN的基礎，如果不清楚DQN可以參考強化學習入門筆記）。

import torch import torch.nn as nn import torch.nn.functional as F import numpy as np import gym from torch.utils.tensorboard import SummaryWriter# Hyper Parameters EPOCH = 400 BATCH_SIZE = 32 LR = 0.01 # learning rate EPSILON = 0.9 # greedy policy GAMMA = 0.9 # reward discount TARGET_REPLACE_ITER = 100 # target update frequency MEMORY_CAPACITY = 2000 env = gym.make('CartPole-v0') env = env.unwrapped N_ACTIONS = env.action_space.n N_STATES = env.observation_space.shape[0]

import 一些包和定義一些超參數(shù)，這里要用到 gym 庫，需要先pip install gym。

class Net(nn.Module):def __init__(self):super(Net, self).__init__()self.fc1 = nn.Linear(N_STATES, 20)self.fc1.weight.data.normal_(0, 0.1) self.fc2 = nn.Linear(20, N_ACTIONS)self.fc2.weight.data.normal_(0, 0.1) def forward(self, x):x = F.relu(self.fc1(x))return self.fc2(x)

定義一個Net類，這里我們只有一層 Hidden Layer。輸入為 gym 給的 observation 的維度，輸出為 action_space 的維度，下面我們實現(xiàn) DQN 類。

class DQN(object):def __init__(self):self.target_net, self.evaluate_net = Net(), Net()self.memory = np.zeros((MEMORY_CAPACITY, N_STATES * 2 + 2))self.loss_Function = nn.MSELoss()self.optimizer = torch.optim.Adam(self.evaluate_net.parameters(), lr=LR)self.point = 0self.learn_step = 0def choose_action(self, s):s = torch.unsqueeze(torch.FloatTensor(s), 0) # torch 不支持傳入單樣本，只能傳入batch的data，因此這里單樣本數(shù)據(jù)需要提升一個維度if np.random.uniform() < EPSILON: # epsilon-greedy探索 return torch.max(self.evaluate_net.forward(s), 1)[1].data.numpy()[0]else:return np.random.randint(0, N_ACTIONS)def store_transition(self, s, a, r, s_):self.memory[self.point % MEMORY_CAPACITY, :] = np.hstack((s, [a, r], s_))self.point += 1def sample_batch_data(self, batch_size):perm_idx = np.random.choice(len(self.memory), batch_size)return self.memory[perm_idx]def learn(self) -> float:if self.learn_step % TARGET_REPLACE_ITER == 0:self.target_net.load_state_dict(self.evaluate_net.state_dict())self.learn_step += 1batch_memory = self.sample_batch_data(BATCH_SIZE)batch_state = torch.FloatTensor(batch_memory[:, :N_STATES])batch_action = torch.LongTensor(batch_memory[:, N_STATES : N_STATES + 1].astype(int))batch_reward = torch.FloatTensor(batch_memory[:, N_STATES + 1 : N_STATES + 2])batch_next_state = torch.FloatTensor(batch_memory[:, -N_STATES:])q_eval = self.evaluate_net(batch_state).gather(1, batch_action) # 由于返回的是對每個action的value，因此用gather()去獲得采取的action對應的valueq_next = self.target_net(batch_next_state).detach() # target network是不做更新的，所以要detach()q_target = batch_reward + GAMMA * q_next.max(1)[0].view(BATCH_SIZE, 1)loss = self.loss_Function(q_eval, q_target)self.optimizer.zero_grad()loss.backward()self.optimizer.step()return loss.data.numpy()

DQN中一共有幾個需要注意的部分：memory，target network，evaluate network。其中 memory 是一個環(huán)形的隊列，當經(jīng)驗池滿了之后就會把舊的數(shù)據(jù)給覆蓋掉。target network會在一定的steps之后把evaluate network的參數(shù)直接復制到自己的網(wǎng)絡中。

dqn = DQN()writer = SummaryWriter("run/MemoryCapacity_100_CustomReward/") writer.add_graph(dqn.evaluate_net, torch.randn(1, N_STATES))global_step = 0 for i in range(EPOCH):s = env.reset()running_loss = 0cumulated_reward = 0step = 0while True:global_step += 1env.render()a = dqn.choose_action(s)s_, r, done, _ = env.step(a)# 自定義reward，不用原始的rewardx, x_dot, theta, theta_dot = s_r1 = (env.x_threshold - abs(x)) / env.x_threshold - 0.8r2 = (env.theta_threshold_radians - abs(theta)) / env.theta_threshold_radians - 0.5r = r1 + r2dqn.store_transition(s, a, r, s_)cumulated_reward += rif dqn.point > MEMORY_CAPACITY: # 在經(jīng)驗池滿了之后才開始進行學習loss = dqn.learn()running_loss += lossif done or step > 2000:print("【FAIL】Episode: %d| Step: %d| Loss: %.4f, Reward: %.2f" % (i, step, running_loss / step, cumulated_reward))writer.add_scalar("training/Loss", running_loss / step, global_step)writer.add_scalar("training/Reward", cumulated_reward, global_step)breakelse:print("\rCollecting experience: %d / %d..." %(dqn.point, MEMORY_CAPACITY), end='')if done:breakif step % 100 == 99:print("Episode: %d| Step: %d| Loss: %.4f, Reward: %.2f" % (i, step, running_loss / step, cumulated_reward))step += 1s = s_

以上是學習的過程，在 reward 的那個地方，使用了自定義的 reward，而不是使用 gym 給定的 r，合理的制定 reward 可以幫助模型學的更好的效果，我們后面會對使用不同的 reward 學習的效果進行對比。模型結構如下圖所示：

訓練過程中，按照上一節(jié)講的內容利用 tensorboard 追蹤 Loss 和 Reward 兩個變量的值變化情況：

可以看到，Loss 的值在逐步趨于0，這說明模型是趨于收斂的，Reward 值也在總體上升，最高達到600左右（做了 smooth 后的值，不是原本值），倒立擺能夠穩(wěn)住很長一段時間。下面我們來看一下，如果我們修改部分超參數(shù)的值會出現(xiàn)什么樣的訓練效果，我一共做了4個對比試驗：

使用自定義回報值，經(jīng)驗池容量設置為100

使用默認回報值，經(jīng)驗池容量為100

使用默認回報值，使用更為復雜的網(wǎng)絡結構，經(jīng)驗池容量為100

使用默認回報值，使用更為復雜的網(wǎng)絡結構，經(jīng)驗池容量為2000

• 回報值設定對模型效果的影響
  在經(jīng)驗池容量和模型結構都相同的情況下，使用自定義回報（橘色）和默認回報（藍色）的效果如下圖所示：

可以看到，Loss 函數(shù)最終都是趨于很小的值，這說明使用兩種方法模型都是收斂的，但是 Reward 值差別非常大。為什么同樣都是收斂的情況下，效果差這么多？這是因為，模型收斂是指：訓練出來的Q-Net總會選擇含有最大Q值的Action（這樣的Loss最小）。但是Action的Q值是通過 Reward 來計算的：$r_t+argma{x}_a{Q}^{\pi }(s,a)$。因此， reward 的制定直接決定了模型效果的好壞。所以，如果 reward 不能很好的與最終效用產(chǎn)生緊密的聯(lián)系，模型雖然能有找到最大效用行為的能力，但這個最大效用的行為并不能產(chǎn)生很好的效果。因此，如果看到 Loss 已經(jīng)很小，但最終效用不怎么好的情況下，一般就考慮重新制定 reward，選擇一個能夠更精準表示最終效用的評價函數(shù)。

• 模型復雜度對效用的影響
  在經(jīng)驗池容量相同且均使用默認回報的情況下，嘗試修改原有模型，使得模型變得稍微復雜一些，看看效果會不會更好一些，將模型再加一層 hidden layer 并且增加每一層神經(jīng)元的個數(shù)，代碼如下：

class Net(nn.Module):def __init__(self):super(Net, self).__init__()self.fc1 = nn.Linear(N_STATES, 80)self.fc1.weight.data.normal_(0, 0.1) self.fc2 = nn.Linear(80, 40)self.fc2.weight.data.normal_(0, 0.1) self.fc3 = nn.Linear(40, N_ACTIONS)self.fc3.weight.data.normal_(0, 0.1) def forward(self, x):x = F.relu(self.fc1(x))x = F.relu(self.fc2(x))return self.fc3(x)

模型結構如下：

使用復雜模型（紅色）和使用簡單模型（藍色）的 Reward 情況對比如下：

可以看到，兩個模型 Loss 都是趨于0，證明模型均收斂，紅色（復雜）模型的得比藍色（簡單）模型要稍微高一些，但和使用自定義回報的模型比起來還是差很遠。

• 經(jīng)驗池容量對模型效果的影響
  對于相同復雜度的模型，使用相同回報值，通過改變經(jīng)驗池容量來觀察對模型效果有什么影響，容量為100（紅色）和容量為2000（藍色）模型的對比結果如下：

觀察可得，擴展經(jīng)驗池后的效果會比小經(jīng)驗池的效果要好一些。因此，通過以上總結，我們可以得出在DQN中不同超參數(shù)對模型效果影響程度的結論，即：回報函數(shù)制定 > 經(jīng)驗池容量 > 模型復雜度。

2.6 Pytorch實現(xiàn)Policy Gradient算法

在實現(xiàn)了 DQN 這種 value-based 的算法之后，我們嘗試實現(xiàn)一種 policy-based 的方法：Policy-Gradient。策略梯度是很多經(jīng)典算法的基石，包括 A3C，PPO在內的多種算法都是基于策略梯度的基本思想來實現(xiàn)的，因此這次我們同樣基于 CartPole 的簡單場景來實現(xiàn) Policy Gradient 算法（默認已經(jīng)有PG的基礎，如果不清楚PG可以參考強化學習入門筆記）。
Policy Gradinet 的示意圖如下，根據(jù)輸入observation，策略決策網(wǎng)絡會輸出每一個action對應被采取的概率（效用越高的action概率就會被預測的越大）。我們可以根據(jù)這個概率來進行行為選擇，這里和上面的DQN不一樣，DQN的行為選擇是一定概率選擇最大效用的行為，一定概率隨機選行為，在PG算法中直接按照概率來選行為，即結合了多選擇高效用的行為的標準，又結合了一定概率進行行為探索的標準。一旦選擇好了一個行為后，我們就去計算這個行為的效用是多少，如果效用高，我們就增加這個動作的概率；反之則降低選擇該行為的概率。

先定義神經(jīng)網(wǎng)絡層，這里使用1個 hidden layer，10個神經(jīng)元：

import gym import numpy as np import torch import torch.nn.functional as F import torch.nn as nn import matplotlib.pyplot as plt from torch.utils.tensorboard import SummaryWriterWRITE_TENSORBOARD_FLAG = Trueclass Net(nn.Module):def __init__(self, observation_dim, action_dim):super(Net, self).__init__()self.observation_dim = observation_dimself.action_dim = action_dimself.fc1 = nn.Linear(self.observation_dim, 10)self.fc2 = nn.Linear(10, self.action_dim)def forward(self, x):x = F.tanh(self.fc1(x))return F.softmax(self.fc2(x))

隨后我們定義PolicyGradient類，由于Policy Gradient中梯度計算公式為：$▽{}_{\theta }log{\pi }_{\theta }(a|s)R(a)$，${\pi }_{\theta }(a|s)$是在網(wǎng)絡參數(shù)為$\theta$的情況下，行為a被選擇的概率，$R(a)$是行為a選擇后能得到的總回報值，這個回報值通常使用$R(a)={\sum }_{t=0}^T{\gamma }^t{R}_n$來計算，因此我們必須完整的收集了一個Epoch的數(shù)據(jù)信息后才能進行一次梯度更新（不然無法計算累計回報）。這一點也和DQN不一樣，DQN可以進行單步更新，而PG不可以。

class PolicyGradient(object):def __init__(self, observation_dim, action_dim, learning_rate=0.01, gamma=0.95):self.observation_dim = observation_dimself.action_dim = action_dimself.gamma = gammaself.ep_obs, self.ep_r, self.ep_a = [], [], []self.net = Net(observation_dim, action_dim)self.optimizer = torch.optim.Adam(self.net.parameters(), lr=learning_rate)def choose_action(self, observation):prob_list = self.net(observation)action = np.random.choice(range(prob_list.size(0)), p=prob_list.data.numpy())return actiondef store_transition(self, obs, r, a):self.ep_obs.append(obs)self.ep_r.append(r)self.ep_a.append(a)def learn(self):cumulative_reward_list = self.get_cumulative_reward()batch_obs = torch.FloatTensor(np.vstack(self.ep_obs))batch_a = torch.LongTensor(np.array(self.ep_a).reshape(-1, 1))batch_r = torch.FloatTensor(cumulative_reward_list.reshape(-1, 1))action_prob = self.net(batch_obs)action_prob.gather(1, batch_a)gradient = torch.log(action_prob) * batch_rloss = -torch.mean(gradient) # 網(wǎng)絡會對loss進行minimize，但我們是想做梯度上升，所以加一個負號self.optimizer.zero_grad()loss.backward()self.optimizer.step()self.reset_epoch_memory()return loss.data.numpy()def get_cumulative_reward(self):running_r = 0cumulative_reward = np.zeros_like(self.ep_r)for i in reversed(range(len(self.ep_r))):running_r = running_r * self.gamma + self.ep_r[i]cumulative_reward[i] = running_r# normalize cumulative rewardcumulative_reward -= np.mean(cumulative_reward)cumulative_reward /= np.std(cumulative_reward)return cumulative_rewarddef reset_epoch_memory(self):self.ep_a.clear()self.ep_obs.clear()self.ep_r.clear()

值得注意的是，在策略梯度中其實是沒有l(wèi)oss這個概念的（因為根本就沒有標簽），這個loss的梯度是我們通過$log{\pi }_{\theta }(a|s)R(a)$算出來的，由于在神經(jīng)網(wǎng)絡中我們做的是梯度下降：$\theta ?=gradient?LearningRate$，但在策略梯度算法中我們是希望做梯度上升的$\theta +=gradient?LearningRate$，因此我們在求得了梯度之后要添加一個負號再將其作為loss。最后,我們建立 CartPole 場景并將該算法用在訓練場景上：

def main():DISPLAY_REWARD_THRESHOLD = 200RENDER = Falseenv = gym.make('CartPole-v0')env = env.unwrappedPG = PolicyGradient(env.observation_space.shape[0], env.action_space.n)if WRITE_TENSORBOARD_FLAG:writer = SummaryWriter("run/simple_model_experiment")writer.add_graph(PG.net, torch.rand(env.observation_space.shape))for i_eposide in range(120):obs = env.reset()obs = torch.FloatTensor(obs)while True:if RENDER: env.render()action = PG.choose_action(obs)obs_, reward, done, _ = env.step(action)PG.store_transition(obs, reward, action)if done:ep_r = sum(PG.ep_r)if ep_r > DISPLAY_REWARD_THRESHOLD: RENDER = Trueprint("episode: %d | reward: %d" % (i_eposide, ep_r))loss = PG.learn()if WRITE_TENSORBOARD_FLAG:writer.add_scalar("training/loss", loss)writer.add_scalar("training/reward", ep_r)breakobs = torch.FloatTensor(obs_)if __name__ == '__main__':main()

Policy Gradient 訓練結果如下：

loss對應的就是每一次更新的梯度，reward對應的是模型的得分。可以看到使用策略梯度的效果還是蠻不錯的，在100個Epoch之后桿子基本就可以被很好的穩(wěn)住了。

創(chuàng)作挑戰(zhàn)賽新人創(chuàng)作獎勵來咯，堅持創(chuàng)作打卡瓜分現(xiàn)金大獎

總結

以上是生活随笔為你收集整理的Pytorch快速入门笔记的全部內容，希望文章能夠幫你解決所遇到的問題。

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