DGL节点分类【官网的例子】

已于 2024-03-03 12:00:35 修改
阅读量831 收藏 20
点赞数 24
分类专栏： pytorch项目实战 文章标签： 分类 数据挖掘 人工智能
于 2024-03-03 08:53:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bettle_king/article/details/136424337
版权

官网: https://docs.dgl.ai/tutorials/blitz/1_introduction.html#sphx-glr-tutorials-blitz-1-introduction-py
论文地址
点击跳转
参考文章:https://aistudio.baidu.com/projectdetail/2246479?shared=1

目录

Cora 数据集介绍

Cora数据集包含2708篇科学出版物， 5429条边，总共7种类别。数据集中的每个出版物都由一个 0/1 值的词向量描述，表示字典中相应词的缺失/存在。 该词典由 1433 个独特的词组成。意思就是说每一个出版物都由1433个特征构成，每个特征仅由0/1表示。

  • NumNodes: 2708。表示图中有2708个节点
  • NumEdges: 10556。图中有10556条边。看其他说有5429条边但是dgl官网这个例子上显示10556。
  • NumFeats: 1433。每个节点具有1433个特征。
  • NumClasses: 7。数据集中的目标分类数为7。
  • NumTrainingSamples: 140。训练样本数量为140。
  • NumValidationSamples: 500。验证样本数量为500。
  • NumTestSamples: 1000。测试样本数量为1000。

在这里插入图片描述

  • ind.cora.x : 训练集节点特征向量，保存对象为：scipy.sparse.csr.csr_matrix，实际展开后大小为： (140, 1433)
  • ind.cora.tx : 测试集节点特征向量，保存对象为：scipy.sparse.csr.csr_matrix，实际展开后大小为： (1000, 1433)
  • ind.cora.allx : 包含有标签和无标签的训练节点特征向量，保存对象为：scipy.sparse.csr.csr_matrix，实际展开后大小为：(1708, 1433)，可以理解为除测试集以外的其他节点特征集合，训练集是它的子集
  • ind.cora.y : one-hot表示的训练节点的标签，保存对象为：numpy.ndarray
  • ind.cora.ty : one-hot表示的测试节点的标签，保存对象为：numpy.ndarray
  • ind.cora.ally : one-hot表示的ind.cora.allx对应的标签，保存对象为：numpy.ndarray
  • ind.cora.graph : 保存节点之间边的信息，保存格式为：{ index : [ index_of_neighbor_nodes ] }
  • ind.cora.test.index : 保存测试集节点的索引，保存对象为：List，用于后面的归纳学习设置。

一些细节解释

import os
os.environ["DGLBACKEND"] = "pytorch"#设置环境变量以选择后端框架为PyTorch的方式
import dgl
import dgl.data
import torch
import torch.nn as nn
import torch.nn.functional as F

dataset = dgl.data.CoraGraphDataset()
#用于加载Cora数据集。CoraGraphDataset函数会自动下载并处理Cora数据集，使其转换成适合图神经网络处理的格式。
#这个还会自动的输出关于该数据库的描述例如：点的数量，边的数量等等
print(f"Number of categories: {dataset.num_classes}")#输出Cora数据集中类别的总数。
g = dataset[0]
#一个DGL数据集对象可能包含一个或多个图表。本教程中使用的Cora数据集仅包含一个图表。
print("Node features")
print(g.ndata)
print(len(g.ndata))
for i in g.ndata.keys():
    print(i)
for i in g.ndata.values():
    print(i,len(i))

输出结果：

  NumNodes: 2708
  NumEdges: 10556
  NumFeats: 1433
  NumClasses: 7
  NumTrainingSamples: 140
  NumValidationSamples: 500
  NumTestSamples: 1000
Done loading data from cached files.
Number of categories: 7
Node features
{'train_mask': tensor([ True,  True,  True,  ..., False, False, False]), 'label': tensor([3, 4, 4,  ..., 3, 3, 3]), 'val_mask': tensor([False, False, False,  ..., False, False, False]), 'test_mask': tensor([False, False, False,  ...,  True,  True,  True]), 'feat': tensor([[0., 0., 0.,  ..., 0., 0., 0.],
        [0., 0., 0.,  ..., 0., 0., 0.],
        [0., 0., 0.,  ..., 0., 0., 0.],
        ...,
        [0., 0., 0.,  ..., 0., 0., 0.],
        [0., 0., 0.,  ..., 0., 0., 0.],
        [0., 0., 0.,  ..., 0., 0., 0.]])}
