PyTorch在64位Windows下的編譯

各位，愛折騰的我又來啦！此次我準備搞點不同的，在Windows搞定PyTorch的編譯。

首先，我先簡要介紹一下PyTorch吧。PyTorch是Facebook開發維護的一個符號運算庫，可用於搭建動態的神經網絡。它的代碼簡潔，優美，也具備很強的性能。舉個例子，若是咱們要在Theano或者TensorFlow下進行向量的運算，咱們會先定義一個tensor，再對tensor作計算，而後定義一個function，最後調用函數並傳入參數，得到輸出。樣例代碼：

import theano
import theano.tensor as T
x = T.dmatrix('x')
s = 1 / (1 + T.exp(-x))
logistic = function([x], s)
logistic([[0, 1], [-1, -2]])複製代碼

若是咱們使用PyTorch呢，咱們這樣寫

import torch
x = torch.FloatTensor([[0, 1], [-1, -2]])
s = 1 / (1 + torch.exp(-x))複製代碼

只須要定義變量，便可進行運算。是否是更加符合咱們的思惟呢？

最後我再引用一句話來宣傳一波：

Matlab is so 2012.
Caffe is so 2013.
Theano is so 2014.
Torch is so 2015.
TensorFlow is so 2016. :D

‏ --Andrej Karpathy

‏It's 2017 now.

讓咱們步入正題，看看如何在Windows下安裝PyTorch。

先作一個友情提醒，若是不想折騰的話，對於Windows 10 用戶，能夠在WSL下進行體驗，缺點是不能使用GPU進行計算的加速。或者你也能夠等待官方放出正式的安裝包。下面的安裝過程是測試，不保證可以安裝成功。

首先咱們能夠找到官方repo的相關issue。其中有一位大神已經爲咱們作好了大量的工做，他將他的代碼存放在這裏。固然你也能夠直接使用我最終修改後的代碼，就在他的基礎上作了一點工做，不過個人代碼經過了全部的CUDA單元測試，他的尚未。

首先，咱們須要準備好安裝所須要的工具，包括：

• Visual Studio 2015 with Update 1及以上(不能是2013，2017，緣由我下面會解釋)
• CMake
• 一種BLAS運算庫，好比Openblas或者Intel MKL
• PyTorch的源碼，從上面的地址獲取
• CUDA 7.5及以上
• CUDNN 5.1.10及以上
• Anaconda3 （Python版本3.5及以上）

安裝步驟大體以下：

1. 安裝VS，CUDA，cuDNN， CMake，Anaconda。這沒什麼好多說的，至於爲何必定要VS 2015 Update 1及以上，其實這是我踩坑以後獲得的寶貴經驗。VS 2013對C99標準的支持比較弱， VS 2017 尚且不支持做爲CUDA 8.0的編譯器，而原生的VS 2015 會報一個莫名其妙的連接錯誤。選取Anaconda3的緣由也是爲了兼容C99。
2. 添加環境變量，添加CMake和MSBuild的路徑至PATH中。他們大概在這樣的路徑下：

   C:\Program Files\CMake\bin
   C:\Program Files (x86)\MSBuild\14.0\Bin\amd64複製代碼

