Pytorch实战之MNIST识别

最新推荐文章于 2024-01-22 21:38:42 发布
最新推荐文章于 2024-01-22 21:38:42 发布
阅读量1.5k 收藏 20
点赞数 4
分类专栏： PyTorch 文章标签： PyTorch MNIST识别 PyTorch MNIST PyTorch 实战
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/john_bh/article/details/107667830
版权

转载请注明作者和出处： http://blog.csdn.net/john_bh/

在本文中，将在PyTorch中构建一个简单的卷积神经网络，并在MNIST数据集训练它识别手写数字。

文章目录

1. MNIST Data

MNIST包含70,000张手写数字图像: 60,000张用于训练，10,000张用于测试。图像是灰度的，28x28像素的，并且居中的，以减少预处理和加快运行。MNIST Data DownLoad
在这里插入图片描述

2. Load Data

新建 DealData.py文件，处理MNIST Data, 分为两种处理方法：

  1. 先下载MNIST数据集到本地，自己编写处理代码；
  2. 使用 torchvision.datasets 处理MNIST。

代码实现如下：

# -*- coding:utf-8 -*-
import os
import gzip
import numpy as np
from torchvision import transforms
from torchvision.datasets import mnist
import matplotlib.pyplot as plt
from torch.utils.data import DataLoader

def load_data_minist(data_folder):
    files = [
      'train-labels-idx1-ubyte.gz', 'train-images-idx3-ubyte.gz',
      't10k-labels-idx1-ubyte.gz', 't10k-images-idx3-ubyte.gz']

    paths = []
    for fname in files:
        paths.append(os.path.join(data_folder,fname))

    with gzip.open(paths[0], 'rb') as lbpath:
        y_train = np.frombuffer(lbpath.read(), np.uint8, offset=8)

    with gzip.open(paths[1], 'rb') as imgpath:
        x_train = np.frombuffer(imgpath.read(), np.uint8, offset=16).reshape(len(y_train), 28, 28)

    with gzip.open(paths[2], 'rb') as lbpath:
        y_test = np.frombuffer(lbpath.read(), np.uint8, offset=8)

    with gzip.open(paths[3], 'rb') as imgpath:
        x_test = np.frombuffer(imgpath.read(), np.uint8, offset=16).reshape(len(y_test), 28, 28)

    return (x_train, y_train), (x_test, y_test)

def load_data(data_folder,data_name,label_name):
    """
    :param data_folder: 文件目录
    :param data_name: 数据文件名
    :param label_name: 标签数据文件名
    :return:
    """
    with gzip.open(os.path.join(data_folder,label_name), 'rb') as lbpath: # rb表示的是读取二进制数据
        y = np.frombuffer(lbpath.read(), np.uint8, offset=8)

    with gzip.open(os.path.join(data_folder,data_name), 'rb') as imgpath:
        x = np.frombuffer(imgpath.read(), np.uint8, offset=16).reshape(len(y), 28, 28)

    return (x, y)

class DealDataSet():
    """
    """
    def __init__(self,folder,data_name,label_name,transform):
        (X_set,Y_set)=load_data(folder,data_name,label_name)# 其实也可以直接使用torch.load(),读取之后的结果为torch.Tensor形式
        self.X_set=X_set
        self.Y_set=Y_set
        self.transform=transform

    def __getitem__(self,index):
        img,target=self.X_set[index],int(self.Y_set[index])
        if self.transform is not None:
            img=self.transform(img)
        return img,target

    def __len__(self):
        return len(self.X_set)

def load_data_torch():
    # 预处理=>将各种预处理组合在一起
    data_tf = transforms.Compose(
        [transforms.ToTensor(),
         transforms.Normalize([0.5], [0.5])])

    # 使用内置函数下载mnist数据集
    train_set = mnist.MNIST('./MNIST_data', train=True, transform=data_tf, download=True)
    test_set = mnist.MNIST('./MNIST_data', train=False, transform=data_tf, download=True)

    return (train_set,test_set)

