RUN-GNN-transductive关键代码

已于 2024-01-25 12:16:40 修改
阅读量826 收藏 17
点赞数 26
分类专栏： GNN 文章标签： 深度学习 python 神经网络
于 2023-12-15 13:26:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44466434/article/details/135009656
版权

1. RUN_GNN.py

1.1 class RUN_GNN(torch.nn.Module):

1.1.1 def __init__(self, params, loader):

与inductive相比删掉了

# 根据参数中是否存在 uniform_parm 且其值大于0，设置是否使用均匀参数（uniform parameters）。
        if "uniform_parm" in params and params.uniform_parm > 0:
            self.uniform_parm=True
        else:
            self.uniform_parm=False
        ######

增加了

self.params = params

1.1.2 def forward(self, subs, rels, mode='train'):

cuda问题，可以忽略

加入self.params=params也是为了引入device = self.params.device

 def forward(self, subs, rels, mode='train'):
    ######RUN-GNN新加的已经标柱出来，其他的cuda问题可忽略
        n = len(subs)
        if isinstance(subs,torch.Tensor):
            q_sub = subs.to(device = self.params.device)
            q_rel = rels.to(device = self.params.device)
            h0 = torch.zeros((n, self.hidden_dim)).cuda()
            nodes = torch.cat([torch.arange(n).unsqueeze(1).cuda(), q_sub.unsqueeze(1)], 1)
            hidden = torch.zeros(n, self.hidden_dim).cuda()
        elif torch.cuda.is_available():
            q_sub = torch.LongTensor(subs).to(device = self.params.device)
            q_rel = torch.LongTensor(rels).cuda()
            h0 = torch.zeros((n, self.hidden_dim)).cuda()
            nodes = torch.cat([torch.arange(n).unsqueeze(1).cuda(), q_sub.unsqueeze(1)], 1)
            hidden = torch.zeros(n, self.hidden_dim).cuda()
        elif torch.cuda.is_available():
            q_sub = torch.LongTensor(subs).to(device = self.params.device)
            q_rel = torch.LongTensor(rels).cuda()
            h0 = torch.zeros((n, self.hidden_dim)).cuda()
            nodes = torch.cat([torch.arange(n).unsqueeze(1).cuda(), q_sub.unsqueeze(1)], 1)
            hidden = torch.zeros(n, self.hidden_dim).cuda()
        else:
            q_sub = torch.LongTensor(subs)
            q_rel = torch.LongTensor(rels)
            h0 = torch.zeros((n, self.hidden_dim))
            nodes = torch.cat([torch.arange(n).unsqueeze(1), q_sub.unsqueeze(1)], 1)
            hidden = torch.zeros(n, self.hidden_dim)

        scores_all = []
        for i in range(self.n_layer):
            nodes, edges, old_nodes_new_idx = self.loader.get_neighbors(nodes.data.cpu().numpy(), mode=mode)
            hidden, h_n_qr = self.gnn_layers[i](q_sub, q_rel, hidden, edges, nodes.size(0), old_nodes_new_idx)    ########RUN-GNN多加了h_n_qr

但是最后，inductive是这样的

           if i < (self.n_layer-1):
                # 在前 n_layer-1 层使用基本的 GNN 层进行更新
                hidden, h_n_qr = self.gnn_layers[0](q_sub, q_rel, hidden, edges, nodes.size(0), old_nodes_new_idx)
            else:
                # 在最后一层使用特殊的 GNN 层进行更新
                hidden, h_n_qr = self.gnn_layers[i](q_sub, q_rel, hidden, edges, nodes.size(0), old_nodes_new_idx)

倒数第二行，也是cuda问题

        if torch.cuda.is_available():
            scores_all = torch.zeros((n, self.loader.n_ent)).cuda()
        else:
            scores_all = torch.zeros((n, self.loader.n_ent))

1.2 class G_GAT_Layer(torch.nn.Module):

无变化

2. RUN_GNN_raw.py

都是与RUN_GNN.py相比的

2.1 class RUN_GNN_raw(torch.nn.Module):

2.1.1 def __init__(self, params, loader):

删除了

# self.params = params

2.1.2  def forward(self, subs, rels, mode='train'):

