pytorch使用教程及应用-GANS编程(2)-初步使用pytorch建立神经网络

最新推荐文章于 2023-05-19 01:09:35 发布
最新推荐文章于 2023-05-19 01:09:35 发布
阅读量406 收藏 5
点赞数 2
分类专栏： Pytorch and GANs 文章标签： pytorch 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45870904/article/details/115269393
版权

文章目录

1. 下载数据集

建立网络的第一步是下载mnist图像数据集到本地，值得注意的是，其应该被下载到和你的pytorch项目在本地的同一文件夹下.

下载地址：
训练数据:https://pjreddie.com/media/files/mnist_train.csv
测试数据:https://pjreddie.com/media/files/mnist_test.csv

数据集是csv格式的，这也是常见数据集的一般格式

2.用pandas处理数据集

pandas DataFrame是一个与numpy数组相似的数据结构，具有许多附加功能。包括可为列和行命名，以及提供遍历函数对数据求和和过滤等。

我们可以使用head()函数查看一个较大DataFrame的前几行。

import torch
import pandas
df=pandas.read_csv('mnist_train.csv',header=None)
print(df.head())#用head函数查看其前五行
df.info()#查看数据集的基本信息，例如该数据集有60000行

output:
   0    1    2    3    4    5    6    ...  778  779  780  781  782  783  784
0    5    0    0    0    0    0    0  ...    0    0    0    0    0    0    0
1    0    0    0    0    0    0    0  ...    0    0    0    0    0    0    0
2    4    0    0    0    0    0    0  ...    0    0    0    0    0    0    0
3    1    0    0    0    0    0    0  ...    0    0    0    0    0    0    0
4    9    0    0    0    0    0    0  ...    0    0    0    0    0    0    0

Mnist的每一行数据包含包含785个值。第一个值是图像所表示的数字，
剩余的784个值是图像(尺寸为28像素×28像素)的像素值。

[5 rows x 785 columns]
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 60000 entries, 0 to 59999
Columns: 785 entries, 0 to 784
dtypes: int64(785)
memory usage: 359.3 MB

下面我们来可视化mnist数据集中的一个手写数字

import torch
import pandas
import matplotlib.pyplot as plt
df=pandas.read_csv('mnist_train.csv',header=None)
# print(df.head())
# df.info()
#从DataFrame读取数据
row=0
data=df.iloc[row] #选择数据集的第一行并赋值给变量data data此时为一个数组类型
label=data[0] #第一个值是标签
#图像是余下的784个值
img=data[1:].values.reshape(28,28)
plt.title("label="+str(label))
plt.imshow(img,interpolation='none',cmap='Blues')#指定pyplot无须平滑像素以及指定调色板的颜色为蓝色
plt.show()

output:
在这里插入图片描述

你还可以试试通过改变row的值来找到另外一份模拟数字图像

甚至可以为查看这个功能单独编写一个函数

3.简单的神经网络

1. 前言

本次编写神经网络的目的是实现一个神经网络能够识别从mnist数据库提取出的手写数字图像的精确数字，而不需要去用前面使用的label去进行标注。

起始点是一幅mnist数据集中的图像，它的像素个数为28×28=784.

这意味着我们的神经网络的第一层必须有784个节点。

然后在输出层我们可以设计十个结点来分别表示数字0~9，这是一个典型的softmax分类问题，也就是多分类问题。

对于隐藏的中间层，我们有更多的选择。有很多优化神经网络的方法，具体的可以看我其他的博客或者听吴恩达或者其他一些在线的深度学习课程。本篇博文我们会重点关注如何使用pytorch.

此次的中间层我们就先简单设定为200层.

网络中任何一层的所有节点，都会连接到下一层中的所有节点。这种网络也被称为全连接层(fully connected layer)。
在这里插入图片描述

激活函数的选择一直都是一个重要的议题，此次神经网络设计我们暂时先采用sigmoid函数(方便快捷)，当然实际上还有Relu和Leaky Relu tanh等一系列函数可以供我们选择，关于激活函数的选择也可以找一找我的博文。

2.具体代码实现

创建神经网络类时，我们需要继承pytorch的torch.nn模块。这样一来，新的神经网络就具备了许多pytorch的功能，如自动构建计算图、查看权重以及在训练期间更新权重等。

import torch
import torch.nn as nn
class Classifier(nn.Module):
    def __init__(self): #类似于java的构造函数，当我们从一个类中创建对象时其就会自动被调用
        #初始化pytorch父类
        super.__init__()  #继承调用父类的构造函数，然后pytorch.nn模块会为我们设置分类器 一般这个步骤都是必要的，需要通过继承底层的父类的基本属性然后再在后面进行自定义（特定的) 的扩展
        #具体的可以查看csdn博客https://blog.csdn.net/a__int__/article/details/104600972
    #现在开始设计神经网络，设计神经网络结构有很多种方法
    #我们可以使用nn.Sequential(),它允许我们提供了一个网络模块的列表。模块必须按照我们希望的信息传递顺序添加到容器中。

    #定义神经网络层
        self.model=nn.Sequential(
            nn.Linear(784,200), #一个从784个节点到200个节点的全连接映射。这个模块包含节点之间链接的权重，在训练时会被更新。
            nn.sigmoid,#将S型逻辑函数函数应用于前一个模块的输出，也就是本例中200个节点的输出
            nn.Linear(200,10),#一个将200个节点映射到10个节点的全连接映射。它包含中间隐藏层与输出层10个节点之间所有链接的权重。
            nn.sigmoid()#再将S型逻辑激活函数应用于10个节点的输出。其结果就是网络的最终输出。也就是我们需要的分类结果。
        )

