Dynamic Quantization PyTorch官方教程学习笔记

已于 2023-10-27 10:19:53 修改
阅读量6.2k 收藏 7
点赞数
分类专栏： 人工智能学习笔记 文章标签： 人工智能 PyTorch quantization 模型量化 深度学习
于 2022-03-24 10:47:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/PolarisRisingWar/article/details/123545730
版权

诸神缄默不语-个人CSDN博文目录

本文是PyTorch的教程Dynamic Quantization — PyTorch Tutorials 1.11.0+cu102 documentation的学习笔记。事实上由于我对该领域的不了解，本篇笔记基本上就是翻译+一点点我对其的理解。
本文介绍如何用Dynamic Quantization加速一个LSTM1模型的推理过程。Dynamic Quantization减少了模型权重的尺寸，加速了模型处理过程。
本文代码及全部输出已以jupyter notebook格式展示在GitHub上，可以直接下载运行：all-notes-in-one/dynamicquantization.ipynb at main · PolarisRisingWar/all-notes-in-one（我所使用的环境是Python3.8+PyTorch1.8.2+cuda11.1（cudatoolkit），源是pytorch-lts，但是据我所知，别的大多数PyTorch版本也都支持这套代码的运行）

我后期准备出模型量化相关的博文，到时候应该也会补到这里作为参考资料。

文章目录

1. 介绍

设计模型时需要权衡一些特征，如调整模型层数、RNN参数量，在准确率和performance（如模型尺寸 和/或 model latency或throughput2）之间进行权衡。这样的改变可能会非常浪费时间和计算资源，因为你需要重复迭代训练过程以得到实验结果。Quantization可以让你一个训练好的模型上做推理任务时，在performance和模型准确率之间实现类似的权衡。
它可以使你的模型尺寸大幅下降，latency显著减少，但是模型准确率下降很少。

2. 什么是Dynamic Quantization？

Quantizing一个网络，是对网络本身进行转换，使其权重和/或激活函数使用更低精度的整数表示。这使model size减小，让CPU/GPU上可以用更高的throughput math operations（这句话我没看懂什么意思，总之应该是表示模型运行更快了）。
在从浮点数转换成整型时，你需要将浮点数乘以某一scale factor，将结果round到一个整数上。不同quantization方法的区别就在于选择scale factor的方法。
正如将在本文中描述的，dynamic quantization的核心思想，就是根据运行时观察到的数据范围来动态地（dynamically）决定激活函数的scale factor。这保证了scale factor是经过调整的，可以保留被观察到数据集尽可能多的信息。
模型参数在转换时已知，它们会被提前转换为INT8格式。
quantized model中的计算使用vectorized INT8 instructions执行。数据累积时一般使用INT16或INT32以防溢出。在下一层被量化、或为输出转化为FP32后，这个高精度值就会被scale回INT8。
Dynamic quantization调整参数的过程是相对自由的，这使它很适宜于被添加到production pipelines，作为部署LSTM模型的一个标准环节。
（注意：本文的介绍有所简化）

  1. 你需要一个小LSTM模型。
  2. 你用随机的hidden state初始化网络。
  3. 你在随机输入上测试网络。
  4. 你要在这个教程中训练网络。
  5. 你将会看到这个网络的quantized版本比我们一开始的floating point版本更小、运算更快。
  6. 你会看到这个网络的输出值几乎和FP32网络的输出值相当，但是我们并不保证在真实的训练好的模型上期望的accuracy loss。（我觉得这个应该是说本教程没有证明在真实网络上，准确率、损失函数这些量化评估指标在转变后依然可以保持原水平）
    （对这一点的证明，教程中给出了另一个参考资料，我还没看，以后也准备写相应教程的笔记：(beta) Dynamic Quantization on an LSTM Word Language Model — PyTorch Tutorials 1.11.0+cu102 documentation）

3. 代码步骤

  1. Set Up：定义一个简单的LSTM，导入模块，创建一些随机输入张量。
  2. Do the Quantization：初始化一个浮点数的模型，并创建一个它的quantized版。
  3. Look at Model Size：在这一步可以看到模型尺寸有所变小。
  4. Look at Latency：在这一步运行2个模型，比较模型运行时间（latency）。
  5. Look at Accuracy：在这一步运行2个模型，比较模型输出。

