Pytorch學習筆記
幾個重要函式:
torch.utils.data.DataLoader:
首先DataLoader是匯入圖片的操作,裡面有一些引數,比如batch_size和shuffle等,預設load進去的圖片型別是PIL.Image.open的型別,如果你不知道PIL,簡單來說就是一種讀取圖片的庫。torchvision.transforms:
torchvision.transforms裡面的操作是對匯入的圖片做處理,比如可以隨機取(50, 50)這樣的窗框大小,或者隨機翻轉,或者去中間的(50, 50)的窗框大小部分等等,但是裡面必須要用的是transforms.ToTensor(),這可以將PIL的圖片型別轉換成tensor,這樣pytorch才可以對其做處理。- torchvision.datasets
torchvision.datasets裡面有很多資料型別,裡面有官網處理好的資料,比如我們要使用的MNIST資料集,可以通過torchvision.datasets.MNIST()來得到,還有一個常使用的是torchvision.datasets.ImageFolder(),這個可以讓我們按資料夾來取圖片,和keras裡面的flow_from_directory()類似,具體的可以去看看官方文件的介紹。 - nn.Sequential() 這個表示將一個有序的模組寫在一起,也就相當於將神經網路的層按順序放在一起,這樣可以方便結構顯示
nn.Conv2d() 這個是卷積層,裡面常用的引數有四個,in_channels, out_channels, kernel_size, stride, padding
<1> in_channels表示的是輸入卷積層的圖片厚度
<2> out_channels表示的是要輸出的厚度
<3> kernel_size表示的是卷積核的大小,可以用一個數字表示長寬相等的卷積核,比如kernel_size=3,也可以用不同的數字表示長寬不同的卷積核,比如kernel_size=(3, 2)
<4> stride表示卷積核滑動的步長
<5> padding表示的是在圖片周圍填充0的多少,padding=0表示不填充,padding=1四周都填充1維torch.nn.ReLU()
這個表示使用ReLU啟用函式,裡面有一個引數inplace,預設設定為False,表示新建立一個物件對其修改,也可以設定為True,表示直接對這個物件進行修改- torch.nn.MaxPool2d()
這個是最大池化層,當然也有平均池化層,裡面的引數有kernel_size, stride, padding
<1> kernel_size表示池化的視窗大小,和卷積層裡面的kernel_size是一樣的.
<2> stride也和卷積層裡面一樣,需要自己設定滑動步長.
<3> padding也和卷積層裡面的引數是一樣的,預設是0
模型需要傳入的引數是輸入的圖片維數以及輸出的種類數 - nn.LSTM()
LSTM函式有如下幾個引數:
<1> input_size 表示的是輸入的資料維數
<2> hidden_size 表示的是輸出維數
<3> num_layers 表示堆疊幾層的LSTM,預設是1
<4> bias True 或者 False,決定是否使用bias
<5> batch_first True 或者 False,因為nn.lstm()接受的資料輸入是(序列長度,batch,輸入維數),這和我們cnn輸入的方式不太一致,所以使用batch_first,我們可以將輸入變成(batch,序列長度,輸入維數)
<5> dropout 表示除了最後一層之外都引入一個dropout
<6> bidirectional 表示雙向LSTM,也就是序列從左往右算一次,從右往左又算一次,這樣就可以兩倍的輸出
定義模型的框架:
class Logstic_Regression(nn.Module):
def __init__(self, in_dim, n_class):
super(Logstic_Regression, self).__init__()
self.logstic = nn.Linear(in_dim, n_class)
def forward(self, x):
out = self.logstic(x)
return out
model = Logstic_Regression(28*28, 10) # 圖片大小是28x28
# Normal batch generator
# x and y are list or array
class Arrayloader(Dataset):
def __init__(self, x, y):
self.x = x; self.y = y
def __len__(self):
return len(self.y)
def __getitem__(self, idx):
idx_x = torch.from_numpy(np.array(self.x[idx]))
idx_y = torch.from_numpy(np.array([self.y[idx]]))
return idx_x, idx_y
# 注idx_x 類如形式:[[1,2,3,],[1,2,3],......]
# idx_y類如形式:[[0],[1],[0],[1],......]
train_set = Arrayloader(X_train, y_train) # 合併X和y
train_loader = DataLoader(train_set, batch_size = 128, shuffle=True, num_workers=4)
模型訓練設計:
for epoch in range(num_epoches):
print('epoch {}'.format(epoch+1))
print('*'*10)
running_loss = 0.0
running_acc = 0.0
for i, data in enumerate(train_loader, 1):
img, label = data
img = img.view(img.size(0), -1) # 將圖片展開成 28x28
if use_gpu:
img = Variable(img).cuda()
label = Variable(label).cuda()
else:
img = Variable(img)
label = Variable(label)
# 向前傳播
out = model(img)
loss = criterion(out, label)
running_loss += loss.data[0] * label.size(0)
_, pred = torch.max(out, 1)
num_correct = (pred == label).sum()
running_acc += num_correct.data[0]
# 向後傳播
optimizer.zero_grad() # 對所有的引數的梯度緩衝區進行歸零
loss.backward()
optimizer.step()
注:我們如果將模型放到了gpu上,相應的我們的Variable也要放到gpu上。
函式名 | 作用 |
---|---|
torh.cuda.is_available() | 判斷是否可以在GPU上跑 |
nn.Sequential() | 將一個有序的模組寫在一起 |
nn.Conv2d() | 是卷積層 |
模型篇
三層BP
class Neuralnetwork(nn.Module):
def __init__(self, in_dim, n_hidden_1, n_hidden_2, out_dim):
super(Neuralnetwork, self).__init__()
self.layer1 = nn.Linear(in_dim, n_hidden_1)
self.layer2 = nn.Linear(n_hidden_1, n_hidden_2)
self.layer3 = nn.Linear(n_hidden_2, out_dim)
def forward(self, x):
x = self.layer1(x)
x = self.layer2(x)
x = self.layer3(x)
return x
model = Neuralnetwork(28*28, 300, 100, 10)
if torch.cuda.is_available():
model = model.cuda()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=learning_rate)
基本卷積網路:
# 定義 Convolution Network 模型
class Cnn(nn.Module):
def __init__(self, in_dim, n_class):
super(Cnn, self).__init__()
self.conv = nn.Sequential(
nn.Conv2d(in_dim, 6, 3, stride=1, padding=1),
nn.ReLU(True),
nn.MaxPool2d(2, 2),
nn.Conv2d(6, 16, 5, stride=1, padding=0),
nn.ReLU(True),
nn.MaxPool2d(2, 2),
)
self.fc = nn.Sequential(
nn.Linear(400, 120),
nn.Linear(120, 84),
nn.Linear(84, n_class)
)
def forward(self, x):
out = self.conv(x)
out = out.view(out.size(0), -1)
out = self.fc(out)
return out
model = Cnn(1, 10) # 圖片大小是28x28
use_gpu = torch.cuda.is_available() # 判斷是否有GPU加速
if use_gpu:
model = model.cuda()
# 定義loss和optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=learning_rate)
LSTM模型:
class Rnn(nn.Module):
def __init__(self, in_dim, hidden_dim, n_layer, n_class):
super(Rnn, self).__init__()
self.n_layer = n_layer
self.hidden_dim = hidden_dim
self.lstm = nn.LSTM(in_dim, hidden_dim, n_layer, batch_first=True)
self.classifier = nn.Linear(hidden_dim, n_class)
def forward(self, x):
# h0 = Variable(torch.zeros(self.n_layer, x.size(1),
# self.hidden_dim)).cuda()
# c0 = Variable(torch.zeros(self.n_layer, x.size(1),
# self.hidden_dim)).cuda()
out, _ = self.lstm(x)
out = out[:, -1, :]
out = self.classifier(out)
return out