def show_example_img():
    train_set, test_set = load_data_torch()
    train_data = DataLoader(train_set, batch_size=64, shuffle=True)
    test_data = DataLoader(test_set, batch_size=64, shuffle=False)
    examples = enumerate(test_data)
    batch_idx, (example_data, example_targets) = next(examples)

    fig = plt.figure()
    for i in range(6):
        plt.subplot(2, 3, i + 1)
        plt.tight_layout()
        plt.imshow(example_data[i][0], cmap='gray', interpolation='none')
        plt.title("Ground Truth: {}".format(example_targets[i]))
        plt.xticks([])
        plt.yticks([])
    plt.show()

def show_example_targets():
    train_set, test_set = load_data_torch()
    train_data = DataLoader(train_set, batch_size=64, shuffle=True)
    test_data = DataLoader(test_set, batch_size=64, shuffle=False)
    examples = enumerate(test_data)
    batch_idx, (example_data, example_targets) = next(examples)
    print(example_targets)
    print(example_data.shape)


if __name__=="__main__":
    show_example_img()
    show_example_targets()

show_example_img()结果:
在这里插入图片描述
show_example_targets()结果:

tensor([7, 2, 1, 0, 4, 1, 4, 9, 5, 9, 0, 6, 9, 0, 1, 5, 9, 7, 3, 4, 9, 6, 6, 5,4, 0, 7, 4, 0, 1, 3, 1, 3, 4, 7, 2, 7, 1, 2, 1, 1, 7, 4, 2, 3, 5, 1, 2, 4, 4, 6, 3, 5, 5, 6, 0, 4, 1, 9, 5, 7, 8, 9, 3])
torch.Size([64, 1, 28, 28])

3. 定义CNN

新建 model.py文件，编写CNN，具体代码如下：

# -*- coding:utf-8 -*-
from torch import nn

# define Net
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()

        self.layer1 = nn.Sequential(
            nn.Conv2d(1, 16, kernel_size=3),  # 16, 26 ,26
            nn.BatchNorm2d(16),
            nn.ReLU(inplace=True))

        self.layer2 = nn.Sequential(
            nn.Conv2d(16, 32, kernel_size=3),  # 32, 24, 24
            nn.BatchNorm2d(32),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2))  # 32, 12,12     (24-2) /2 +1

        self.layer3 = nn.Sequential(
            nn.Conv2d(32, 64, kernel_size=3),  # 64,10,10
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True))

        self.layer4 = nn.Sequential(
            nn.Conv2d(64, 128, kernel_size=3),  # 128,8,8
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2))  # 128, 4,4

        self.fc = nn.Sequential(
            nn.Linear(128 * 4 * 4, 1024),
            nn.ReLU(inplace=True),
            nn.Linear(1024, 128),
            nn.ReLU(inplace=True),
            nn.Linear(128, 10))

    def forward(self, x):
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)

        return x

4. Train & Test

这里写了一个完整的训练代码，包括：参数的设定，加载MNIST数据，使用网络，定义损失函数和优化器，训练网络，保存模型，保存训练过程中的loss和acc并做可视化，设置验证集（测试集）。具体代码如下：

# -*- coding:utf-8 -*-
from torch.utils.data import DataLoader
import torch
from torch import nn
from torch.autograd import Variable
from torch import optim
from DealDataSet import load_data_torch

from model import Net
import os
import matplotlib.pyplot as plt
import numpy as np

#Parameters
max_epoch=3
learning_rate=1e-1
momentum=0.9
batch_size=64
display_step=100
mode_dir="./models/model1"
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

#Network Parameters
num_input=784 # MNIST data input (img shape: 28*28)
num_classes=10 # MNIST total classes (0-9 digits)
dropout=0.75 # Dropout, probability to keep units