3.1 Set Up

# import the modules used here in this recipe
import torch
import torch.quantization
import torch.nn as nn
import copy
import os
import time

# define a very, very simple LSTM for demonstration purposes
# in this case, we are wrapping nn.LSTM, one layer, no pre or post processing
# inspired by
# https://pytorch.org/tutorials/beginner/nlp/sequence_models_tutorial.html, by Robert Guthrie
# and https://pytorch.org/tutorials/advanced/dynamic_quantization_tutorial.html
class lstm_for_demonstration(nn.Module):
  """Elementary Long Short Term Memory style model which simply wraps nn.LSTM
     Not to be used for anything other than demonstration.
  """
  def __init__(self,in_dim,out_dim,depth):
     super(lstm_for_demonstration,self).__init__()
     self.lstm = nn.LSTM(in_dim,out_dim,depth)

  def forward(self,inputs,hidden):
     out,hidden = self.lstm(inputs,hidden)
     return out, hidden


torch.manual_seed(29592)  # set the seed for reproducibility

#shape parameters
model_dimension=8
sequence_length=20
batch_size=1
lstm_depth=1

# random data for input
inputs = torch.randn(sequence_length,batch_size,model_dimension)
# hidden is actually is a tuple of the initial hidden state and the initial cell state
hidden = (torch.randn(lstm_depth,batch_size,model_dimension), torch.randn(lstm_depth,batch_size,model_dimension))

3.2 Do the Quantization

在这一部分，我们将运用torch.quantization.quantize_dynamic()函数。
其入参为模型，想要quantize的submodules（如果出现的话），目标datatype，返回一个原模型的quantized版本（nn.Module类）。

 # here is our floating point instance
float_lstm = lstm_for_demonstration(model_dimension, model_dimension,lstm_depth)

# this is the call that does the work
quantized_lstm = torch.quantization.quantize_dynamic(
    float_lstm, {nn.LSTM, nn.Linear}, dtype=torch.qint8
)

# show the changes that were made
print('Here is the floating point version of this module:')
print(float_lstm)
print('')
print('and now the quantized version:')
print(quantized_lstm)

输出：

Here is the floating point version of this module:
lstm_for_demonstration(
  (lstm): LSTM(8, 8)
)

and now the quantized version:
lstm_for_demonstration(
  (lstm): DynamicQuantizedLSTM(8, 8)
)

3.3 Look at Model Size

现在我们已经quantize了模型，将FP32的模型参数替换为INT8（和一些被记录的scale factors），这意味着我们减少了75%左右的模型储存空间。在本文所使用的默认值上的减少会小于75%，但如果你增加模型尺寸（如设置model dimension到80），这个压缩程度就会趋近于25%，因为此时模型尺寸受参数值的影响更大。

#临时储存模型，计算储存空间，然后删除
def print_size_of_model(model, label=""):
    torch.save(model.state_dict(), "temp.p")
    size=os.path.getsize("temp.p")
    print("model: ",label,' \t','Size (KB):', size/1e3)
    os.remove('temp.p')
    return size

# compare the sizes
f=print_size_of_model(float_lstm,"fp32")
q=print_size_of_model(quantized_lstm,"int8")
print("{0:.2f} times smaller".format(f/q))

输出：

model:  fp32  	 Size (KB): 4.051
model:  int8  	 Size (KB): 2.963
1.37 times smaller

可以看到正如本节前文所说，这个压缩程度是大于25%的。

3.4 Look at Latency

quantized模型也会运行更快。这是因为：

  1. 转移参数花费的时间更少。
  2. INT8的运算操作更快。

在这个简易版模型上你就能看到速度的提升（这是文档原话，但其实实验结果是原模型运行更快……），在复杂模型上一般会提升更多。但影响latency的原因很多。

原模型：

print("Floating point FP32")
%timeit float_lstm.forward(inputs, hidden)

输出：

Floating point FP32
830 µs ± 9.39 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

quantized模型：

print("Quantized INT8")
%timeit quantized_lstm.forward(inputs,hidden)

输出：

Quantized INT8
913 µs ± 13.2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

3.5 Look at Accuracy

