MNIST 数据集分类

最新推荐文章于 2024-07-16 11:20:53 发布
最新推荐文章于 2024-07-16 11:20:53 发布
阅读量1.8k 收藏 15
点赞数 2
分类专栏： 深度学习 文章标签： 分类 深度学习 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51544319/article/details/127326242
版权

构建简单的CNN对 mnist 数据集进行分类。同时，还会在实验中学习池化与卷积操作的基本作用。

1. 引入库文件

mport torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
import matplotlib.pyplot as plt
import numpy

# 一个函数，用来计算模型中有多少参数
def get_n_params(model):
    np=0
    for p in list(model.parameters()):
        np += p.nelement()
    return np

# 使用GPU训练，可以在菜单 "代码执行工具" -> "更改运行时类型" 里进行设置
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

2. 加载数据

PyTorch里包含了 MNIST， CIFAR10 等常用数据集，调用 torchvision.datasets 即可把这些数据由远程下载到本地，下面给出MNIST的使用方法：

torchvision.datasets.MNIST(root, train=True, transform=None, target_transform=None, download=False)

  • root 为数据集下载到本地后的根目录，包括 training.pt 和 test.pt 文件
  • train，如果设置为True，从training.pt创建数据集就是为训练集，否则从test.pt创建即测试集。
  • download，如果设置为True, 从互联网下载数据并放到root文件夹下
  • transform, 一种函数或变换，输入PIL图片，返回变换之后的数据。
  • target_transform 一种函数或变换，输入目标，进行变换。

配合DataLoader进行使用
loader_data=DataLoader(test_set,batch_size=64,shuffle=True,drop_last=True)

  • 首先传入一个dataset数据类型的数据
  • batch_size：可以理解为一副牌，每个人手里拿几张牌
  • shuffle：是否每次随机抓取，就是是否重新洗牌
  • drop_last：总共的dataset的数量除以batch_size的余数是否保留
  • num_workers：加载数据的时候使用几个子进程
input_size  = 28*28   # MNIST上的图像尺寸是 28x28
output_size = 10      # 类别为 0 到 9 的数字，因此为十类

train_loader = torch.utils.data.DataLoader(
    datasets.MNIST('./data', train=True, download=True,
        transform=transforms.Compose(
            [transforms.ToTensor(),
             transforms.Normalize((0.1307,), (0.3081,))])),
    batch_size=64, shuffle=True)

test_loader = torch.utils.data.DataLoader(
    datasets.MNIST('./data', train=False, transform=transforms.Compose([
             transforms.ToTensor(),
             transforms.Normalize((0.1307,), (0.3081,))])),
    batch_size=1000, shuffle=True)

在这里插入图片描述

2.1 查看数据

除了使用老师提供的plt，还可以使用tensorboard展示

#显示数据集中的部分图像
#除了老师使用的plt还可以使用SummaryWriter
from torch.utils.tensorboard import SummaryWriter
writer=SummaryWriter('logs')#日志文件的存放地址
step=0
for data in train_loader:
  img,target=data
  writer.add_images('train_loader',img,step)
  step=step+1
%load_ext tensorboard
%tensorboard --logdir logs
writer.close()

在这里插入图片描述
这里的图像呈现灰色，是因为前面做了标准化处理transforms.Normalize

3. 创建网络

定义网络时，需要继承nn.Module，并实现它的forward方法，把网络中具有可学习参数的层放在构造函数init中。
注：这两个方法必须重写！

只要在nn.Module的子类中定义了forward函数，backward函数就会自动被实现(利用autograd)。