#load data
train_set,test_set=load_data_torch()
train_data = DataLoader(train_set, batch_size=batch_size, shuffle=True)
test_data = DataLoader(test_set, batch_size=batch_size, shuffle=False)

# Initialize the model
net = Net()
net.to(device)

# Define loss function and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=learning_rate,momentum=momentum)

def draw_train_process(title,iters,costs,accs,label_cost,lable_acc):
    plt.title(title, fontsize=24)
    plt.xlabel("iter", fontsize=20)
    plt.ylabel("acc(\%)", fontsize=20)
    plt.plot(iters, costs,color='red',label=label_cost)
    plt.plot(iters, accs,color='green',label=lable_acc)
    plt.legend()
    plt.grid()
    plt.show()

def showTestResult(test_data):
    examples = enumerate(test_data)
    batch_idx, (example_data, example_targets) = next(examples)
    with torch.no_grad():
        output = net(example_data)
    fig = plt.figure()
    for i in range(6):
        plt.subplot(2, 3, i + 1)
        plt.tight_layout()
        plt.imshow(example_data[i][0], cmap='gray', interpolation='none')
        plt.title("Prediction: {}".format(
            output.data.max(1, keepdim=True)[1][i].item()))
        plt.xticks([])
        plt.yticks([])
    plt.show()

def train():
    global net
    # 如果有模型则加载
    if os.path.exists(mode_dir):
        print("Use pre_mode")
        net.load_state_dict(torch.load(os.path.join(mode_dir,'model.pth')))
        optimizer.load_state_dict(torch.load(os.path.join(mode_dir,'optimizer.pth')))
    else:
        os.makedirs(os.path.join(os.getcwd(),mode_dir))

    train_losses=[]
    train_acces=[]
    # epoch_size = int(mnist.train.num_examples / batch_size)

    for epoch in range(max_epoch):
        net = net.train() # 执行网络训练
        for step, (img,label) in enumerate(train_data):
            img = Variable(img)
            img = img.to(device)
            label = label.to(device)
            label = Variable(label)

            optimizer.zero_grad()  # Gradient clear
            output = net(img)
            loss = criterion(output, label) # Calculate loss
            loss.backward() # Backpropagation
            optimizer.step() # Update gradient

            _, pred = torch.max(output.data,1) # Calculation accuracy
            num_correct = (pred == label).sum().item()
            train_acc = num_correct / img.shape[0]

            # Record loss and accuracy
            train_loss = loss.item()
            train_losses.append(train_loss )
            train_acces.append(train_acc*100 )

            if(step+1)%display_step ==0 or (step+1) == len(train_data):
                print('Epoch:{} [{}/{}], Loss:{:.4f}, Acc:{}'.format(epoch,step+1,len(train_data),train_loss,train_acc))

        # Save model
        torch.save(net.state_dict(), os.path.join(mode_dir,'model.pth'))
        torch.save(optimizer.state_dict(),os.path.join(mode_dir,'optimizer.pth'))

        print('Epoch {}: Train Loss: {} Train  Accuracy: {} '.format(epoch + 1, np.mean(train_losses), np.mean(train_acces)))
        # Set up validation set
        print("############## val this epoch ##############")
        test()

    # Draw loss and acc charts
    draw_train_process('training', range(len(train_losses)), train_losses, train_acces, 'training loss', 'training acc')

def test():
    net.eval()
    test_loss=[]
    test_acc=[]

    with torch.no_grad(): # The network does not update the gradient during evaluation
        for i,(img,label) in enumerate(test_data):
            output=net(img)
            test_loss.append(criterion(output, label))
            _,test_pred=torch.max(output.data,1) # test_pred = output.data.max(1)[1]
            num_correct = (test_pred == label).sum().item()
            test_acc.append(num_correct / img.shape[0])
            # test_acc += label.size(0)
            # test_acc.append ((test_pred == label).sum().item()) #test_acc.append(test_pred.eq(label.data.view_as(test_pred)).sum())

        print("avg loss：{}, avg acc：{}".format(np.mean(test_loss),np.mean(test_acc)))

    #Draw loss and acc charts
    draw_train_process("Test", range(len(test_loss)), test_loss, test_acc, "testing loss", "testing acc")
    showTestResult(test_data)

