通过pytorch，零基础了解深度学习

这是我的代码和注释，你可以通过直接复制代码到你的pycharm中跑起来。

你不需要另外去准备数据集，当本地没有数据集运行代码就会自动下载

这是一个很小的项目，你不需要准备GPU

mnist_train.py

import torch

# nn包用来完成神经网络的搭建
from torch import nn

# functional包含常用的函数
from torch.nn import functional as F

# optim优化数据包，用来更新权重
from torch import optim

# 视觉相关的工具包
import torchvision

# 导入画图工具包
from matplotlib import pyplot as plt

# 从utils 包里导入所需工具
from utils import plot_image, plot_curve, one_hot

# step1. load dataset 加载数据集

# 这里设定一次处理多少张图片
batch_size = 512

# 加载训练集
train_loader = torch.utils.data.DataLoader(
    # 加载MNIST数据集(1.图片路径，2.指定下载的图片为text还是train，3.download若1本地没有则去网上下载，
    # 4.transform格式转换，网上图片一般为numpy格式，转为totensor格式)
    torchvision.datasets.MNIST('mnist_data', train=True, download=True,
                               transform=torchvision.transforms.Compose([
                                   torchvision.transforms.ToTensor(),
                                   torchvision.transforms.Normalize(
                                       (0.1307,), (0.3081,))
                                   # 这个参数是正则化，防止过拟合，防止参数过多或过大，避免模型过复杂。有L1正则化和L2正则化，这里是让参数维持在0的附近均匀的分配
                               ])),  # 0.3081是均差
    batch_size=batch_size, shuffle=True)  # 加载数据并随机打散数据

# 加载测试集
test_loader = torch.utils.data.DataLoader(
    torchvision.datasets.MNIST('mnist_data/', train=False, download=True,
                               transform=torchvision.transforms.Compose([
                                   torchvision.transforms.ToTensor(),
                                   torchvision.transforms.Normalize(
                                       (0.1307,), (0.3081,))
                               ])),
    batch_size=batch_size, shuffle=False)


# # 查看图片
x, y = next(iter(train_loader))
print(x.shape, y.shape, x.min(), x.max())
plot_image(x, y, 'image sample')


# 设置网络层

class Net(nn.Module):

    def __init__(self):
        super(Net, self).__init__()

        # xw + b
        # 第一层，第一个参数为图像大小，第二个参数根据经验值设置输出层大小
        self.fc1 = nn.Linear(28 * 28, 256)
        # 第二层，第一个个参数为上一层的输出大小，第二个大小根据经验设置输出层大小
        self.fc2 = nn.Linear(256, 64)
        # 最后一层，第一个值为上一层输出大小，第二个参数为输出的种类数
        self.fc3 = nn.Linear(64, 10)

    # 计算函数
    def forward(self, x):
        # x:[b,1,28,28]  #relu将线性函数调整变种为非线性函数
        # h1=relu(xw1 +b1)
        x = F.relu(self.fc1(x))
        # h2=relu(h1w2+b20
        x = F.relu(self.fc2(x))
        # 第三层为输出层，一般输出概率值
        x = self.fc3(x)

        return x


# 对创建的神经网络进行初始化
net = Net()

# 设置对计算后的梯度进行梯度更新方法，这里采用SGD随机梯度下降,lr是学习率
optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9)

train_loss = []

for epoch in range(3):
    # 对整个数据集迭代三次
    for batch_idx, (x, y) in enumerate(train_loader):
        # 对整个数据集迭代一次

        # x :
        # print(x.shape,y.shape)

        # 输入
        x = x.view(x.size(0), 28 * 28)

        # 输出
        out = net(x)  # 我们的目的是将输出更加接近于y

        # 将真实的y转为独热编码
        y_onehot = one_hot(y)

        # 通过mse_loss计算误差值,也就是均方差
        loss = F.mse_loss(out, y_onehot)

        # 清零梯度
        optimizer.zero_grad()
        # 计算梯度
        loss.backward()
        # 更新梯度
        optimizer.step()

        # 最后我们会得到较为合适的[w1,b1,w2,b2,w3,b3]

        # 将loss数据收集,以便用matplotlib将其变化图示化
        train_loss.append(loss.item())


        # 查看loss下降的变化
        if batch_idx % 10 == 0:

            print(epoch, batch_idx, loss.item())


 plot_curve(train_loss)

# 我们最终想要看到的并不是loss而是准确率
# 准确度的测试
# 在test测试集取数据然后进行测试
total_correct = 0
for x,y in test_loader:
    x  = x.view(x.size(0), 28*28)
    out = net(x)
    # out: [b, 10] => pred: [b]
    pred = out.argmax(dim=1)
    correct = pred.eq(y).sum().float().item()
    total_correct += correct
145 total_num = len(test_loader.dataset)
acc = total_correct / total_num
print('test acc:', acc)
149 x, y = next(iter(test_loader))
out = net(x.view(x.size(0), 28*28))
pred = out.argmax(dim=1)
plot_image(x, pred, 'test')

utils.py文件中包含的是画图函数，和独热编码的函数，可以直接调用,比如上面的代码就调用了它。将它一并放入你的pycharm中

import torch
from matplotlib import pyplot as plt


# 画一条曲线
def plot_curve(data):
    fig = plt.figure()
    plt.plot(range(len(data)), data, color='blue')
    plt.legend(['value'], loc='upper right')
    plt.xlabel('step')
    plt.ylabel('value')
    plt.show()



# 可视化查看识别结果
def plot_image(img, label, name):
    fig = plt.figure()
    for i in range(6):
        plt.subplot(2, 3, i + 1)
        plt.tight_layout()
        plt.imshow(img[i][0] * 0.3081 + 0.1307, cmap='gray', interpolation='none')
        plt.title("{}: {}".format(name, label[i].item()))
        plt.xticks([])
        plt.yticks([])
    plt.show()


def one_hot(label, depth=10):
    out = torch.zeros(label.size(0), depth)
    idx = torch.LongTensor(label).view(-1, 1)
    out.scatter_(dim=1, index=idx, value=1)  # 生成独热编码
    return out