机器学习入门篇之环境的搭建

基本环境和软件

大家好，这是本人第一次写博客。
由于课程需要和本人兴趣，之前一段时间从零开始探索如何搭建深度学习所需的环境。
因为之前看到csdn上关于如何从零到有搭建出可以使用GPU运行深度学习的简单环境的文章比较分散且时间比较久远，互联网更新换代速度太快，不可避免的会出现许多不可预料的问题，本人在排查完这些雷区之后决定写一篇文章整合现有的资源，结合自己的经验，概述如何从0到1。旨在帮助机械院2020学年人工智能班级的同学节约宝贵的时间，维持充满热情的心态。由于本人也是新手小白，如有错误，恳请各路大神批评指正。
在本篇博客中，我们针对N卡和win10用户，首先安装CUDA和CUDNN，然后使用anaconda搭建pytorch环境，在pycharm中运行最基本的全神经连接网络代码，实现mnist的手写字识别。

CUDA和CUDNN的安装

官方英文安装教程

CUDA: link.
CUDNN: link.

CUDA的安装

十系显卡直接安装最新版即可，早期版本显卡请自行查询对应的CUDA版本
CUDA下载链接：link.

按如上图所示选择本地下载，
下载完成之后进行安装，可以自行选择安装路径，进行到如下这一步时请务必选择自定义安装

记住自己的安装路径，方便之后配置环境变量和安装cuDNN
安装结束后：
win+r 输入cmd调出控制台，确认安装：nvcc -V

至此，CUDA安装完成。

cuDNN的安装

下载链接：link.
下载之前需要注册，按流程操作即可

登录之后进入下载界面，打勾之后选择对应的版本，这里我们直接选择第一个就好了
下载后将文件解压，将cuDNN解压后文件路径中对应的文件拷贝到CUDA刚刚的安装路径中，（lib/x64、bin、include）
最后添加环境变量，右键此电脑—属性—高级系统设置，选择环境变量
双击Path，进入编辑界面

新建环境变量：C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.0\lib\x64（对应自定义安装的路径）
至此，cuDNN安装完成。

使用anaconda搭建pytorch

anaconda的安装

anaconda官方下载网站: link.
如果你够顶的话，可以直接在此网站自行选择对应版本下载
但是在国内的网络环境中，横跨太平洋的服务器总是和我们有些距离，所以我们一般会用到清华大学的开源镜像网站，不仅仅是在此软件的安装上。
清华大学资源地址: link.
如果你也是64位系统的话，这里我们选择此项进行下载

下载完成后，按流程进行安装，中间可自行指定安装路径，进行到下图
请务必勾选第一项添加环境变量，其后按流程操作即可。
至此，anaconda安装完成，下面我们开始搭建环境
安装完成后，请大家切勿随意卸载anaconda，如要卸载，请保证注册表信息全部清除。

使用anaconda搭建pytorch环境

打开anaconda navigator，第一次打开会需要3-5min，稍安勿躁
我们开始准备搭建环境
选择environment下的create选项，这里我们直接搭建是行不通的，还是之前提到过的网络问题，跨越太平洋的信号总是那么顶，我们需要把系统默认的源下载地址改成我们自己的镜像地址，用的还是清华大学的资源
在 C:\Users\用户名 路径下有一个.condarc的记事本文件，我们将里面的内容修改为如下
这里将清华大学的此部分帮助贴出来，大家可以根据他的提示操作
link.
修改完文件之后，我们再次创建新环境

这里我们创建一个pytorch的新环境（我打错了，难顶难顶，你们不要在意），解释器选择python3.7
创建完成后我们来添加环境变量
我们来到anaconda的安装目录下，有一个名为envs的文件夹
选择我们刚刚新建的环境pytorch

其中有一个scripts文件夹，复制其路径
路径后部分应为anaconda3\envs\pytorch\Scripts
依旧右击此电脑—高级系统属性—环境变量

选择用户变量的Path项进行编辑，将刚刚复制的路径添加进去即可

接着我们准备安装pytorch，打开anaconda prompt
然后输入“activate pytorch”，将当前环境切换到刚刚创建的新环境pytorch

我们进入官方提供的地址生成pytorch的下载命令
link.

按如上图选择即可，然后将生成的命令复制到prompt执行