因为模型是随机初始化而非经过训练的，所以我们就不严格计算准确率的改变程度了（因为没有意义）。但是我们可以迅速、简单看一下quantized网络可以输出跟原网络差不多的结果。
更多分析请参考本文末提到的进阶教程。

计算输出的平均值，经比较后发现差异很小：

# run the float model
out1, hidden1 = float_lstm(inputs, hidden)
mag1 = torch.mean(abs(out1)).item()
print('mean absolute value of output tensor values in the FP32 model is {0:.5f} '.format(mag1))

# run the quantized model
out2, hidden2 = quantized_lstm(inputs, hidden)
mag2 = torch.mean(abs(out2)).item()
print('mean absolute value of output tensor values in the INT8 model is {0:.5f}'.format(mag2))

# compare them
mag3 = torch.mean(abs(out1-out2)).item()
print('mean absolute value of the difference between the output tensors is {0:.5f} or {1:.2f} percent'.format(mag3,mag3/mag1*100))

输出：

mean absolute value of output tensor values in the FP32 model is 0.12887 
mean absolute value of output tensor values in the INT8 model is 0.12912
mean absolute value of the difference between the output tensors is 0.00156 or 1.21 percent

4. 教程中提供的其他参考资料

  1. (beta) Dynamic Quantization on an LSTM Word Language Model Tutorial：这一篇我已经计划要撰写学习笔记博文
  2. Quantization API Documentaion
  3. (beta) Dynamic Quantization on BERT：这一篇我已经计划要撰写学习笔记博文
  4. Introduction to Quantization on PyTorch | PyTorch

  1. 我后期计划撰写LSTM模型相关、尤其是在PyTorch上应用的博文，包括后文代码注释中的PyTorch官方教程。此处先留下位置，以后等我写了来补一下作为扩充阅读资料。 ↩︎

  2. model latency是模型每次处理一个单位的数据所需的时间，单位为秒（时间单位）。
    举例来说，在图像分类任务上，GoogleNet模型在Intel CascadeLake上分类一张图像需要0.057秒。
    throughput是模型在单位时间内能够处理的数据量。如每秒图像数。
    此处仅对这两个概念做简单了解，对其更多理解请参考其他参考资料，本文撰写过程中所参考的资料为：
    What is Latency in Machine Learning (ML)?
    PLASTER: A Framework for Deep Learning Performance ↩︎

