神经网络模型实现（训练、测试）

已于 2024-07-19 13:59:31 修改
阅读量382 收藏 1
点赞数 2
分类专栏： Pytorch 文章标签： 神经网络 深度学习 人工智能
于 2024-07-17 19:47:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53881899/article/details/140498872
版权

目录

一、神经网络骨架：

import torch
from torch import nn


#神经网络
class CLH(nn.Module):
    def __init__(self):
        super().__init__()

    def forward(self, input):
        output=input+1
        return output

clh = CLH()
x = torch.tensor(1.0)
output = clh(x)
print(output)

二、卷积操作：

import torch
import torch.nn.functional as F

input = torch.tensor([
    [1,2,0,3,1],
    [0,1,2,3,1],
    [1,2,1,0,0],
    [5,2,3,1,1],
    [2,1,0,1,1]
])
#卷积核
kernel = torch.tensor([
    [1,2,1],
    [0,1,0],
    [2,1,0]
])
#变化为卷积规定输入格式的维度：这里二维（x,y）转四维（t,z,x,y）
input = torch.reshape(input,(1,1,5,5))
kernel = torch.reshape(kernel,(1,1,3,3))

#对输入矩阵的上下左右进行分别padding扩充1列0，执行一次stride步长为1的卷积
output = F.conv2d(input, kernel, stride=1, padding=1)
print(output)

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

执行过程：
在这里插入图片描述

三、卷积层：

卷积在神经网络中用于提取输入数据的特征，通过与卷积核进行卷积操作来实现特征的提取和学习。

import torchvision
from torch import nn
from torch.utils.data import DataLoader
import torch.nn.functional as F

test_data = torchvision.datasets.CIFAR10("./dataset",train=False,transform=torchvision.transforms.ToTensor(),download=False)
#将数据划分为batch，每个batch有64个样本
dataloader = DataLoader(test_data,batch_size=64)

#神经网络
class CLH(nn.Module):
    def __init__(self):
        super(CLH,self).__init__()
        #神经网络中设置一个卷积层，in_channels表示输入通道数，out_channels表示输出通道数，并且卷积核尺寸为3×3的随机矩阵
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=6, kernel_size=3, stride=1, padding=0)
    def forward(self,input):
        #对输入数据执行一次二维卷积
        return self.conv1(input)

clh = CLH()

#data是一个batch
for data in dataloader:
    imgs,targets = data
    output = clh(imgs)
    #torch.Size([64, 3, 32, 32])表示[batchs大小，每个batch的通道数，每个通道x轴像素数，每个通道y轴像素数]
    print(imgs.shape)
    #torch.Size([64, 6, 30, 30])表示[batchs大小，每个batch的通道数，每个通道x轴像素数，每个通道y轴像素数]
    #其中每个通道由32×32像素变为30×30像素，其余的像素点组合成该batch的其他通道
    print(output.shape)

在这里插入图片描述

四、池化层：

最大池化的作用是为了保留特征同时将数据量缩小。
例如：1080p图像经过最大池化层变为720p。

import torch
from torch import nn
from torch.nn import MaxPool2d
#输入像素变为tensor类型
input = torch.tensor([
    [1,2,0,3,1],
    [0,1,2,3,1],
    [1,2,1,0,0],
    [5,2,3,1,1],
    [2,1,0,1,1]
],dtype=torch.float32)
#变化为池化规定输入格式的维度：这里二维（x,y）转四维（t,z,x,y）
input = torch.reshape(input,(1,1,5,5))

#神经网络
class CLH(nn.Module):
    def __init__(self):
        super(CLH,self).__init__()
        #神经网络中设置一个池化层，ceil_mode表示池化合覆盖输入数据不够时是否计算
        self.maxpool1 = MaxPool2d(kernel_size=3, ceil_mode=True)
    def forward(self,input):
        #对输入数据执行一次最大池化操作
        return self.maxpool1(input)

#创建神经网络
clh = CLH()

output = clh(input)
print(output)

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

执行过程：
1