class FC2Layer(nn.Module):
    def __init__(self, input_size, n_hidden, output_size):
        # nn.Module子类的函数必须在构造函数中执行父类的构造函数
        # 下式等价于nn.Module.__init__(self)        
        super(FC2Layer, self).__init__()
        self.input_size = input_size
        # 这里直接用 Sequential 就定义了网络，注意要和下面 CNN 的代码区分开
        self.network = nn.Sequential(
            nn.Linear(input_size, n_hidden), 
            nn.ReLU(), 
            nn.Linear(n_hidden, n_hidden), 
            nn.ReLU(), 
            nn.Linear(n_hidden, output_size), 
            nn.LogSoftmax(dim=1)
        )
    def forward(self, x):
        # view一般出现在model类的forward函数中，用于改变输入或输出的形状
        # x.view(-1, self.input_size) 的意思是多维的数据展成二维
        # 代码指定二维数据的列数为 input_size=784，行数 -1 表示我们不想算，电脑会自己计算对应的数字
        # 在 DataLoader 部分，我们可以看到 batch_size 是64，所以得到 x 的行数是64
        # 大家可以加一行代码：print(x.cpu().numpy().shape)
        # 训练过程中，就会看到 (64, 784) 的输出，和我们的预期是一致的

        # forward 函数的作用是，指定网络的运行过程，这个全连接网络可能看不啥意义，
        # 下面的CNN网络可以看出 forward 的作用。
        x = x.view(-1, self.input_size)
        return self.network(x)
class CNN(nn.Module):
    def __init__(self, input_size, n_feature, output_size):
        # 执行父类的构造函数，所有的网络都要这么写
        super(CNN, self).__init__()
        # 下面是网络里典型结构的一些定义，一般就是卷积和全连接
        # 池化、ReLU一类的不用在这里定义
        self.n_feature = n_feature
        self.conv1 = nn.Conv2d(in_channels=1, out_channels=n_feature, kernel_size=5)
        self.conv2 = nn.Conv2d(n_feature, n_feature, kernel_size=5)
        self.fc1 = nn.Linear(n_feature*4*4, 50)
        self.fc2 = nn.Linear(50, 10)    
    
    # 下面的 forward 函数，定义了网络的结构，按照一定顺序，把上面构建的一些结构组织起来
    # 意思就是，conv1, conv2 等等的，可以多次重用
    def forward(self, x, verbose=False):
        x = self.conv1(x)
        x = F.relu(x)
        x = F.max_pool2d(x, kernel_size=2)
        x = self.conv2(x)
        x = F.relu(x)
        x = F.max_pool2d(x, kernel_size=2)
        x = x.view(-1, self.n_feature*4*4)
        x = self.fc1(x)
        x = F.relu(x)
        x = self.fc2(x)
        x = F.log_softmax(x, dim=1)
        return x

3.2 定义训练和测试函数

# 训练函数
def train(model):
    model.train()
    # 主里从train_loader里，64个样本一个batch为单位提取样本进行训练
    for batch_idx, (data, target) in enumerate(train_loader):
        # 把数据送到GPU中
        data, target = data.to(device), target.to(device)

        optimizer.zero_grad()
        output = model(data)
        loss = F.nll_loss(output, target)
        loss.backward()
        optimizer.step()
        if batch_idx % 100 == 0:
            print('Train: [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                batch_idx * len(data), len(train_loader.dataset),
                100. * batch_idx / len(train_loader), loss.item()))


def test(model):
    model.eval()
    test_loss = 0
    correct = 0
    for data, target in test_loader:
        # 把数据送到GPU中
        data, target = data.to(device), target.to(device)
        # 把数据送入模型，得到预测结果
        output = model(data)
        # 计算本次batch的损失，并加到 test_loss 中
        test_loss += F.nll_loss(output, target, reduction='sum').item()
        # get the index of the max log-probability，最后一层输出10个数，
        # 值最大的那个即对应着分类结果，然后把分类结果保存在 pred 里
        pred = output.data.max(1, keepdim=True)[1]
        # 将 pred 与 target 相比，得到正确预测结果的数量，并加到 correct 中
        # 这里需要注意一下 view_as ，意思是把 target 变成维度和 pred 一样的意思                                                
        correct += pred.eq(target.data.view_as(pred)).cpu().sum().item()

    test_loss /= len(test_loader.dataset)
    accuracy = 100. * correct / len(test_loader.dataset)
    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
        test_loss, correct, len(test_loader.dataset),
        accuracy))

4.1 在小型全连接网络上训练（Fully-connected network）

