72_text_generation\unimo-text 理解

最新推荐文章于 2024-01-25 18:08:18 发布
最新推荐文章于 2024-01-25 18:08:18 发布
阅读量530 收藏 2
点赞数 1
分类专栏： PP/TF/PT 文章标签： 自动驾驶 深度学习 神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_15821487/article/details/120023581
版权
UNIMO模型通过学习图像、文本和图像-文本对的数据，构建了强大的跨模态表示，将视觉和文本表示融合到同一语义空间。该模型使用多头注意力机制的Transformer编码器层，通过大规模语料库进行对比学习，提升了模型的泛化能力。适用于图像检索、文本理解、语义融合等多个任务。
摘要由CSDN通过智能技术生成

UNIMO learns from different modalities of data, including images, texts and image-text
pairs, thus achieving more robust and generalizable
representations for both textual and visual input.
人类识别的角度，所谓的智能就是模仿人的智能，创新的模型架构一般都是受人的智能启发
Humans perceive the world through many modalities, such as sound, vision and language.
图像，文本，图像文本对
在这里插入图片描述
在这里插入图片描述
UNIMO learns visual
representations and textual representations simultaneously, and unifies them into the same semantic
space via cross-modal contrastive learning (CMCL)
based on a large-scale corpus of image collections,
text corpus and image-text pairs.
相当于三个模型，融合对比，图像，文本，图像文本对。

class UNIMOEmbeddings(nn.Layer):
    #Include embeddings from word, position and token_type.

    def __init__(self,
                 vocab_size,
                 hidden_size=768,
                 hidden_dropout_prob=0.1,
                 max_position_embeddings=512,
                 type_vocab_size=4):
        super(UNIMOEmbeddings, self).__init__()
        self.word_embeddings = nn.Embedding(vocab_size, hidden_size)
        self.position_embeddings = nn.Embedding(max_position_embeddings,
                                                hidden_size)
        self.token_type_embeddings = nn.Embedding(type_vocab_size, hidden_size)

    def forward(self, input_ids, token_type_ids, position_ids):
        input_embedings = self.word_embeddings(input_ids)
        position_embeddings = self.position_embeddings(position_ids)
        token_type_embeddings = self.token_type_embeddings(token_type_ids)

        embeddings = input_embedings + position_embeddings + token_type_embeddings
        return embeddings

transformer系列的编码都是如此，三个变量加权。