变化

    def forward(self, subs, rels, mode='train'):
        n = len(subs)
        ##########RUN-GNN和RUN-GNN_raw区别
        if torch.cuda.is_available():
            q_sub = torch.LongTensor(subs).cuda()
            q_rel = torch.LongTensor(rels).cuda()
            h0 = torch.zeros((n, self.hidden_dim)).cuda()
            nodes = torch.cat([torch.arange(n).unsqueeze(1).cuda(), q_sub.unsqueeze(1)], 1)
            hidden = torch.zeros(n, self.hidden_dim).cuda()
        else:
            q_sub = torch.LongTensor(subs)
            q_rel = torch.LongTensor(rels)
            h0 = torch.zeros((n, self.hidden_dim))
            nodes = torch.cat([torch.arange(n).unsqueeze(1), q_sub.unsqueeze(1)], 1)
            hidden = torch.zeros(n, self.hidden_dim)

2.2 class G_GAT_Layer(torch.nn.Module):

3. w_addition.py

3.1 class w_addition(torch.nn.Module):

删除了

# self.params = params

改变了

    def forward(self, subs, rels, mode='train'):
        n = len(subs)
        if torch.cuda.is_available():
            q_sub = torch.LongTensor(subs).cuda()
            q_rel = torch.LongTensor(rels).cuda()
            h0 = torch.zeros((n, self.hidden_dim)).cuda()
            nodes = torch.cat([torch.arange(n).unsqueeze(1).cuda(), q_sub.unsqueeze(1)], 1)
            hidden = torch.zeros(n, self.hidden_dim).cuda()
        else:
            q_sub = torch.LongTensor(subs)
            q_rel = torch.LongTensor(rels)
            h0 = torch.zeros((n, self.hidden_dim))
            nodes = torch.cat([torch.arange(n).unsqueeze(1), q_sub.unsqueeze(1)], 1)
            hidden = torch.zeros(n, self.hidden_dim)

3.2 class SES_v20p4(torch.nn.Module):

self.n_layer 变为self.n_layer + 1

self.gnn_layers = []
        for i in range(self.n_layer + 1):
            self.gnn_layers.append(G_GAT_Layer(self.hidden_dim, self.hidden_dim, self.attn_dim, self.n_rel, act=act))
        self.gnn_layers = nn.ModuleList(self.gnn_layers)

删除了self.n_extra_layer = params.n_extra_layer，self.n_extra_layer变self.n_layer

self.extra_gnn_layers = []
        for i in range(self.n_layer):
            self.extra_gnn_layers.append(G_GAT_Layer(self.hidden_dim, self.hidden_dim, self.attn_dim, self.n_rel, act=act))
        self.extra_gnn_layers = nn.ModuleList(self.extra_gnn_layers)

删除了

self.params = params

改变了

    def forward(self, subs, rels, mode='train'):
        n = len(subs)
        if torch.cuda.is_available():
            q_sub = torch.LongTensor(subs).cuda()
            q_rel = torch.LongTensor(rels).cuda()
            h0 = torch.zeros((n, self.hidden_dim)).cuda()
            nodes = torch.cat([torch.arange(n).unsqueeze(1).cuda(), q_sub.unsqueeze(1)], 1)
            hidden = torch.zeros(n, self.hidden_dim).cuda()
        else:
            q_sub = torch.LongTensor(subs)
            q_rel = torch.LongTensor(rels)
            h0 = torch.zeros((n, self.hidden_dim))
            nodes = torch.cat([torch.arange(n).unsqueeze(1), q_sub.unsqueeze(1)], 1)
            hidden = torch.zeros(n, self.hidden_dim)

for i in range(self.n_extra_layer):改变为

        for i in range(4):
            hidden = hidden[old_nodes_new_idx]
            hidden, h_n_qr = self.extra_gnn_layers[i](q_sub, q_rel, hidden, edges, nodes.size(0), old_nodes_new_idx)
            hidden = self.dropout(hidden)
            hidden = self.gate(hidden, h_n_qr, h0)
            h0 = hidden

3.3 class G_GAT_Layer(torch.nn.Module):

unique_relation_identity = self.gate(h_r, h_qr, h_s)变为

unique_relation_identity = h_r+h_s

4. w_sigmoid.py