五、激活函数（以ReLU为例）：

import torch
from torch import nn
from torch.nn import MaxPool2d, ReLU

#输入像素变为tensor类型
input = torch.tensor([
    [1,2,0,3,1],
    [0,1,2,3,1],
    [1,2,1,0,0],
    [5,2,3,1,1],
    [2,1,0,1,1]
],dtype=torch.float32)
#变化为池化规定输入格式的维度：这里二维（x,y）转四维（t,z,x,y）
input = torch.reshape(input,(1,1,5,5))

#神经网络
class CLH(nn.Module):
    def __init__(self):
        super(CLH,self).__init__()
        #神经网络中设置一个激活函数
        self.relu = ReLU()
    def forward(self,input):
        #对输入数据执行一次最大池化操作
        return self.relu(input)

#创建神经网络
clh = CLH()

output = clh(input)
print(output)

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

六、模型搭建：

在这里插入图片描述
上面的卷积神经网络模型共有8个隐藏层（卷积层+池化层）和1个输出层。

from torch import nn
from torch.nn import Module
from torch.nn import Conv2d
from torch.nn import MaxPool2d, Flatten, Linear, Sequential
import torch


# 神经网络
class CLH(nn.Module):
    def __init__(self):
        super(CLH, self).__init__()
        #搭建模型架构，模型会按顺序从上到下执行
        self.model1 = Sequential(
            #卷积层，提取特征
            Conv2d(3, 32, 5, padding=2),
            #最大池化层，减小数据维度，防止过拟合
            MaxPool2d(2),
            #卷积层
            Conv2d(32, 32, 5, padding=2),
            #最大池化层
            MaxPool2d(2),
            #卷积层
            Conv2d(32, 64, 5, padding=2),
            #最大池化层
            MaxPool2d(2),
            #展平层，将输入数据展平为一维
            Flatten(),
            #全连接（线性）层，输入1024长度的一维向量，学习输入数据的非线性关系，输出64的特征一维向量
            Linear(1024, 64),

        )

    def forward(self, x):
        x = self.model1(x)
        return x


clh = CLH()
print(clh)
#构建一个全0的输入，batch大小64，三通道，宽高为32×32
input = torch.ones((64, 3, 32, 32))
output = clh(input)
print(output.shape)

输出结果：
在这里插入图片描述

七、损失函数、梯度下降：

from torch import nn
from torch.nn import Conv2d
from torch.nn import MaxPool2d,Flatten,Linear, Sequential
import torch
import torchvision
from torch.utils.data import DataLoader
#获取数据，CIFAR10是一个十分类数据集
dataset = torchvision.datasets.CIFAR10("./dataset",train= False, transform =torchvision.transforms.ToTensor(), download=False)
#切分数据为batch
dataloader = DataLoader(dataset, batch_size=1, drop_last=True)

#神经网络模型搭建
class Tudui(nn.Module):
    def __init__(self):
        super(Tudui,self).__init__()
        self.model1 = Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32,64,5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024,64),
            Linear(64, 10)
        )
    def forward(self, x):
        x = self.model1(x)
        return x

tudui = Tudui()

#损失函数
loss = nn.CrossEntropyLoss()
#SGD（随机梯度下降）优化器，用于更新模型clh中的参数以最小化损失函数
optim = torch.optim.SGD(tudui.parameters(), lr=0.01)

#每个batch（data）执行如下操作
for data in dataloader:
    #特征和真实标签值
    imgs, targets = data
    #训练结果
    outputs = tudui(imgs)
    #计算损失
    result_loss = loss(outputs, targets)
    #每轮训练梯度清零，避免梯度累积
    optim.zero_grad()
    #反向传播计算损失函数关于模型各个参数的梯度（偏导数）
    result_loss.backward()
    #根据梯度更新模型参数，使用梯度下降算法进行参数更新
    optim.step()
    print(result_loss)

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

八、模型保存与加载：

保存：

import torchvision
import torch
vgg16 = torchvision.models.vgg16(pretrained=False)
# 保存方式1--保存模型结构及模型参数
torch.save(vgg16,"vgg16_method1.pth")

