PyTorch安装及CNN手写数字识别

PyTorch安装

1.创建虚拟环境
打开Anaconda Prompt，输入以下命令，创建Python 3.7版本的虚拟环境：

conda create -n pytorch python=3.7

pytorch为环境名称，可以自定义

2.激活虚拟环境
在终端或Anaconda Prompt中输入以下命令，激活环境：

conda activate pytorch

3.安装PyTorch
在激活虚拟环境的状态下，使用pip命令安装PyTorch：

pip install torch==1.2.0 torchvision==0.4.0 -f https://download.pytorch.org/whl/torch_stable.html -i https://pypi.tuna.tsinghua.edu.cn/simple/

4.添加环境变量
输入以下命令，查看PyTorch模块的安装路径：

python -c "import torch as t; print(t.__file__)"

复制到torch部分，比如：

C:\ProgramData\Anaconda3\envs\pytorch\lib\site-packages\torch

依次打开控制面板系统和安全系统高级系统设置环境变量，在系统变量一栏选择Path，点击编辑，点击新建，粘贴上刚刚复制的路径，依次点击三个确定以保存设置。

5.安装matplotlib（根据需要）
调用matplotlib时显示

ModuleNotFoundError: No module named ‘matplotlib’

在虚拟环境运行：

pip install matplotlib

6.调用torchvision（根据需要）
调用torchvision显示

ImportError: cannot import name ‘PILLOW_VERSION’ from ‘PIL’ (C:\ProgramData\Anaconda3\envs\pytorch\lib\site-packages\PIL_init_.py)

解决方法：看评论

若C盘中找不到ProgramData文件夹：
在C盘点击上方的查看，在右侧勾选隐藏的项目
之后按照链接中的方法找到文件后，用记事本打开，修改保存即可

7.在虚拟环境中安装jupyter
使用以下命令安装：

conda install jupyter

（有一点耗时间）

8.打开jupyter
在虚拟环境中输入：

jupyter notebook

CNN手写数字识别

代码来自：CSDN
在此之上加了一些注释

import torch
import numpy as np
from matplotlib import pyplot as plt
from torch.utils.data import DataLoader
from torchvision import transforms
from torchvision import datasets
import torch.nn.functional as F

transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])
#归一化[0,1] 标准化[-1,1]

train_dataset = datasets.MNIST(root='./data/mnist', train=True, download=True, transform=transform)  
test_dataset = datasets.MNIST(root='./data/mnist', train=False, download=True, transform=transform)  
# train=True训练集，=False测试集

需要一点点时间

train_loader = DataLoader(train_dataset, batch_size = batch_size, shuffle = True)
test_loader = DataLoader(test_dataset, batch_size = batch_size, shuffle = False)

fig = plt.figure()
for i in range(12):
    plt.subplot(3, 4, i+1)
    plt.tight_layout()
    plt.imshow(train_dataset.train_data[i], cmap = 'gray')
plt.show()

class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = torch.nn.Sequential(
            torch.nn.Conv2d(1, 10, 5),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(2),
        )
        self.conv2 = torch.nn.Sequential(
            torch.nn.Conv2d(10, 20, 5),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(2),
        )
        self.fc = torch.nn.Sequential(
            torch.nn.Linear(320, 50),
            torch.nn.Linear(50, 10),
        )
        
    def forward(self, x):
        batch_size = x.size(0)
        x = self.conv1(x)
        x = self.conv2(x)
        x = x.view(batch_size, -1) #?
        x = self.fc(x)
        return x

model = Net()

#损失和优化
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), 
                            lr = learning_rate, 
                            momentum = momentum)

def train(epoch):
    running_loss = 0.0
    running_total = 0
    running_correct = 0
    for batch_idx, data in enumerate(train_loader, 0):
        inputs, target = data #输入、标签
        optimizer.zero_grad() #梯度初始化为0
        
        outputs = model(inputs)
        loss = criterion(outputs, target) #交叉熵
        
        loss.backward() #梯度累积
        optimizer.step() #梯度下降 x = x - lr * ( x * grad)
        
        running_loss += loss.item() #loss是一个张量，item()获取数值
        
        _, predicted = torch.max(outputs.data, dim = 1)
        # dim=1时，按行返回最大值所在索引
        #_,predicted = torch.max(outputs.data,dim)：返回最大值所在索引
        #predicted = torch.max(outputs.data,dim)：返回最大值
        #类似独热编码
        
        running_total += inputs.shape[0] 
        #批次大小，第一个批次处理了64张图片
        
        running_correct += (predicted == target).sum().item()
        #(predicted == target)逐元素比较，返回一个布尔数组，True表示相符
        #.sum()计算True的数量,这是一个张量（看不懂，先不管）
        #.item()获取数值
        
        if batch_idx % 300 == 299:
            print('[%d, %5d]: loss: %.3f , acc: %.2f %%'
                 % (epoch + 1, batch_idx + 1, running_loss / 300, 
                    100 * running_correct / running_total))
            #每处理300张图片
            #[%d整数, %5d五位数整数]: loss: %.3f保留三位小数 ,
            #acc: %.2f保留两位 %%百分号
            #输出当前轮次epoch+1，批次编号batch_idx+1
            #平均损失、准确率
            running_loss = 0.0
            running_total = 0
            running_correct = 0

def test():
    correct = 0
    total = 0
    with torch.no_grad():
        #with 上下文管理器，在with区块内的操作不记录梯度no_grad()
        for data in test_loader:
            images, labels = data #输入图片，标签
            outputs = model(images)
            _, predicted = torch.max(outputs.data, dim = 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    acc = correct / total
    print('[%d / %d]: Accuracy on test set: %.1f %% '
         % (epoch + 1, EPOCH, 100 * acc))
    return acc

batch_size = 64
learning_rate = 0.01
momentum = 0.5
EPOCH = 10

if __name__ == '__main__':
    acc_list_test = []
    for epoch in range(EPOCH):
        train(epoch)
        acc_test = test()
        acc_list_test.append(acc_test)
        
    plt.plot(acc_list_test)
    plt.xlabel('Epoch')
    plt.ylabel('Accuracy On TestSet')
    plt.show()

机房电脑十分钟左右就可以完成