n_hidden = 8 # number of hidden units

model_fnn = FC2Layer(input_size, n_hidden, output_size)
model_fnn.to(device)
optimizer = optim.SGD(model_fnn.parameters(), lr=0.01, momentum=0.5)
print('Number of parameters: {}'.format(get_n_params(model_fnn)))

train(model_fnn)
test(model_fnn)

运行结果
在这里插入图片描述

4.2 在卷积神经网络上训练

#@title 3.2 在卷积神经网络上训练
# Training settings 
n_features = 6 # number of feature maps

model_cnn = CNN(input_size, n_features, output_size)
model_cnn.to(device)
optimizer = optim.SGD(model_cnn.parameters(), lr=0.01, momentum=0.5)
print('Number of parameters: {}'.format(get_n_params(model_cnn)))

train(model_cnn)
test(model_cnn)

运行结果
在这里插入图片描述
通过上面的测试结果，可以发现，含有相同参数的 CNN 效果要明显优于 简单的全连接网络，是因为 CNN 能够更好的挖掘图像中的信息，主要通过两个手段：

  • 卷积：Locality and stationarity in images
  • 池化：Builds in some translation invariance

5. 打乱像素顺序再次在两个网络上训练与测试

5.1 图像的形态

考虑到CNN在卷积与池化上的优良特性，如果我们把图像中的像素打乱顺序，这样 卷积 和 池化 就难以发挥作用了，为了验证这个想法，我们把图像中的像素打乱顺序再试试。

首先下面代码展示随机打乱像素顺序后，图像的形态：

#@title 4. 打乱像素顺序再次在两个网络上训练与测试
# 这里解释一下 torch.randperm 函数，给定参数n，返回一个从0到n-1的随机整数排列
perm = torch.randperm(784)
plt.figure(figsize=(8, 4))
for i in range(10):
    image, _ = train_loader.dataset.__getitem__(i)
    # permute pixels
    image_perm = image.view(-1, 28*28).clone()
    image_perm = image_perm[:, perm]
    image_perm = image_perm.view(-1, 1, 28, 28)
    plt.subplot(4, 5, i + 1)
    plt.imshow(image.squeeze().numpy(), 'gray')
    plt.axis('off')
    plt.subplot(4, 5, i + 11)
    plt.imshow(image_perm.squeeze().numpy(), 'gray')
    plt.axis('off')
# 对每个 batch 里的数据，打乱像素顺序的函数
def perm_pixel(data, perm):
    # 转化为二维矩阵
    data_new = data.view(-1, 28*28)
    # 打乱像素顺序
    data_new = data_new[:, perm]
    # 恢复为原来4维的 tensor
    data_new = data_new.view(-1, 1, 28, 28)
    return data_new

# 训练函数
def train_perm(model, perm):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        # 像素打乱顺序
        data = perm_pixel(data, perm)

        optimizer.zero_grad()
        output = model(data)
        loss = F.nll_loss(output, target)
        loss.backward()
        optimizer.step()
        if batch_idx % 100 == 0:
            print('Train: [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                batch_idx * len(data), len(train_loader.dataset),
                100. * batch_idx / len(train_loader), loss.item()))

# 测试函数
def test_perm(model, perm):
    model.eval()
    test_loss = 0
    correct = 0
    for data, target in test_loader:
        data, target = data.to(device), target.to(device)

        # 像素打乱顺序
        data = perm_pixel(data, perm)

        output = model(data)
        test_loss += F.nll_loss(output, target, reduction='sum').item()
        pred = output.data.max(1, keepdim=True)[1]                                            
        correct += pred.eq(target.data.view_as(pred)).cpu().sum().item()

    test_loss /= len(test_loader.dataset)
    accuracy = 100. * correct / len(test_loader.dataset)
    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
        test_loss, correct, len(test_loader.dataset),
        accuracy))

在这里插入图片描述
重新定义训练与测试函数，我们写了两个函数 train_perm 和 test_perm，分别对应着加入像素打乱顺序的训练函数与测试函数。