nn.Linear因何得名？这是因为，当数值从输入端传递到输出端时，该模块对它们应用了Ax+B形式的线性函数。这里，A为链接权重(weights)，B为偏差(bias)，当然，相信大家都有基本的神经网络知识都了解，这两个参数都被称之为可学习参数(learnable parameter)，因为它们可以在训练时被更新。

接下来的任务是定义cost function和参数的优化方法:

  1. cost function定义

cost function(error function or loss function)一个最为简单的是均方误差(mean squared error)。均分误差先计算每个输出节点的实际输出和预期输出之差的平方，再计算平均值，Pytorch将其定义为torch.nn.MSELoss().

self.loss_function=nn.MSELoss()
  1. 优化方法选择(这里选择最简单的随机梯度下降 SGD)–什么是随机梯度下降可以查看我的其他博客有详细介绍，其是mini-batch gradient descent 的一个极端情况
self.optimiser=torch.optim.SGD(self.parameters(),lr=0.01) #创建优化器，使用简单的梯度下降，设定学习率为0.01
  1. 定义前向传播函数

pytorch需要在模型类里面创建一个forward方法，其可以非常简短;

关于forward函数的理解，可以查看博客 https://blog.csdn.net/xu380393916/article/details/97280035 https://blog.csdn.net/u011501388/article/details/84062483

forward函数我们每次设计神经网络的时候都是必须使用的，官方要求我们自定义module的时候必须覆写该方法.

def forward(self,inputs):
#直接运行模型
return self.model(inputs)

我们将输入传递给self.mode(),它由nn.Sequential()定义，模型的输出直接返回给forward()的主调函数。

目前为止的进展是：

1. 通过继承nn.Module,我们创建了一个神经网络类。它从nn.Module中继承了训练神经网络所需的大部分功能。
2. 我们定义了处理信息的神经网络模块。对于简单的神经网络，我们选择使用精简的nn.Sequential方法。
3. 我们定义了成本函数和更新网络可学习参数的优化器。
4. 最后，我们添加了一个forward()函数，Pytorch会通过它将信息传递给网络。

综合一下目前的代码：
在这里插入图片描述

import torch
import torch.nn as nn
class Classifier(nn.Module):
    def __init__(self): #类似于java的构造函数，当我们从一个类中创建对象时其就会自动被调用
        #初始化pytorch父类
        super().__init__()  #继承调用父类的构造函数，然后pytorch.nn模块会为我们设置分类器 一般这个步骤都是必要的，需要通过继承底层的父类的基本属性然后再在后面进行自定义（特定的) 的扩展
    #现在开始设计神经网络，设计神经网络结构有很多种方法
    #我们可以使用nn.Sequential(),它允许我们提供了一个网络模块的列表。模块必须按照我们希望的信息传递顺序添加到容器中。

    #定义神经网络层
        self.model=nn.Sequential(
            nn.Linear(784,200), #一个从784个节点到200个节点的全连接映射。这个模块包含节点之间链接的权重，在训练时会被更新。
            nn.Sigmoid,#将S型逻辑函数函数应用于前一个模块的输出，也就是本例中200个节点的输出
            nn.Linear(200,10),#一个将200个节点映射到10个节点的全连接映射。它包含中间隐藏层与输出层10个节点之间所有链接的权重。
            nn.Sigmoid()#再将S型逻辑激活函数应用于10个节点的输出。其结果就是网络的最终输出。也就是我们需要的分类结果。
        )
        #创建损失函数
        self.loss_function=nn.MSELoss()
        
        #创建优化器，使用简单的梯度下降
        self.optimiser=torch.optim.SGD(self.parameters(),lr=0.01)
        
        pass  #Python pass 是空语句，是为了保持程序结构的完整性。
              #pass 不做任何事情，一般用做占位语句。
	def forward(self,inputs):
	 	#直接运行模型
	 	return self.model(inputs)

接下来，我们需要想办法来训练这个网络

我们不需要一个像forward()一样的train()函数，pytorch允许我们按照自己的想法构建网络的训练代码。

但是为了代码更加好看，我们选择与forward()函数保持一致，创建一个train()函数。

train()即需要网络的输入值，也需要预期的目标值。这样才可以与实际输出进行比较，并计算损失值。

代码实现：