5
train_mask
label
val_mask
test_mask
feat
tensor([ True,  True,  True,  ..., False, False, False]) 2708
tensor([3, 4, 4,  ..., 3, 3, 3]) 2708
tensor([False, False, False,  ..., False, False, False]) 2708
tensor([False, False, False,  ...,  True,  True,  True]) 2708
tensor([[0., 0., 0.,  ..., 0., 0., 0.],
        [0., 0., 0.,  ..., 0., 0., 0.],
        [0., 0., 0.,  ..., 0., 0., 0.],
        ...,
        [0., 0., 0.,  ..., 0., 0., 0.],
        [0., 0., 0.,  ..., 0., 0., 0.],
        [0., 0., 0.,  ..., 0., 0., 0.]]) 2708

进程已结束，退出代码为 0

从上面可以看到该数据集的点的特征名称有5个。
需要注意的是，当运行数据集加载代码的时候会自动生成两个文件。
在这里插入图片描述
当您运行上述代码，加载Cora数据集时，DGL会自动下载原始数据文件，并在本地处理这些数据以构建图结构。处理完成后，为了提高未来加载数据的效率，DGL会将处理后的图数据保存到本地文件系统中。这就是cora_v2_dgl_graph.bin和cora_v2_dgl_graph.pkl文件的作用。

  • cora_v2_dgl_graph.bin: 这个文件包含了处理后的Cora图数据的二进制表示。具体来说，它保存了图的结构（节点和边的信息）以及节点和边的特征数据。使用二进制格式可以有效地压缩数据大小，并加快数据的加载速度。
  • cora_v2_dgl_graph.pkl: 这个文件是一个Pickle格式的文件，通常用于保存Python对象。在这个上下文中，它可能被用来存储与图相关的额外信息，例如数据集的元数据（如类别标签的映射）。然而，具体存储哪些信息可能取决于DGL的版本和数据集的实现细节。

这两个文件使得在您下次需要加载Cora数据集时，DGL可以直接从这些本地文件中读取处理好的图数据，而无需重新执行下载和处理的步骤。这大大减少了数据准备的时间，特别是在进行多次实验或模型训练时。

import os
os.environ["DGLBACKEND"] = "pytorch"#设置环境变量以选择后端框架为PyTorch的方式
import dgl
import dgl.data
import torch
import torch.nn as nn
import torch.nn.functional as F

dataset = dgl.data.CoraGraphDataset()
#用于加载Cora数据集。CoraGraphDataset函数会自动下载并处理Cora数据集，使其转换成适合图神经网络处理的格式。
#这个还会自动的输出关于该数据库的描述例如：点的数量，边的数量等等
print(f"Number of categories: {dataset.num_classes}")#输出Cora数据集中类别的总数。
g = dataset[0]
#一个DGL数据集对象可能包含一个或多个图表。本教程中使用的Cora数据集仅包含一个图表。
print("Edge features")
print(g.edata)

在这里插入图片描述
上图说明了边没有特征。
在这里插入图片描述
可以看到一共2708个点每一个点的特征维度是1433。

总代码

import os
os.environ["DGLBACKEND"] = "pytorch"#设置环境变量以选择后端框架为PyTorch的方式
import dgl
import dgl.data
import torch
import torch.nn as nn
import torch.nn.functional as F

dataset = dgl.data.CoraGraphDataset()
#用于加载Cora数据集。CoraGraphDataset函数会自动下载并处理Cora数据集，使其转换成适合图神经网络处理的格式。
#这个还会自动的输出关于该数据库的描述例如：点的数量，边的数量等等
print(f"Number of categories: {dataset.num_classes}")#输出Cora数据集中类别的总数。
g = dataset[0]
#一个DGL数据集对象可能包含一个或多个图表。本教程中使用的Cora数据集仅包含一个图表。
print("Node features")
print(g.ndata)
print("Edge features")
print(g.edata)


from dgl.nn import GraphConv


