[pytorch]分布式训练在第二个纪元关闭

您有多少个数据加载器？如果不止一个，请使用fork_server或spawn启动方法multiprocessing如下：

import torch.multiprocessing as mp

if __name__ == '__main__':
      mp.set_start_method('forkserver')

fork我认为在使用默认启动方法进行多处理时遇到了完全相同的问题

multiprocessing.set_start_method('forkserver')@teng-li和 之间有什么区别吗torch.multiprocessing.set_start_method('forkserver')？我尝试过前者，但数据加载器在一个纪元后仍然关闭。这是修改后的代码：

import argparse,os,time
import torch.multiprocessing as mp
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torch.distributed as dist
import torch.utils.data.distributed
import torchvision
from torchvision import datasets, transforms
import numpy as np
import models
from utils import *
def train(epoch):
    for batch_idx, (data, label) in enumerate(train_loader, 0):
        optimizer.zero_grad()
        data, label = data.cuda(), label.cuda()

        output, grid = model(data)
        nll_loss = F.nll_loss(output, label)
        de_loss = deformation_constraint_loss(grid, opt.grid_s)
        loss =  nll_loss + de_loss
        loss.backward()
        optimizer.step()

if __name__ == '__main__':
    mp.set_start_method('forkserver')
    parser = argparse.ArgumentParser()
    parser.add_argument('--start_epoch', type=int, default=1, help='start epoch number')
    parser.add_argument('--epoch', type=int, default=25, help='number of epochs to train for')
    parser.add_argument('--lr', type=float, default=0.1, help='learning rate, default=0.1')
    parser.add_argument('--momentum', type=float, default=0.9, help='momentum, default=0.9')
    parser.add_argument('--weight_decay', type=float, default=0.0002, help='weight_decay, default=0.0002')
    parser.add_argument('--batch_s', type=int, default=64, help='input batch size')
    parser.add_argument('--grid_s', type=int, default=8, help='grid size')
    parser.add_argument('--data', type=str, default='../vgg2data', help='data directory')
    parser.add_argument('--workers', type=int, default=1, help='number of data loading workers')
    parser.add_argument('--output_dir', type=str, default='./output/', help='model_saving directory')
    parser.add_argument('--resume', type=str, default='', help='resume')
    parser.add_argument("--display_interval", type=int, default=50)
    parser.add_argument("--local_rank", type=int)
    opt = parser.parse_args()
    torch.cuda.set_device(opt.local_rank)

    dist.init_process_group(backend='nccl', init_method='env://', world_size=8)

    train_dir = os.path.join(opt.data, 'train')
    train_dataset = datasets.ImageFolder(
        train_dir,
        transforms.Compose([transforms.ToTensor()])
    )
    train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset)
    train_loader = torch.utils.data.DataLoader(
            train_dataset,
            batch_size=opt.batch_s,
            num_workers=opt.workers,
            drop_last=True,
            pin_memory=False,
            shuffle=False,
            sampler=train_sampler
        )

    input_size = (opt.batch_s, 3, 128, 128)
    num_classes = 9092
    #num_classes = 34
    model = models.se_resnet34_v3(input_size, opt.grid_s, num_classes)
    if opt.resume:
        if os.path.isfile(opt.resume):
            print("=> loading checkpoint '{}'".format(opt.resume))
            checkpoint = torch.load(opt.resume)
            model.load_state_dict(checkpoint['state_dict'])
            print("=> loaded checkpoint '{}' (epoch {})"
                .format(opt.resume, checkpoint['epoch']))
    model.cuda()
    model = torch.nn.parallel.DistributedDataParallel(model,\
        device_ids=[opt.local_rank], output_device=opt.local_rank)

    optimizer = optim.SGD([
            {'params': get_parameters(model, bias=False)},
            {'params': get_parameters(model, bias=True), 'lr':opt.lr * 2, 'weight_decay': 0},
            {'params': get_parameters(model, bn=True), 'lr':opt.lr * 1.00001001358, 'weight_decay':0}
        ], lr=opt.lr, momentum=opt.momentum, weight_decay=opt.weight_decay)

    if opt.resume:
        if os.path.isfile(opt.resume):
            checkpoint = torch.load(opt.resume)
            optimizer.load_state_dict(checkpoint['optimizer'])

    scheduler = optim.lr_scheduler.MultiStepLR(optimizer, \
        milestones=[8,10,12,14,15,16,17,18,19,20,21,22,23,24], gamma=0.5)

    for epoch in range(opt.start_epoch, opt.epoch + 1):
        train_sampler.set_epoch(epoch)
        scheduler.step() 
        model.train()
        train(epoch)

我还尝试了一些其他解决方案：