与之前的训练与测试函数基本上完全相同，只是对 data 加入了打乱顺序操作。

5.2 在全连接网络上训练与测试：

#@title 4.1 在全连接网络上训练与测试：
perm = torch.randperm(784)
n_hidden = 8 # number of hidden units

model_fnn = FC2Layer(input_size, n_hidden, output_size)
model_fnn.to(device)
optimizer = optim.SGD(model_fnn.parameters(), lr=0.01, momentum=0.5)
print('Number of parameters: {}'.format(get_n_params(model_fnn)))

train_perm(model_fnn, perm)
test_perm(model_fnn, perm)

在这里插入图片描述

5.3 在卷积神经网络上训练与测试:

#@title 4.2 在卷积神经网络上训练与测试:
perm = torch.randperm(784)
n_features = 6 # number of feature maps

model_cnn = CNN(input_size, n_features, output_size)
model_cnn.to(device)
optimizer = optim.SGD(model_cnn.parameters(), lr=0.01, momentum=0.5)
print('Number of parameters: {}'.format(get_n_params(model_cnn)))

train_perm(model_cnn, perm)
test_perm(model_cnn, perm)

在这里插入图片描述
从打乱像素顺序的实验结果来看，全连接网络的性能基本上没有发生变化，但是 卷积神经网络的性能明显下降。

这是因为对于卷积神经网络，会利用像素的局部关系，但是打乱顺序以后，这些像素间的关系将无法得到利用。

关于实验中的一些问题

  1. dataloader 里面 shuffle 取不同值有什么区别

当shuffle取True时就是每次取为乱序
取False就不会重新随机排序

  1. transform 里，取了不同值，这个有什么区别？
transform=transforms.Compose(
            [transforms.ToTensor(),
             transforms.Normalize((0.1307,), (0.3081,))])

首先理解transform是对数据进行一些预处理的操作
1. Compose为一个流水线操作，就是依次执行数组里的操作
2. ToTensor将数据转为tensor数据类型
3. Normalize进行归一化处理，这就是为什么查看图片会是灰色的
  1. epoch 和 batch 的区别？
    • Epoch：所有训练样本在神经网络中都进行了一次正向传播和一次反向传播。也就是1个epoch等于使用训练集中的全部样本训练一次。
    • Batch：将整个训练样本分成若干个Batch。
  2. 1x1的卷积和 FC 有什么区别？主要起什么作用？
    • 1x1的卷积是针对矩阵的卷积操作，1x1卷积不改变宽度和高度，只改变channel数，主要作用是升维、降维以及提升网络的非线性；
    • FC是针对神经元的操作。FC的作用主要是将局部特征进行整合，并得到分类标签。