4.1 class w_sigmoid(torch.nn.Module):

    def forward(self, subs, rels, mode='train'):
        n = len(subs)
        #######和RUN_GNN相比变动
        if isinstance(subs,torch.Tensor):
            q_sub = subs.to(device = self.params.device)
            q_rel = rels.to(device = self.params.device)
            h0 = torch.zeros((n, self.hidden_dim)).cuda()
            nodes = torch.cat([torch.arange(n).unsqueeze(1).cuda(), q_sub.unsqueeze(1)], 1)
            hidden = torch.zeros(n, self.hidden_dim).cuda()
        elif torch.cuda.is_available():
            q_sub = torch.LongTensor(subs).to(device = self.params.device)
            q_rel = torch.LongTensor(rels).cuda()
            h0 = torch.zeros((n, self.hidden_dim)).cuda()
            nodes = torch.cat([torch.arange(n).unsqueeze(1).cuda(), q_sub.unsqueeze(1)], 1)
            hidden = torch.zeros(n, self.hidden_dim).cuda()
        else:
            q_sub = torch.LongTensor(subs)
            q_rel = torch.LongTensor(rels)
            h0 = torch.zeros((n, self.hidden_dim))
            nodes = torch.cat([torch.arange(n).unsqueeze(1), q_sub.unsqueeze(1)], 1)
            hidden = torch.zeros(n, self.hidden_dim)

4.2 class SES_v20p4(torch.nn.Module):

self.n_layer 变为self.n_layer + 1

self.gnn_layers = []
        for i in range(self.n_layer+1):
            self.gnn_layers.append(G_GAT_Layer(self.hidden_dim, self.hidden_dim, self.attn_dim, self.n_rel, act=act))
        self.gnn_layers = nn.ModuleList(self.gnn_layers)

删除了self.n_extra_layer = params.n_extra_layer，self.n_extra_layer变self.n_layer

self.extra_gnn_layers = []
        for i in range(self.n_layer):
            self.extra_gnn_layers.append(G_GAT_Layer(self.hidden_dim, self.hidden_dim, self.attn_dim, self.n_rel, act=act))
        self.extra_gnn_layers = nn.ModuleList(self.extra_gnn_layers)

删除了

self.params = params

改变了

    def forward(self, subs, rels, mode='train'):
        n = len(subs)
        if torch.cuda.is_available():
            q_sub = torch.LongTensor(subs).cuda()
            q_rel = torch.LongTensor(rels).cuda()
            h0 = torch.zeros((n, self.hidden_dim)).cuda()
            nodes = torch.cat([torch.arange(n).unsqueeze(1).cuda(), q_sub.unsqueeze(1)], 1)
            hidden = torch.zeros(n, self.hidden_dim).cuda()
        else:
            q_sub = torch.LongTensor(subs)
            q_rel = torch.LongTensor(rels)
            h0 = torch.zeros((n, self.hidden_dim))
            nodes = torch.cat([torch.arange(n).unsqueeze(1), q_sub.unsqueeze(1)], 1)
            hidden = torch.zeros(n, self.hidden_dim)

 for i in range(self.n_extra_layer):改变为

        for i in range(4):
            hidden = hidden[old_nodes_new_idx]
            hidden, h_n_qr = self.extra_gnn_layers[i](q_sub, q_rel, hidden, edges, nodes.size(0), old_nodes_new_idx)
            hidden = self.dropout(hidden)
            hidden = self.gate(hidden, h_n_qr, h0)
            h0 = hidden

 4.3 class G_GAT_Layer(torch.nn.Module):

unique_relation_identity = self.gate(h_r, h_qr, h_s)

        unique_message = unique_relation_identity
        unique_attend_weight = self.w_alpha(self.relu(self.Ws_attn(unique_message) + self.Wqr_attn(h_qr)))

        unique_exp_attend = torch.exp(unique_attend_weight)
        exp_attend = unique_exp_attend[inverse_indices]
        unique_message = unique_exp_attend * unique_message

        message = unique_message[inverse_indices]
        sum_exp_attend = scatter(exp_attend, dim=0, index=obj, dim_size=n_node, reduce="sum")
        no_attend_message_agg = scatter(message, index=obj, dim=0, dim_size=n_node, reduce='sum')
        message_agg = no_attend_message_agg / sum_exp_attend