def train(self,inputs,targets):
# 计算网络的输出值
outputs=self.forward(inputs)
# 计算 cost
loss=self.loss_function(outputs,targets)
#pytorch简化了我们自己造轮子时需要为每个节点计算误差梯度，再更新链接权值。
# 梯度归零，反向传播，并更新权重
self.optimiser.zero_grad() #将计算图中的梯度全部归0，也就是我们的初始化
loss.backward() #从loss函数中反向传播计算梯度
self.optimiser.step() #使用这些梯度来更新网络的可学习参数
#在每次训练网络之前，我们都需要将梯度归零。否则，每次loss.backward()计算出来的梯度会累积。

可视化训练：

使用可视化训练的方式，我们实时监控到目前网络优化的效果，可以知道目前的迭代优化进行得是否顺利。

在train()里面，我们在每次计算损失值时，将副本保存在一个列表里。这意味着该表会变得非常大，因为训练神经网络通过会允许成千上万、甚至百万个样本。MNist数据集有60000个训练样本，且我们需要遍历几次（epoch)。 所以，我们设计为在每完成10个训练样本之后保留一份损失副本。所以，我们还需要记录train()的运行频率。

#记录训练进展的计数器和列表
self.counter=0
self.progress=[]
#在train()函数中，我们可以每隔10个训练样本增加一次计数器的值，并将损失值添加进列表的末尾。
#每隔10个训练样本增加一次计数器的值，并将损失值添加进列表的末尾
self.counter += 1
if(self.counter%10 ==0):
	self.progress.append(loss.item()) #item函数方便我们展开一个单值张量，获取里面的数字
	pass
#方便了解训练目前的进展快慢
if(self.counter%10000==0):
	print("counter =",self.counter)
	pass
#将损失值可视化绘制成图，我们可以在神经网络类中添加一个新函数plot_progress()
def plot_progress(self):
	df=pandas.DataFrame(self.progress,columns=['loss']) #将损失值列表progress转换成一个pandas DataFrame对象
	df.plot(ylim=(0,1.0),figsize=(16,8),alpha=0.1,marker='.', #使用plot()函数的选项，设计图的设计和风格
	grid=True,yticks=(0,0.25,0.5))
	pass
3.Mnist数据集类

用pandas读取数据集自然是不错的选择，但我们现在在学习pytorch，还是应该去学习使用pytorch独特的方式去读取和处理数据。

Pytorch使用torch.utils.data.DataLoader实现了一些实用的功能，比如自动打乱数据顺序、多个进程并行加载、分批处理等，但这都需要先将数据载入一个torch.utils.Dataset对象。

from torch.utils.data import Dataset

和我们从nn.Module继承一个神经网络类时需要覆写forward()方法一样，同样地，对于继承自Dataset的数据集，我们需提供以下两个特殊的函数。

__len__(), 返回数据集中的项目总数
__getitem__(), 返回数据集中的第n项
接下来，我们会创建一个MnistDataset类，并提供__len__()方法，允许Pytorch通过len(mnist_dataset)获取数据集的大小。同时，我们也会提供getitem__(),允许我们通过索引获取项目，例如使用mnist_dataset[3]访问第四项这样子

上源码：

import torch
import torch.nn as nn
import pandas
import matplotlib.pyplot as plt
from torch.utils.data import Dataset
class MnistDataset(Dataset):
    def __init__(self,csv_file):
        self.data_df=pandas.read_csv(csv_file,header=None)
        pass
    def __len__(self):
        return len(self.data_df)
    def __getitem__(self, index):
  #目标图像（标签）
        label=self.data_df.iloc[index,0] #从数据集中的第index项中提取该数字的标签-也就是该数字具体是多少
        targets=torch.zeros((10))   #初始化都为0，最后的结果应该为除了与标签相对应的项是1之外，其他值皆为0.比如，标签0所对应的张量是[1,0,0,0,0,0,0,0,0,0] 这种表示方法叫做 one-hot encoding
        targets[label]=1.0

        #图像数据，取值范围是0~255，标准化为0~1
        image_values=torch.FloatTensor(self.data_df.iloc[index,1:].values)/255.0  #将图像像素值标准化
        #返回标签、图像数据张量以及目标张量
        return label,image_values,targets
    #添加一个可视化函数
    def plot_image(self,index):
        arr=self.data_df.iloc[index,1:].values.reshape(28,28)
        plt.title("label="+str(self.data_df.iloc[index,0]))
        plt.imshow(arr,interpolation='none',cmap='Blues')
        plt.show()
        pass
    pass
if __name__ == '__main__':
    mnist_dataset=MnistDataset('mnist_train.csv')
    print(mnist_dataset[2])  #注意两个函数的顺序,画图一般在后
    mnist_dataset.plot_image(9)
  