江野_c
关注
  • 2
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SVM算法对MNIST数据集分类
12-24
代码使用matlab编写，压缩包中包含MNIST数据集及其读取函数、SVM算法实现和ReadMe.txt。 SVM算法中使用了PCA降维处理数据减少运行时间，但是由于使用的SMO算法较为原始，运行速度仍然较慢。由于实现未经过任何优化，...
3.MNIST数据集分类
booze_的博客
07-05 4928
大多数示例使用手写数字的MNIST数据集。该数据集包含60,000个用于训练的示例和10,000个用于测试的示例。 每一张图片包含28*28个像素，在MNIST训练数据集中是一个形状为[60000,28,28]的张量，我们首先需要把数据集转成[60000,784],然后才能放到网络中训练。第一个维度数字用来索引图片，第二个维度数字用来索引每张图片中的像素点。一般我们还需要把图片中的数据归一化0~1之间。 MNIST数据集的标签是介于0-9的数字，我们要把标签转化为"one-hotvectors"。一个o
学习笔记：Pytorch对MNIST数据集分类
weixin_45276852的博客
10-22 2082
Pytorch入门学习总结
深度学习：Pytorch实现全连接网络的MNIST数据集分类及性能指标（准确率、精确率、召回率和混淆矩阵）分析
最新发布
Curry0330的博客
07-16 1675
深度学习实战——基于Pytorch实现MNIST数据集分类
PyTorch 之 神经网络 Mnist 分类任务
每天进步一点点！
03-20 3881
在上一篇博客当中，我们通过搭建 PyTorch 神经网络实现了气温预测，这本质上是一个回归任务。在本次博文当中，我们使用 PyTorch 做一个分类任务。其实，分类任务和回归任务在本质上没有任何区别，只是说在结果上是不同的，损失函数是不同的，中间的网络架构却是大体一致的。在本次的分类任务当中，我们使用的数据集是 Mnist 数据集，这个数据集大家都比较熟悉，可以在中获取，主要包括四个文件：文件名称大小内容9,681 kb55000 张训练集，5000 张验证集29 kb。
从手写数字识别入门深度学习丨MNIST数据集详解
热门推荐
OpenDataLab的博客
07-13 4万+
就像无数人从敲下“Hello World”开始代码之旅一样，许多研究员从“MNIST数据集”开启了人工智能的探索之路。
[Python从零到壹] 六十七.图像识别及经典案例篇之基于卷积神经网络的MNIST图像分类
杨秀璋的专栏
07-24 3346
欢迎大家来到“Python从零到壹”，在这里我将分享约200篇Python系列文章，带大家一起去学习和玩耍。图像分类是根据图像信息中所反映的不同特征，把不同类别的目标区分开来的图像处理方法。上一篇文章主要讲解常见的图像分类算法，并介绍了Python环境下的贝叶斯图像分类算法和基于KNN算法的图像分类等案例。这篇文章将利用卷积神经网络实现MNIST（手写数字）图像分类，这也是经典的图像分类案例。希望文章对您有所帮助，如果有不足之处，还请海涵。
KNN算法对MNIST数据集分类
12-24
代码使用matlab编写，压缩包中包含MNIST数据集及其读取函数、KNN算法实现和ReadMe.txt。 KNN算法中使用了PCA降维处理数据减少运行时间，正确率可达95%，有部分注释。请结合ReadMe文件使用。
Chinese MNIST数据集
05-02
中国 MNIST 数据集在纽卡斯尔大学的一个项目框架内收集的数据,可以用于深度学习模型分类识别任务使用。 项目介绍 一百名中国公民参与了数据收集。 每个参与者都用标准黑色墨水笔在一张表格中写下所有 15 个数字，...
SVM实现MNIST数据集分类
01-19
本代码为matlab实现的支持向量机模式识别算法，对MNIST数据集进行三种样本分类，如果电脑内存够大，可以实现更多的类别分类，另外exclass是对随机的两个样本分类，也可以参考，exmuticlassall为对MNIST数据集分类，...
CNN实现MNIST数据集分类
10-28
在“CNN实现MNIST数据集分类”这个项目中，开发者提供了多种不同的CNN结构来解决MNIST手写数字识别问题。MNIST数据集是机器学习和计算机视觉领域的一个经典基准，它包含60,000个训练样本和10,000个测试样本，每个...
Mnist数据集——图像多分类
方寸想法，编码宇宙
04-20 986
文章目录数据集介绍一、Keras方法 数据集介绍 一、Keras方法 1.读取数据集 MNIST 数据集预先加载在Keras 库中，其中包括4 个Numpy 数组。 from keras.datasets import mnist (train_images, train_labels), (test_images, test_labels) = mnist.load_data() 2.查看数据...
CNN简单应用-MNIST数字分类
qq_64334741的博客
11-28 254
MNIST数字分类项目旨在使用机器学习技术来构建一个模型，能够自动识别手写数字的图像。这个项目是一个经典的图像分类任务，常用于入门级机器学习和深度学习示例。我们会使用MNIST数据集，这个数据集包含了一系列28x28像素的手写数字图像，从0到9。项目的目标是训练一个模型，能够准确地将这些手写数字图像分类到正确的数字标签。
Pytorch深度学习——用全连接神经网络实现MNIST数据集分类
Learning_AI的博客
01-24 7450
我们之前学习的案例中，输入x都是一个向量；在MNIST数据集中，我们需要输入的是一个图像，怎样，图像怎么才能输入到模型中进行训练呢？一种方法是我们可以把图像映射成一个矩向量，再输入到模型中进行训练。 怎样将一个图像映射成一个向量？ 如图所示是MNIST数据集中一个方格的图像，它是由28x28=784个像素组成，其中越深的地方数值越接近0，越亮的地方数值越接近1。 因此可以将此图像按照对应的像素和数值映射成一个28x28的一个矩阵，如下...
一文搞清pytorch搭建神经网络实现mnist数据集的分类识别（超详细）
q774798577的博客
01-22 1862
pytorch实现一个简单的神经网络实现手写数字识别
MNIST手写数字识别：分类应用入门（理论篇）
小汤同学
10-20 1893
> 慕课：《深度学习应用开发-TensorFlow实践》 > 章节：第七讲 MNIST手写数字识别：分类应用入门
4.mnist数据集分类（caffe手写数字识别）
罗伊的博客
05-13 1948
由于我使用了Github图库，你可能会遇到我图片无法显示的问题，建议开启VPN查看本文章 1.目的 （1）caffe实现手写数字识别 （2）验证caffe是否安装成功 2.下载手写体数字识别数据集 （1）下载链接： http://yann.lecun.com/exdb/mnist/ （2）准备+存放位置（推荐，你也可以自己选择） 如果你是之前的步骤就跟着我一起弄的话，接下来的步骤就会轻松很多 打开G:\caffe\caffe-windows\examples\mnist文件夹 caffe-w.
机器学习基础+Jupyter编程MNIST数据集10（0-9）个字符的分类识别
lxzysx的博客
04-27 1225
目录定义查准率查全率F1-ScoreROC混淆矩阵MNIST训练一个二分类器性能考核使用交叉验证测量精度混淆矩阵精度和召回率精度/召回率权衡ROC曲线训练一个随机森林分类器，并计算ROC和ROC AUC分数多类别分类器错误分析 定义 查准率 查准率（Precision）（精度）是衡量某一检索系统的信号噪声比的一种指标，即检出的相关文献与检出的全部文献的百分比。普遍表示为：查准率=（检索出的相关信息...
最简单的神经网络-Mnist数据集的分类
Data _designer
10-05 3162
最简单的神经网络-Mnist数据集的分类 线性分类器：y=A×xy = A \times xy=A×x 误差值(E) = （期望目标值-实际输出值）= δA×x\delta A \times xδA×x 适度改进：不要使改进过于激烈，采用几分之一个变化值而不是采用整个变化的∆A(为什么要进行适度改进，即来自真实世界的训练样本会充满噪声或者包含错误，进行适度更新可以有效限制这些错误样本的影响。) 学...
mnist数据集分类
09-06
嗨！对于MNIST数据集分类的任务，您可以使用各种机器学习算法和深度学习模型来完成。以下是一种常用的方法： 1. 数据预处理：首先，您需要加载MNIST数据集并进行预处理。这包括将图像数据转换为适当的格式，并对其进行标准化和缩放。 2. 特征提取：在训练模型之前，您可能需要对图像进行特征提取。对于MNIST数据集来说，这一步骤可以跳过，因为图像已经是数字的灰度图像。如果您使用的是其他图像数据集，可以考虑使用卷积神经网络（CNN）等方法来提取特征。 3. 模型选择：根据您的需求和问题复杂性，选择适当的分类模型。对于MNIST数据集，深度学习模型如卷积神经网络（CNN）在分类任务中表现良好。 4. 模型训练和调优：使用训练集对选定的模型进行训练，并使用验证集进行调优。您可以尝试不同的超参数和优化算法来改善模型性能。 5. 模型评估：使用测试集评估您的模型性能。常用的指标包括准确率、精确率、召回率和F1分数等。 6. 预测：在模型训练和评估完成后，您可以使用模型进行预测。将新的图像输入模型，然后输出对应的分类标签。 这是一个简单的流程，您可以根据需要进行调整和改进。希望对您有所帮助！如果您需要更详细的说明或有其他问题，请随时询问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值