3. 定位到pytorch代碼目錄的torch\lib下面，咱們新建一個目錄tmp_install，在這個目錄下面再新建一個目錄lib，而後將blas相關的lib通通丟進去。而後對build_all.bat進行修改，定位到結尾，能夠發現這樣一段代碼

   cmake ../../%~1 -G "Visual Studio 14 2015 Win64" ^
                  -DCMAKE_MODULE_PATH=%BASE_DIR%/cmake/FindCUDA ^
                  -DTorch_FOUND="1" ^
                  -DCMAKE_INSTALL_PREFIX="%INSTALL_DIR%" ^
                  -DCMAKE_C_FLAGS="%C_FLAGS%" ^
                  -DCMAKE_SHARED_LINKER_FLAGS="%LINK_FLAGS%" ^
                  -DCMAKE_CXX_FLAGS="%C_FLAGS% %CPP_FLAGS%" ^
                  -DCUDA_NVCC_FLAGS="%BASIC_CUDA_FLAGS%" ^
                  -DTH_INCLUDE_PATH="%INSTALL_DIR%/include" ^
                  -DTH_LIB_PATH="%INSTALL_DIR%/lib" ^
                  -DTH_LIBRARIES="%INSTALL_DIR%/lib/TH.lib" ^
                  -DTHS_LIBRARIES="%INSTALL_DIR%/lib/THS.lib" ^
                  -DTHC_LIBRARIES="%INSTALL_DIR%/lib/THC.lib" ^
                  -DTHCS_LIBRARIES="%INSTALL_DIR%/lib/THCS.lib" ^
                  -DTH_SO_VERSION=1 ^
                  -DTHC_SO_VERSION=1 ^
                  -DTHNN_SO_VERSION=1 ^
                  -DTHCUNN_SO_VERSION=1 ^
                  -DCMAKE_BUILD_TYPE=Release ^
                  -DLAPACK_LIBRARIES="%INSTALL_DIR%/lib/mkl_rt.lib" -DLAPACK_FOUND=TRUE複製代碼

   能夠將最後一行進行適當的修改，如使用OpenBlas可將其改成openblas.lib；如不打算使用blas，則將最後一行去掉。
4. 打開一個CMD窗口，定位到pytorch代碼根目錄下，而後執行如下代碼：

   cd torch\lib
   build_all.bat --with-cuda複製代碼

   而後你們就能夠喝喝茶，看看電影，度過這個漫長的編譯時間。
5. 檢查一下torch\lib下是否包含THPP.dll，若是沒有的話，說明編譯失敗了。看看以前的輸出，想一想問題大概出在哪裏。
6. 若是順利的話，咱們再鍵入最後兩行命令。

   cd ..\..
   python setup.py install複製代碼

7. 若是沒有報錯的話，恭喜你，安裝成功了。不過，還須要一些小小的操做。咱們先找到cudart和cudnn模塊，他們通常在這個位置：

   C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v8.0\bin\cudart64_80.dll
   C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v8.0\bin\cudnn64_6.dll 
   # 若是使用cudnn v5，那麼就是
   C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v8.0\bin\cudnn64_5.dll複製代碼

8. 將他們拷貝至Anaconda3的Lib\site-packages\torch\lib下面