if __name__=="__main__":
    train()

Epoch:0 [100/938], Loss:0.0004, Acc:1.0
Epoch:0 [200/938], Loss:0.0572, Acc:0.984375
Epoch:0 [300/938], Loss:0.0010, Acc:1.0
Epoch:0 [400/938], Loss:0.0344, Acc:0.984375
Epoch:0 [500/938], Loss:0.0047, Acc:1.0
Epoch:0 [600/938], Loss:0.0010, Acc:1.0
Epoch:0 [700/938], Loss:0.0003, Acc:1.0
Epoch:0 [800/938], Loss:0.0005, Acc:1.0
Epoch:0 [900/938], Loss:0.0439, Acc:0.984375
Epoch:0 [938/938], Loss:0.0022, Acc:1.0
Epoch 1: Train Loss: 0.011573510118567332 Train Accuracy: 0.9966184701492538
############## val this epoch ##############
avg loss：0.030577583238482475, avg acc：0.9914410828025477
Epoch:1 [100/938], Loss:0.0000, Acc:1.0
Epoch:1 [200/938], Loss:0.0001, Acc:1.0
Epoch:1 [300/938], Loss:0.0247, Acc:0.984375
Epoch:1 [400/938], Loss:0.0002, Acc:1.0
Epoch:1 [500/938], Loss:0.0114, Acc:1.0
Epoch:1 [600/938], Loss:0.1161, Acc:0.984375
Epoch:1 [700/938], Loss:0.0000, Acc:1.0
Epoch:1 [800/938], Loss:0.0003, Acc:1.0
Epoch:1 [900/938], Loss:0.0000, Acc:1.0
Epoch:1 [938/938], Loss:0.0003, Acc:1.0
Epoch 2: Train Loss: 0.011195699965508517 Train Accuracy: 0.9966767723880597
############## val this epoch ##############
avg loss：0.03695254400372505, avg acc：0.9913415605095541
Epoch:2 [100/938], Loss:0.1651, Acc:0.984375
Epoch:2 [200/938], Loss:0.0689, Acc:0.984375
Epoch:2 [300/938], Loss:0.0001, Acc:1.0
Epoch:2 [400/938], Loss:0.0031, Acc:1.0
Epoch:2 [500/938], Loss:0.0114, Acc:1.0
Epoch:2 [600/938], Loss:0.3162, Acc:0.9375
Epoch:2 [700/938], Loss:0.0206, Acc:0.984375
Epoch:2 [800/938], Loss:0.0003, Acc:1.0
Epoch:2 [900/938], Loss:0.0047, Acc:1.0
Epoch:2 [938/938], Loss:0.0562, Acc:0.96875
Epoch 3: Train Loss: 0.011290731870277657 Train Accuracy: 0.9967073116560057
############## val this epoch ##############
avg loss：0.027084697037935257, avg acc：0.9937300955414012

可视化中间结果，每一个epoch结果如下：
在这里插入图片描述在这里插入图片描述
在这里插入图片描述在这里插入图片描述

在这里插入图片描述在这里插入图片描述

训练过程可视化：
在这里插入图片描述