class GCN(nn.Module):
    def __init__(self, in_feats, h_feats, num_classes):
        super(GCN, self).__init__()
        self.conv1 = GraphConv(in_feats, h_feats)
        self.conv2 = GraphConv(h_feats, num_classes)

    def forward(self, g, in_feat):#刚开始的in_feat是(2708,1433)
        h = self.conv1(g, in_feat)#(2708,16)
        h = F.relu(h)
        h = self.conv2(g, h)#(2708,7)
        return h

model = GCN(g.ndata["feat"].shape[1], 16, dataset.num_classes)#1433,16,7

def train(g, model):
    optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
    best_val_acc = 0
    best_test_acc = 0

    features = g.ndata["feat"]#(2708,1433)
    labels = g.ndata["label"]#(2708),其中labels的每一个值在[0-6]之间代表其所属的类
    train_mask = g.ndata["train_mask"]#(2708)
    val_mask = g.ndata["val_mask"]#(2708)
    test_mask = g.ndata["test_mask"]#(2708)
    for e in range(100):
        # Forward
        logits = model(g, features)#logits的维度(2708,7)
        # Compute prediction
        pred = logits.argmax(1)#每一行找到最大值的索引.(2708)
        # Compute loss
        # Note that you should only compute the losses of the nodes in the training set.
        loss = F.cross_entropy(logits[train_mask], labels[train_mask])
        #根据train_mask和train_mask取出训练好的预测标签和其真正对应的标签计算交叉熵损失
        # Compute accuracy on training/validation/test
        train_acc = (pred[train_mask] == labels[train_mask]).float().mean()
        #将预测标签和真的标签对比一样就是True,否则就是False,将其转换成浮点数，计算均值其实就是其准确率
        #需要注意的是这里训练是所有的点都进入网络，但是只有训练集才更新其参数
        val_acc = (pred[val_mask] == labels[val_mask]).float().mean()
        test_acc = (pred[test_mask] == labels[test_mask]).float().mean()

        # Save the best validation accuracy and the corresponding test accuracy.
        if best_val_acc < val_acc:
            best_val_acc = val_acc
            best_test_acc = test_acc

        # Backward
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if e % 5 == 0:
            print(
                f"In epoch {e}, loss: {loss:.3f}, val acc: {val_acc:.3f} (best {best_val_acc:.3f}), test acc: {test_acc:.3f} (best {best_test_acc:.3f})"
            )


model = GCN(g.ndata["feat"].shape[1], 16, dataset.num_classes)
train(g, model)

print(dgl.backend.backend_name)  # 应该输出 'pytorch'
######################################################################
# Training on GPU
# ---------------
#
# Training on GPU requires to put both the model and the graph onto GPU
# with the ``to`` method, similar to what you will do in PyTorch.
#
# .. code:: python
#
#    g = g.to('cuda')
#    model = GCN(g.ndata['feat'].shape[1], 16, dataset.num_classes).to('cuda')
#    train(g, model)
#

需要注意的一个点：
在图神经网络（GNN）中，确保只有训练集参与反向传播的关键在于损失函数的计算。具体来说，虽然整个图的所有节点都参与前向传播过程，以便节点可以接收来自其邻居的信息，但在计算损失和进行反向传播时，只考虑训练集中的节点。这是通过使用所谓的“掩码”（mask）操作来实现的。

 loss = F.cross_entropy(logits[train_mask], labels[train_mask])
 这里只是用训练集来计算损失，计算得到的损失仅基于训练集，反向传播过程（loss.backward()）也因此只会更新这部分数据对应的模型参数梯度。

可以打印参数看一下
在这里插入图片描述