# 保存方式2--仅保存模型参数存为字典，不保存模型结构（官方推荐）
torch.save(vgg16.state_dict(),"vgg16_method2.pth")

读取：

import torch
import torchvision
# 保存方式1对应的加载模型结构 + 参数方式
model = torch.load("vgg16_method1.pth")
print(model)

# 保存方式2对应的加载模型参数方式
model2 = torch.load("vgg16_method2.pth") #加载的是字典
print(model2)

vgg16 = torchvision.models.vgg16(pretrained=False) #为方式2创建模型结构并加载参数的完整写法
vgg16.load_state_dict(torch.load("vgg16_method2.pth"))
print(vgg16)

九、模型训练：

在这里插入图片描述
上面的卷积神经网络模型共有8个隐藏层（卷积层+池化层）和1个输出层。

from torch.utils.tensorboard import SummaryWriter

import torch
import torchvision
import torch.nn as nn
from torch.utils.data import DataLoader

# 定义训练的设备
device = torch.device("cuda")
# 准备训练集
train_data = torchvision.datasets.CIFAR10("./dataset", train=True, transform=torchvision.transforms.ToTensor(),
                                          download=True)
# 准备测试集
test_data = torchvision.datasets.CIFAR10("./dataset", train=False, transform=torchvision.transforms.ToTensor(),
                                         download=True)
# len()获取数据集长度
train_data_size = len(train_data)
test_data_size = len(test_data)
print("训练数据集的长度为：{}".format(train_data_size))
print("测试数据集的长度为：{}".format(test_data_size))

# 利用dataloader加载数据集,一个batch包含64个图片样本
train_dataloader = DataLoader(train_data, batch_size=64, drop_last=True)
test_dataloader = DataLoader(test_data, batch_size=64, drop_last=True)


# 创建网络模型，这里一般将网络模型单独定义一个文件
class CLH(nn.Module):
    def __init__(self):
        super(CLH, self).__init__()
        self.model = nn.Sequential(
            #卷积层
            nn.Conv2d(3, 32, 5, 1, 2),
            #最大池化层
            nn.MaxPool2d(2),
            nn.Conv2d(32, 32, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 5, 1, 2),
            nn.MaxPool2d(2),
            #展平为一维
            nn.Flatten(),  # 展平后的序列长度为 64*4*4=1024
            #全连接层
            nn.Linear(1024, 64),
            nn.Linear(64, 10)

        )

    def forward(self, x):
        x = self.model(x)
        return x


clh = CLH()
#设置为GPU训练
clh = clh.to(device)

# 损失函数
loss_fn = nn.CrossEntropyLoss()
loss_fn = loss_fn.to(device)

# 优化器（梯度下降算法）对clh.parameters()中的参数进行更新
learning_rate = 1e-2
optimizer = torch.optim.SGD(clh.parameters(), lr=learning_rate)

# 设置训练网络的一些参数
# 1.记录训练的次数
total_train_step = 0
# 2.记录测试的次数
total_test_step = 0
# 3.训练的轮数
epoch = 10

# 添加tensorboard可视化结果
writer = SummaryWriter("../logs_train")