1. 关闭 pin_memory
2. 来自这里的拉取请求
3. mp.set_start_method('spwan') 它们都不起作用。为我安排num_workers=0工作，但速度不够快。

嘿@yingjianling，你能制作一个我可以复制的版本吗？例如，torchvision中有没有我们可以使用的模型来代替models.se_resnet34_v3？我真的很想为你调查一下这个问题。

编辑：如果我们可以使用 torchvision 数据集之一，我可以要求它下载，那是最简单的。

我创建了以下代码片段（如下）来尝试简化和重现该问题，但对于 8 个工作人员、20 个时期和批量大小为 100 的我来说，它工作正常。您是否可能错误地设置了较高的类别数？

编辑：抱歉，忘记提及现在只有 2 个 GPU，正在努力获取 8 个 GPU 的机器。使用更少的 GPU 是否重要，或者无论您使用的 GPU 数量如何，您都会遇到这个问题吗？

更新：8 gpu 机器似乎也可以在 --workers=8 下正常运行，至少 30 个周期。

import argparse,os,time
import torch.multiprocessing as mp
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torch.distributed as dist
import torch.utils.data.distributed
import torchvision
from torchvision import datasets, transforms
import numpy as np

class MLPNet(nn.Module):
    def __init__(self):
        super(MLPNet, self).__init__()
        self.fc1 = nn.Linear(28*28, 500)
        self.fc2 = nn.Linear(500, 256)
        self.fc3 = nn.Linear(256, 10)

    def forward(self, x):
        x = x.view(-1, 28*28)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

    def name(self):
        return "MLP"

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('--start_epoch', type=int, default=1, help='start epoch number')
    parser.add_argument('--epoch', type=int, default=25, help='number of epochs to train for')
    parser.add_argument('--lr', type=float, default=0.1, help='learning rate, default=0.1')
    parser.add_argument('--momentum', type=float, default=0.9, help='momentum, default=0.9')
    parser.add_argument('--weight_decay', type=float, default=0.0002, help='weight_decay, default=0.0002')
    parser.add_argument('--batch_s', type=int, default=64, help='input batch size')
    parser.add_argument('--grid_s', type=int, default=8, help='grid size')
    parser.add_argument('--data', type=str, default='../vgg2data', help='data directory')
    parser.add_argument('--workers', type=int, default=1, help='number of data loading workers')
    parser.add_argument('--output_dir', type=str, default='./output/', help='model_saving directory')
    parser.add_argument('--resume', type=str, default='', help='resume')
    parser.add_argument("--display_interval", type=int, default=50)
    parser.add_argument("--local_rank", type=int)
    opt = parser.parse_args()

    torch.cuda.set_device(opt.local_rank)

    dist.init_process_group(backend='nccl', init_method='env://')

    trans = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (1.0,))])
    mnist = torchvision.datasets.MNIST(root="~/Documents/workspace/datasets/mnist", train=True, transform=trans, download=True)

    train_sampler = torch.utils.data.distributed.DistributedSampler(mnist)
    train_loader = torch.utils.data.DataLoader(
            mnist,
            batch_size=opt.batch_s,
            num_workers=opt.workers,
            drop_last=True,
            pin_memory=False,
            shuffle=False,
            sampler=train_sampler
        )

    model = MLPNet().cuda()
    criterion = nn.CrossEntropyLoss()
    model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[opt.local_rank], output_device=opt.local_rank)
    optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

    scheduler = optim.lr_scheduler.MultiStepLR(optimizer,
        milestones=[8,10,12,14,15,16,17,18,19,20,21,22,23,24], gamma=0.5)

    for epoch in range(opt.start_epoch, opt.epoch + 1):
        print(epoch)
        train_sampler.set_epoch(epoch)
        scheduler.step()
        for batch_idx, (x, target) in enumerate(train_loader):
          optimizer.zero_grad()
          x, target = x.cuda(), target.cuda()
          out = model(x)
          loss = criterion(out, target)
          loss.backward()
          optimizer.step()

仅供参考@mcarilli

@yingjianling 我的印象是，在使用时datasets.ImageFolder，数据集从数据目录中的文件夹数量推断类的数量。也许正如 @mruberry 所说，推断的数字与您手动指定的数字 (9092) 之间不匹配，这在某种程度上导致了问题。

我将尝试在本地重现该故障。可以使用易于访问的（例如 torchvision）数据集来触发它吗？

@mruberry嗨，这个问题仅在数据集很大时发生。我尝试过 MNIST 数据集和只有 34 个类的小版本 vggface2 数据集，并且工作正常。然而，当我使用完整版的vggface2数据集时，发生了这个错误。顺便说一句，我认为使用带有 resnet 模型的 imagenet 数据集可能会重现这个问题。