输入y，等待下载完成即可。
下面我们开始验证pytorch是否安装成功，在命令行键入python
并导入torch模块，成功后如下图所示

至此，pytorch的环境搭建完成。

python和pycharm的安装

请自行百度，网上的教程也都能用，因为装了太久…我已经忘了，难顶难顶

代码测试

pycharm中新建pytorch环境项目运行代码

新建项目中选择我们刚刚创立好的环境，接下来就可以编写代码了

例程代码

为了方便大家，我直接给大家贴上两篇测试代码，资料来源于网络，因为比较久远，本人记忆力老化，来源已经不可考了，就谢谢各路大神⑧

import torch
import torchvision
import torchvision.transforms as transforms
import torch.utils.data.dataloader as dataloader
import torch.nn as nn
import torch.optim as optim
import os
os.environ["CUDA_VISIBLE_DEVICES"] = "3"


train_set = torchvision.datasets.MNIST(
    root="./data",
    train=True,
    transform=transforms.ToTensor(),
    download=True
)
train_loader = dataloader.DataLoader(
    dataset=train_set,
    batch_size=100,
    shuffle=False,
)

test_set = torchvision.datasets.MNIST(
    root="./data",
    train=False,
    transform=transforms.ToTensor(),
    download=True
)
test_loader = dataloader.DataLoader(
    dataset=test_set,
    batch_size=100,
    shuffle=False,
)

class NeuralNet(nn.Module):

    def __init__(self, input_num, hidden_num, output_num):
        super(NeuralNet, self).__init__()
        self.fc1 = nn.Linear(input_num, hidden_num)
        self.fc2 = nn.Linear(hidden_num, output_num)
        self.relu = nn.ReLU()

    def forward(self,x):
        x = self.fc1(x)
        x = self.relu(x)
        y = self.fc2(x)
        return y


epoches = 20
lr = 0.001
input_num = 784
hidden_num = 500
output_num = 10
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

model = NeuralNet(input_num, hidden_num, output_num)
model.to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=lr)


for epoch in range(epoches):
    for i, data in enumerate(train_loader):
        (images, labels) = data
        images = images.reshape(-1, 28*28).to(device)
        labels = labels.to(device)

        output = model(images)
        loss = criterion(output, labels)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if (i+1) % 100 == 0:
            print('Epoch [{}/{}], Loss: {:.4f}'
                  .format(epoch + 1, epoches, loss.item()))


