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
- 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')