变为：

unique_message = self.gate(h_r, h_qr, h_s)
        unique_attend_weight = self.w_alpha(self.relu(self.Ws_attn(unique_message) + self.Wqr_attn(h_qr)))

        ########变动
        unique_sig_attend = torch.sigmoid(unique_attend_weight)
        unique_message = unique_sig_attend * unique_message

        message = unique_message[inverse_indices]
        message_agg = scatter(message, index=obj, dim=0, dim_size=n_node, reduce='sum')

5. w_times.py

5.1 class w_times(torch.nn.Module):

删除了

self.params = params

改变了

    def forward(self, subs, rels, mode='train'):
        n = len(subs)
        if torch.cuda.is_available():
            q_sub = torch.LongTensor(subs).cuda()
            q_rel = torch.LongTensor(rels).cuda()
            h0 = torch.zeros((n, self.hidden_dim)).cuda()
            nodes = torch.cat([torch.arange(n).unsqueeze(1).cuda(), q_sub.unsqueeze(1)], 1)
            hidden = torch.zeros(n, self.hidden_dim).cuda()
        else:
            q_sub = torch.LongTensor(subs)
            q_rel = torch.LongTensor(rels)
            h0 = torch.zeros((n, self.hidden_dim))
            nodes = torch.cat([torch.arange(n).unsqueeze(1), q_sub.unsqueeze(1)], 1)
            hidden = torch.zeros(n, self.hidden_dim)

5.2 class G_GAT_Layer(torch.nn.Module):

unique_relation_identity = self.gate(h_r, h_qr, h_s)改为

unique_relation_identity = h_r * h_s

6. wo_buffer.py

6.1 class wo_buffer(torch.nn.Module):

没加

# self.n_extra_layer = params.n_extra_layer
        # self.extra_gnn_layers = []
        # for i in range(self.n_extra_layer):
        #     self.extra_gnn_layers.append(
        #         G_GAT_Layer(self.hidden_dim, self.hidden_dim, self.attn_dim, self.n_rel, act=act))
        # self.extra_gnn_layers = nn.ModuleList(self.extra_gnn_layers)

改变了

    def forward(self, subs, rels, mode='train'):
        n = len(subs)
        if isinstance(subs,torch.Tensor):
            q_sub = subs.to(device = self.params.device)
            q_rel = rels.to(device = self.params.device)
            h0 = torch.zeros((n, self.hidden_dim)).cuda()
            nodes = torch.cat([torch.arange(n).unsqueeze(1).cuda(), q_sub.unsqueeze(1)], 1)
            hidden = torch.zeros(n, self.hidden_dim).cuda()
        elif torch.cuda.is_available():
            q_sub = torch.LongTensor(subs).to(device = self.params.device)
            q_rel = torch.LongTensor(rels).to(device = self.params.device)
            h0 = torch.zeros((n, self.hidden_dim)).cuda()
            nodes = torch.cat([torch.arange(n).unsqueeze(1).cuda(), q_sub.unsqueeze(1)], 1)
            hidden = torch.zeros(n, self.hidden_dim).cuda()
        else:
            q_sub = torch.LongTensor(subs)
            q_rel = torch.LongTensor(rels)
            h0 = torch.zeros((n, self.hidden_dim))
            nodes = torch.cat([torch.arange(n).unsqueeze(1), q_sub.unsqueeze(1)], 1)
            hidden = torch.zeros(n, self.hidden_dim)

没加

# for i in range(self.n_extra_layer):
        #     hidden = hidden[old_nodes_new_idx]
        #     hidden, h_n_qr = self.extra_gnn_layers[i](q_sub, q_rel, hidden, edges, nodes.size(0), old_nodes_new_idx)
        #     hidden = self.dropout(hidden)
        #     hidden = self.gate(hidden, h_n_qr, h0)
        #     h0 = hidden

6.2 class G_GAT_Layer(torch.nn.Module):

不变

 