john_bh
关注
  • 4
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Pytorch框架实现mnist手写库识别（与tensorflow对比）
12-17
前言最近在学习过程中需要用到pytorch框架，简单学习了一下，写了一个简单的案例，记录一下pytorch中搭建一个识别网络基础的东西。对应一位博主写的tensorflow的识别mnist数据集，将其改为pytorch框架，也可以详细看到两个框架大体的区别。 Tensorflow版本转载来源（CSDN博主「兔八哥1024」）：https://www.jb51.net/article/191157.htm Pytorch实战mnist手写数字识别 #需要导入的包 import torch import torch.nn as nn#用于构建网络层 import torch.optim as
【Pytorch】MNIST 图像分类代码 - 超详细解读
qq_25426559的博客
12-07 1万+
最近机器学习在低年级本科生中热度剧增，小编经常看见在自习室里啃书的小伙伴。但是缺少经验指导，也许原理清楚了，但是由于很多书中对细节上的函数等等介绍不多，很多小伙伴对于具体代码只是一知半解。这篇文章基于当下最热门的学习框架 Pytorch，详细讲解图像分类中最基础的图像分类 —— MNIST 数据集分类。
一文搞清pytorch搭建神经网络实现mnist数据集的分类识别（超详细）
最新发布
q774798577的博客
01-22 844
pytorch实现一个简单的神经网络实现手写数字识别
基于pytorch使用NNI的mnist例子分析（附完整代码）
Melody
02-13 4064
工程目录 config.yml ：配置文件 main.py ：mnist_pytorch程序 search_space.json ：搜索空间定义文件 配置文件（config.yml） authorName: default experimentName: mnist_pytorch trialConcurrency: 1 maxExecDuration: 100h maxTrialNum: ...
用PyTorch实现MNIST手写数字识别(非常详细)
热门推荐
xfxuezhang.cn
04-30 15万+
hello大家好！我又来搬文章了！我就不信还有比这更详细的？！ MNIST可以说是机器学习入门的hello word了！导师一般第一个就让你研究MNIST，研究透了，也算基本入门了。好的，今天就来扯一扯学一学。 在本文中，我们将在PyTorch中构建一个简单的卷积神经网络，并使用MNIST数据集训练它识别手写数字。在MNIST数据集上训练分类器可以看作是......
PyTorch项目笔记（一）MNIST数字识别
a1016249126的博客
12-23 2673
本文使用PyTorch在MNIST数据集上实现了手写体数字识别
pytorch——mnist手写数据识别
m0_51311105的博客
12-03 1万+
1、pytorch自带的数据集 pytorch中自带数据集由两个上层的API提供，分别是torchvision和torchtext。其中，torchvision提供了对照片数据处理相关的API和数据，数据所在位置：torchvision.datasets，比如torchvision.datasets.MNIST（手写数字照片数据）；torchtext提供了对文本数据处理相关的API和数据，数据所在位置：torchtext.datasets，比如torchtext.datasets.IMDB...
用PyTorch实现MNIST手写数字识别（最新，非常详细）
qq_45588019的博客
01-20 5万+
1 MNIST数据集(提取码: zm7q )
手把手实战PyTorch手写数据集MNIST识别项目全流程
m0_58092763的博客
07-06 4616
手把手实战PyTorch手写数据集MNIST识别项目全流程 MNIST手写数据集是跑深度学习模型中很基础的、几乎所有初学者都会用到的数据集，认真领悟手写数据集的识别过程对于深度学习框架有着弥足重要的意义。然而目前各类文章中关于项目完全实战的记录较少，无法满足广大初学者的要求，故本文受B站Tommy启发来手把手从引入库开始进行对整个手写数据集识别的流程，这对于笔者以后的深度学习有着很大的必要性。...
PyTorch之示例——MNIST
CodeTutor
05-16 2万+
from __future__ import print_function import argparse import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim from torchvision import datasets, transforms from to
LeNet-pytorch-FashionMNIST分类识别
01-06
LeNetLeNet模型构造读入数据和数据预览定义device定义网络计算准确率训练测试局限 LeNet 1、使用全连接层的局限性： 图像在同一列邻近的像素在这个向量中可能相距较远。它们构成的模式可能难以被模型识别。对于大尺寸的输入图像，使用全连接层容易导致模型过大。 2、使用卷积层的优势： 卷积层保留输入形状。卷积层通过滑动窗口将同一卷积核与不同位置的输入重复计算，从而避免参数尺寸过大。 LeNet分为卷积层块和全连接层块两个部分 卷积层块里的基本单位是卷积层后接平均池化层：卷积层用来识别图像里的空间模式，如线条和物体局部，之后的平均池化层则用来降低卷积层对位置的敏感性。 卷积层块由两个这
用于手写数字识别的Demo，使用pyTorch训练Minist数据集，导出ONNX模型文件.zip
12-29
用于手写数字识别的Demo，使用pyTorch训练Minist数据集，导出ONNX模型文件.zip
PyTorch CNN实战之MNIST手写数字识别示例
09-20
本篇文章主要介绍了PyTorch CNN实战之MNIST手写数字识别示例，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
PyTorch CNN实战之MNIST手写数字识别示例.pdf
04-17
PyTorch CNN实战之MNIST手写数字识别示例
使用PyTorch实现MNIST手写体识别代码
01-20
本文使用的CNN网络将MNIST数据的识别率提高到了99%。下面我们就开始进行实战。 导入包 import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim from torchvision imp
PyTorch环境搭建
不忘初心~
05-16 3万+
PyTorch环境搭建
PyTorch固定随机数种子
不忘初心~
08-01 3万+
在神经网络中，参数默认是进行随机初始化的。不同的初始化参数往往会导致不同的结果。当得到比较好的结果时我们通常希望这个结果是可以复现的，在PyTorch中，通过设置全局随机数种子可以实现这个目的。本文总结了PyTorch中固定随机种子的方法。
Ubuntu18.04 配置 LibTorch
不忘初心~
08-29 8480
Ubuntu18.04 配置LibTorch
基于pytorch的mnist识别
04-02
以下是一个基于PyTorch的MNIST识别的代码示例： 首先，导入必要的库和模块： ``` import torch import torch.nn as nn import torch.optim as optim import torchvision import torchvision.transforms as transforms ``` 然后，定义网络模型。这里我们定义了一个简单的卷积神经网络，包含两个卷积层和两个全连接层： ``` class Net(nn.Module): def __init__(self): super(Net, self).__init__() self.conv1 = nn.Conv2d(1, 6, 5) self.pool = nn.MaxPool2d(2, 2) self.conv2 = nn.Conv2d(6, 16, 5) self.fc1 = nn.Linear(16 * 4 * 4, 120) self.fc2 = nn.Linear(120, 84) self.fc3 = nn.Linear(84, 10) def forward(self, x): x = self.pool(nn.functional.relu(self.conv1(x))) x = self.pool(nn.functional.relu(self.conv2(x))) x = x.view(-1, 16 * 4 * 4) x = nn.functional.relu(self.fc1(x)) x = nn.functional.relu(self.fc2(x)) x = self.fc3(x) return x net = Net() ``` 接着，定义损失函数和优化器： ``` criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) ``` 然后，加载MNIST数据集，并进行预处理： ``` transform = transforms.Compose( [transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))]) trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform) trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True, num_workers=2) testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform) testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False, num_workers=2) ``` 最后，开始训练模型： ``` for epoch in range(5): # 训练5轮 running_loss = 0.0 for i, data in enumerate(trainloader, 0): inputs, labels = data optimizer.zero_grad() outputs = net(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() running_loss += loss.item() if i % 100 == 99: # 每100个batch输出一次训练状态 print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 100)) running_loss = 0.0 print('Finished Training') ``` 最后，计算测试集上的准确率： ``` correct = 0 total = 0 with torch.no_grad(): for data in testloader: images, labels = data outputs = net(images) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() print('Accuracy of the network on the 10000 test images: %d %%' % ( 100 * correct / total)) ``` 这就是一个基于PyTorch的MNIST识别的完整代码示例。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值