9. 若是你使用的是cudnn v5的話，打開Anaconda3的Lib\site-packages\torch\backends\cudnn下面的__init__.py。將_libcudnn函數修改成：

   def _libcudnn():
    global lib, __cudnn_version
    if lib is None:
        lib = ctypes.cdll.LoadLibrary("cudnn64_5")
        if hasattr(lib, 'cudnnGetErrorString'):
            lib.cudnnGetErrorString.restype = ctypes.c_char_p
            __cudnn_version = lib.cudnnGetVersion()
        else:
            lib = None
    return lib複製代碼

   就這樣，咱們就完成了PyTorch在64位Windows下的安裝。咱們能夠跑一下MNIST來測試一下：

   from __future__ import print_function
   import argparse
   import time
   import torch
   import torch.nn as nn
   import torch.nn.functional as F
   import torch.optim as optim
   from torchvision import datasets, transforms
   from torch.autograd import Variable
   from torch.backends import cudnn
   if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='PyTorch MNIST Example')
    parser.add_argument('--batch-size', type=int, default=64, metavar='N',
                        help='input batch size for training (default: 64)')
    parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N',
                        help='input batch size for testing (default: 1000)')
    parser.add_argument('--epochs', type=int, default=10, metavar='N',
                        help='number of epochs to train (default: 10)')
    parser.add_argument('--lr', type=float, default=0.01, metavar='LR',
                        help='learning rate (default: 0.01)')
    parser.add_argument('--momentum', type=float, default=0.5, metavar='M',
                        help='SGD momentum (default: 0.5)')
    parser.add_argument('--no-cuda', action='store_true', default=False,
                        help='disables CUDA training')
    parser.add_argument('--seed', type=int, default=1, metavar='S',
                        help='random seed (default: 1)')
    parser.add_argument('--log-interval', type=int, default=10000, metavar='N',
                        help='how many batches to wait before logging training status')
    args = parser.parse_args()
    args.cuda = not args.no_cuda and torch.cuda.is_available()
   
    print('Using CUDA:' + str(args.cuda))
   
    torch.manual_seed(args.seed)
    if args.cuda:
        torch.cuda.manual_seed(args.seed)
   
    class Net(nn.Module):
        def __init__(self):
            super(Net, self).__init__()
            self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
            self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
            self.conv2_drop = nn.Dropout2d()
            self.fc1 = nn.Linear(320, 50)
            self.fc2 = nn.Linear(50, 10)
   
        def forward(self, x):
            x = F.relu(F.max_pool2d(self.conv1(x), 2))
            x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
            x = x.view(-1, 320)
            x = F.relu(self.fc1(x))
            x = F.dropout(x, training=self.training)
            x = self.fc2(x)
            return F.log_softmax(x)
   
    model = Net()
    if args.cuda:
        model.cuda()
   
    # cudnn.enabled = False
    cudnn.benchmark = True
   
    kwargs = {'num_workers': 1, 'pin_memory': True} if args.cuda else {}
    train_dataset = datasets.MNIST('../data', train=True, download=True, transform=transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.1307,), (0.3081,))
    ]))
    test_dataset = datasets.MNIST('../data', train=False, transform=transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.1307,), (0.3081,))
    ]))
    train_loader = torch.utils.data.DataLoader(
        train_dataset, batch_size=args.batch_size, shuffle=True, **kwargs)
    test_loader = torch.utils.data.DataLoader(
        test_dataset, batch_size=args.batch_size, shuffle=True, **kwargs)
   
    optimizer = optim.SGD(model.parameters(), lr=args.lr,
                          momentum=args.momentum)
   
    def train(epoch):
        model.train()
   
        for batch_idx, (data, target) in enumerate(train_loader):
            if args.cuda:
                data, target = data.cuda(), target.cuda()
            data, target = Variable(data), Variable(target)
            optimizer.zero_grad()
            output = model(data)
            loss = F.nll_loss(output, target)
            loss.backward()
            optimizer.step()
   
            if batch_idx % args.log_interval == 0:
                print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                          epoch, batch_idx *
                          len(data), len(train_loader.dataset),
                          100. * batch_idx / len(train_loader), loss.data[0]))
   
    def test(epoch):
        model.eval()
        test_loss = 0
        correct = 0
        for data, target in test_loader:
            if args.cuda:
                data, target = data.cuda(), target.cuda()
            data, target = Variable(data, volatile=True), Variable(target)
            output = model(data)
            test_loss += F.nll_loss(output, target).data[0]
            # get the index of the max log-probability
            pred = output.data.max(1)[1]
            correct += pred.eq(target.data).cpu().sum()
   
        test_loss = test_loss
        # loss function already averages over batch size
        test_loss /= len(test_loader)
        print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
            test_loss, correct, len(test_loader.dataset),
            100. * correct / len(test_loader.dataset)))
   
    for epoch in range(1, args.epochs + 1):
        train(epoch)
        test(epoch)複製代碼

爲啥必定要在外層用主模塊判斷呢？實際上是由於如今PyTorch在Windows下的Multi Processing庫還存在一些問題，在DataLoader加載時，會用另一個線程從新打開該文件，形成衝突。其餘基本上沒有太大的問題，能夠正常使用。MNIST的運行實測以下圖，跑的仍是挺快的。

以上，就是文章的所有內容啦，若是感受還意猶未盡的話，能夠給個人Github 主頁或者 項目加個watch或者star之類的（滑稽），之後說不定還會再分享一些相關的經驗。