幾個重要函式：

1. torch.utils.data.DataLoader：
   首先DataLoader是匯入圖片的操作，裡面有一些引數，比如batch_size和shuffle等，預設load進去的圖片型別是PIL.Image.open的型別，如果你不知道PIL，簡單來說就是一種讀取圖片的庫。

2. torchvision.transforms：
   torchvision.transforms裡面的操作是對匯入的圖片做處理，比如可以隨機取(50, 50)這樣的窗框大小，或者隨機翻轉，或者去中間的(50, 50)的窗框大小部分等等，但是裡面必須要用的是transforms.ToTensor()，這可以將PIL的圖片型別轉換成tensor，這樣pytorch才可以對其做處理。
3. torchvision.datasets
   torchvision.datasets裡面有很多資料型別，裡面有官網處理好的資料，比如我們要使用的MNIST資料集，可以通過torchvision.datasets.MNIST()來得到，還有一個常使用的是torchvision.datasets.ImageFolder()，這個可以讓我們按資料夾來取圖片，和keras裡面的flow_from_directory()類似，具體的可以去看看官方文件的介紹。
4. nn.Sequential() 這個表示將一個有序的模組寫在一起，也就相當於將神經網路的層按順序放在一起，這樣可以方便結構顯示

5. 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維

6. torch.nn.ReLU()
   這個表示使用ReLU啟用函式，裡面有一個引數inplace，預設設定為False，表示新建立一個物件對其修改，也可以設定為True，表示直接對這個物件進行修改

7. torch.nn.MaxPool2d()
   這個是最大池化層，當然也有平均池化層，裡面的引數有kernel_size, stride, padding
   <1> kernel_size表示池化的視窗大小，和卷積層裡面的kernel_size是一樣的.
   <2> stride也和卷積層裡面一樣，需要自己設定滑動步長.
   <3> padding也和卷積層裡面的引數是一樣的，預設是0
   模型需要傳入的引數是輸入的圖片維數以及輸出的種類數
8. 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上。

模型篇

三層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