小蜗子
关注
专栏目录
BertGCN的fastNLP实现
WetHong的博客
02-25 1865
目的 本文主要介绍如何实现fastNLP 来复现今年发表在顶会的一篇论文BertGCN: Transductive Text Classification by Combining GCN and BERT。 FastNLP配置 本文采用的fastNLP版本号为0.6.0，可采用一下命令来安装 pip install -b dev https://github.com/fastnlp/fastNLP.git python setup.py build python setup.py install 数据预
PM2.5-GNN:PM2.5-GNN
05-09
下载从数据集KnowAir或与代码ni44 。 要求 Python 3.7.3 PyTorch 1.7.0 PyG: https://github.com/rusty1s/pytorch_geometric#pytorch-170 pip install -r requirements.txt 实验设置 打开config.yaml ，执行以下设置...
Towards Enhancing Relational Rules for Knowledge Graph Link Prediction
weixin_44466434的博客
11-14 158
1
RUN-GNN-inductive关键代码
weixin_44466434的博客
12-11 161
1
【GNN】task2-消息传递图神经网络
发现问题，并解决问题，批判性思维
06-20 1288
文章目录消息传递图神经网络一、引言二、 消息传递范式介绍三、Pytorch Geometric中的`MessagePassing`基类1.总MessagePassing()2.MessagePassing.propagate()3.MessagePassing.message(...)4.MessagePassing.message_and_aggregate(...)5. MessagePassing.update(aggr_out, ...)四、继承`MessagePassing`类的`GCNConv`
图神经网络（一）—GraphSAGE-pytorch版本代码详解
热门推荐
weixin_44027006的博客
05-16 1万+
GraphSAGE代码详解-pytorch版本1. GraphSAGE导入2. 代码解析2.1 加载数据2.2 Unsupervised Loss2.3 Models2.4 评估与模型使用2.5 Main参考资料 1. GraphSAGE导入 论文标题：Inductive Representation Learning on Large Graphs 作者：William L. Hamilton, Rex Ying and Jure Leskovec 在GraphSAGE之前提出的图神经网络方法，如
深度之眼Paper带读笔记GNN.06.GAT
老毛的博客
11-28 1375
文章目录前言导读论文结构学习目标研究背景图卷积Notation归纳式学习空域与时域卷积GAT模型多头注意力机制研究成果数据集实验：节点分类任务结果可视化意义泛读摘要论文结构精读算法模型总览GNN的layer 前言 本课程来自深度之眼，部分截图来自课程视频。 文章标题：Graph Attention Networks 图注意力网络（GAT） 作者：Petar Veličković, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Liò,
Re6：读论文 LeSICiN: A Heterogeneous Graph-based Approach for Automatic Legal Statute Identification fro
诸神缄默不语的博客
07-22 788
论文阅读笔记：LeSICiN: A Heterogeneous Graph-based Approach for Automatic Legal Statute Identification from Indian Legal Documents 1. Background与Motivation（模型构造思路） 2. 问题定义与模型介绍 2.1 异质图构建与归纳式链路预测范式 2.2 LeSICiN 3. 模型原理：引用网络有效性 4. 实验 5. 模型复现..................
GraphSAGE学习笔记
myblog
12-13 2096
简介 GraphSAGE作为GCN的一个变种，其核心思想是，从邻居节点聚合（平均，池化，拼接)信息，然后更新自身节点的信息； 核心步骤： init h0 ∈ V #初始化节点特征 for i in K: #K为聚合邻居节点的跳数   for v in V: #对于每个节点     hk,v = Aggregate(hk-1,u, u∈N(v)) #聚合所有邻居节点u的信息     hk,v = σ(W
L2P-GNN:AAAI-2021论文“学习预训练图神经网络”的代码和数据集
05-08
学习预训练图神经网络 该存储库是AAAI-2021论文《的正式实施 要求 要安装要求： pip install -r requirements.txt ...要在带有GIN模型的生物学数据集上对L2P-GNN进行预训练，请运行以下命令： python
Fi_GNN:[CIKM 2019]“ Fi-GNN的代码和数据集
05-04
CIKM2019中我们论文的代码和数据：Fi-GNN：通过图形神经网络为CTR预测建模特征交互， 。 首先将输入的稀疏多场特征向量映射到稀疏的一热嵌入向量，然后通过嵌入层和多头自注意层将其嵌入到密集场嵌入向量中。 然后...
GPT-GNN:KDD'20“图形神经网络的生成式预训练”的代码
04-01
关键包是GPT_GNN，其中包含高级GPT-GNN预训练框架，基本GNN模型以及基本图结构和数据加载器。 为了说明如何将GPT_GNN框架应用于任意图，我们提供了在异构图（OAG）和齐次图（reddit）上进行预训练的示例。 他们两个...
DeepSS2GO——基于 CNN 的模型可以根据化学键预测蛋白质的功能
知来者逆的博客
09-24 629
研究发现，DeepSS2GO通过减少主序列中的冗余信息并引入一个整合二级结构特征的学习模块，提高了预测蛋白质功能的性能。作者引入了经典的卷积神经网络来提高该模型二次结构的有效性，但认为可以利用GNN 和****自监督学习来进一步提高功能预测模型的性能。此外，用于预测一级结构和二级结构的算法认为，氨基酸长度超过 1024 个的大型蛋白质不在预测范围之内。今后，必须引入对更长序列进行二级结构预测的方法。此外，该模型还可用于预测多肽的功能，从而更广泛地阐明疾病和发现药物靶点。
对比学习训练是如何进行的
qq_45809323的博客
09-25 485
对比学习（Contrastive Learning）是一种自监督学习的方法，旨在通过拉近相似样本的表示、拉远不相似样本的表示来学习特征表示。在训练过程中，模型并不依赖标签，而是通过样本之间的相似性进行学习。
【深度学习】03-神经网络2-1损失函数
weixin_41645791的博客
09-23 860
L2 的特点是，当初始值的给的不好，导致预测值和目标值差异大的时候，会产生梯度爆炸，所以我们也不用这个损失函数，而是做正则化来缓解过拟合。热编码是，默认会找你的最大值去，确定有多少个0，因为0也算一个位置，所以如果最大值为5，那么就一共有6位（0，1，2，3，4，5。L1 这个损失函数最大的特点是： 零点不平滑，导致不可导，跳过极小值，所以不会用来做损失函数，而是做正则化用来缓解过拟合。这里的是API 的注意⚠️，但是在真实的公式中，目标值一定是热编码之后的，但是在API中可以是热编码之前的。
24.9.24学习笔记
m0_64006292的博客
09-24 817
编码器（Encoder）：将输入序列编码成一个固定长度的上下文向量（也称为隐状态或编码器的最终状态）。解码器（Decoder）：根据编码器生成的上下文向量，逐步生成目标序列。
基于深度学习的缺失数据的图像修复
最新发布
weixin_42605076的博客
09-26 753
图像修复的基本目标是根据图像的上下文信息恢复缺失的部分。卷积神经网络（CNN）：CNN通过学习图像的局部特征，能够有效捕捉到图像的空间信息。模型通常在含有缺失区域的图像和相应的完整图像之间进行训练，以学习如何填补这些缺失区域。生成对抗网络（GANs）：GANs通过对抗训练的方式提高生成图像的质量。修复网络和判别网络相互竞争，修复网络努力生成真实的缺失部分，而判别网络则尝试区分修复后的图像和真实图像。这样可以生成更加自然和真实的修复结果。自编码器。
深入探索卷积神经网络（CNN）
码途探索
09-24 915
在当今这个数据驱动的时代，图像识别、分析和理解已成为人工智能领域中最为活跃的研究方向之一。从自动驾驶汽车到智能手机的人脸识别功能，再到医学影像分析，图像处理技术的应用无处不在，且其重要性日益凸显。卷积神经网络（CNN），作为深度学习领域的一项突破性技术，已经成为图像识别和分类任务中的首选工具。CNN之所以强大，是因为它能够自动、高效地从大量图像数据中学习到有用的特征，而无需人工干预。这种能力使得CNN在图像和视频分析、自然语言处理甚至游戏等领域都取得了令人瞩目的成就。
tensorflow-gnn代码
07-27
Tensorflow-GNN是一个基于Tensorflow的图神经网络库。图神经网络主要用于处理图数据，它能够从图中学习节点和边的表示，从而应用于节点分类、图分类、链接预测等任务。 Tensorflow-GNN提供了一系列的图神经网络模型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小蜗子

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

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

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

打赏作者

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

抵扣说明：

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

余额充值