幽殇默
关注
  • 24
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
DGL简单示例，GCN，GAT
03-08
学习DGL用到的资料，包括DGL中文文档，空手道俱乐部进行节点分类的简单示例，以及用DGL实现的GCN和GAT
GraphSaint:GraphSaint的dgl实现
04-01
GraphSaint GraphSaint的dgl实现 比较 F1-微型 方法 生产者价格指数 Flickr的 Reddit 节点（纸） 0.960±0.001 0.507±0.001 0.962±0.001 边缘（纸） 0.981±0.007 0.510±0.002 0.966±0.001 RW（纸） 0.981±0.004 0.511±0.001 0.966±0.001 节点（运行） 0.9628 0.5077 0.9622 边缘（运行） 0.9810 0.5066 0.9656 RW（运行） 0.9812 0.5104 0.9648 节点（dgl） 0.5462 0.4981 0.9373 边缘（dgl） 0.6065 0.5067 0.9137 RW（dgl） 0.4116 nan nan 采样时间 方法 生
简明DGL中文文档1
08-08
DGL中文手册目录 begin 安装 4 使用conda安装 4 使用pip安装 4 使用源安装 4 设置默认的Backend 4 1. 图 4 1.1 关
社区发现常见数据集..
01-18
包含football，空手道俱乐部karate，海豚Dolphin，facebook4000节点的稍大网络的txt，和gml文件，txt文件有两种格式
DGL-waic-2019-master.zip
02-14
DGL-waic-2019-master.zip
GCN节点分类Cora数据集
03-22
GCN节点分类Cora数据集
图神经网络：(节点分类)Cora数据集实现图神经网络
zhishichengjin的博客
05-02 2798
图神经网路：在Cora上动手实现图神经网络
基于GCN和DGL实现的图上 node 分类, 值得一看!!!
qq_25459495的博客
01-24 646
这里我们采用 dgl 官方实现的 graphConv 算子进行邻居节点信息的聚合，不进行邻居节点的采样。@ 欢迎关注微信公众号：算法全栈之路if i!= 0:return h我们可以看到：这里的网络结构选择的是gcn。在上面的网络结构中，nn.ModuleList中放有2层的GraphConv卷积层，并在其中加入了dropout层。图卷基层之间也是可以加入dropout层的，和传统的深度学习DNN无任何区别。为了加深理解，我们可以重点关注下gcn模型的初始化参数以及输入输出参数。
GCN、GAT实现Cora数据集节点分类（pytorch-geometric框架）
qq_20805805的博客
06-09 9296
Cora数据集 介绍 下载地址：https://linqs-data.soe.ucsc.edu/public/lbc/cora.tgz Cora数据集由深度学习论文组成，论文表示为节点，论文之间的引用关系表示为节点之间的边，每篇论文引用或被至少一篇其他论文引用，不存在孤立节点。 论文被分为以下七类之一: Case_Based Genetic_Algorithms Neural_Networks Probabilistic_Methods Reinforcement_Learning Rule_Learni
（节点分类）四大图数据集AIFB,MUTAG,BGS,AM数据集获取
qq_43391414的博客
12-13 5129
网址：http://data.dws.informatik.uni-mannheim.de/rmlod/LOD_ML_Datasets/data/datasets/RDF_Datasets/ 数据集概览： 前三个数据集介绍，后一个没有找到。 不管怎么说，一个特点就是：上面的4个图全都是异构图。
DGL库CPU版本和CUDA版本
最新发布
02-27
DGL库CPU版本和CUDA版本 dgl-0.9.1-cp37-cp37m-win_amd64.whl win-64-dgl-cuda11.1-0.9.1-py37-0.tar.bz DGL库CPU版本和CUDA版本 dgl-0.9.1-cp37-cp37m-win_amd64.whl win-64-dgl-cuda11.1-0.9.1-py37-0.tar.bz DGL库CPU版本和CUDA版本 dgl-0.9.1-cp37-cp37m-win_amd64.whl win-64-dgl-cuda11.1-0.9.1-py37-0.tar.bz DGL库CPU版本和CUDA版本 dgl-0.9.1-cp37-cp37m-win_amd64.whl win-64-dgl-cuda11.1-0.9.1-py37-0.tar.bz DGL库CPU版本和CUDA版本 dgl-0.9.1-cp37-cp37m-win_amd64.whl win-64-dgl-cuda11.1-0.9.1-py37-0.tar.bz DGL库CPU版本和CUDA版本 dgl-0.9.1-cp37-cp37m-wi
图神经网络实践之图节点分类（一）
sjx674749057的博客
03-17 3662
本文主要以Deep Graph Library（DGL）为基础，利用图神经网络来进行图节点分类任务。本篇针对的图为同构图。 1. DGL 介绍 DGL是一个python包，用以在现有的深度学习框架上（包括Pytorch、MXNet和TensorFlow）来实现图神经网络系列模型。它提供了对消息传递的通用控制，通过自动批处理和高度调整的稀疏矩阵内核进行速度优化，以及多 GPU/CPU 训练以扩展到数亿个节点和边缘的图形。DGL拥有丰富的文档及相关接口，而且文档有中文版本，十分容易学习和上手。DGL的gith
GNN之节点分类任务—Cora数据集分类（半监督）
☆下山☆的博客
02-17 3025
GNN之节点分类任务—Cora数据集分类（半监督）
【DGL】节点分类（GCN、SAGE、自定义）
悲伤无声地涌出来
02-07 1857
dgl入门——节点分类
使用DGL完成节点分类任务
test
05-05 2810
节点分类任务概述 节点分类(node classification)任务是在图数据处理中最流行任务之一，一个模型需要预测每个节点属于哪个类别。 在图神经网络出现之前，用于结点分类任务的方法可归为两大类： 仅使用连通性（如DeepWalk或node2vec） 简单地结合连通性和节点自身的特征 相比之下，GNNs是一个通过结合局部邻域（广义上的邻居，包含结点自身）的连通性及其特征来获得节点表征的方法。 Kipf等人将节点分类问题描述为一个半监督的节点分类任务。图神经网络只需要一小部分已标记的节点，即可准确地
图数据集的构建以及基于图的节点分类和边预测
weixu22的博客
07-03 5251
程序 = 数据结构 + 算法。若想使用 PyTorch geometric 中各种有用的模型和函数，数据集的结构必须符合 PyG 的既定标准，例如 PyG 自带的 Planetoid 等数据集类。为了处理自己独有的数据集，我们必须掌握如何将原始数据转化为对应的数据集类。 PyG 构建数据集分两种， 一种继承 torch_geometric.data.InMemoryDataset，一次性加载所有数据到内存；另一种继承torch_geometric.data.Dataset, 分次加载到内存。对于占用内存有
图神经网络：(节点分类)KarateClub数据集上实现图神经网络
zhishichengjin的博客
05-01 1991
文献”SEMI-SUPERVISED CLASSIFICATION WITH GRAPH CONVOLUTIONAL NETWORKS“解读。使用GCN解决KarateClub社交网络问题。
通过GCN来实现对Cora数据集节点的分类
keepgoinggetstro的博客
01-16 415
网络中节点的一个案例的代码，每一段或者每一行的作用进行详细的解释，解释文字为#后内容。下载、解压，放在哪都可以，但是在运行前，要改为自己电脑上的绝对路径。本文代码、数据集来自。
写一段图神经网络节点分类代码
09-22
### 回答1： 以下是一个简单的图神经网络节点分类的代码示例： ```python import torch import torch.nn.functional as F from torch_geometric.nn import GCNConv class GCN(torch.nn.Module): def __init__(self, num_features, num_classes): super(GCN, self).__init__() self.conv1 = GCNConv(num_features, 16) self.conv2 = GCNConv(16, num_classes) def forward(self, x, edge_index): x = F.relu(self.conv1(x, edge_index)) x = F.dropout(x, training=self.training) x = self.conv2(x, edge_index) return F.log_softmax(x, dim=1) ``` 这个模型使用了 PyTorch Geometric 库中的 GCNConv 层来进行图卷积操作。输入的节点特征 x 和边索引 edge_index 会被传入两个 GCNConv 层中，最后输出一个经过 softmax 处理的概率分布，表示每个节点属于不同类别的概率。 ### 回答2： 图神经网络（Graph Neural Network，GNN）是一种用于处理图结构数据的深度学习模型。节点分类是GNN的一种常见任务，通过将节点分为不同的类别来预测节点的标签。 下面是一个简单的图神经网络节点分类的代码示例： 1. 首先导入所需的库，包括PyTorch和DGL（Deep Graph Library）： ```python import torch import torch.nn as nn import dgl import dgl.function as fn from dgl.nn.pytorch import GraphConv ``` 2. 定义图神经网络模型，这里使用了两层Graph Convolutional Network（GCN）： ```python class GCN(nn.Module): def __init__(self, in_feats, hid_feats, out_feats): super(GCN, self).__init__() self.conv1 = GraphConv(in_feats, hid_feats) self.conv2 = GraphConv(hid_feats, out_feats) def forward(self, g, features): x = torch.relu(self.conv1(g, features)) x = self.conv2(g, x) return x ``` 3. 创建图和特征，并初始化模型： ```python # 创建图 g = dgl.graph(([0, 1, 2, 3], [1, 2, 3, 0])) # 创建节点特征 features = torch.tensor([[0.0], [1.0], [2.0], [3.0]]) # 创建标签（用于训练） labels = torch.tensor([0, 1, 0, 1]) # 初始化模型 in_feats = features.shape[1] hid_feats = 2 out_feats = 2 model = GCN(in_feats, hid_feats, out_feats) ``` 4. 定义损失函数和优化器： ```python criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=0.01) ``` 5. 进行模型训练： ```python def train(epoch): model.train() optimizer.zero_grad() logits = model(g, features) loss = criterion(logits, labels) loss.backward() optimizer.step() print('Epoch {}, Loss: {:.4f}'.format(epoch, loss.item())) for epoch in range(100): train(epoch) ``` 以上代码中，首先定义了一个两层的GCN模型，然后创建了一个包含4个节点的图和对应的节点特征和标签。接着定义了损失函数和优化器，并进行了模型的训练。每个epoch，模型会前向传播计算输出，然后计算损失并进行反向传播更新模型参数。 这只是一个简单的示例，实际应用中可能还需要进行更复杂的模型设计和调参。此外，为了更好地处理大规模图数据，还可以使用更高级的图神经网络模型和优化算法。 ### 回答3： 图神经网络（Graph Neural Network，简称GNN）是一种能够处理图数据的神经网络模型。节点分类是GNN的一种常见任务，即给定一个图，预测出每个节点的类别。下面是一个简单的例子，演示了如何使用DGL库构建一个GNN模型来进行节点分类的代码。 首先，需要导入必要的库，包括DGL库和其他相关的深度学习库： ```python import dgl import torch import torch.nn as nn import torch.nn.functional as F from dgl.nn import GraphConv ``` 接下来，定义一个GNN模型类，继承自`nn.Module`： ```python class GNN(nn.Module): def __init__(self, in_dim, hidden_dim, num_classes): super(GNN, self).__init__() self.graph_conv1 = GraphConv(in_dim, hidden_dim) self.graph_conv2 = GraphConv(hidden_dim, hidden_dim) self.graph_conv3 = GraphConv(hidden_dim, num_classes) def forward(self, g, features): h = self.graph_conv1(g, features) h = F.relu(h) h = self.graph_conv2(g, h) h = F.relu(h) h = self.graph_conv3(g, h) return h ``` 在`__init__`函数中，定义了三个GraphConv层，每个层的输入维度、隐藏层维度和输出类别数目分别为`in_dim`、`hidden_dim`和`num_classes`。在`forward`函数中，通过多次使用GraphConv层和ReLU激活函数进行特征的传播和变换。 最后，训练和评估模型的代码如下所示： ```python # 构建图数据 g = dgl.graph(([0, 1, 2, 3, 4], [1, 2, 3, 4, 0])) features = torch.randn(5, in_dim) labels = torch.tensor([0, 1, 0, 1, 0]) # 初始化模型和优化器 model = GNN(in_dim, hidden_dim, num_classes) optimizer = torch.optim.Adam(model.parameters(), lr=0.01) # 训练模型 for epoch in range(num_epochs): logits = model(g, features) loss = F.cross_entropy(logits, labels) optimizer.zero_grad() loss.backward() optimizer.step() print('Epoch {}, Loss: {}'.format(epoch, loss.item())) # 评估模型 with torch.no_grad(): logits = model(g, features) predicted_labels = torch.argmax(logits, dim=1) accuracy = torch.sum(predicted_labels == labels).item() / len(labels) print('Accuracy: {}'.format(accuracy)) ``` 在训练阶段，通过计算预测值和真实标签之间的交叉熵损失来优化模型。在评估阶段，使用训练好的模型对新的样本进行预测，并计算准确率。 以上是一个简单的图神经网络节点分类的代码示例，实际应用中可以根据具体情况进行调整和扩展。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值