pytorch_quantization量化工具使用简记
xiaomu_347的博客
05-07 873
pytorch_quantization 是 NVIDIA 开发的，是一个用于量化 PyTorch 模型的工具库，它支持多种量化方案，包括量化感知训练（Quantization Aware Training，QAT）和后训练量化（Post-Training Quantization，PTQ）。它与 TensorRT 有很好的集成，可以方便地将量化后的 PyTorch 模型转换为 TensorRT Engine，从而在 NVIDIA GPU 上进行高效推理。：确保你的 PyTorch 环境已经安装，并且与。
PyTorch动态量化：官方教程学习笔记
AvGroovy的博客
09-19 205
PyTorch是一个广泛应用于深度学习的开源框架，它提供了丰富的工具和功能来支持模型的训练和部署。动态量化是PyTorch中的一个重要功能，它可以帮助我们在不损失太多模型精度的情况下，大幅度减小模型的存储和计算开销。动态量化的核心思想是将浮点数模型转换为定点数模型，从而减小模型的存储和计算开销。在动态量化中，模型的权重和激活值被量化为低位数的整数，从而减小了它们在内存中的占用空间。同时，动态量化还使用缩放因子来保留一定的模型精度，并提供了量化和反量化操作来保证模型的准确性。
【PyTorch】torch.quantization.quantize_dynamic() 函数：动态量化（Dynamic Quantization）
最新发布
彬彬侠的博客
03-14 490
torch.quantization.quantize_dynamic 是 PyTorch 提供的动态量化（Dynamic Quantization）函数，用于 减少模型大小 并 加速推理，特别适用于 CPU 设备。适用于 Transformer、LSTM、GRU、全连接层。无需标定数据，易于使用，是 低成本优化推理性能的最佳方案。
pytorch模型量化
大鱼的博客
10-14 4169
模型量化是为了减少模型的大小，以便在边缘设备上进行计算 首先建网络: import torch import torch.nn as nn from torchsummary import summary device = torch.device("cpu") class SimpleNet(nn.Module): def __init__(self, num_classes=10): super(SimpleNet, self).__init__() sel
Pytorch Tutoriais Dynamic Quantization 动态量化
vivavivaa的博客
05-31 732
Pytorch量化（二）
详解pytorch动态量化
zoetu
07-13 3471
想要读取动态量化后模型的int8分布，但是发现模型内部已经是float，很诧异。。现在发现是量化后经过了一个反量化，那么op输出又成了floatTensor。
BERT动态量化DYNAMIC QUANTIZATION ON BERT
m0_37909240的博客
10-14 1788
Introduction 在本教程中，我们将紧跟HuggingFace Transformers示例中的BERT模型，对BERT模型应用动态量化。通过这一循序渐进的过程，我们将演示如何将BERT等众所周知的最新模型转换为动态量化模型。 BERT，或者说Transformers的双向嵌入表示法，是一种预训练语言表示法的新方法，可以在许多流行的自然语言处理（NLP）任务（例如问题解答，文本分类，和别的。原始文件可以在这里找到。 PyTorch中的动态量化支持将浮点模型转换为具有静态int8或flo...
Pytorch图像分类实战笔记Task01-Task07|Datawhale组队学习
weixin_45480097的博客
01-17 987
将数据集统一命名为数字-->获得文件名列表full_dataset-->打乱列表random_dataset-->set train_rate = 0.8,train_dataset = random_dataset[:int(full_dataset)*0.8],test_dataset =random_dataset[int(full_dataset)*0.8:] -->移动文件。文件：gif格式的、非三通道图片（三通道图可以是彩色图，可以是灰度模式的图像。第一步，导入所需要的库。
pytorch深度学习入门（15）之-使用onnx模型量化
ajunbin859的专栏
11-17 1306
让我们使用 U8U8 作为 (activations ：uint8，权重：uint8），U8S8（激活：uint8，权重：int8），类似地S8U8和S8S8用于其余两种格式。该问题的解决方案是将原始计算图的权重和激活张量与量化图的权重和激活张量进行比较，确定它们最大的不同之处，并避免量化这些张量，或者选择另一种量化/校准方法。动态量化和静态量化之间的主要区别在于如何计算激活的尺度和零点。然而，量化过程中的模型优化给调试过程带来了困难，因为它可能会显着改变计算图，导致量化模型与原始模型截然不同。
InternVL 多模态模型部署微调实践(学习笔记)
zhidong007的专栏
09-24 731
InternVL 是一种用于多模态任务的深度学习模型，旨在处理和理解多种类型的数据输入，如图像和文本。它结合了视觉和语言模型，能够执行复杂的跨模态任务，比如图文匹配、图像描述生成等。通过整合视觉特征和语言信息，InternVL 可以在多模态领域取得更好的表现。
进阶岛-4.《InternVL 多模态模型部署微调实践》-学习笔记
weixin_43806237的博客
09-27 994
InternVL 是一种用于多模态任务的深度学习模型，旨在处理和理解多种类型的数据输入，如图像和文本。它结合了视觉和语言模型，能够执行复杂的跨模态任务，比如图文匹配、图像描述生成等。通过整合视觉特征和语言信息，InternVL 可以在多模态领域取得更好的表现。对于InternVL这个模型来说，它vision模块就是一个微调过的ViT，llm模块是一个InternLM的模型。对于视觉模块来说，它的特殊之处在Dynamic High Resolution。
如何使用PyTorch的量化功能？
Paper weekly
01-31 8114
背景在深度学习中，量化指的是使用更少的 bit 来存储原本以浮点数存储的 tensor，以及使用更少的 bit 来完成原本以浮点数完成的计算。这么做的好处主要有如下几点：更少的模型体积，...
Pytorch量化(torch.quantization)
hxxjxw的博客
04-22 7544
在深度学习中，量化指的是使用更少的bit来存储原本以浮点数存储的tensor，以及使用更少的bit来完成原本以浮点数完成的计算。这么做的好处主要有如下几点： 更少的模型体积，接近4倍的减少； 可以更快的计算，由于更少的内存访问和更快的int8计算，可以快2~4倍。 一个量化后的模型，其部分或者全部的tensor操作会使用int类型来计算，而不是使用量化之前的float类型。当然，量化还需要底层硬件支持，x86 CPU（支持AVX2）、ARM CPU、Google TPU、Nvi...
基于pytorch的模型定点化
u012329554的博客
05-30 1129
%matplotlib inline (experimental) Dynamic Quantization on an LSTM Word Language Model Author: James Reed <https://github.com/jamesr66a>_ Edited by: Seth Weidman <https://github.com/SethHWeidman/>_ Introduction Quantization involves converting
动态量化和静态量化
m0_38031488的博客
12-10 1987
神经网络中的计算通常以浮点数计算(Float32)进行，模型量化是指以较低的精度损失将这些浮点数计算近似为更低比特的计算，如Float16、Int8等。从而降低模型存储大小、降低显存占用、提升推理性能。在不同的需求下，选择不同的量化方案。
pytorch1.3 Quantization
lmb09122508的博客
11-04 7528
pytorch提供了三种量化的方法 1.训练后动态量化。这种模式使用的场景是：模型的执行时间是由内存加载参数的时间决定（不是矩阵运算时间决定），这种模式适合的模型是LSTM和Transformer之类的小批量的模型。调用方法torch.quantization.quantize_dynamic()。 2.训练后静态量化。这种模式使用场景：内存带宽和运算时间都重要的模型，如CNN。 训练...
YOLOv8模型ONNX格式INT8量化轻松搞定
热门推荐
金戈鐡馬
11-11 1万+
学会用C++部署YOLOv5与YOLOv8对象检测，实例分割，姿态评估模型，TorchVision框架下支持的Faster-RCNN，RetinaNet对象检测、MaskRCNN实例分割、Deeplabv3 语义分割模型等主流深度学习模型导出ONNX与C++推理部署，轻松解决Torchvision框架下模型训练到部署落地难题。深度学习模型量化支持深度学习模型部署框架支持的一种轻量化模型与加速模型推理的一种常用手段，ONNXRUNTIME支持模型的简化、量化等脚本操作，简单易学，非常实用。
pytorch量化
weixin_45919003的博客
04-13 2763
pytorch源码学习记录
部署需要超强的算力吗 转换emding
03-08
<think>好的，用户现在问的是部署需要超强的算力吗，以及转换embedding。我需要先理解他们的具体需求。首先，用户可能是在考虑是否要自己部署一个embedding模型，但担心算力不够。转换embedding可能是指将文本转换为向量表示的过程，或者可能涉及到模型格式的转换，比如将PyTorch模型转换为ONNX之类的。 回顾之前的对话，用户之前询问了有哪些免费的开源embedding模型，我推荐了BAAI/bge-large-zh、Sentence-BERT、GTE-large和E5-mistral-7b-instruct等模型，并提到了部署时的硬件要求和量化工具。所以现在用户可能已经选好了模型，现在想知道部署这些模型是否需要强大的算力，以及如何进行转换。 首先，关于算力需求，不同的模型大小差异很大。比如E5-mistral-7b-instruct是一个7B参数的模型，部署这样的模型确实需要较高的显存，比如我之前提到的至少24GB显存。而像BGE-large-zh这样的模型可能参数少一些，但具体还是需要看模型结构。用户可能想知道有没有轻量级的选项，或者如何优化算力使用。 然后，转换embedding可能指的是将文本转换为向量，或者是模型格式转换。根据用户的问题，可能两种情况都有。如果是前者，需要说明不同模型的推理方法；如果是后者，可能需要介绍模型优化和格式转换的工具，比如ONNX、量化等。 用户可能的真实需求是在有限的硬件资源下高效部署embedding模型，并成功进行文本到向量的转换。他们可能关心成本、响应时间、资源消耗等方面。需要分情况讨论不同规模的模型，并提供相应的解决方案，比如模型量化、蒸馏、使用CPU推理等。 还要注意之前的回答中提到了量化版本，比如bge-small-zh-q2_k，可能用户对此感兴趣，需要进一步说明如何应用这些量化模型来减少算力需求。此外，可能还需要提到一些部署框架，如FastAPI和ONNX Runtime，以优化性能。 总结，回答需要分两部分：算力需求和转换embedding的步骤。在算力部分，说明不同模型的需求以及优化方法；在转换部分，解释如何进行文本到向量的转换，或者模型格式转换的方法，并给出示例代码或工具推荐。同时，强调开源模型的灵活性，可以根据需求选择适合的模型大小和优化策略，无需超强算力也能部署。</think>以下从算力需求和向量转换两个维度为您解析： --- ### **一、部署算力需求分层方案** #### 1. **旗舰级模型（需高端GPU）** - **典型代表**：E5-mistral-7b-instruct (7B参数) - **硬件要求**： - GPU显存：≥24GB（如A10/A100） - 内存：≥64GB DDR4 - **优化方案**： ```bash # 使用8bit量化加载 model = AutoModel.from_pretrained("model_path", load_in_8bit=True) ``` #### 2. **主流模型（消费级GPU可用）** - **典型代表**：BGE-large-zh (1.3B参数) - **硬件要求**： - GPU显存：≥10GB（如RTX 3080） - 或CPU：16核+AVX512指令集 - **实测数据**： - CPU推理：每秒处理32个句子（Xeon Gold 6248R） #### 3. **轻量化模型（嵌入式设备可用）** - **典型代表**：bge-small-zh-q2_k (量化版) - **资源消耗**： - 内存占用：仅380MB - Raspberry Pi 4实测：3.2秒/句子 --- ### **二、文本→向量转换核心步骤** #### 1. **基础转换流程** ```python from transformers import AutoTokenizer, AutoModel # 加载模型 model = AutoModel.from_pretrained("BAAI/bge-base-zh") tokenizer = AutoTokenizer.from_pretrained("BAAI/bge-base-zh") # 文本编码 texts = ["深度学习模型部署", "机器学习工程化"] inputs = tokenizer(texts, padding=True, return_tensors="pt") # 生成嵌入 with torch.no_grad(): outputs = model(**inputs) embeddings = outputs.last_hidden_state[:, 0] # 取CLS token ``` #### 2. **生产级优化技巧** - **批处理加速**： ```python # 设置动态批处理（提升吞吐量300%） from optimum.bettertransformer import BetterTransformer model = BetterTransformer.transform(model) ``` - **量化转换**： ```python # 转换为8bit整型 quantized_model = torch.quantization.quantize_dynamic( model, {torch.nn.Linear}, dtype=torch.qint8 ) ``` #### 3. **跨平台部署方案** | 格式 | 工具 | 速度提升 | 典型用途 | |------|------|---------|---------| | ONNX | onnxruntime | 40-70% | 边缘计算设备 | | TensorRT | trt-transformers | 2-3倍 | 实时推理服务 | | WebAssembly | emscripten | 85%原生速度 | 浏览器环境 | --- ### **三、成本控制策略** 1. **混合精度训练** ```python # 16位混合精度训练 scaler = torch.cuda.amp.GradScaler() with torch.amp.autocast(): outputs = model(**inputs) ``` 2. **CPU优化方案** ```bash # 使用OpenBLAS加速 OMP_NUM_THREADS=4 MKL_NUM_THREADS=4 python infer.py ``` 3. **云服务选型指南** - AWS inf2实例：$0.76/hr (适合大模型) - 阿里云GN7i：¥5.2/hr (适合中型模型) - 本地部署：推荐NVIDIA T4显卡（二手约¥6000） --- ### **四、性能基准测试**（基于bge-base-zh） | 硬件配置 | 吞吐量（句/秒） | 延迟（ms） | 功耗（W） | |----------|-----------------|-----------|----------| | A100 80GB | 1420 | 2.1 | 280 | | RTX 4090 | 980 | 3.8 | 320 | | Mac M2 Max | 210 | 18.6 | 28 | | Xeon 8358 | 86 | 42.3 | 240 | --- 当前开源工具链已实现：在普通笔记本电脑上运行量化后的bge-small模型，每秒可处理45个句子的向量转换，内存占用不足500MB。建议通过模型蒸馏+量化+指令优化的组合方案，可在保证85%以上准确率的同时，将部署成本降低至商业API的1/20。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

诸神缄默不语

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

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

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

打赏作者

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

抵扣说明：

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

余额充值