PyTorch 超全資源列表，看這篇就夠了

PyTorch 如今已經稱為最受歡迎的深度學習框架之一了！豐富的 PyTorch 教程，完備的 PyTorch 學習路線往往能幫助我們事半功倍！

今天給大家推薦一個比較完備的 PyTorch 資源列表，內容涉及 PyToch 基本知識，PyToch 在 CV、NLP 領域的應用，PyTorch 教程、PyTorch 相關論文等。

首先放上該專案地址：

https://github.com/bharathgs/Awesome-pytorch-list

該專案非常受歡迎，目前已經收穫了 6000+ 的 stars 了。

資源列表：

Pytorch & related libraries
- NLP & Speech Processing<p>
- Computer Vision
- Probabilistic/Generative Libraries
- Other libraries
Tutorials & examples
Paper implementations
Pytorch elsewhere

下面，我們來分別介紹這份 PyTorch 資源。

PyTorch & related libraries

這部分主要介紹了 PyTorch 及相關的庫函式。

1. NLP & Speech Processing

這部分主要介紹 PyTorch 在自然語言處理 NLP 領域的應用及其相關資源，總共包含了 33 份資料。

涉及的內容包括：seq2seq, speech, quick-nlp 等。不僅包含了 PyToch 在 NLP 的快速入門，也包含了最新的 BERT 的 PyTorch 實現。

2. Computer Vision

這部分主要介紹 PyTorch 在計算機視覺 CV 領域的應用及其相關資源，總共包含了 18 份資料。

內容上涉及了近年來 CV 領域非常火熱的研究，如經典的 LSTM 的 PyTorch 實現，流行的 face-alignment 等。

3. Probabilistic/Generative Libraries

這部分主要介紹 PyTorch 一些機率/生成庫，總共包含了 8 份資料。

4. Other libraries

這部分主要介紹 PyTorch 其它的一些庫，總共包含了 101 份資料，非常全面。

這部分可以當作字典來用，平時需要使用到 PyTorch 的一些其它相關庫，可在這裡查詢。

Tutorials & examples

這部分是硬核內容，專門講了 PyTorch 額詳細教程並配備相關的例項。總共包含了 58 份資源。

例如 pytorch-tutorial，這裡獲星 10k+。從 PyTorch 的基礎語法知識、張量介紹起，然後是簡單的例項、進階例項等。整個教程學習梯度清晰，難易程度適中，便於進階提升。

下面是使用 PyTorch 實現一個線性迴歸的簡單例子：

import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt


# Hyper-parameters
input_size = 1
output_size = 1
num_epochs = 60
learning_rate = 0.001

# Toy dataset
x_train = np.array([[3.3], [4.4], [5.5], [6.71], [6.93], [4.168],
[9.779], [6.182], [7.59], [2.167], [7.042],
[10.791], [5.313], [7.997], [3.1]], dtype=np.float32)

y_train = np.array([[1.7], [2.76], [2.09], [3.19], [1.694], [1.573],
[3.366], [2.596], [2.53], [1.221], [2.827],
[3.465], [1.65], [2.904], [1.3]], dtype=np.float32)

# Linear regression model
model = nn.Linear(input_size, output_size)

# Loss and optimizer
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

# Train the model
for epoch in range(num_epochs):
# Convert numpy arrays to torch tensors
inputs = torch.from_numpy(x_train)
targets = torch.from_numpy(y_train)

# Forward pass
outputs = model(inputs)
loss = criterion(outputs, targets)

# Backward and optimize
optimizer.zero_grad()
loss.backward()
optimizer.step()

if (epoch+1) % 5 == 0:
print ('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))

# Plot the graph
predicted = model(torch.from_numpy(x_train)).detach().numpy()
plt.plot(x_train, y_train, 'ro', label='Original data')
plt.plot(x_train, predicted, label='Fitted line')
plt.legend()
plt.show()

# Save the model checkpoint
torch.save(model.state_dict(), 'model.ckpt')

下面是使用 PyTorch 實現一個 CNN 模型的稍複雜例子：

import torch
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms


# Device configuration
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')

# Hyper parameters
num_epochs = 5
num_classes = 10
batch_size = 100
learning_rate = 0.001

# MNIST dataset
train_dataset = torchvision.datasets.MNIST(root='../../data/',
train=True,
transform=transforms.ToTensor(),
download=True)

test_dataset = torchvision.datasets.MNIST(root='../../data/',
train=False,
transform=transforms.ToTensor())

# Data loader
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
batch_size=batch_size,
shuffle=True)

test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
batch_size=batch_size,
shuffle=False)

# Convolutional neural network (two convolutional layers)
class ConvNet(nn.Module):
def __init__(self, num_classes=10):
super(ConvNet, self).__init__()
self.layer1 = nn.Sequential(
nn.Conv2d(1, 16, kernel_size=5, stride=1, padding=2),
nn.BatchNorm2d(16),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2, stride=2))
self.layer2 = nn.Sequential(
nn.Conv2d(16, 32, kernel_size=5, stride=1, padding=2),
nn.BatchNorm2d(32),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2, stride=2))
self.fc = nn.Linear(7*7*32, num_classes)

def forward(self, x):
out = self.layer1(x)
out = self.layer2(out)
out = out.reshape(out.size(0), -1)
out = self.fc(out)
return out

model = ConvNet(num_classes).to(device)

# Loss and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

# Train the model
total_step = len(train_loader)
for epoch in range(num_epochs):
for i, (images, labels) in enumerate(train_loader):
images = images.to(device)
labels = labels.to(device)

# Forward pass
outputs = model(images)
loss = criterion(outputs, labels)

# Backward and optimize
optimizer.zero_grad()
loss.backward()
optimizer.step()

if (i+1) % 100 == 0:
print ('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}' 
.format(epoch+1, num_epochs, i+1, total_step, loss.item()))

# Test the model
model.eval() # eval mode (batchnorm uses moving mean/variance instead of mini-batch mean/variance)
with torch.no_grad():
correct = 0
total = 0
for images, labels in test_loader:
images = images.to(device)
labels = labels.to(device)
outputs = model(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()

print('Test Accuracy of the model on the 10000 test images: {} %'.format(100 * correct / total))

# Save the model checkpoint
torch.save(model.state_dict(), 'model.ckpt')