Win10+GPU版Pytorch1.1安装的安装步骤

以下是Win10+GPU版Pytorch1.1安装的完整步骤攻略：

步骤1：安装CUDA

首先需要安装NVIDIA CUDA Toolkit，前往NVIDIA官网下载对应的版本。安装时需要注意选择适合你电脑的操作系统和显卡型号的版本。

安装完成后，需要将CUDA的bin和lib路径加入到环境变量PATH中。

步骤2：安装cuDNN

cuDNN是NVIDIA针对深度学习推出的GPU加速库，可以提高PyTorch的性能。前往NVIDIA官方网站下载对应的cuDNN版本，并解压到CUDA的安装目录下。

在解压后的文件夹中，可以看到包含了多个文件，将其加入到环境变量中的方法和上一步类似。

步骤3：安装Anaconda

Anaconda是一个Python的集成开发环境，包含了Python解释器以及数个常用第三方库。

前往Anaconda官网下载对应的版本。安装时需要注意在安装向导中选择添加Anaconda到系统环境变量。

步骤4：创建Python虚拟环境

使用Anaconda自带的conda命令创建一个Python虚拟环境，这可以避免多个Python版本互相干扰。

conda create --name pytorch_gpu python=3.6

该命令会在Anaconda安装目录下的envs文件夹中创建一个名为pytorch_gpu的Python虚拟环境。其中python=3.6表示使用Python 3.6版本，可以根据需要修改。

步骤5：激活Python虚拟环境

创建成功后，需要通过以下命令激活该虚拟环境。

activate pytorch_gpu

Windows系统中，如果没有安装Anaconda，则需要使用以下命令激活虚拟环境。

conda activate pytorch_gpu

步骤6：安装PyTorch

使用conda命令安装PyTorch。

conda install pytorch torchvision cudatoolkit=9.0 -c pytorch

该命令会自动安装适合当前环境的PyTorch和Torchvision。

步骤7：测试PyTorch

安装完成后，通过以下命令检查PyTorch是否安装成功。

python -c "import torch;print(torch.__version__)"

执行后，将会输出当前电脑上安装的PyTorch版本号。

示例说明1：使用PyTorch进行MNIST训练

下面是一个使用PyTorch训练MNIST数据集的示例。首先需要从torchvision.datasets中加载MNIST的训练数据和测试数据。

import torch
import torchvision

train_dataset = torchvision.datasets.MNIST('.', train=True, download=True, transform=torchvision.transforms.ToTensor())
test_dataset = torchvision.datasets.MNIST('.', train=False, download=True, transform=torchvision.transforms.ToTensor())

然后使用torch.nn创建一个简单的神经网络模型，这里使用一个包含一层隐含层的多层感知机。

class MLP(torch.nn.Module):
    def __init__(self):
        super(MLP, self).__init__()
        self.fc1 = torch.nn.Linear(784, 256)
        self.fc2 = torch.nn.Linear(256, 10)

    def forward(self, x):
        x = x.view(-1, 784)
        x = torch.nn.functional.relu(self.fc1(x))
        x = self.fc2(x)
        return x

model = MLP()

然后定义损失函数和优化器。

criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

最后使用训练数据对神经网络进行训练。

for epoch in range(10):
    for i, (images, labels) in enumerate(train_loader):
        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

示例说明2：使用PyTorch进行图像分割

下面是一个使用PyTorch进行图像分割的示例。首先需要从torchvision.datasets中加载图像数据集。

import torchvision.datasets as datasets
import torchvision.transforms as transforms

dataset = datasets.Cityscapes('./data/cityscapes', split='train', mode='fine', target_type='semantic',
                              transform=transforms.Compose([
                                  transforms.RandomCrop((256, 512)),
                                  transforms.ToTensor(),
                                  transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
                              ]))

然后使用torch.utils.data.DataLoader对数据集进行封装。

from torch.utils.data import DataLoader

dataloader = DataLoader(dataset, batch_size=8, shuffle=True, num_workers=4)

然后定义一个简单的UNet网络结构。

import torch
import torch.nn as nn

class UNet(nn.Module):
    def __init__(self):
        super().__init__()

        def down(in_channels, out_channels):
            return nn.Sequential(
                nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1),
                nn.BatchNorm2d(out_channels),
                nn.LeakyReLU(inplace=True),
                nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1),
                nn.BatchNorm2d(out_channels),
                nn.LeakyReLU(inplace=True),

            )

        def up(in_channels, out_channels):
            return nn.Sequential(
                nn.ConvTranspose2d(in_channels, out_channels, kernel_size=2, stride=2),
                nn.BatchNorm2d(out_channels),
                nn.LeakyReLU(inplace=True)
            )

        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)

        self.down1 = down(3, 64)
        self.down2 = down(64, 128)
        self.down3 = down(128, 256)
        self.down4 = down(256, 512)

        self.center = down(512, 1024)

        self.up4 = up(1024, 512)
        self.up3 = up(512, 256)
        self.up2 = up(256, 128)
        self.up1 = up(128, 64)

        self.final = nn.Conv2d(64, 34, kernel_size=1)


    def forward(self, x):
        x1 = self.down1(x)
        x2 = self.pool(x1)
        x2 = self.down2(x2)
        x3 = self.pool(x2)
        x3 = self.down3(x3)
        x4 = self.pool(x3)
        x4 = self.down4(x4)
        x5 = self.pool(x4)
        x5 = self.center(x5)
        x = self.up4(x5)
        x = torch.cat([x, x4], dim=1)
        x = self.up3(x)
        x = torch.cat([x, x3], dim=1)
        x = self.up2(x)
        x = torch.cat([x, x2], dim=1)
        x = self.up1(x)
        x = torch.cat([x, x1], dim=1)
        x = self.final(x)
        return x