Assignment2之PyTorch實踐
- 2019 年 10 月 5 日
- 筆記
Assignment2之PyTorch實踐
0.說在前面1.準備工作1.1 transform1.2 ToTensor1.3 Normalize1.4 datasets1.5 DataLoader1.6 GPU與CPU2.Barebones PyTorch2.1 Flatten Function2.2 Two-Layer Network2.3 Three-Layer ConvNet2.4 Initialization2.5 Check Accuracy2.6 Training Loop2.7 Train a Two-Layer Network2.8 Training a ConvNet3.PyTorch Module API3.1 Three-Layer ConvNet3.2 Train a Three-Layer ConvNet4.PyTorch Sequential API4.1 Three-Layer ConvNet5. CIFAR-10 open-ended challenge
0.說在前面
本節更新week8作業的PyTorch.ipynb，順便一起來學習一下PyTorch的一些基本用法！
下面一起來實踐吧！
1.準備工作
在這一部分，需要注意幾個函數，分別如下：
1.1 transform
T.Compose將多個transforms的list組合起來。
transform = T.Compose([ T.ToTensor(), T.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)) ])
1.2 ToTensor
transforms.ToTensor()將 PIL.Image/numpy.ndarray 數據進轉化為torch.FloadTensor，並歸一化到[0, 1.0]。
- 取值範圍為[0, 255]的PIL.Image，轉換成形狀為[C, H, W]，取值範圍是[0, 1.0]的torch.FloadTensor；
- 形狀為[H, W, C]的numpy.ndarray，轉換成形狀為[C, H, W]，取值範圍是[0, 1.0]的torch.FloadTensor。
T.ToTensor()
1.3 Normalize
歸一化對神經網路是非常重要的，那麼如何歸一化到[-1.0，1.0]？
這裡就用到了transforms.Normalize()，channel=（channel-mean）/std。
上述可轉化為：
T.Normalize(mean=(0.4914, 0.4822, 0.4465), std=(0.2023, 0.1994, 0.2010))
1.4 datasets
使用datasets下載數據集。
import torchvision.datasets as dset cifar10_train = dset.CIFAR10('./cs231n/datasets', train=True, download=True, transform=transform)
1.5 DataLoader
組合數據集和取樣器，並在數據集上提供單進程或多進程迭代器。
可以把下面通俗的理解為：使用取樣器隨機在數據集中取樣，並用DataLoader將取樣器與數據集進行裝載，然後返回的結果是個迭代器，取出數據得通過for循環取出！
from torch.utils.data import DataLoader from torch.utils.data import sampler loader_train = DataLoader(cifar10_train, batch_size=64, sampler=sampler.SubsetRandomSampler(range(NUM_TRAIN)))
1.6 GPU與CPU
我覺得這一段程式碼寫的很棒，是因為簡潔明了的將cpu與gpu一同來進行判別，直接確定你最後使用的是gpu還是cpu的設備去運行！
USE_GPU = True dtype = torch.float32 # we will be using float throughout this tutorial if USE_GPU and torch.cuda.is_available(): device = torch.device('cuda') else: device = torch.device('cpu') # Constant to control how frequently we print train loss print_every = 100 print('using device:', device)
2.Barebones PyTorch
2.1 Flatten Function
這一節來實現PyTorch中的Flatten函數！
這裡做的工作在注釋中給出了明確的說明，我們來看一下：
The flatten function below first reads in the N, C, H, and W values from a given batch of data, and then returns a "view" of that data. "View" is analogous to numpy's "reshape" method: it reshapes x's dimensions to be N x ??, where ?? is allowed to be anything (in this case, it will be C x H x W, but we don't need to specify that explicitly.
這裡有幾個地方非常重要，第一：view類似與numpy中reshape方法，主要是將維度變為Nx?? 而兩個問號又該是什麼值呢，這就引出了第二個關鍵點：兩個問號不需要明確指定。
那麼根據前面的兩個關鍵點，就可以明白下面函數所要做的事情了，那就是將(N,C,H,W)維度變為(N,CxHxW)!不需要明確指定就是-1即可完成，而reshape用view函數，那麼這樣的話，下面函數就so easy了！
2.2 Two-Layer Network
這一節來實現兩層神經網路！注釋中說明，這一節不用寫任何程式碼，但你需要理解！
A fully-connected neural networks; the architecture is:NN is fully connected -> ReLU -> fully connected layer.
全連接網路架構為：NN->ReLU->NN
這裡的x.mm解釋一下：x是一個pytorch 張量，x.mm使用了pytorch裡面的矩陣乘法函數，作用就是實現x與w1的矩陣相乘，是真正的矩陣相乘，而不是對應元素相乘！
這裡我們來看注釋維度！
注意點：d1 * ... * dM = D Inputs: - x: A PyTorch Tensor of shape (N, d1, ..., dM) giving a minibatch of input data. - params: A list [w1, w2] of PyTorch Tensors giving weights for the network; w1 has shape (D, H) and w2 has shape (H, C).
具體實現如下：先轉化x維度為(N,D)，再通過矩陣乘法(N,D)x(D,H)得到(N,H)，此時是x.mm(w1)的結果，也就完成了NN層這一步，接著就是ReLU，那麼用F.relu()完成了ReLU層，最後再做一次矩陣乘法，(N,H)x(H,C)，得到(N,C)，也就是x.mm(w2)的結果，最後返回即可！
import torch.nn.functional as F x = flatten(x) w1, w2 = params x = F.relu(x.mm(w1)) x = x.mm(w2)
後面則是兩層神經網路的測試，可以自己走一遍，這裡就不闡述了！
2.3 Three-Layer ConvNet
為什麼前面不寫程式碼呢，就是因為讓你縣看懂，看懂完了，來實現三層卷積。
卷積架構如下：
- A convolutional layer (with bias) with
channel_1filters, each with shapeKW1 x KH1, and zero-padding of two - ReLU nonlinearity
- A convolutional layer (with bias) with
channel_2filters, each with shapeKW2 x KH2, and zero-padding of one - ReLU nonlinearity
- Fully-connected layer with bias, producing scores for C classes.
接著來看一下給定的要求：
輸入: - x: (N, 3, H, W) - params: should contain the following: -conv_w1 : (channel_1, 3, KH1, KW1) 第一層卷積權重 -conv_b1 : (channel_1,) 第一層卷積偏值 -conv_w2 : (channel_2, channel_1, KH2, KW2) 第二層卷積權重 -conv_b2 : (channel_2,) 第二層卷積偏值 - fc_w: 全連接層權重 - fc_b: 全連接層偏值 返回: - scores: (N,C)
具體解釋看注釋！
# 完成卷積一層操作(實現通過F.conv2d) # 填入輸入數據，權重，偏值，步長及零填補(看上面卷積架構) # 後面的按照上面架構來就行了 # # shape=(N,channel_1,H,W) conv1 = F.conv2d(x, weight=conv_w1, bias=conv_b1,stride=1, padding=2) # shape=(N,channel_1,H,W) relu1 = F.relu(conv1) # shape=(N,channel_2,H,W) conv2 = F.conv2d(relu1, weight=conv_w2, bias=conv_b2, stride=1,padding=1) # shape=(N,channel_2,H,W) relu2 = F.relu(conv2) # 利用上面的兩層神經網路的實現，直接調用即可！ # shape=(N,CxHxW) relu2_flat = flatten(relu2) # shape=(N,C) scores = relu2_flat.mm(fc_w) + fc_b
2.4 Initialization
讓我們編寫幾個實用程式方法來初始化我們模型的權重矩陣。
random_weight(shape)用Kaiming歸一化方法初始化權重張量。zero_weight(shape)用全零初始化權重張量。用於實例化偏差參數。
2.5 Check Accuracy
在訓練模型時，我們將使用以下函數來檢查我們的模型在訓練或驗證集上的準確性。
在檢查精度時，我們不需要計算任何梯度;因此，當我們計算分數時，我們不需要PyTorch為我們構建計算圖。
2.6 Training Loop
我們現在可以建立一個基本的訓練循環來訓練我們的網路。我們將使用沒有動量的隨機梯度下降來訓練模型。我們將使用torch.functional.cross_entropy來計算損失; 訓練循環將神經網路函數，初始化參數列表（在我們的示例中為[w1，w2]）和學習速率作為輸入。
2.7 Train a Two-Layer Network
現在我們準備好運行訓練循環了。我們需要為完全連接的權重w1和w2明確地分配張量。
CIFAR的每個小批量都有64個例子，因此張量形狀為[64,3,32,32]。
展平後，x形應為[64,3 * 32 * 32]。這將是w1的第一個維度的大小。 w1的第二個維度是隱藏層大小，它也是w2的第一個維度。
最後，網路的輸出是一個10維向量，表示10個類的概率分布。您不需要調整任何超參數，但在訓練一個紀元後，您應該看到精度超過40％！
2.8 Training a ConvNet
這裡是調用了上述初始化函數，初始化w與b，由於傳遞的是shape，那麼我們可以根據在上面的卷積神經網路注釋的提示裡面的shape來進行編寫，上面的注釋如下：
-conv_w1 : (channel_1, 3, KH1, KW1) 第一層卷積權重 -conv_b1 : (channel_1,) 第一層卷積偏值 -conv_w2 : (channel_2, channel_1, KH2, KW2) 第二層卷積權重 -conv_b2 : (channel_2,) 第二層卷積偏值
KH1與KW1，KH2與KW2是多少呢？這個注釋也給出了，看本節的注釋如下：
- Convolutional layer (with bias) with 32 5×5 filters, with zero-padding of 2
- ReLU
- Convolutional layer (with bias) with 16 3×3 filters, with zero-padding of 1
- ReLU
- Fully-connected layer (with bias) to compute scores for 10 classes
那麼最後就直接傳參就行了！
conv_w1 = random_weight((channel_1,3,5,5)) conv_b1 = zero_weight((channel_1,)) conv_w2 = random_weight((channel_2,channel_1,3,3)) conv_b2 = zero_weight((channel_2,)) fc_w = random_weight((channel_2*channel_1*channel_1,10)) fc_b = zero_weight((10,))
3.PyTorch Module API
本節則簡單，就是實現調用pytorch封裝的api實現就行了！這裡我們直接來看需要填寫程式碼處！
3.1 Three-Layer ConvNet
初始化conv1，w1，b1，conv2，w2，b2，以及fc及fc的w與b。
self.conv1 = nn.Conv2d(in_channel,channel_1,kernel_size=5,padding=2,bias=True) nn.init.kaiming_normal_(self.conv1.weight) nn.init.constant_(self.conv1.bias,0) self.conv2 = nn.Conv2d(channel_1,channel_2,kernel_size=3,padding=1,bias=True) nn.init.kaiming_normal_(self.conv2.weight) nn.init.constant_(self.conv1.bias,0) self.fc = nn.Linear(channel_2*32*32,num_classes) nn.init.kaiming_normal_(self.fc.weight) nn.init.constant_(self.fc.bias,0)
前向傳播
調用API實現即可！
relu1 = F.relu(self.conv1(x)) relu2 = F.relu(self.conv2(relu1)) scores = self.fc(flatten(relu2))
3.2 Train a Three-Layer ConvNet
訓練三層卷積神經網路！
model = ThreeLayerConvNet(3,channel_1,channel_2,10) optimizer = optim.SGD(model.parameters(), lr=learning_rate)
4.PyTorch Sequential API
Pytorch中提供了容器模組，可以將上述model封裝起來。
4.1 Three-Layer ConvNet
就直接用nn.Sequential包裝起來即可！其餘的基本一樣！
model = nn.Sequential( nn.Conv2d(3,channel_1,kernel_size=5,padding=2), nn.ReLU(), nn.Conv2d(channel_1,channel_2,kernel_size=3,padding=1), nn.ReLU(), Flatten(), nn.Linear(channel_2*32*32, 10), ) optimizer = optim.SGD(model.parameters(), lr=learning_rate, momentum=0.9, nesterov=True)
5. CIFAR-10 open-ended challenge
這一節則是隨意的調用api去實現自己的網路架構，然後去訓練模型，使得自己的模型要在測試集上分數高於70%!
模型架構：
- [conv-bn-relu-pool]x3 -> [affine]x1 -> [softmax or SVM]
layer1 = nn.Sequential( nn.Conv2d(3, 30, kernel_size=5, padding=2), nn.BatchNorm2d(30), nn.ReLU(), nn.MaxPool2d(2) ) layer2 = nn.Sequential( nn.Conv2d(30, 50, kernel_size=3, padding=1), nn.BatchNorm2d(50), nn.ReLU(), nn.MaxPool2d(2) ) layer3 = nn.Sequential( nn.Conv2d(50, 100, kernel_size=3, padding=1), nn.BatchNorm2d(100), nn.ReLU(), nn.MaxPool2d(2) ) fc = nn.Linear(100*4*4, 10) model = nn.Sequential( layer1, layer2, layer3, Flatten(), fc ) learning_rate = 1e-3 optimizer = optim.RMSprop(model.parameters(), lr=learning_rate)
最後跑分：
best_model = model check_accuracy_part34(loader_test, best_model)
結果為：
Checking accuracy on test set Got 7712 / 10000 correct (77.12)