#训练epoch轮
for i in range(epoch):
    print("-------------第 {} 轮训练开始------------".format(i + 1))
    # 训练步骤开始
    clh.train()
    #对于每个batch（data，包含64张图片）
    for data in train_dataloader:
        #获取batch中的样本和真实值标签
        imgs, targets = data

        imgs = imgs.to(device)
        targets = targets.to(device)
        #该batch的训练结果
        output = clh(imgs)
        #计算该batch（data）上的损失
        loss = loss_fn(output, targets)

        # 优化器优化模型
        #梯度清零
        optimizer.zero_grad()
        #计算损失函数关于每个参数的梯度
        loss.backward()
        #梯度下降算法更新参数
        optimizer.step()
        total_train_step = total_train_step + 1
        print("训练次数：{}， Loss：{}".format(total_train_step, loss.item()))
        writer.add_scalar("train_loss", loss.item(), total_train_step)


    # 测试步骤开始（感觉更像验证，但是并没有更新一些学习率之类的参数，仅仅进行了测试）
    clh.eval()
    total_test_loss = 0
    total_accuracy = 0
    #设置禁止更新梯度，防止测试集更新模型参数
    with torch.no_grad():
        #对于测试集上的每个batch（data，包含64张图片）
        for data in test_dataloader:
            imgs, targets = data
            imgs = imgs.to(device)
            targets = targets.to(device)
            #仅计算预测结果而不更新参数（torch.no_grad()）
            outputs = clh(imgs)
            #计算该batch（data）上的损失
            loss = loss_fn(outputs, targets)
            #计算整个测试集上的损失
            total_test_loss = total_test_loss + loss.item()
    print("整个测试集上的Loss：{}".format(total_test_loss))
    writer.add_scalar("test_loss", total_test_loss, total_test_step)
    total_test_step = total_test_step + 1

    #每轮（epoch）训练完成后保存该轮的训练模型
    torch.save(clh, "clh_{}.pth".format(i))
    print("-------------第{}轮训练结束，模型已保存-------------".format(i + 1))

writer.close()

部分执行结果：
在这里插入图片描述
在这里插入图片描述

十、模型测试：

import torchvision
from PIL import Image
import torch
#注意导入模型结构文件
from CLHmodule import *

#获取测试样本
image_path = "./dog.png"
image = Image.open(image_path)
print(image)

#将测试样本转换为模型规定的格式（和训练集样本尺寸要一样）
image = image.convert('RGB')
transform = torchvision.transforms.Compose([torchvision.transforms.Resize((32,32)),
                                            torchvision.transforms.ToTensor()
                                           ])
image = transform(image)
print(image)
image = torch.reshape(image,(1,3,32,32))

#加载模型
model = torch.load("clh_0.pth",map_location=torch.device("cuda"))
print(model)

#执行预测
model.eval()
with torch.no_grad():
    image = image.to("cuda")
    output = model(image)
#预测结果，十分类结果为10个值的一维向量，表示各个分类上的可能性
print(output)
#输出可能性最大的结果
print(output.argmax(1))

输出结果：
在这里插入图片描述