//
output: (4, tensor([0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.2627, 0.9098,
        0.1529, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.2431, 0.3176, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.4706,
        0.7059, 0.1529, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.4941, 0.6392, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0078,
        0.6000, 0.8235, 0.1569, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.8627, 0.6392, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.1059, 0.9961, 0.6353, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.8706, 0.6392, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.7176, 0.9961, 0.4902, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.1804, 0.9608, 0.6392, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.7765, 0.9961, 0.2196, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.4706, 0.9961, 0.6392, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0902, 0.9059, 0.9961, 0.1137, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.6235, 0.9961, 0.4706,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.6392, 0.9961, 0.8471, 0.0627, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.6235, 0.9961,
        0.2627, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0549, 0.3373, 0.6980, 0.9725, 0.9961, 0.3569, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.6235,
        0.9961, 0.3333, 0.0000, 0.0000, 0.0000, 0.1843, 0.1922, 0.4549, 0.5647,
        0.5882, 0.9451, 0.9529, 0.9176, 0.7020, 0.9451, 0.9882, 0.1569, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.5882, 0.9922, 0.9294, 0.8118, 0.8118, 0.8118, 0.9922, 0.9961, 0.9804,
        0.9412, 0.7765, 0.5608, 0.3569, 0.1098, 0.0196, 0.9137, 0.9804, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.4667, 0.6941, 0.6941, 0.6941, 0.6941, 0.6941, 0.3843,
        0.2196, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.4000, 0.9961, 0.8627,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.6627, 0.9961,
        0.5373, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.6627,
        0.9961, 0.2235, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.6627, 0.9961, 0.2235, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.6627, 1.0000, 0.3686, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.6627, 0.9961, 0.3765, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.6627, 0.9961, 0.6000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.6627, 1.0000, 0.6000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.3765, 0.9961, 0.6000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
        0.0000]), tensor([0., 0., 0., 0., 1., 0., 0., 0., 0., 0.]))

Process finished with exit code 0

在这里插入图片描述

经过测试，我们的可视化数据集已经编写成功

4.训练分类器

我们在前面已经完成了复杂的工作，定义数据集类和神经网络类。

现在我们开始训练分类器softmax

if __name__ == '__main__':
    #创建神经网络
    C=Classifier()
    #训练网络的代码同样很简单：
    #在Mnist数据集训练神经网络
    for label,image_data_tensor,target_tensor in mnist_dataset :
        C.train(image_data_tensor,target_tensor)
        pass

mnist_dataset继承了pytorch Dataset，它允许我们使用for循环遍历所有训练数据。对于每个样本，我们只将图像数据和目标张量传递给分类器的train()方法。SGD方法每次训练就是只要一个样本

当然，我们可以多次遍历数据集，只需要在训练循环周围添加一个外部周期循环即可，这有利于我们进一步优化我们的神经网络

实际训练上，我们会使用矩阵的方法一次遍历多个训练样本，这叫做mini-batch 梯度下降，大家感兴趣的可以看看我的其他博客。

当然，现在是处于学习阶段，我们可以添加一个程序计时器，这样方便我们进行复盘，也可以估计出大概的时间为以后的实验打好基础，在以后的实验过程中我们就可以算好时间去刷B站了，回来再看结果，对吧。

完整代码
import torch
import torch.nn as nn
import pandas
import time
import matplotlib.pyplot as plt
from torch.utils.data import Dataset
class Classifier(nn.Module):
    def __init__(self): #类似于java的构造函数，当我们从一个类中创建对象时其就会自动被调用
        #初始化pytorch父类
        super().__init__()  #继承调用父类的构造函数，然后pytorch.nn模块会为我们设置分类器 一般这个步骤都是必要的，需要通过继承底层的父类的基本属性然后再在后面进行自定义（特定的) 的扩展
    #现在开始设计神经网络，设计神经网络结构有很多种方法
    #我们可以使用nn.Sequential(),它允许我们提供了一个网络模块的列表。模块必须按照我们希望的信息传递顺序添加到容器中。

    #定义神经网络层
        self.model=nn.Sequential(
            nn.Linear(784,200), #一个从784个节点到200个节点的全连接映射。这个模块包含节点之间链接的权重，在训练时会被更新。
            nn.Sigmoid(),#将S型逻辑函数函数应用于前一个模块的输出，也就是本例中200个节点的输出
            nn.Linear(200,10),#一个将200个节点映射到10个节点的全连接映射。它包含中间隐藏层与输出层10个节点之间所有链接的权重。
            nn.Sigmoid()#再将S型逻辑激活函数应用于10个节点的输出。其结果就是网络的最终输出。也就是我们需要的分类结果。
        )
        self.loss_function = nn.MSELoss()

        # 创建优化器，使用简单的梯度下降
        self.optimiser = torch.optim.SGD(self.parameters(), lr=0.01)

        # 记录训练进展的计数器和列表
        self.counter = 0
        self.progress = []
        pass  # Python pass 是空语句，是为了保持程序结构的完整性。
        # pass 不做任何事情，一般用做占位语句。
        pass
    def forward(self,inputs):
#直接运行模型
        return self.model(inputs)
    def train(self,inputs,targets):
# 计算网络的输出值
        outputs=self.forward(inputs)
# 计算 cost
        loss=self.loss_function(outputs,targets)
#pytorch简化了我们自己造轮子时需要为每个节点计算误差梯度，再更新链接权值。
# 梯度归零，反向传播，并更新权重
        self.optimiser.zero_grad() #将计算图中的梯度全部归0，也就是我们的初始化
        loss.backward() #从loss函数中反向传播计算梯度
        self.optimiser.step() #使用这些梯度来更新网络的可学习参数