UNIMOLMHeadModel(
  (unimo): UNIMOModel(
    (embeddings): UNIMOEmbeddings(
      (word_embeddings): Embedding(18000, 768, sparse=False)
      (position_embeddings): Embedding(513, 768, sparse=False)
      (token_type_embeddings): Embedding(4, 768, sparse=False)
    )
    (encoder_norm): LayerNorm(normalized_shape=[768], epsilon=1e-05)
    (dropout): Dropout(p=0.1, axis=None, mode=upscale_in_train)
    (encoder): TransformerEncoder(
      (layers): LayerList(
        (0): TransformerEncoderLayer(
          (self_attn): MultiHeadAttention(
            (q_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (k_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (v_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (out_proj): Linear(in_features=768, out_features=768, dtype=float32)
          )
          (linear1): Linear(in_features=768, out_features=3072, dtype=float32)
          (dropout): Dropout(p=0, axis=None, mode=upscale_in_train)
          (linear2): Linear(in_features=3072, out_features=768, dtype=float32)
          (norm1): LayerNorm(normalized_shape=[768], epsilon=1e-05)
          (norm2): LayerNorm(normalized_shape=[768], epsilon=1e-05)
          (dropout1): Dropout(p=0.1, axis=None, mode=upscale_in_train)
          (dropout2): Dropout(p=0.1, axis=None, mode=upscale_in_train)
        )
        (1): TransformerEncoderLayer(
          (self_attn): MultiHeadAttention(
            (q_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (k_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (v_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (out_proj): Linear(in_features=768, out_features=768, dtype=float32)
          )
          (linear1): Linear(in_features=768, out_features=3072, dtype=float32)
          (dropout): Dropout(p=0, axis=None, mode=upscale_in_train)
          (linear2): Linear(in_features=3072, out_features=768, dtype=float32)
          (norm1): LayerNorm(normalized_shape=[768], epsilon=1e-05)
          (norm2): LayerNorm(normalized_shape=[768], epsilon=1e-05)
          (dropout1): Dropout(p=0.1, axis=None, mode=upscale_in_train)
          (dropout2): Dropout(p=0.1, axis=None, mode=upscale_in_train)
        )
        (2): TransformerEncoderLayer(
          (self_attn): MultiHeadAttention(
            (q_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (k_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (v_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (out_proj): Linear(in_features=768, out_features=768, dtype=float32)
          )
          (linear1): Linear(in_features=768, out_features=3072, dtype=float32)
          (dropout): Dropout(p=0, axis=None, mode=upscale_in_train)
          (linear2): Linear(in_features=3072, out_features=768, dtype=float32)
          (norm1): LayerNorm(normalized_shape=[768], epsilon=1e-05)
          (norm2): LayerNorm(normalized_shape=[768], epsilon=1e-05)
          (dropout1): Dropout(p=0.1, axis=None, mode=upscale_in_train)
          (dropout2): Dropout(p=0.1, axis=None, mode=upscale_in_train)
        )
        (3): TransformerEncoderLayer(
          (self_attn): MultiHeadAttention(
            (q_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (k_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (v_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (out_proj): Linear(in_features=768, out_features=768, dtype=float32)
          )
          (linear1): Linear(in_features=768, out_features=3072, dtype=float32)
          (dropout): Dropout(p=0, axis=None, mode=upscale_in_train)
          (linear2): Linear(in_features=3072, out_features=768, dtype=float32)
          (norm1): LayerNorm(normalized_shape=[768], epsilon=1e-05)
          (norm2): LayerNorm(normalized_shape=[768], epsilon=1e-05)
          (dropout1): Dropout(p=0.1, axis=None, mode=upscale_in_train)
          (dropout2): Dropout(p=0.1, axis=None, mode=upscale_in_train)
        )
        (4): TransformerEncoderLayer(
          (self_attn): MultiHeadAttention(
            (q_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (k_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (v_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (out_proj): Linear(in_features=768, out_features=768, dtype=float32)
          )
          (linear1): Linear(in_features=768, out_features=3072, dtype=float32)
          (dropout): Dropout(p=0, axis=None, mode=upscale_in_train)
          (linear2): Linear(in_features=3072, out_features=768, dtype=float32)
          (norm1): LayerNorm(normalized_shape=[768], epsilon=1e-05)
          (norm2): LayerNorm(normalized_shape=[768], epsilon=1e-05)
          (dropout1): Dropout(p=0.1, axis=None, mode=upscale_in_train)
          (dropout2): Dropout(p=0.1, axis=None, mode=upscale_in_train)
        )
        (5): TransformerEncoderLayer(
          (self_attn): MultiHeadAttention(
            (q_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (k_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (v_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (out_proj): Linear(in_features=768, out_features=768, dtype=float32)
          )
          (linear1): Linear(in_features=768, out_features=3072, dtype=float32)
          (dropout): Dropout(p=0, axis=None, mode=upscale_in_train)
          (linear2): Linear(in_features=3072, out_features=768, dtype=float32)
          (norm1): LayerNorm(normalized_shape=[768], epsilon=1e-05)
          (norm2): LayerNorm(normalized_shape=[768], epsilon=1e-05)
          (dropout1): Dropout(p=0.1, axis=None, mode=upscale_in_train)
          (dropout2): Dropout(p=0.1, axis=None, mode=upscale_in_train)
        )
        (6): TransformerEncoderLayer(
          (self_attn): MultiHeadAttention(
            (q_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (k_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (v_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (out_proj): Linear(in_features=768, out_features=768, dtype=float32)
          )
          (linear1): Linear(in_features=768, out_features=3072, dtype=float32)
          (dropout): Dropout(p=0, axis=None, mode=upscale_in_train)
          (linear2): Linear(in_features=3072, out_features=768, dtype=float32)
          (norm1): LayerNorm(normalized_shape=[768], epsilon=1e-05)
          (norm2): LayerNorm(normalized_shape=[768], epsilon=1e-05)
          (dropout1): Dropout(p=0.1, axis=None, mode=upscale_in_train)
          (dropout2): Dropout(p=0.1, axis=None, mode=upscale_in_train)
        )
        (7): TransformerEncoderLayer(
          (self_attn): MultiHeadAttention(
            (q_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (k_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (v_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (out_proj): Linear(in_features=768, out_features=768, dtype=float32)
          )
          (linear1): Linear(in_features=768, out_features=3072, dtype=float32)
          (dropout): Dropout(p=0, axis=None, mode=upscale_in_train)
          (linear2): Linear(in_features=3072, out_features=768, dtype=float32)
          (norm1): LayerNorm(normalized_shape=[768], epsilon=1e-05)
          (norm2): LayerNorm(normalized_shape=[768], epsilon=1e-05)
          (dropout1): Dropout(p=0.1, axis=None, mode=upscale_in_train)
          (dropout2): Dropout(p=0.1, axis=None, mode=upscale_in_train)
        )
        (8): TransformerEncoderLayer(
          (self_attn): MultiHeadAttention(
            (q_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (k_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (v_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (out_proj): Linear(in_features=768, out_features=768, dtype=float32)
          )
          (linear1): Linear(in_features=768, out_features=3072, dtype=float32)
          (dropout): Dropout(p=0, axis=None, mode=upscale_in_train)
          (linear2): Linear(in_features=3072, out_features=768, dtype=float32)
          (norm1): LayerNorm(normalized_shape=[768], epsilon=1e-05)
          (norm2): LayerNorm(normalized_shape=[768], epsilon=1e-05)
          (dropout1): Dropout(p=0.1, axis=None, mode=upscale_in_train)
          (dropout2): Dropout(p=0.1, axis=None, mode=upscale_in_train)
        )
        (9): TransformerEncoderLayer(
          (self_attn): MultiHeadAttention(
            (q_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (k_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (v_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (out_proj): Linear(in_features=768, out_features=768, dtype=float32)
          )
          (linear1): Linear(in_features=768, out_features=3072, dtype=float32)
          (dropout): Dropout(p=0, axis=None, mode=upscale_in_train)
          (linear2): Linear(in_features=3072, out_features=768, dtype=float32)
          (norm1): LayerNorm(normalized_shape=[768], epsilon=1e-05)
          (norm2): LayerNorm(normalized_shape=[768], epsilon=1e-05)
          (dropout1): Dropout(p=0.1, axis=None, mode=upscale_in_train)
          (dropout2): Dropout(p=0.1, axis=None, mode=upscale_in_train)
        )
        (10): TransformerEncoderLayer(
          (self_attn): MultiHeadAttention(
            (q_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (k_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (v_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (out_proj): Linear(in_features=768, out_features=768, dtype=float32)
          )
          (linear1): Linear(in_features=768, out_features=3072, dtype=float32)
          (dropout): Dropout(p=0, axis=None, mode=upscale_in_train)
          (linear2): Linear(in_features=3072, out_features=768, dtype=float32)
          (norm1): LayerNorm(normalized_shape=[768], epsilon=1e-05)
          (norm2): LayerNorm(normalized_shape=[768], epsilon=1e-05)
          (dropout1): Dropout(p=0.1, axis=None, mode=upscale_in_train)
          (dropout2): Dropout(p=0.1, axis=None, mode=upscale_in_train)
        )
        (11): TransformerEncoderLayer(
          (self_attn): MultiHeadAttention(
            (q_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (k_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (v_proj): Linear(in_features=768, out_features=768, dtype=float32)
            (out_proj): Linear(in_features=768, out_features=768, dtype=float32)
          )
          (linear1): Linear(in_features=768, out_features=3072, dtype=float32)
          (dropout): Dropout(p=0, axis=None, mode=upscale_in_train)
          (linear2): Linear(in_features=3072, out_features=768, dtype=float32)
          (norm1): LayerNorm(normalized_shape=[768], epsilon=1e-05)
          (norm2): LayerNorm(normalized_shape=[768], epsilon=1e-05)
          (dropout1): Dropout(p=0.1, axis=None, mode=upscale_in_train)
          (dropout2): Dropout(p=0.1, axis=None, mode=upscale_in_train)
        )
      )
    )
  )
  (lm_head): UNIMOLMHead(
    (transform): Linear(in_features=768, out_features=768, dtype=float32)
    (layer_norm): LayerNorm(normalized_shape=[768], epsilon=1e-05)
  )
)

在这里插入图片描述

DEBUG代码看模型的结构定义是最清晰的方式，每一层是什么，结构是什么，参数是什么，输入输出是什么。比文档还清晰明了

在这里插入图片描述
在这里插入图片描述
https://blog.csdn.net/qq_15821487/article/details/120035220 参考python传参定义

input = paddle.to_tensor([[1,2],[3,4],[5,6]])
            index = paddle.to_tensor([0,1])
            output = paddle.gather(input, index, axis=0)
            # expected output: [[1,2],[3,4]]

截断，某个函数不清晰，直接点进去源码看一眼就好了，看多了自然就记住了
在这里插入图片描述
文件里面进去没找到对应的原函数的时候，直接按住ctrl，然后从弹出的列表中对照参数找到对应的函数。
在这里插入图片描述
通用的生成函数，聊天机器人的也是这个

   The interface for generation task. This method can generate sequences 
        by using decoding strategy. Currently, there are three decoding 
        strategies supported: "greedy_search", "sampling" and "beam_search".

text retrieval
文本检索

Cross-Modal Contrastive Learning

图像文本融合学习

Text Rewriting

文本重写和增强

Text Enhance Vision

Text Enhance Vision

互相融合和增加，各种语义特征空间

（四十九）：UNIMO: Towards Unified-Modal Understanding and Generation via Cross-Modal Contrastive Learning
Wangzx的博客
09-03 624
（四十九）：UNIMO: Towards Unified-Modal Understanding and Generation via Cross-Modal Contrastive LearningAbstract1 Introduction2 UNIMO2.1 Cross-Modal Contrastive Learning2.2 Visual Learning2.3 Language Learning3 Experimental Settings3.1 Pre-training Dataset3.2
文本摘要相关问题：
丨汀、的博客
06-09 1198
据悉，2022年教育部将围绕“巩固提高、深化落实、创新突破”三个关键词展开工作。要进一步强化学校教育主阵地作用，继续把落实“双减”作为学校工作的重中之重，重点从提高作业设计水平、提高课后服务水平、提高课堂教学水平、提高均衡发展水平四个方面持续巩固提高学校“双减”工作水平。‘教育部：将从四个方面持续巩固提高学校“双减”工作水平’
6:UNIMO模型
qq_41887799的博客
01-24 2463
Towards Unified-Modal Understanding and Generation via Cross-Modal Contrastive Learning code：https://github.com/PaddlePaddle/ Research/tree/master/NLP/UNIMO. 1.摘要 存在的单模型和多模型任务彼此间不能很好的适应，本文提出了一种UNIMO来提高多模态的理解和生成任务。大量的图片和文本用来整合提高视觉和文本的理解。并且交...
[UNIMO]-跨模态论文阅读笔记
yangyanbao8389的博客
01-18 2911
论文：https://arxiv.org/pdf/2012.15409.pdf code：Research/NLP/UNIMO at master · PaddlePaddle/Research · GitHub 背景 motivation:人类大脑能够处理文本、图像、语音等各种模态的信息，并通过模态间的交互增强提升对世界的认知能力。现存预训练方法只能处理单模或多模任务中的一种，同时也只能利用单模data(text or image)或有限的多模data(image-text pairs)。 a
『千言：面向事实一致性的生成评测比赛』基线系统
m0_63642362的博客
11-10 733
千言：面向事实一致性的生成评测比赛。 比赛报名链接： https://aistudio.baidu.com/aistudio/competition/detail/105
百度商业AI 技术创新大赛赛道二：AIGC推理性能优化TOP10之经验分享
Frank-Li的博客
08-22 1799
上面是我整个项目的尝试，具体细节信息各位赛友自己跑一跑我的代码才知道，里面有很多错误尝试，包括我甚至还尝试了内存共享技术、多线程技术、多进程技术和异步处理等等，都不是很理想，可能你们尝试后会有提高，这里面提升最大的还得是超参优化和so库调用。
基于PaddleHUB实现人工智能相声生成
m0_63642362的博客
02-25 657
基于PaddleHUB完成文本对话生成类任务，包括数据集的制作，预训练模型的选择并进行训练。帮助你从头开始一步步实现完成自己的想法。
UNIMO：Towards Unified-Modal Understanding and Generation via Cross-Modal Contrastive Learning
BachelorSC ' s Notes
03-01 3474
**本文内容仅代表个人理解，如有错误，欢迎指正** 1. Points 1) UNIMO是一个预训练模型，其输入可以有不同的形式(eg, Image collections, Text corpus, Image-Text Pairs)，并且可以微调后用于单模态(Single-modal)任务与多模态(Multi-modal)任务。即不仅在预训练时利用了image-text pair的数据，还充分利用了大量单模态的数据(non-paired single-modal, like images and t
questiongenerator:一个简单的问题生成器
05-31
问题生成器 一个简单的问题生成器，由 Retrospring（以前的 justask）使用。 安装 将此行添加到应用程序的 Gemfile 中： gem 'questiongenerator' 如果您感到前卫，可以添加以下行： ...用法 require '...
通过一个预训练的unimo模型，如何在paddle上进行推理加速，使用fast_transformer算子
07-13
'unimo_text_cls_base_zh', fusion=True ) # 设置输入数据 input_ids = paddle.to_tensor([[1, 2, 3, 4, 5]]) segment_ids = paddle.to_tensor([[0, 0, 0, 0, 0]]) position_ids = paddle.to_tensor([[0, 1, 2, 3,...
Text-Rewriting-Simplification:Text神经文本简化以提高Chatbot性能
04-30
使用Tensorflow简化神经文本 该项目是将张量流的神经机器翻译模型（ ）掺杂到文本简化任务中的探索。 它类似于基于。 交互式演示位于。 快速开始： 以递归方式将存储库克隆到本地计算机： git clone --recursive https://github.com/captainjtx/SimpleText.git 安装python软件包： cd SimpleText pip install -r requirements.txt 将预训练的模型下载到本地目录（./model）： mkdir model python script/download_models.py 在其中一个预训练模型上运行推断（seq2seq，具有Attention的2隐藏层LSTM，压差0.25，）。 默认输入为test / complex.tt，默认输出为test / inference.
UNIMO：基于跨模态对比学习的统一模态理解和生成
qq_45331246的博客
10-02 2648
UNIMO、跨模态对比学习、统一模态
【论文阅读】统一模态 UNIMO 模型
m0_37477175的博客
11-05 682
统一模态 前言： 多模态成对的数据是非常有限的！ 现有的模型预训练方法要么专注于单模态任务，要么专注于多模态任务，不能有效地相互适应。 （多模态任务模型应用于单模态任务上，效果会大大下降，，多模态模型如何应用到单模态的任务上呢？多模态训练的模型不是必须要有两种不同的输入才行，只属于一种不行吧？。。） 它们只能使用单模态数据（即文本或图像）或有限的多模态数据（即图像-文本对）。 提出了一种 UNIfied-Modal 预训练架构，即 UNIMO，它可以有效地适应单模态和多模态的理解和生成任务。 利用大规模的.
百度UNIMO模型--统一模态理解、跨模态对比学习
zephyr_wang的博客
05-25 606
我们提出了UNIMO（UNIfied-MOdal ），可以同时使用单模态数据和多模态数据，在理解和生成任务。
UNIMO：通过跨模态对比学习实现统一模态的理解和生成
weixin_51697828的博客
07-23 1194
现有的预训练方法或侧重于单模态任务，或侧重于多模态任务，不能有效地相互适应，只能利用单模态数据或有限的多模态数据。作者提出了统一模态预训练体系架构UNIMO，可以有效地适应单模态和多模态的理解生成任务。UNIMO利用大规模自由文本语料库和图像集来提高视觉文本理解能力，利用跨模态对比学习（CMCL）将文本和视觉信息整合到统一语义空间中，形成一个由图像和文本组成的“图像-文本对”语料库。UNIMO借助丰富的非配对单模态数据，通过允许文本视觉知识在统一语义空间中相互增强，从而学习到更泛化的表示。实验结果表明，UN
（2024，MLLM，扩散，中文数据集扩散预训练，多模态提示引导微调）UNIMO-G：通过多模态条件扩散进行统一图像生成
最新发布
qq_44681809的博客
01-25 449
本文介绍了 UNIMO-G，它使用两阶段训练策略：首先在大规模中文文本-图像对上进行预训练，然后使用由 MLLM生成的多模态提示进行微调，以提高图像的逼真度和忠诚度。
UNIMO-2: 端到端的统一视觉语言全面学习
qq_45331246的博客
10-04 1642
UNIMO2、VLP、统一模态
广告行业中那些趣事系列55：文本和图像领域大一统的UNIMO模型详解
abc50319的专栏
07-21 3027
导读：本文是“数据拾光者”专栏的第五十五篇文章，这个系列将介绍在广告行业中自然语言处理和推荐系统实践。本篇主要介绍了百度在多模态学习领域的成果UNIMO模型，对多模态学习感兴趣并且希望应用到项目实践的小伙伴可能有所帮助。欢迎转载，转载请注明出处以及链接，更多关于自然语言处理、推荐系统优质内容请关注如下频道。知乎专栏：数据拾光者公众号：数据拾光者摘要：本篇主要介绍了百度在多...
【多模态】UNIMO
joyce_peng的博客
06-21 599
unimo模型
怎样继承unimo的解码函数
03-23
您可以通过以下代码来继承unimo的解码函数： ```python from transformers import UnimoTokenizer, UnimoForCausalLM tokenizer = UnimoTokenizer.from_pretrained("unimo-base") model = UnimoForCausalLM.from_pretrained("unimo-base") def decode(input_ids): output = model.generate(input_ids=input_ids, max_length=50, do_sample=True) return tokenizer.decode(output[0], skip_special_tokens=True) ``` 这里我们使用了 transformers 库中的 UnimoTokenizer 和 UnimoForCausalLM 类来加载预训练模型，然后定义了一个 decode 函数，输入为 input_ids，输出为模型生成的文本。在函数中，我们调用了 model.generate 方法来生成文本，同时使用 tokenizer.decode 方法将生成的文本转换为可读的字符串。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值