@mcarilli 我用来ls -l |grep "^d"|wc -l获取文件夹的数量。我认为不匹配可能不是原因，因为当我使用num_workers=0完整版本的 vggface2 数据集（同时使用训练集和测试集来训练模型）时，它工作正常。

@yingjianling 好的，我会用 imagenet 尝试一下。不过今天我可能没有机会了。

当我运行 apex/example/imagenet/main.py 时，我遇到了同样的问题。火车数据是 imagenet 我的命令是python -m torch.distributed.launch --nproc_per_node=2 main.py --fp16 --arch resnet18 --epochs 90 --workers 25 --batch-size=256 /imagenet

PyTorch 版本：0.4.1 torchvision 版本：0.2.1 操作系统：Ubuntu 16.04.3 LTS

Python 版本：3.6 CUDA 是否可用：是 CUDA 运行时版本：9.2 Nvidia 驱动程序版本：396.44 GPU 型号和配置： GPU 0：Tesla V100-SXM2 GPU 1：Tesla V100-SXM2

@wangdongxuking61 谢谢，我现在在本地运行 Pytorch dockerhub 容器（版本 0.4.1）。我确实在第一个纪元结束时收到错误，但它并不是无声的：

ConnectionResetError: [Errno 104] Connection reset by peer

25 名工人数量异常庞大。拥有比机器上（逻辑）核心数量更多的工作线程是没有意义的，对吧？

作为最初的健全性检查，我将尝试两件事： 1. 每个进程运行更少的工作人员。2.使用top-of-tree pytorch运行。

有趣的。正如我之前所说，如果我在 Dockerhub pytorch/pytorch 容器中运行，我会看到以下内容。命令：

python -m torch.distributed.launch --nproc_per_node=2 main.py --fp16 --arch resnet18 --epochs 90 --workers 2 --batch-size=128 .

结果

Epoch: [0][4990/5005]   Time 0.249 (0.247)  Speed 1026.899 (1037.399)   Data 0.041 (0.079)  Loss 4.9688 (5.8149)    Prec@1 10.547 (4.484)   Prec@5 25.781 (12.641)
Process Process-1:
...
ConnectionResetError: [Errno 104] Connection reset by peer

换句话说，错误发生在第一个 epoch 结束时、验证之前。

如果我在 18.09 容器中运行，该容器具有从上个月的 master 分叉的 Pytorch 版本，我会看到

python -m torch.distributed.launch --nproc_per_node=2 main.py --fp16 --arch resnet18 --epochs 90 --workers 2 --batch-size=128 

通过多个时期的训练和验证愉快地训练。

@yingjianling 我意识到这是“黑匣子”/cargo 邪教调试，但是你可以尝试使用树顶 Pytorch 而不是 0.4.1 来运行你的案例吗？我不知道数据加载器之间发生了什么变化，但如果树顶成功，至少我们有更多信息。

@mcarilli 非常感谢您的回复。我会尝试一下。

@mcarilli 我可以使用 18.06.1 docker 这是我可以更新以通过运行获取您的 pytorch 映像的最新版本吗docker pull pytorch/pytorch？

docker pull pytorch/pytorch拉取由 Facebook 人员创建的官方 Pytorch 容器，其中包含（据我所知）Pytorch 0.4.1。

18.0* 容器是 Nvidia 创建的容器，可通过 Nvidia NGC 获取。它们包含滚动更新的 Pytorch master 快照，但公开可用的 NGC 容器中的快照往往落后于树顶 master 1-2 个月。比如我刚刚训练成功的18.09容器还没有公开。

由于这种滞后，IMO 在您的情况下最好尝试的方法是从 Github 拉取最新的 Pytorch master 并从源代码重建。如果您没有在裸机上安装 NCCL 或 CuDNN，请 pull pytorch/pytorch:0.4.1-cuda9-cudnn7-devel，其中应包含 NCCL 和 CUDNN 共享对象库。在该容器中，您可以卸载现有的 Pytorch (0.4.1) 并重新编译树顶：

pip uninstall torch
git clone https://github.com/pytorch/pytorch.git
cd pytorch
python setup.py install

编译大约需要 20 分钟，但使用更新的 Pytorch 确实对我有帮助，所以也许这将启用您的用例。

现在我讲述我的故事...

首先，我想fp16在我的服务器上运行 apex/example/imagenet/main.py （有 2 个 V100，56 个逻辑核心）。

但我总是得到ConnectionResetError: [Errno 104] Connection reset by peer和EOFError

在第一个时期的最后几次迭代中。