#在每次训练网络之前，我们都需要将梯度归零。否则，每次loss.backward()计算出来的梯度会累积。
#在train()函数中，我们可以每隔10个训练样本增加一次计数器的值，并将损失值添加进列表的末尾。
#每隔10个训练样本增加一次计数器的值，并将损失值添加进列表的末尾
        self.counter += 1
        if(self.counter%10 ==0):
	        self.progress.append(loss.item()) #item函数方便我们展开一个单值张量，获取里面的数字
	        pass
#方便了解训练目前的进展快慢
        if(self.counter%10000==0):
	        print("counter =",self.counter)
	        pass

    # 将损失值可视化绘制成图，我们可以在神经网络类中添加一个新函数plot_progress()
    def plot_progress(self):
         df = pandas.DataFrame(self.progress, columns=['loss'])  # 将损失值列表progress转换成一个pandas DataFrame对象
         df.plot(ylim=(0, 1.0), figsize=(16, 8), alpha=0.1, marker='.',  # 使用plot()函数的选项，设计图的设计和风格
         grid=True, yticks=(0, 0.25, 0.5))
         plt.show()
         pass
class MnistDataset(Dataset):
    def __init__(self,csv_file):
        self.data_df=pandas.read_csv(csv_file,header=None)
        pass
    def __len__(self):
        return len(self.data_df)
    def __getitem__(self, index):
  #目标图像（标签）
        label=self.data_df.iloc[index,0] #从数据集中的第index项中提取该数字的标签-也就是该数字具体是多少
        targets=torch.zeros((10))   #初始化都为0，最后的结果应该为除了与标签相对应的项是1之外，其他值皆为0.比如，标签0所对应的张量是[1,0,0,0,0,0,0,0,0,0] 这种表示方法叫做 one-hot encoding
        targets[label]=1.0

        #图像数据，取值范围是0~255，标准化为0~1
        image_values=torch.FloatTensor(self.data_df.iloc[index,1:].values)/255.0  #将图像像素值标准化
        #返回标签、图像数据张量以及目标张量
        return label,image_values,targets
    #添加一个可视化函数
    def plot_image(self,index):
        arr=self.data_df.iloc[index,1:].values.reshape(28,28)
        plt.title("label="+str(self.data_df.iloc[index,0]))
        plt.imshow(arr,interpolation='none',cmap='Blues')
        plt.show()
        pass
    pass
if __name__ == '__main__':
    mnist_dataset=MnistDataset('mnist_train.csv')
    t0=time.time()
    #创建神经网络
    C=Classifier()
    #训练网络的代码同样很简单：
    #在Mnist数据集训练神经网络
    epochs=3
    for i in range(epochs):
        print('training epoch',i+1,"of",epochs)
        for label,image_data_tensor,target_tensor in mnist_dataset:
            C.train(image_data_tensor,target_tensor)
            pass
        C.plot_progress() #绘制可视化训练图 一般来说 python遇到绘图代码时运行会发生停顿，这是正常的，需要多耐心等待一下
        print('一个周期的训练耗费了'+str(time.time()-t0)+'s')
        pass

可视化损失下降绘制图：
在这里插入图片描述

训练过程截图：

在这里插入图片描述

训练神经网络存在一定的随机性。

结论：

  1. 从上图可见，损失值从一开始迅速下降到大约0.1，并在训练过程中越来越慢地去接近0.但是同时，也可以看到，后面的训练存在很多噪声，或者说振荡。大家可以进一步去了解凸优化和梯度下降的过程，就能够明白为什么会发生这种震荡。

  2. 损失值的下降意味着网络分类图像的能力越来越好。

  3. 损失图实用性很高，他能够让我们去了解到网络训练是否有效，而且还能让我们指导训练过程是平稳的，还是不稳定和混乱的。

5.检验分类器效果

先附上最新的完整代码：

import torch
import torch.nn as nn
import pandas
import time
import matplotlib.pyplot as plt
from torch.utils.data import Dataset
class Classifier(nn.Module):
    def __init__(self): #类似于java的构造函数，当我们从一个类中创建对象时其就会自动被调用
        #初始化pytorch父类
        super().__init__()  #继承调用父类的构造函数，然后pytorch.nn模块会为我们设置分类器 一般这个步骤都是必要的，需要通过继承底层的父类的基本属性然后再在后面进行自定义（特定的) 的扩展
    #现在开始设计神经网络，设计神经网络结构有很多种方法
    #我们可以使用nn.Sequential(),它允许我们提供了一个网络模块的列表。模块必须按照我们希望的信息传递顺序添加到容器中。

    #定义神经网络层
        self.model=nn.Sequential(
            nn.Linear(784,200), #一个从784个节点到200个节点的全连接映射。这个模块包含节点之间链接的权重，在训练时会被更新。
            nn.Sigmoid(),#将S型逻辑函数函数应用于前一个模块的输出，也就是本例中200个节点的输出
            nn.Linear(200,10),#一个将200个节点映射到10个节点的全连接映射。它包含中间隐藏层与输出层10个节点之间所有链接的权重。
            nn.Sigmoid()#再将S型逻辑激活函数应用于10个节点的输出。其结果就是网络的最终输出。也就是我们需要的分类结果。
        )
        self.loss_function = nn.MSELoss()

        # 创建优化器，使用简单的梯度下降
        self.optimiser = torch.optim.SGD(self.parameters(), lr=0.01)

        # 记录训练进展的计数器和列表
        self.counter = 0
        self.progress = []
        pass  # Python pass 是空语句，是为了保持程序结构的完整性。
        # pass 不做任何事情，一般用做占位语句。
        pass
    def forward(self,inputs):
