PyTorch极简教程

PyTorch：深度学习框架，神经网络界的Numpy。所以PyTorch的使用方式基本与Numpy一致。

Tensor：PyTorch的核心，与Numpy最大的不同。将一个变量声明为Tensor，才能在神经网络中自动求导，并且使用GPU。

计算图：用tensor构建计算图，但是只有用户提交的tensor数据是叶子节点，中间运算产生的tensor不是叶子节点。只有叶子节点在反向传播的时候有梯度。梯度会累加，所以每次循环的时候都要把梯度重置。

PyTorch构建神经网络结构需要包括5个部分。

1. 数据
2. 模型
3. 损失函数
4. 优化器
5. 迭代训练

1. 数据：Dataset，Dataloader

Dataset定义了数据的来源，包括数据的读取目录，返回结果和图像变换。建立dataset后交给Dataloader。
Dataloader定义了数据的加载方式，报告batch大小，是否打乱等。
加载图片可以使用torchvision中的dataset，返回图片和标签名。

import torchvision
from torchvision import datasets, models, transforms

data_transforms = {
    'train': transforms.Compose([
        transforms.RandomResizedCrop(224),
        transforms.RandomHorizontalFlip(),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ]),
    'val': transforms.Compose([
        transforms.Resize(256),
        transforms.CenterCrop(224),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ]),
}

data_dir = 'data/hymenoptera_data'
image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x),
                                          data_transforms[x])
                  for x in ['train', 'val']}
dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=4,
                                             shuffle=True, num_workers=4)
              for x in ['train', 'val']}
dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']}
class_names = image_datasets['train'].classes

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

如果有需要，可以自定义dataset，比如不光返回图片，还返回文件名。

class MyDataset(Dataset):

    def __init__(self, root_dir, transform=None):
        self.root_dir = root_dir
        self.transform = transform
        self.size = 0
        self.names_list = []

        if not os.path.isdir(self.root_dir):
            print(self.root_dir + 'does not exist!')

        self.names_list = os.listdir(self.root_dir)
        self.size = self.names_list.__len__()

    def __len__(self):
        return self.size

    def __getitem__(self, idx):
        image_path = os.path.join(self.root_dir, self.names_list[idx])
        if not os.path.isfile(image_path):
            print(image_path + 'does not exist!')
            return None
        # image = io.imread(image_path)   # use skitimage
        image = Image.open(image_path)  # use pil
        name = self.names_list[idx]

        if self.transform:
            sample = {'image': self.transform(image), 'name':name}
        else:
            sample = {'image': image, 'name': name}

        return sample

2. 模型

定义网络结构和前向传播。

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 4 * 4, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 4 * 4)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

net = Net()

3. 损失函数

损失函数就是计算模型输出结果和真实值的差距，可以直接计算向量距离，就是nn.MSELoss。
现在一般用交叉熵nn.CrossEntropyLoss()。

import torch.nn as nn
criterion = nn.CrossEntropyLoss()

4. 优化器

当得到了Loss值，就可以反向传播得到梯度，有了梯度该怎么对权值进行更新，就是优化器的工作。
SGD是最基础的优化器，最慢但是不会出问题。之后有很多优化，现在可以考虑Adam。

import torch.optim as optim
optimizer = optim.SGD(net.parameters(), lr=LR, momentum=0.9)                        # 选择优化器
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1)     # 设置学习率下降策略

5. 迭代训练

迭代时要重置梯度，计算loss，反向传播，更新优化器。如果学习率有更新策略的话还有更新学习率。

for epoch in range(MAX_EPOCH):

    loss_mean = 0.
    correct = 0.
    total = 0.

    net.train()
    for i, data in enumerate(train_loader):

        # forward
        inputs, labels = data
        outputs = net(inputs)

        # backward
        optimizer.zero_grad()
        loss = criterion(outputs, labels)
        loss.backward()

        # update weights
        optimizer.step()

        # 统计分类情况
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).squeeze().sum().numpy()

        # 打印训练信息
        loss_mean += loss.item()
        train_curve.append(loss.item())
        if (i+1) % log_interval == 0:
            loss_mean = loss_mean / log_interval
            print("Training:Epoch[{:0>3}/{:0>3}] Iteration[{:0>3}/{:0>3}] Loss: {:.4f} Acc:{:.2%}".format(
                epoch, MAX_EPOCH, i+1, len(train_loader), loss_mean, correct / total))
            loss_mean = 0.

    scheduler.step()  # 更新学习率

完

---

进阶

Tensorboard

使用SummaryWriter生成一个记录器，如果函数中用log_dir，就会在指定地址中生成记录；如果用comment, 就会自动生成一个run文件夹，里面的文件夹以comment定义的字段结尾。
writer.add_scalar记录标量，一个参数是名称，第二个参数是y值，第三参数是x值。
还可以记录图片、计算图、直方图。

from torch.utils.tensorboard import SummaryWriter
writer = SummaryWriter(comment='test_tensorboard')
#writer = SummaryWriter(log_dir='./board')

for x in range(100):

    writer.add_scalar('y=2x', x * 2, x)
    writer.add_scalar('y=pow(2, x)',  2 ** x, x)
    
    writer.add_scalars('data/scalar_group', {"xsinx": x * np.sin(x),
                                             "xcosx": x * np.cos(x),
                                             "arctanx": np.arctan(x)}, x)
writer.close()

更新中......