于是我就去看了pytorch的关于dataloader.py. 问题10366和我的类似。所以我更新dataloader.py到最新版本。然后我得到了 shut down on second epoch错误（也许是其他原因导致了错误，我记不清了，因为我做了很多尝试来避免错误ConnectionResetError......）。然后我在这个问题上报告我的问题。

今天，我现在无法shut down on second epoch再次重现错误，但我确信我已经遇到了它。现在我只收到第一个错误：ConnectionResetError: [Errno 104] Connection reset by peer并且EOFError

所以我做了很多测试...

• Ps1：test1,2,3仅在apex的DDP上进行测试。test4,5,6 在 和 上进行了apex' DDP测试torch.nn.parallel.DistributedDataParallel。结果与这两个DDP无关。
• Ps2：我使用mp.set_start_method('forkserver')，它没用。而且我也把python3.6改成2.7,3.7，也没用...

命令是：

# test1
python -m torch.distributed.launch --nproc_per_node=2 main.py --fp16 --arch resnet18 --epochs 90 --workers 25 --batch-size=256 /imagenet

# test2 test3
# the same as test1

# test4
# should change: nproc_per_node, batch-size, --fp16

# test5, test6
# should change: nproc_per_node, batch-size, --fp16
python -m torch.distributed.launch --nproc_per_node=NUM_GPUS_YOU_HAVE --nnodes=2 --node_rank=0 --master_addr="192.168.1.1" --master_port=1234 main.py --fp16 --arch resnet18 --epochs 90 --workers 25 --batch-size=256 /imagenet

我个人的结论，错误只会在某种情况下发生：

• torch版本> = 0.4.1（与dataloader.py相关）
• DDP进程数=2（1台服务器有2块GPU，或者2台服务器各有1块GPU）

另外两条信息：

• python torch-0.4.1/test/test_dataloader.py也会导致ConnectionResetError: [Errno 104]（torch0.4.1安装在python env中）。

  但是 torch-0.4.0/test/test_dataloader.py 是可以的（torch0.4.0 安装在 python 环境中）。

• 停止的迭代次数与worker编号相关，类似线性关系

如果你不介意这个bug，那么使用pytorch训练的话，我建议尝试使用这两种方法之一： 1、使用pytorch-0.4.0 2、torch.nn.parallel.DataParallel替代DistributedDataParallel

翻译如下：如果你不关心这个bug，只想使用pytorch训练，我建议你尝试以下两种方法之一：1使用pytorch-0.4.0 2使用torch.nn.parallel.DataParallel而不是DistributedDataParallel

@wangdongxuking61 我们有一些证据表明它已在 master 中修复。您介意构建 PyTorch master 并看看它是否仍然存在问题吗？那会有很大帮助！

确实如此，我的测试表明，当我使用相对较新版本的 Pytorch master 运行时，错误消失了（几乎位于树顶，但不完全是）。dataloader.py 也从其他文件中提取实用程序，这些文件可能已更新。

我在上一篇文章中提供了如何使用最新的 Pytorch master 构建容器的说明，而无需手动安装 NCCL 或 CuDNN （@ezyang 可能比我更了解，所以如果有更简单/更多的方法，请纠正我执行此操作的规范方法）

好吧，我正在训练主构建。我稍后再报告。

成功到达 epoch 1

@wangdongxuking61 如果你能给我一个可以重现该问题的 docker 镜像名称，我可以再试一次。与此同时，我还建议进行主构建。请注意，您可能需要根据此补丁更改 apex 代码： https: //gist.github.com/SsnL/6427cbf04a3c5e765f7de6e0874cfb50，以及 pytorchtorch/utils/data/distributed.py的导入到import torch.distributed.deprecated as dist.

@mcarilli @ezyang @SsnL

谢谢你们。我已经构建了 PyTorch master。问题就消失了。BTW，谁能解释一下这个bug的原因？

正如我之前所说，我无法重现该shut down on second epoch错误。但我可以轻松地在第一个时期的最后几次迭代中重现ConnectionResetError: [Errno 104] Connection reset by peer或错误：EOFError

• 蟒蛇3.6
• 火炬0.4.1
• 顶点/示例/imagenet/main.py

  python -m torch.distributed.launch --nproc_per_node=2 main.py --fp16 --arch resnet18 --epochs 90 --workers 2 --batch-size=128

@wangdongxuking61 @mcarilli 谢谢你的回复。问题已经被楼主解决了。

@wangdongxuking61 我相信这些也已经在 master 中得到了修复。

是的，构建 master 后我没有收到任何错误。谢谢。

我在 pytorch 1.1 版本中遇到了同样的问题。我想知道哪个版本好？

根据这里的时间安排，1.2应该没问题