torch多GPU运行的代码示例

### 回答1：

可以参考PyTorch官方文档给出的多GPU示例，例如下面的代码：import torch#CUDA device 0
device = torch.device("cuda:0")#Create two random tensors
x = torch.randn(3,3).to(device)
y = torch.randn(3,3).to(device)#Multiply two random tensors
z = x * y#Print the result
print(z)

### 回答2：
使用torch运行多个GPU可以通过以下代码示例完成：
import torch
import torch.nn as nn
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP

# 初始化多个GPU设备
device_ids = [0, 1, 2]
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# 定义模型
class MyModel(nn.Module):
def __init__(self):
super(MyModel, self).__init__()
self.fc = nn.Linear(10, 2)

def forward(self, x):
x = self.fc(x)
return x

model = MyModel().to(device)

# 初始化分布式环境
dist.init_process_group(backend="nccl")

# 使用torch.nn.parallel.DistributedDataParallel包裹模型，实现多GPU并行化
model = DDP(model, device_ids=device_ids, output_device=device_ids[0])

# 定义输入数据
input_data = torch.randn(128, 10).to(device)

# 在多个GPU上进行前向传播
output_data = model(input_data)

# 打印输出结果
print(output_data)：

这段代码首先初始化了多个GPU设备，然后定义了一个简单的模型，模型包含一个全连接层。接下来，使用torch.nn.parallel.DistributedDataParallel将模型包裹起来，实现多GPU的并行计算。在初始化分布式环境后，将模型移到指定的设备上，并用DDP包裹。然后，定义了一个输入数据，并将其移到指定的设备上。最后，通过对模型进行前向传播来计算输出结果，并将结果打印出来。

### 回答3：
下面是一个torch多GPU运行的代码示例：

import torch
import torch.nn as nn
import torch.optim as optim
import torch.distributed as dist
import torch.multiprocessing as mp
from torch.nn.parallel import DistributedDataParallel as DDP

def train(model, device, train_loader, optimizer, criterion):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()

def main(rank, world_size):
    # 初始化进程组
    dist.init_process_group(backend='nccl', init_method='env://', world_size=world_size, rank=rank)
    # 创建模型和优化器
    model = Net().to(rank)
    ddp_model = DDP(model, device_ids=[rank])
    optimizer = optim.SGD(ddp_model.parameters(), lr=0.01)

    # 分布式数据加载器
    train_dataset = ...
    train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset)
    train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, sampler=train_sampler)

    # 训练模型
    num_epochs = 10
    for epoch in range(num_epochs):
        train(ddp_model, rank, train_loader, optimizer)
        train_sampler.set_epoch(epoch)

    dist.destroy_process_group()

if __name__ == '__main__':
    # 启动多个进程进行分布式训练
    world_size = torch.cuda.device_count()
    mp.spawn(main, args=(world_size, ), nprocs=world_size)

上述代码示例中，我们使用了torch的`DistributedDataParallel`模块来实现多GPU训练。首先使用`torch.multiprocessing.spawn`方法启动多个进程，并在每个进程中调用`main`函数。在`main`函数中，我们首先使用`dist.init_process_group`初始化进程组，然后创建模型和优化器，并将模型放在指定的GPU设备上。接着，我们使用`torch.utils.data.distributed.DistributedSampler`和`torch.utils.data.DataLoader`创建分布式数据加载器。最后，我们迭代进行训练，并在每个epoch结束时调用`train_sampler.set_epoch(epoch)`来确保每个进程使用不同的数据划分。训练完成后，我们使用`dist.destroy_process_group`结束进程组。