with torch.no_grad():
    correct = 0
    total = 0
    for images, labels in test_loader:
        images = images.reshape(-1, 28*28).to(device)
        labels = labels.to(device)
        output = model(images)
        _, predicted = torch.max(output, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    print("The accuracy of total {} images: {}%".format(total, 100 * correct/total))

运行结果如下

再插入一段雷指导提供的代码：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
import  torch.nn.functional as F

batch_size =200
epochs=10
learning_rate = 0.01
train_data_1=datasets.MNIST("data",train=True,download=True,transform=transforms.Compose(
    [transforms.ToTensor(),transforms.Normalize((0.1307,),(0.3081,))]))
train_batch_data=DataLoader(train_data_1,batch_size=batch_size,shuffle=True)
test_data=datasets.MNIST("data",train=False,transform=transforms.Compose(
    [transforms.ToTensor(),transforms.Normalize((0.1307,),(0.3081,))]))
test_batch_data=DataLoader(test_data,batch_size=batch_size,shuffle=True)
train_data_1,validation_data_2=torch.utils.data.random_split(train_data_1,[50000,10000])
train_batch_data_1=torch.utils.data.DataLoader(train_data_1,batch_size=batch_size,shuffle=True)
validation_batch_data2=DataLoader(validation_data_2,batch_size=batch_size,shuffle=True)

class FullyConnectedNeuralNet(nn.Module):
   def __init__(self):
      super(FullyConnectedNeuralNet, self).__init__()
      # 定义一个全连接神经网络结构,每层使用Leakly ReLU激活函数
      self.model = nn.Sequential(
         nn.Linear(784, 200),
         nn.LeakyReLU(inplace=True),
         nn.Linear(200, 200),
         nn.LeakyReLU(inplace=True),
         nn.Linear(200, 10),
         nn.LeakyReLU(inplace=True),
      )

   # 定义前向网络
   def forward(self, x):
      x = self.model(x)

      return x
# class ConvNet(nn.Module):
#     def __init__(self):
#         super().__init__()
#         self.conv1=nn.Conv2d(in_channels=1,out_channels=10,kernel_size=5)
#         self.conv2=nn.Conv2d(in_channels=10,out_channels=20,kernel_size=3)
#         self.fc1=nn.Linear(20*10*10,500)
#         self.fc2=nn.Linear(500,10)
#
#     def forward(self, x):
#         in_size = x.size(0)
#         out = self.conv1(x)
#         out = F.relu(out)
#         out = F.max_pool2d(out, kernel_size=2, stride=2)
#         out = self.conv2(out)
#         out = F.relu(out)
#         out = out.view(-1, 20 * 10 * 10)
#         out = self.fc1(out)
#         out = F.relu(out)
#         out = self.fc2(out)
#         out = F.log_softmax(out, dim=1)
#         return out

DEVICE=torch.device("cuda"if torch.cuda.is_available() else exit)
net=FullyConnectedNeuralNet().to(DEVICE)
#optimizer=optim.Adam(net.parameters())
optimizer = optim.SGD(net.parameters(), lr=learning_rate)

for epoch in range(epochs):
   # train_batch_data_1每次从train_data_1训练集中取出batch_size个样本进行训练
   for iter_index, (data, label) in enumerate(train_batch_data_1):
      data = data.view(-1, 28 * 28)
      # 训练数据和训练标签都放到GPU中训练
      data, label = data.to(DEVICE), label.to(DEVICE)
      optimizer.zero_grad()
      preds = net(data)
      # 计算损失函数结果
      loss = F.nll_loss(preds, label)
      # 每轮iteration反向传播梯度更新参数
      loss.backward()
      # optimizer.step()用在每个batch中,使用optimizer.step(),模型参数才会更新
      optimizer.step()
      # 每训练100轮iteration100轮打印loss值
      if iter_index % 10 == 0:
         print("epoch:{} [{}/{}({:.0f}%)],train_loss: {:.6f}".format(epoch, iter_index * len(data),
                                                                    len(train_batch_data_1.dataset),
                                                                    100.0 * iter_index / len(train_batch_data_1),
                                                                    loss.item()))


   validation_loss=0
   validation_acc=0
   for data,label in validation_batch_data2:
        data = data.view(-1, 28 * 28)
        data,label=data.to(DEVICE),label.to(DEVICE)
        preds=net(data)
        validation_loss+=F.nll_loss(preds, label,reduction='sum').item()
        pred_label=preds.data.max(1)[1]
        # print(pred_label.shape)
        validation_acc+=pred_label.eq(label.data).sum()
       #此处可能需要修改

   validation_loss/=len(validation_batch_data2.dataset)
   print("Validation average loss:{:.0f},Validation accuracy:{}/{}({:.6f}%)".format(validation_loss,validation_acc,
                                                                                     len(validation_batch_data2.dataset),
                                                                                     100.0*validation_acc/len(
                                                                                         validation_batch_data2.dataset)))
test_loss=0
test_acc=0
for data,label in test_batch_data:
    data = data.view(-1, 28 * 28)
    data,label=data.to(DEVICE),label.to(DEVICE)
    preds=net(data)
    #print("preds:",preds.shape)
    #print("data:",data.shape)
    #print(pred_label.shape)
    #print(preds.data.max(1)[1].shape)

    test_loss +=F.nll_loss(preds, label,reduction='sum').item()
    pred_label +=preds.data.max(1)[1]

    test_acc +=pred_label.eq(label.data).sum()


test_loss /=len(test_batch_data.dataset)
print("Test average loss:{:.4f},Test accuracy:{}/{}({:.0f}%)".format(test_loss,test_acc,len(test_batch_data.dataset),
                                                                     100.0*test_acc/len(test_batch_data.dataset)))

运行结果如下
好了到了这里，我们就可以说是推开了机器学习的大门，接下来就是看懂代码 改动代码 调试代码的过程了，大家加油，拥抱机器学习吧！！

写在最后

谢谢大家看到这里，有什么错误和问题一定要提出来哦。
顺便一提，大家如果在这篇博客的实际操作过程中或者在后续机器学习的过程中遇到了什么了问题，一定要去问雷同学哦，他非常乐于助人，一定能够帮助你解决这些困难的！
最后希望每一位机械院的同学都能拥有光明的未来！
加油吧，少年。