#直接运行模型
        return self.model(inputs)
    def train(self,inputs,targets):
# 计算网络的输出值
        outputs=self.forward(inputs)
# 计算 cost
        loss=self.loss_function(outputs,targets)
#pytorch简化了我们自己造轮子时需要为每个节点计算误差梯度，再更新链接权值。
# 梯度归零，反向传播，并更新权重
        self.optimiser.zero_grad() #将计算图中的梯度全部归0，也就是我们的初始化
        loss.backward() #从loss函数中反向传播计算梯度
        self.optimiser.step() #使用这些梯度来更新网络的可学习参数
#在每次训练网络之前，我们都需要将梯度归零。否则，每次loss.backward()计算出来的梯度会累积。
#在train()函数中，我们可以每隔10个训练样本增加一次计数器的值，并将损失值添加进列表的末尾。
#每隔10个训练样本增加一次计数器的值，并将损失值添加进列表的末尾
        self.counter += 1
        if(self.counter%10 ==0):
	        self.progress.append(loss.item()) #item函数方便我们展开一个单值张量，获取里面的数字
	        pass
#方便了解训练目前的进展快慢
        if(self.counter%10000==0):
	        print("counter =",self.counter)
	        pass

    # 将损失值可视化绘制成图，我们可以在神经网络类中添加一个新函数plot_progress()
    def plot_progress(self):
         df = pandas.DataFrame(self.progress, columns=['loss'])  # 将损失值列表progress转换成一个pandas DataFrame对象
         df.plot(ylim=(0, 1.0), figsize=(16, 8), alpha=0.1, marker='.',  # 使用plot()函数的选项，设计图的设计和风格
         grid=True, yticks=(0, 0.25, 0.5))
         plt.show()
         pass
class MnistDataset(Dataset):
    def __init__(self,csv_file):
        self.data_df=pandas.read_csv(csv_file,header=None)
        pass
    def __len__(self):
        return len(self.data_df)
    def __getitem__(self, index):
  #目标图像（标签）
        label=self.data_df.iloc[index,0] #从数据集中的第index项中提取该数字的标签-也就是该数字具体是多少
        targets=torch.zeros((10))   #初始化都为0，最后的结果应该为除了与标签相对应的项是1之外，其他值皆为0.比如，标签0所对应的张量是[1,0,0,0,0,0,0,0,0,0] 这种表示方法叫做 one-hot encoding
        targets[label]=1.0

        #图像数据，取值范围是0~255，标准化为0~1
        image_values=torch.FloatTensor(self.data_df.iloc[index,1:].values)/255.0  #将图像像素值标准化-很重要的一步
        #返回标签、图像数据张量以及目标张量
        return label,image_values,targets
    #添加一个可视化函数
    def plot_image(self,index):
        arr=self.data_df.iloc[index,1:].values.reshape(28,28)
        plt.title("label="+str(self.data_df.iloc[index,0]))
        plt.imshow(arr,interpolation='none',cmap='Blues')
        plt.show()
        pass
    pass
if __name__ == '__main__':
    mnist_dataset=MnistDataset('mnist_train.csv')
    mnist_test_dataset=MnistDataset('mnist_test.csv') #mnist_test_dataset有1万条数据
    t0=time.time()
    count=0
    #创建神经网络
    C=Classifier()
    #训练网络的代码同样很简单：
    #在Mnist数据集训练神经网络
    epochs=3
    for i in range(epochs):
        print('training epoch',i+1,"of",epochs)
        for label,image_data_tensor,target_tensor in mnist_dataset:
            C.train(image_data_tensor,target_tensor)
            pass
        print(str(count+1)+'个周期的训练耗费了'+str(time.time()-t0)+'s')
        count+=1
        pass
    record=19
    image_data=mnist_test_dataset[record][1]  #默认使用getitem方法 该方法已被覆写
    output=C.forward(image_data)
    pandas.DataFrame(output.detach().numpy()).plot(kind='bar',legend=False,ylim=(0,1))
    plt.show()

大家都知道，对于逻辑回归，我们的输出函数使用的是sigmoid(),而多分类，当然也是使用的sigmoid()，使用one-hot-code格式，但是我们这里并不是采用的在最后接softmax层的方法，而只是简单的深层神经网络方法。而使用sigmoid()函数，也意味着我们输出的是该东西为1的概率。p(y=1),而多分类，输出的当然就是等于各个可能结果的概率。