姓蔡小朋友
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【神经网络的训练与验证】如何进行神经网络的训练和验证
禅与计算机程序设计艺术
07-26 2659
作者：禅与计算机程序设计艺术 1.简介 神经网络的训练，也叫做模型的训练、优化或者学习，是一个非常复杂的过程。它的目的在于找到最优的权重参数值，使得神经网络模型能够在给定数据集上实现更高的准确率或性能指标。本文将会详细介绍神经网络的训练过程，包括参数初始化，数据处理，梯度下降，批次大小设置，正则化项选择
神经网络模型--数学建模
qq_51533426的博客
04-28 9491
神经网络是一种人工智能算法，它受到了生物神经网络的启发。类似于生物神经网络，神经网络也由许多相互连接的简单单元组成，这些单元被称为神经元。神经网络通常被分为三个主要部分：输入层、隐藏层和输出层。输入层接受输入数据，输出层输出结果，而隐藏层在输入和输出层之间处理信息。每个神经元接收来自其他神经元的输入，并将这些输入加权总和，并通过激活函数来产生输出。激活函数可以是线性函数，也可以是非线性函数，如sigmoid、ReLU等。神经网络通过训练来学习输入和输出之间的关系。
神经网络——训练集、验证集、测试集
TJ_429的博客
04-07 3015
训练集，验证集，测试集
【神经网络】学习笔记十五——训练集，验证集和测试集
杨的博客
08-31 1万+
以前一直知道神经网络划分数据集时要分为训练集，测试集和验证集，但不知道并且一般以6：2：2的比例划分，到头来不知道这三者各是啥，以及他们的作用是什么。本片文档解释一下三者的作用。 重点在于验证集和测试集的区别以及用处。 1. 三者的功能简述 在机器学习中，我们的模型一般包括以下几点： （1）模型设计； （2）模型架构（模型多少层，每层神经元个数）； （3）神经元内置参数； （4）模型训练的参数：超参数（模型外置参数，如学习率，优化函数等）； 简单来说，训练集的作用是得出神经元内置参数，验证集
验证集、训练集及测试集概念
Ethan_Rich的博客
12-18 453
(花书给出了解答)一是超参数一般难以优化(无法像普通参数一样通过梯度下降的方式进行优化).二是超参数很多时候不适合在训练集上进行训练,例如,如果在训练集上训练能控制模型容量的超参数,这些超参数总会被训练成使得模型容量最大的参数(因为模型容量越大,训练误差越小),所以训练集上训练超参数的结果就是模型绝对过拟合.:从字面意思理解即为用于验证模型性能的样本集合.不同神经网络在训练集上训练结束后,通过验证集来比较判断各个模型的性能.这里的不同模型主要是指对应不同超参数的神经网络,也可以指完全不同结构的神经网络.
神经网络训练中的训练集、验证集以及测试集合
silence1214的专栏
03-18 1万+
1：在NN训练中我们很常用的是训练集合以及测试集合，在训练集合上训练模型（我个人认为模型就是训练的方法以及对应的参数值，更偏重于参数值吧），训练好之后拿到测试集合上验证模型的泛华（就是该模型可以拿去实战的效果）的能力。 2：但是对于上述情况，举个例子，比如是在训练一个多层网络，我们用类似minFUNC的方法来训练，那么这个优化包会直接根据我们的输入直接迭代出来一个很好地结果了，此时模型就
Python实现Keras搭建神经网络训练分类模型教程
12-17
在本教程中，我们将探讨如何使用Python中的Keras库搭建一个神经网络模型，用于训练分类任务。这个示例特别关注手写数字识别问题，利用经典的MNIST数据集。以下是实现的关键知识点： 1. **Keras库**：Keras是一个...
python实现BP神经网络回归预测模型.rar
05-05
1. 数据预处理：通常涉及数据清洗、归一化、划分训练集和测试集等步骤，以确保输入数据适合神经网络模型。 2. 构建神经网络结构：定义输入层、隐藏层和输出层的节点数量，以及连接这些层的权重和偏置。 3. 激活函数...
matlab使用Alexnet模型方式的卷积神经网络训练并测试自己的数据集
03-19
在本文中，我们将深入探讨如何在MATLAB中利用Alexnet模型构建卷积神经网络（CNN）来训练和测试自定义数据集。Alexnet是深度学习领域的一个里程碑，它在2012年的ImageNet竞赛中取得了显著的成功，开启了深度学习在...
基于Pytorch的Resnet深度学习神经网络CIFAR10识别分类训练测试实现
05-04
本程序实现了对CIFAR10数据集的下载，处理，以及数据增强，并将其分解为训练集和测试集，并完整搭建好Resent网络，实现模型的训练和测试，并得到测试准曲率结果，适合基于Pytorch的Resnet深度学习网络分类识别的功能...
resnet56神经网络模型 代码示例
04-28
在训练神经网络模型时，我们将使用ResNet56()函数来创建相应的模型实例，并使用PyTorch提供的优化器和损失函数进行训练和测试。需要注意的是，在实际使用过程中，我们需要根据数据集的特点和需求来选择合适的超参数...
神经网络训练集和测试集,神经网络验证集作用
aifamao6的博客
08-24 7842
假设现在有12个月的数据，从1月-12月。方案一：设置1月-6月为训练集，7月-9月为测试集，10月-12月为验证集；方案二：设置1月-6月为训练集，7月-9月为验证集，10月-12月为测试集。训练集：是用于训练的样本集合，主要用来训练神经网络中的参数。验证集：用于验证模型性能的样本集合，不同神经网络在训练集上训练结束后，通过验证集来比较判断各个模型的性能，这里的不同模型主要是指对应不同超参数的神经网络，也可以指完全不同结构的神经网络。测试集：对于训练完成的神经网络，测试集用于客观的评价神经网络的性能。扩展
神经网络的训练集、测试集、验证集
qq_37008037的博客
07-09 3万+
训练集（Training set）作用是用来拟合模型，通过设置分类器的参数，训练分类模型。后续结合验证集作用时，会选出同一参数的不同取值，拟合出多个分类器。验证集(Cross Validation set)作用是当通过训练集训练出多个模型后，为了能找出效果最佳的模型，使用各个模型对验证集数据进行预测，并记录模型准确率。选出效果最佳的模型所对应的参数，即用来调整模型参数。如svm中的参数c和核函数等...
神经网络中训练数据、验证数据、测试数据三者的含义
qq_45208848的博客
09-10 4251
训练数据是用来训练神经网络模型的数据，验证数据的作用是在神经网络训练的过程中不断测试模型的误差，验证数据的误差随着神经网络模型训练的次数增加会呈现先减小后增加的数据，所以验证数据的误差会存在一个拐点，当达到这个拐点时停止神经网络的训练，这时得到的神经网络的误差最小。而测试数据就是用来在神经网络训练完毕的时候测试模型的误差的数据。 总结至https://www.bilibili.com/video/av97628861/ 中14:30处 ...
神经网络---训练集、验证集、测试集
计算机视觉
07-08 1462
训练集、验证集、测试集以及交验验证的理解https://blog.csdn.net/kieven2008/article/details/81582591
神经网络中验证集、训练集和测试集
gyqJulius_Caesar的博客
03-21 5536
验证集 对于所有的训练集，训练一个epoch之后(当然也可以自己设定)，使用用验证集来测试一下模型训练效果，由于训练集和验证集的不可交性，所以在验证集上面的结果是有参考意义的。 验证集并没有参与训练过程中的梯度下降过程，狭义上来讲就是不参与反向传播过程中的参数更新。 但是广义上来讲，验证集存在的意义确实参与了一个“人工调参”的过程，根据模型训练一段时间后，在valid data上的表现来决定是否需要训练提前终止，或者根据这个过程模型的性能变化来调整模型的超参数，如学习率，batchsize等 因此，也可以
训练集、验证集、测试集以及交验验证的理解
热门推荐
kieven2008的专栏
08-11 20万+
在人工智能机器学习中，很容易将“验证集”与“测试集”，“交叉验证”混淆。 一、三者的区别 训练集（train set） —— 用于模型拟合的数据样本。 验证集（development set）—— 是模型训练过程中单独留出的样本集，它可以用于调整模型的超参数和用于对模型的能力进行初步评估。 在神经网络中， 我们用验证数据集去寻找最优的网络深度（nu...
PyTorch 基础学习（5）- 神经网络
最新发布
fenglingguitar的专栏
08-13 814
PyTorch 提供了一套强大的工具来构建和训练神经网络。其中的核心组件之一是torch.nn，它提供了模块和类以帮助您创建和定制神经网络。
卷积神经网络实现神经网络模型训练
10-29
卷积神经网络是一种深度学习模型，它在图像识别、语音识别、自然语言处理等领域都有广泛的应用。卷积神经网络的训练过程一般包括以下几个步骤： 1. 数据预处理：将原始数据转换为神经网络可以处理的格式，例如将图像转换为矩阵。 2. 网络搭建：选择合适的网络结构，例如VGG、ResNet、Inception等，并根据具体任务进行调整。 3. 损失函数选择：选择合适的损失函数，例如交叉熵、均方误差等。 4. 优化器选择：选择合适的优化器，例如SGD、Adam等，用于更新网络参数。 5. 训练网络：将数据输入网络，计算损失函数并更新网络参数，直到达到预设的停止条件。 6. 测试网络：使用测试集对训练好的网络进行测试，评估网络的性能。 以上是卷积神经网络训练的基本步骤，具体实现过程会因任务不同而有所差异。如果您需要更具体的实现方法，可以参考引用中提供的代码和教程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

姓蔡小朋友

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值