大家如果想要仔细了解logistic regression和softmax还有两个损失函数(不同)

可以看看这篇知乎:https://www.zhihu.com/question/341500352/answer/795497527

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

希望大家能分清楚什么是单(标签)(多)分类交叉熵和多标签分类交叉熵

在这里插入图片描述

最后，我们检测4这个数字，发现网络认为该数字为4的概率大于9，这说明，我们的网络训练取得了不错的成效。但是我们也必须清楚，神经网络大多是存在误差的，例如对于比较潦草的数字，像素值有偏差的，就容易出现识别错误的现象。

6.完整的测试简单的分类器的性能

接下来我们来完整地测试一下我们模型的性质，我们使用一种比较直接的方法，对MNIST测试数据集中所有10000幅图像进行分类，并记录正确分类的样本数。

分类是否正确可以通过比较网络输出和图像的标签来分辨。

#测试用训练数据训练后的网络

score=0
items=0

for label,image_data_tensor,target_tensor in mnist_test_dataset:
	answer=C.forward(image_data_tensor).detach().numpy()
	#argmax返回向量中最大值的索引
	if (answer.argmax()==label):
		score+=1
		pass
	items+=1
	pass
print(score,items,score/times)

不爱写程序的程序猿
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
PyTorch模型训练最新实用教程 (余霆嵩) PDF版
12-24
本教程以实际应用、工程开发为目的，着重介绍模型训练过程中遇到的实际问题和方法。如上图所示，在机器学习模型开发中，主要涉及三大部分，分别是数据、模型和损失函数及优化器。本文也按顺序的依次介绍数据、模型和损失函数及优化器，从而给大家带来清晰的机器学习结构。 本教程内容主要为在 PyTorch 中训练一个模型所可能涉及到的方法及函数，并且对 PyTorch 提供的数据增强方法（22 个）、权值初始化方法（10 个）、损失函数（17 个）、优化器（6 个）及 tensorboardX 的方法（13 个）进行了详细介绍。 本教程分为四章，结构与机器学习三大部分一致： 第一章，介绍数据的划分，预处理，数据增强； 第二章，介绍模型的定义，权值初始化，模型 Finetune； 第三章，介绍各种损失函数及优化器； 第四章，介绍可视化工具，用于监控数据、模型权及损失函数的变化。
第二章——Pytorch初步应用
qq_39079631的博客
10-20 150
Pytorch初步应用 使用Pytorch构建一个神经网络 构建神经网络的典型流程： 定义一个拥有可学习参数的神经网络 遍历训练数据集 处理输入数据使其流经神经网络 计算损失值 将网络参数的梯度进行反向传播 以一定规则更新网络权重 下面是定义一个Pytorch实现的神经网络 # -*- coding: utf-8 -*- """ Created on Tue Oct 19 15:50:59 2021 @author: Lancibe """ import torch import torch.
深度学习 | 【02】Pytorch初步使用
weixin_45926547的博客
05-14 908
文章目录Pytorch初始使用1、Tensor2、Pytorch如何创建张量2.1 创建张量2.2 tensor与ndarray的关系2.3 常用api常用方法4、数据类型4.1 获取数据类型5、tensor的其他操作5.1 相加5.2 tensor与数字的操作6、CUDA中的tensor Pytorch初始使用 1、Tensor Tensor(张量是一个统称，其中包括很多类型)： 0阶张量：标量、常数、0-D Tensor； 1阶张量：向量、1-D Tensor； 2阶张量：矩阵、2-D Tensor
pytorch新手入门：认识+理解+实战
CSer
08-28 2882
某天在微博上看到@爱可可-爱生活 老师推了Pytorch的入门教程，就顺手下来翻了。虽然完工的比较早但是手头菜的没有linux服务器没法子运行结果。开学以来终于在师兄的机器装上了Torch，中间的运行结果也看明白了。所以现在发一下这篇两周之前做的教程翻译。首先惯例上原文链接，特别的原作者是以ipyhton notebook来写的教程，运行相当的方便。但带来的问题就是翻译作为专栏文章的效果实在是太差...
pytorch使用教程及应用-GANS编程(4)-CUDA
ChadWick的博客
06-01 291
CUDA基础知识 文章目录CUDA基础知识1.numpy与python的比较2.NVIDIA CUDA3.在python中使用CUDA(anaconda3+pycharm+pytorch+cuda10.0+cudnn) 在前面，我们介绍了信号如何传递并通过神经网络，以及反向传播更新网络链接权重的计算过程。 它们都可以用矩阵乘法计算。一个简单的矩阵乘法，可以取代成百上万次单独计算。也就是吴恩达老师最喜欢的向量化运算代替FOR循环，详情可以查看我前面的文章，numpy作为python的科学计算库使用C语言实现的
a-PyTorch-Tutorial-to-Super-Resolution:使用生成对抗网络的逼真的单图像超分辨率|英特尔:registered:开发人员专区超级解析的PyTorch教程
05-26
假定具备PyTorch的基本知识，即卷积神经网络。 如果您是PyTorch的新手，请先阅读PyTorch的和 。 问题，建议或更正可以作为问题发布。 我在Python 3.6使用PyTorch 1.4 。 2020年1月27日： 现已提供代码。内容客观的...
Pytorch学习记录分享11-PyTorch GAN对抗生成网络
01-03
GANs是由Ian Goodfellow等人在2014年提出的，它通过两个神经网络——生成器（Generator）和判别器（Discriminator）之间的博弈来学习数据的分布，进而生成与训练数据相似的新样本。 **1. GAN的基本原理** GAN的核心...
pytorch-使用Pytorch实现的GAN生成对抗网络.zip
03-02
生成对抗网络（Generative Adversarial Networks, GANs）是一种深度学习模型，由Ian Goodfellow在2014年提出，其核心思想是通过两个神经网络之间的博弈来生成新的、类似于训练数据的样本。一个网络称为生成器...
Pytorch-pytorch深度学习教程之生成对抗网络.zip
最新发布
05-22
在深度学习领域，PyTorch是一个非常流行的开源框架，它为构建和训练复杂的神经网络提供了便利。本教程将深入探讨如何使用PyTorch实现生成对抗网络（GANs），这是一种强大的机器学习模型，能够生成与训练数据类似的新...
深度学习与PyTorch入门实战教程-对抗生成网络GAN.rar
04-07
4. **模型构建**：详细阐述如何使用PyTorch构建生成器和判别器的神经网络结构，包括选择合适的激活函数、损失函数和优化器。 5. **训练过程**：描述GANs的训练流程，包括前向传播、反向传播、损失计算和参数更新等...
pytorch使用教程及应用-GANS编程(1)-基础使用
ChadWick的博客
03-27 300
Pytorch使用教程及应用-GANS(构建生成对抗神经网络) 本博文基于书籍–<<Pytorch 生成对抗网络编程>>，欢迎大家购买书籍支持原创 1.基础使用 建立张量: x=torch.tensor(3.5,requires_grad=True)#建立一个值为3.5且需要计算其梯度的张量 求解函数y对于x的梯度: import torch x=torch.tensor(3.5,requires_grad=True) y=(x-1)*(X-2) y.backward() #必要步
PyTorch - 00 - 先决条件-神经网络编程系列
weixin_48367136的博客
10-22 318
欢迎使用PyTorch进行有关神经网络编程的系列文章。在这篇文章中，我们将研究进行最佳准备所需的先决条件。 我们将对该系列进行概述，并简要介绍我们将要进行的项目。 这将使我们对本系列中学到什么以及将要掌握的技能有一个很好的了解。
Pytorch 网络结构的可视化
齐落山大勇的博客
02-23 685
在使用Pytorch时，常用的模型可视化法方法
pytorch学习笔记——4.1Pytorch中网络结构的可视化
weixin_52067875的博客
07-30 1000
深度学习网络通常具有比较深的层次结构，因此需要可视化工具将建立的深度学习网络结构层次化的展示出来。本文中我们首先定义一个简单的CNN网络对MNIST数据进行分类，并通过PytorchViz库进行网络的可视化处理。...
mseloss pytorch_线性回归模型与pytorch实现
weixin_39920403的博客
11-27 592
线性回归模型是非常基本的回归模型，其原理比较简单，所以文章仅仅简单介绍，并给出pytorch实现代码。文章分为4个部分：（1）线性回归模型的理论基础（2）网络设计与pytorch实现（3）构建数据与网络训练测试（4）拟合过程可视化1、线性回归模型的理论基础这里简单的线性回归模型视为：y=kx+b，其中x是输入数据，k和b是需要学习的参数，y是网络的预测输出。那么学习的目的就是让网络预测输出尽可能接...
pytorch的初步使用
m0_67821723的博客
05-19 721
pytorch介绍以及基本语法
【Python机器学习基础教程8】神经网络用于手写识别
Frank Kong的博客
10-22 374
训练集数据 http://www.pjreddie.com/media/files/mnist_train.csv 测试集数据 https://raw.githubusercontent.com/makeyourownneuralnetwork/makeyourownneuralnetwork/master/mnist_dataset/mnist_test_10.csv 说明：...
PyTorch 深度学习实践 第9讲
热门推荐
bit452的专栏
11-14 3万+
第9讲 多分类问题源代码 B站 刘二大人，传送门PyTorch深度学习实践——多分类问题 视频中截图 说明： 1、softmax的输入不需要再做非线性变换，也就是说softmax之前不再需要激活函数(relu) 2、y的标签编码方式是one-hot。我对one-hot的理解是只有一位非零(不一定非的是1)，其他位为0 3、多分类问题，标签y的类型是LongTensor。比如说0-9分类问题，如果y = torch.LongTensor([3])...
pytorch学习（二）
qq_42036869的博客
03-29 576
1.logistic回归实战
PyTorch官方教程：快速入门与实战应用
该教程特别强调了PyTorch的特点，如其动态图机制，强大的GPU加速能力以及对动态神经网络的支持，这是TensorFlow等其他框架所不具备的优势。它提供了丰富的学习路径，适合不同层次的学习者。 对于初学者，教程首先...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值