Skip to content

点
点头人工智能课程-v6.0-AI交叉
Commit 8923a7f7 by Leo
Options

upload code

parent 4606f1b4
Showing with 1629 additions and 0 deletions
1-框架拆解/1.3-图神经网络框架（DGL）/code/show_graph.py 0 → 100644
import dgl
import dgl
import networkx as nx
import matplotlib.pyplot as plt
import torch
# 假设你已经有了一个DGL图对象bg
# 如果没有，这里提供一个示例图的创建
# u = torch.tensor([0, 1, 2, 3, 2])
# v = torch.tensor([1, 2, 3, 4, 0])
# bg = dgl.graph((u, v))
def visualize_dgl_graph(g, node_labels=None, edge_labels=None, figsize=(32, 16)):
"""
可视化DGL图
参数:
g: DGL图对象
node_labels: 节点标签字典 (可选)
edge_labels: 边标签字典 (可选)
figsize: 图像大小
"""
# 将DGL图转换为NetworkX图
nx_g = dgl.to_networkx(g)
# 创建图形
plt.figure(figsize=figsize)
# 设置布局
pos = nx.spring_layout(nx_g, seed=42)
# 绘制节点
nx.draw_networkx_nodes(nx_g, pos,
node_color='lightblue',
node_size=500,
alpha=0.8)
# 绘制边
nx.draw_networkx_edges(nx_g, pos,
edge_color='gray',
arrows=True,
arrowsize=20,
alpha=0.6)
# 绘制节点标签
if node_labels is None:
node_labels = {i: str(i) for i in range(g.num_nodes())}
nx.draw_networkx_labels(nx_g, pos, node_labels, font_size=8)
# 绘制边标签（如果提供）
if edge_labels is not None:
nx.draw_networkx_edge_labels(nx_g, pos, edge_labels)
plt.title(f"DGL\n num_nodes: {g.num_nodes()}, num_edges: {g.num_edges()}")
plt.axis('off')
plt.tight_layout()
plt.show()
# # 使用示例
# visualize_dgl_graph(bg)
\ No newline at end of file
1-框架拆解/1.3-图神经网络框架（DGL）/code/图的构键.ipynb 0 → 100644
{
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 基本图"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"![图](..\\picture\\image.png)"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Graph(num_nodes=4, num_edges=4,\n",
" ndata_schemes={}\n",
" edata_schemes={})\n",
"tensor([0, 1, 2, 3])\n",
"(tensor([0, 0, 0, 1]), tensor([1, 2, 3, 3]))\n",
"(tensor([0, 0, 0, 1]), tensor([1, 2, 3, 3]), tensor([0, 1, 2, 3]))\n"
]
}
],
"source": [
"import dgl\n",
"import torch as th\n",
"\n",
"# 边 0->1, 0->2, 0->3, 1->3\n",
"\n",
"u, v = th.tensor([0, 0, 0, 1]), th.tensor([1, 2, 3, 3])\n",
"g = dgl.graph((u, v))\n",
"print(g) # 图中节点的数量是DGL通过给定的图的边列表中最大的点ID推断所得出的\n",
"\n",
"# 获取节点的ID\n",
"print(g.nodes())\n",
"# 获取边的对应端点\n",
"print(g.edges())\n",
"# 获取边的对应端点和边ID\n",
"print(g.edges(form='all'))\n",
"\n",
"# 如果具有最大ID的节点没有边，在创建图的时候，用户需要明确地指明节点的数量。\n",
"g = dgl.graph((u, v), num_nodes=8)"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(tensor([0, 0, 0, 1, 1, 2, 3, 3]), tensor([1, 2, 3, 0, 3, 0, 0, 1]))"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"##转化成无向图\n",
"bg = dgl.to_bidirected(g)\n",
"bg.edges()"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Graph(num_nodes=6, num_edges=4,\n",
" ndata_schemes={}\n",
" edata_schemes={})"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"## 节点特征和边特征\n",
"import dgl\n",
"import torch as th\n",
"g = dgl.graph(([0, 0, 1, 5], [1, 2, 2, 0])) # 6个节点，4条边\n",
"g\n"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Graph(num_nodes=6, num_edges=4,\n",
" ndata_schemes={'x': Scheme(shape=(3,), dtype=torch.float32)}\n",
" edata_schemes={'x': Scheme(shape=(), dtype=torch.int32)})"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"g.ndata['x'] = th.ones(g.num_nodes(), 3) # 长度为3的节点特征\n",
"g.edata['x'] = th.ones(g.num_edges(), dtype=th.int32) # 标量整型特征\n",
"g"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"tensor([1., 1., 1.])\n",
"tensor([1, 1], dtype=torch.int32)\n"
]
}
],
"source": [
"# 不同名称的特征可以具有不同形状\n",
"g.ndata['y'] = th.randn(g.num_nodes(), 5)\n",
"print(g.ndata['x'][1]) # 获取节点1的特征\n",
"print(g.edata['x'][th.tensor([0, 3])]) # 获取边0和3的特征"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Graph(num_nodes=4, num_edges=4,\n",
" ndata_schemes={}\n",
" edata_schemes={'w': Scheme(shape=(), dtype=torch.float32)})"
]
},
"execution_count": 19,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"## 加权图\n",
"# 边 0->1, 0->2, 0->3, 1->3\n",
"edges = th.tensor([0, 0, 0, 1]), th.tensor([1, 2, 3, 3])\n",
"weights = th.tensor([0.1, 0.6, 0.9, 0.7]) # 每条边的权重\n",
"g = dgl.graph(edges)\n",
"g.edata['w'] = weights # 将其命名为 'w'\n",
"g"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Graph(num_nodes=100, num_edges=500,\n",
" ndata_schemes={}\n",
" edata_schemes={})"
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"## 外部创建接口\n",
"## scipy构建\n",
"import dgl\n",
"import torch as th\n",
"import scipy.sparse as sp\n",
"spmat = sp.rand(100, 100, density=0.05) # 5%非零项\n",
"dgl.from_scipy(spmat) # 来自SciPy"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [],
"source": [
"## networkx\n",
"import networkx as nx\n",
"nx_g = nx.path_graph(5) # 一条链路0-1-2-3-4\n",
"g=dgl.from_networkx(nx_g) # 来自NetworkX\n"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [],
"source": [
"## 保存dgl图\n",
"dgl.save_graphs(\"graph.dgl\", g)"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [],
"source": [
"read_g=dgl.load_graphs('graph.dgl')"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"([Graph(num_nodes=5, num_edges=8,\n",
" ndata_schemes={}\n",
" edata_schemes={})],\n",
" {})"
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"read_g"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "lbb",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.20"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
1-框架拆解/1.3-图神经网络框架（DGL）/code/异构图.ipynb 0 → 100644
This source diff could not be displayed because it is too large. You can view the blob instead.
1-框架拆解/1.3-图神经网络框架（DGL）/code/数据集构建.ipynb 0 → 100644
This source diff could not be displayed because it is too large. You can view the blob instead.
1-框架拆解/1.3-图神经网络框架（DGL）/code/模型构建.ipynb 0 → 100644
{
{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import torch.nn as nn\n",
"\n",
"from dgl.utils import expand_as_pair\n",
"import dgl.function as fn\n",
"import torch.nn.functional as F\n",
"from dgl.utils import check_eq_shape\n",
"class SAGEConv(nn.Module):\n",
" def __init__(self,\n",
" in_feats,\n",
" out_feats,\n",
" aggregator_type,\n",
" bias=True,\n",
" norm=None,\n",
" activation=None):\n",
" super(SAGEConv, self).__init__()\n",
"\n",
" self._in_src_feats, self._in_dst_feats = expand_as_pair(in_feats)\n",
" self._out_feats = out_feats\n",
" self._aggre_type = aggregator_type\n",
" self.norm = norm\n",
" self.activation = activation\n",
" # 聚合类型：mean、pool、lstm、gcn\n",
" if aggregator_type not in ['mean', 'pool', 'lstm', 'gcn']:\n",
" raise KeyError('Aggregator type {} not supported.'.format(aggregator_type))\n",
" if aggregator_type == 'pool':\n",
" self.fc_pool = nn.Linear(self._in_src_feats, self._in_src_feats)\n",
" if aggregator_type == 'lstm':\n",
" self.lstm = nn.LSTM(self._in_src_feats, self._in_src_feats, batch_first=True)\n",
" if aggregator_type in ['mean', 'pool', 'lstm']:\n",
" self.fc_self = nn.Linear(self._in_dst_feats, out_feats, bias=bias)\n",
" self.fc_neigh = nn.Linear(self._in_src_feats, out_feats, bias=bias)\n",
" self.reset_parameters()\n",
" \n",
" def reset_parameters(self):\n",
" \"\"\"重新初始化可学习的参数\"\"\"\n",
" gain = nn.init.calculate_gain('relu')\n",
" if self._aggre_type == 'pool':\n",
" nn.init.xavier_uniform_(self.fc_pool.weight, gain=gain)\n",
" if self._aggre_type == 'lstm':\n",
" self.lstm.reset_parameters()\n",
" if self._aggre_type != 'gcn':\n",
" nn.init.xavier_uniform_(self.fc_self.weight, gain=gain)\n",
" nn.init.xavier_uniform_(self.fc_neigh.weight, gain=gain)\n",
"\n",
" \n",
" def forward(self, graph, feat):\n",
" with graph.local_scope():\n",
" # 指定图类型，然后根据图类型扩展输入特征\n",
" feat_src, feat_dst = expand_as_pair(feat, graph)\n",
" h_self = feat_dst\n",
" if self._aggre_type == 'mean':\n",
" graph.srcdata['h'] = feat_src\n",
" graph.update_all(fn.copy_u('h', 'm'), fn.mean('m', 'neigh'))\n",
" h_neigh = graph.dstdata['neigh']\n",
" elif self._aggre_type == 'gcn':\n",
" check_eq_shape(feat)\n",
" graph.srcdata['h'] = feat_src\n",
" graph.dstdata['h'] = feat_dst\n",
" graph.update_all(fn.copy_u('h', 'm'), fn.sum('m', 'neigh'))\n",
" # 除以入度\n",
" degs = graph.in_degrees().to(feat_dst)\n",
" h_neigh = (graph.dstdata['neigh'] + graph.dstdata['h']) / (degs.unsqueeze(-1) + 1)\n",
" elif self._aggre_type == 'pool':\n",
" graph.srcdata['h'] = F.relu(self.fc_pool(feat_src))\n",
" graph.update_all(fn.copy_u('h', 'm'), fn.max('m', 'neigh'))\n",
" h_neigh = graph.dstdata['neigh']\n",
" else:\n",
" raise KeyError('Aggregator type {} not recognized.'.format(self._aggre_type))\n",
"\n",
" # GraphSAGE中gcn聚合不需要fc_self\n",
" if self._aggre_type == 'gcn':\n",
" rst = self.fc_neigh(h_neigh)\n",
" else:\n",
" rst = self.fc_self(h_self) + self.fc_neigh(h_neigh)\n",
" # 激活函数\n",
" if self.activation is not None:\n",
" rst = self.activation(rst)\n",
" # 归一化\n",
" if self.norm is not None:\n",
" rst = self.norm(rst)\n",
" return rst"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"sage=SAGEConv(in_feats=32,out_feats=32,aggregator_type='mean')"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"import random\n",
"import torch \n",
"import dgl\n",
"feature=torch.randn(10,32)\n",
"g = dgl.graph(([0, 1, 1, 3,6,8,5,8,2], [1, 2, 8,9,7,6,0,3,4]))"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 1000x800 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"from show_graph import visualize_dgl_graph\n",
"\n",
"\n",
"visualize_dgl_graph(g)"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([[-9.6490e-01, -1.9022e+00, 3.2530e+00, 9.8642e-01, -2.9214e+00,\n",
" 6.6813e-01, -6.5806e-01, 2.1334e-01, -2.3813e+00, 1.4279e+00,\n",
" 2.4934e-01, -1.9641e+00, 4.1958e-01, 4.8639e+00, -2.3342e+00,\n",
" 2.1080e+00, 1.8954e+00, -6.0483e-02, 2.6170e+00, 6.4117e-02,\n",
" 1.7755e+00, -9.9459e-01, -5.5936e-02, 1.2980e+00, 2.4753e+00,\n",
" 1.8620e+00, 2.3168e+00, -9.2108e-02, 1.9715e+00, 4.8170e+00,\n",
" 2.9038e+00, -1.0317e+00],\n",
" [-1.8761e+00, -2.6733e+00, 1.2828e+00, -9.2004e-01, -1.6127e+00,\n",
" -1.1511e+00, -4.4329e-01, -4.2901e+00, -9.5168e-01, 1.9406e+00,\n",
" 1.5974e+00, -1.8932e+00, -4.0697e-02, 1.7480e+00, 3.4592e+00,\n",
" -7.7324e-01, -4.6919e+00, 2.1080e+00, -4.5661e+00, 5.2768e-01,\n",
" -4.2414e+00, -3.4478e+00, 1.7463e+00, 7.0594e-02, 1.6743e+00,\n",
" 5.3143e-01, 1.5393e+00, 3.1564e+00, -1.9402e+00, -5.9402e+00,\n",
" 2.6716e+00, 2.8637e+00],\n",
" [ 3.1006e+00, 2.6569e+00, -2.1073e+00, 1.6839e+00, 1.3948e+00,\n",
" 1.3118e+00, -4.1418e+00, -3.8318e+00, -2.0636e-01, 9.3139e-01,\n",
" -2.6870e+00, 2.5147e+00, 4.0110e+00, -1.8345e+00, 2.8440e+00,\n",
" -1.1138e+00, 2.4028e+00, -1.4960e+00, -1.8237e+00, 5.1955e-02,\n",
" 5.3907e+00, -2.3788e+00, -5.0904e-01, 3.4928e+00, 4.9565e-03,\n",
" -8.5098e-01, 1.5774e+00, 1.2181e+00, -3.9730e+00, -2.0996e+00,\n",
" -2.6367e-01, -1.5128e+00],\n",
" [ 6.7993e-01, 2.2361e-01, 2.0539e-01, 2.2908e-01, -9.9973e-01,\n",
" 3.5098e-01, -2.4861e+00, -2.1380e+00, -3.0203e-01, 2.0767e+00,\n",
" -1.7382e+00, 2.4252e-01, 1.7421e+00, -3.4618e+00, -5.5090e-01,\n",
" -9.0776e-01, 2.1274e+00, 2.2359e-02, -2.1845e+00, -1.8908e+00,\n",
" -2.0645e+00, 9.5528e-01, 9.1364e-01, 7.4539e-01, -1.6237e+00,\n",
" 5.4151e-01, -1.3003e+00, -3.9585e+00, 1.1016e+00, -1.6522e+00,\n",
" 1.4803e+00, 1.1523e+00],\n",
" [-2.2501e+00, 1.7463e+00, -3.7890e+00, 3.4260e+00, 1.2573e+00,\n",
" 1.9678e-01, -1.4035e+00, -3.7209e+00, 2.9785e+00, -2.0380e+00,\n",
" 3.7757e-01, -1.8998e-01, 2.8124e+00, -1.3296e+00, 1.4714e+00,\n",
" 8.3152e-03, 1.0145e+00, -1.6152e+00, -1.6013e+00, 3.3268e-01,\n",
" 3.7386e+00, 1.9178e+00, -7.1175e-01, 2.5218e-01, 2.2201e+00,\n",
" -2.5519e-01, 2.1971e+00, -4.1698e+00, -2.2542e+00, -2.6237e+00,\n",
" -1.9793e+00, -5.2448e+00],\n",
" [ 1.5215e+00, -7.5937e-01, 9.2270e-01, -4.6868e-02, -9.7279e-02,\n",
" -3.0665e-01, -1.1146e+00, -6.2991e-01, -3.6704e-01, 3.3924e-01,\n",
" 1.3374e+00, 6.7225e-01, -8.5759e-01, 1.0404e+00, 1.7861e+00,\n",
" 1.3301e+00, 9.5792e-01, -2.3408e-01, -1.6806e+00, 5.4661e-01,\n",
" 5.7294e-01, -5.2837e-01, 1.8126e+00, -4.5460e-01, -6.4962e-01,\n",
" -2.7730e+00, 1.0892e+00, 1.2829e+00, 2.5834e-01, 4.2540e-02,\n",
" 8.8713e-02, -7.9993e-01],\n",
" [ 1.2823e+00, 7.8648e-01, -2.6415e+00, -1.9701e+00, -1.1994e+00,\n",
" -2.2449e-02, -3.4577e-01, -1.5492e+00, -3.7314e-02, 2.0416e-01,\n",
" -2.2100e-01, -4.7846e-01, 7.6816e-01, -4.6944e+00, 3.5767e+00,\n",
" -1.4031e+00, 1.2247e+00, -3.5666e+00, -2.9713e+00, 1.5585e+00,\n",
" -1.3184e+00, 1.1589e+00, 6.8929e-01, 1.4142e+00, -1.9140e+00,\n",
" -5.8461e-01, -2.0744e+00, -2.1260e+00, 2.0627e+00, -3.0446e+00,\n",
" -7.8576e-02, -9.7511e-01],\n",
" [-4.0026e-01, 2.9805e-01, 1.0402e+00, 2.1791e+00, 3.5239e+00,\n",
" -1.1926e+00, 1.2793e+00, -2.8650e+00, -6.5055e-01, -1.4988e+00,\n",
" 1.7552e+00, -2.1288e+00, 2.1987e+00, -2.8234e+00, -1.4042e+00,\n",
" 4.7342e-02, 1.3003e+00, -2.1159e+00, 7.2112e-01, 3.2388e+00,\n",
" 1.5675e+00, -1.2049e+00, 1.4009e-01, -1.7273e-02, 9.4091e-01,\n",
" -1.7791e+00, 2.9495e-01, -3.2822e+00, 1.8330e-01, 9.0581e-01,\n",
" -2.7346e+00, -2.3808e+00],\n",
" [ 6.2013e-01, -9.0084e-01, -2.1480e-01, 4.8600e-01, 6.9743e-01,\n",
" 1.3314e+00, -2.6345e+00, -2.6115e+00, 1.8483e-01, 3.6727e+00,\n",
" -2.5919e+00, 2.8184e+00, -8.2165e-02, -4.5039e-01, 7.7221e-01,\n",
" -1.7326e+00, 1.6755e+00, 1.6077e+00, -3.4239e-01, 1.0900e+00,\n",
" 9.7456e-01, 8.4072e-02, -2.6320e+00, 2.3142e-01, 1.8978e+00,\n",
" 8.7410e-01, -1.2108e+00, -1.7599e+00, -3.4067e+00, 6.6433e-01,\n",
" 1.4871e+00, 1.7228e+00],\n",
" [ 3.0571e-01, -2.2480e+00, -5.2352e-01, -1.2337e+00, -1.2371e+00,\n",
" -9.7689e-01, -5.6765e-01, -1.1776e+00, 1.4804e-02, -1.9551e+00,\n",
" -9.3313e-01, 3.0317e+00, -2.6520e-01, -2.8600e+00, -8.8953e-01,\n",
" -8.6820e-01, -3.8387e+00, -3.1136e+00, -2.3196e+00, 1.3496e+00,\n",
" -3.6214e+00, 1.2780e+00, -2.6955e+00, 7.5525e-01, -1.0487e+00,\n",
" -8.9145e-01, -3.0168e+00, -1.0683e+00, -3.3603e+00, 2.2406e+00,\n",
" -2.8727e+00, 7.9460e-01]], grad_fn=<AddBackward0>)"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"sage(g,feature)"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "lbb",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.20"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
1-框架拆解/1.3-图神经网络框架（DGL）/code/消息传传递.ipynb 0 → 100644
{
{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import dgl.function as fn\n",
"\n",
"import dgl\n",
"import copy\n",
"import torch as th"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 基本机制"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"from show_graph import visualize_dgl_graph"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"## 消息函数\n",
"dgl.function.u_add_v('hu', 'hv', 'he')\n",
"orignal_g = dgl.graph(([0, 0, 1, 5], [1, 2, 2, 0]))\n",
"orignal_g.ndata['x'] = th.ones(orignal_g .num_nodes(), 3) # 长度为3的节点特征\n",
"orignal_g.edata['x'] = th.ones(orignal_g .num_edges(), dtype=th.int32) "
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 1000x800 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"visualize_dgl_graph(orignal_g)"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"g1=copy.deepcopy(orignal_g)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"## 消息和更新函数\n",
"g1.update_all(fn.u_add_v('x','x','m'),\n",
" fn.sum('m','h'))"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([[2., 2., 2.],\n",
" [2., 2., 2.],\n",
" [4., 4., 4.],\n",
" [0., 0., 0.],\n",
" [0., 0., 0.],\n",
" [0., 0., 0.]])"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"g1.ndata['h']"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([[1., 1., 1.],\n",
" [1., 1., 1.],\n",
" [1., 1., 1.],\n",
" [1., 1., 1.],\n",
" [1., 1., 1.],\n",
" [1., 1., 1.]])"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"orignal_g.ndata['x']"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
"## 加上更新函数\n",
"import dgl.function as fn\n",
"def update_all_example(graph):\n",
" # 在graph.ndata['ft']中存储结果\n",
" graph.update_all(fn.u_add_v('x', 'x', 'm'),\n",
" fn.sum('m', 'x'))\n",
" # 在update_all外调用更新函数\n",
" final_ft = graph.ndata['x'] * 2\n",
" return final_ft"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"g2=copy.deepcopy(orignal_g)"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([[1., 1., 1.],\n",
" [1., 1., 1.],\n",
" [1., 1., 1.],\n",
" [1., 1., 1.],\n",
" [1., 1., 1.],\n",
" [1., 1., 1.]])"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"g2.ndata['x']"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"tensor([0, 1, 2, 3, 4, 5])\n",
"tensor([0, 1, 2, 3, 4, 5])\n"
]
}
],
"source": [
"print(g2.srcnodes())\n",
"print(g2.dstnodes())"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [],
"source": [
"h=update_all_example(g2)"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([[4., 4., 4.],\n",
" [4., 4., 4.],\n",
" [8., 8., 8.],\n",
" [0., 0., 0.],\n",
" [0., 0., 0.],\n",
" [0., 0., 0.]])"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"h"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 降维操作"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [],
"source": [
"import dgl.function as fn\n",
"import torch.nn as nn\n",
"import torch\n",
"node_feat_dim=1433\n",
"out_dim=64\n",
"g3=copy.deepcopy(orignal_g)\n",
"g3.ndata['feat'] = torch.randn(g3.num_nodes(), node_feat_dim)\n",
"linear_src = nn.Parameter(torch.FloatTensor(size=(node_feat_dim, out_dim)))\n",
"linear_dst = nn.Parameter(torch.FloatTensor(size=(node_feat_dim, out_dim)))\n",
"out_src = g3.ndata['feat'] @ linear_src\n",
"out_dst =g3.ndata['feat'] @ linear_dst\n",
"g3.srcdata.update({'out_src': out_src})\n",
"g3.dstdata.update({'out_dst': out_dst})\n",
"g3.apply_edges(fn.u_add_v('out_src', 'out_dst', 'out'))"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([[1., 1., 1.],\n",
" [1., 1., 1.],\n",
" [1., 1., 1.],\n",
" [1., 1., 1.],\n",
" [1., 1., 1.],\n",
" [1., 1., 1.]])"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"orignal_g.ndata['x']"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 子图进行消息传递"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [],
"source": [
"nid=[0,1,2]\n",
"g4=copy.deepcopy(orignal_g)\n",
"sg = g4.subgraph(nid)"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 1000x800 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"visualize_dgl_graph(sg)"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([[1., 1., 1.],\n",
" [1., 1., 1.],\n",
" [1., 1., 1.]])"
]
},
"execution_count": 19,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"sg.ndata['x']"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([[0., 0., 0.],\n",
" [4., 4., 4.],\n",
" [8., 8., 8.]])"
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"h_sub=update_all_example(sg)\n",
"h_sub"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "lbb",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.20"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
1-框架拆解/1.3-图神经网络框架（DGL）/code/训练流程.ipynb 0 → 100644
{
{
"cells": [
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"# 构建一个2层的GNN模型\n",
"import dgl.nn as dglnn\n",
"import torch.nn as nn\n",
"import torch.nn.functional as F\n",
"class SAGE(nn.Module):\n",
" def __init__(self, in_feats, hid_feats, out_feats):\n",
" super().__init__()\n",
" # 实例化SAGEConve，in_feats是输入特征的维度，out_feats是输出特征的维度，aggregator_type是聚合函数的类型\n",
" self.conv1 = dglnn.SAGEConv(\n",
" in_feats=in_feats, out_feats=hid_feats, aggregator_type='mean')\n",
" self.conv2 = dglnn.SAGEConv(\n",
" in_feats=hid_feats, out_feats=out_feats, aggregator_type='mean')\n",
"\n",
" def forward(self, graph, inputs):\n",
" # 输入是节点的特征\n",
" h = self.conv1(graph, inputs)\n",
" h = F.relu(h)\n",
" h = self.conv2(graph, h)\n",
" return h"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"def evaluate(model, graph, features, labels, mask):\n",
" model.eval()\n",
" with torch.no_grad():\n",
" logits = model(graph, features)\n",
" logits = logits[mask]\n",
" labels = labels[mask]\n",
" _, indices = torch.max(logits, dim=1)\n",
" correct = torch.sum(indices == labels)\n",
" return correct.item() * 1.0 / len(labels)"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" NumNodes: 2708\n",
" NumEdges: 10556\n",
" NumFeats: 1433\n",
" NumClasses: 7\n",
" NumTrainingSamples: 140\n",
" NumValidationSamples: 500\n",
" NumTestSamples: 1000\n",
"Done loading data from cached files.\n",
"1.949838638305664\n",
"1.9358097314834595\n",
"1.9219502210617065\n",
"1.9081010818481445\n",
"1.8941532373428345\n",
"1.8800199031829834\n",
"1.865597128868103\n",
"1.850832223892212\n",
"1.8356748819351196\n",
"1.8200792074203491\n",
"1.8040268421173096\n",
"1.7875289916992188\n",
"1.7705438137054443\n",
"1.7531026601791382\n",
"1.735211730003357\n",
"1.716886281967163\n",
"1.6981059312820435\n",
"1.6789307594299316\n",
"1.6594184637069702\n",
"1.6395537853240967\n",
"1.619325041770935\n",
"1.5987473726272583\n",
"1.5778186321258545\n",
"1.5565370321273804\n",
"1.534938931465149\n",
"1.5130054950714111\n",
"1.4908182621002197\n",
"1.4683568477630615\n",
"1.4456417560577393\n",
"1.4227211475372314\n",
"1.399627923965454\n",
"1.3763319253921509\n",
"1.3528709411621094\n",
"1.3292958736419678\n",
"1.3056401014328003\n",
"1.281915545463562\n",
"1.2581247091293335\n",
"1.2343021631240845\n",
"1.2104600667953491\n",
"1.1866297721862793\n",
"1.1628280878067017\n",
"1.139069676399231\n",
"1.1153767108917236\n",
"1.0917530059814453\n",
"1.0682175159454346\n",
"1.044796347618103\n",
"1.0215240716934204\n",
"0.9984098076820374\n",
"0.9754566550254822\n",
"0.9526885747909546\n",
"0.930131196975708\n",
"0.9077998399734497\n",
"0.8857099413871765\n",
"0.863884449005127\n",
"0.8423382043838501\n",
"0.8210814595222473\n",
"0.8001234531402588\n",
"0.7794760465621948\n",
"0.7591519951820374\n",
"0.7391610145568848\n",
"0.7195146679878235\n",
"0.7002249956130981\n",
"0.6812953352928162\n",
"0.6627280712127686\n",
"0.6445322036743164\n",
"0.6267086267471313\n",
"0.6092639565467834\n",
"0.5921995639801025\n",
"0.5755224227905273\n",
"0.559232234954834\n",
"0.5433287024497986\n",
"0.5278133153915405\n",
"0.5126844048500061\n",
"0.49794137477874756\n",
"0.48357924818992615\n",
"0.4695985019207001\n",
"0.4559986889362335\n",
"0.4427717626094818\n",
"0.429914265871048\n",
"0.41742244362831116\n",
"0.4052915871143341\n",
"0.39351686835289\n",
"0.38209041953086853\n",
"0.37100687623023987\n",
"0.3602590560913086\n",
"0.3498398959636688\n",
"0.33974385261535645\n",
"0.32996422052383423\n",
"0.32049286365509033\n",
"0.3113235533237457\n",
"0.3024483323097229\n",
"0.29385843873023987\n",
"0.2855471670627594\n",
"0.27750858664512634\n",
"0.2697344124317169\n",
"0.2622153162956238\n",
"0.25494545698165894\n",
"0.24791717529296875\n",
"0.2411225438117981\n",
"0.23455502092838287\n"
]
},
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 1200x400 with 2 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"from dgl.data import CoraGraphDataset\n",
"import torch\n",
"import torch.nn.functional as F\n",
"import matplotlib.pyplot as plt\n",
"graph=CoraGraphDataset()[0]\n",
"node_features = graph.ndata['feat']\n",
"node_labels = graph.ndata['label']\n",
"train_mask = graph.ndata['train_mask']\n",
"valid_mask = graph.ndata['val_mask']\n",
"test_mask = graph.ndata['test_mask']\n",
"n_features = node_features.shape[1]\n",
"n_labels = int(node_labels.max().item() + 1)\n",
"model = SAGE(in_feats=n_features, hid_feats=100, out_feats=n_labels)\n",
"opt = torch.optim.Adam(model.parameters())\n",
"\n",
"losses = []\n",
"accs = []\n",
"for epoch in range(100):\n",
" model.train()\n",
" # 使用所有节点(全图)进行前向传播计算\n",
" logits = model(graph, node_features)\n",
" # 计算损失值\n",
" loss = F.cross_entropy(logits[train_mask], node_labels[train_mask])\n",
" # 计算验证集的准确度\n",
" acc = evaluate(model, graph, node_features, node_labels, valid_mask)\n",
" losses.append(loss.item())\n",
" accs.append(acc)\n",
" # 进行反向传播计算\n",
" opt.zero_grad()\n",
" loss.backward()\n",
" opt.step()\n",
" print(loss.item())\n",
"##绘制训练曲线\n",
"plt.figure(figsize=(12, 4))\n",
"\n",
"plt.subplot(1, 2, 1)\n",
"plt.plot(losses)\n",
"plt.title('Training Loss')\n",
"plt.xlabel('Epoch')\n",
"plt.ylabel('Loss')\n",
"\n",
"plt.subplot(1, 2, 2)\n",
"plt.plot(accs)\n",
"plt.title('Validation Accuracy')\n",
"plt.xlabel('Epoch')\n",
"plt.ylabel('Accuracy')\n",
"\n",
"# plt.tight_layout()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 边链接预测"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"import dgl\n",
"src = np.random.randint(0, 100, 500)\n",
"dst = np.random.randint(0, 100, 500)\n",
"# 同时建立反向边\n",
"edge_pred_graph = dgl.graph((np.concatenate([src, dst]), np.concatenate([dst, src])))\n",
"# 建立点和边特征，以及边的标签\n",
"edge_pred_graph.ndata['feature'] = torch.randn(100, 10)\n",
"edge_pred_graph.edata['feature'] = torch.randn(1000, 10)\n",
"edge_pred_graph.edata['label'] = torch.randn(1000)\n",
"# 进行训练、验证和测试集划分\n",
"edge_pred_graph.edata['train_mask'] = torch.zeros(1000, dtype=torch.bool).bernoulli(0.6)"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
"import dgl.function as fn\n",
"class DotProductPredictor(nn.Module):\n",
" def forward(self, graph, h):\n",
" # h是从5.1节的GNN模型中计算出的节点表示\n",
" with graph.local_scope():\n",
" graph.ndata['h'] = h\n",
" graph.apply_edges(fn.u_dot_v('h', 'h', 'score'))\n",
" return graph.edata['score']"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [],
"source": [
"class MLPPredictor(nn.Module):\n",
" def __init__(self, in_features, out_classes):\n",
" super().__init__()\n",
" self.W = nn.Linear(in_features * 2, out_classes)\n",
"\n",
" def apply_edges(self, edges):\n",
" h_u = edges.src['h']\n",
" h_v = edges.dst['h']\n",
" score = self.W(torch.cat([h_u, h_v], 1))\n",
" return {'score': score}\n",
"\n",
" def forward(self, graph, h):\n",
" # h是从5.1节的GNN模型中计算出的节点表示\n",
" with graph.local_scope():\n",
" graph.ndata['h'] = h\n",
" graph.apply_edges(self.apply_edges)\n",
" return graph.edata['score']"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"class Model(nn.Module):\n",
" def __init__(self, in_features, hidden_features, out_features):\n",
" super().__init__()\n",
" self.sage = SAGE(in_features, hidden_features, out_features)\n",
" self.pred = DotProductPredictor()\n",
" def forward(self, g, x):\n",
" h = self.sage(g, x)\n",
" return self.pred(g, h)"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"350.0605163574219\n",
"325.6413879394531\n",
"302.6919250488281\n",
"281.1639099121094\n",
"261.0151672363281\n",
"242.17723083496094\n",
"224.6167449951172\n",
"208.26734924316406\n",
"193.07431030273438\n",
"178.9709930419922\n"
]
}
],
"source": [
"node_features = edge_pred_graph.ndata['feature']\n",
"edge_label = edge_pred_graph.edata['label']\n",
"train_mask = edge_pred_graph.edata['train_mask']\n",
"model = Model(10, 20, 5)\n",
"opt = torch.optim.Adam(model.parameters())\n",
"for epoch in range(10):\n",
" pred = model(edge_pred_graph, node_features)\n",
" loss = ((pred[train_mask] - edge_label[train_mask]) ** 2).mean()\n",
" opt.zero_grad()\n",
" loss.backward()\n",
" opt.step()\n",
" print(loss.item())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 链接预测"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [],
"source": [
"class DotProductPredictor(nn.Module):\n",
" def forward(self, graph, h):\n",
" # h是从5.1节的GNN模型中计算出的节点表示\n",
" with graph.local_scope():\n",
" graph.ndata['h'] = h\n",
" graph.apply_edges(fn.u_dot_v('h', 'h', 'score'))\n",
" return graph.edata['score']"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [],
"source": [
"def construct_negative_graph(graph, k):\n",
" src, dst = graph.edges()\n",
"\n",
" neg_src = src.repeat_interleave(k)\n",
" neg_dst = torch.randint(0, graph.num_nodes(), (len(src) * k,))\n",
" return dgl.graph((neg_src, neg_dst), num_nodes=graph.num_nodes())"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [],
"source": [
"class Model(nn.Module):\n",
" def __init__(self, in_features, hidden_features, out_features):\n",
" super().__init__()\n",
" self.sage = SAGE(in_features, hidden_features, out_features)\n",
" self.pred = DotProductPredictor()\n",
" def forward(self, g, neg_g, x):\n",
" h = self.sage(g, x)\n",
" return self.pred(g, h), self.pred(neg_g, h)"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.9940666556358337\n",
"0.9909564256668091\n",
"0.9874159693717957\n",
"0.9834043383598328\n",
"0.9785149693489075\n",
"0.9733799695968628\n",
"0.9669748544692993\n",
"0.9600772261619568\n",
"0.9514783620834351\n",
"0.9420233964920044\n"
]
}
],
"source": [
"def compute_loss(pos_score, neg_score):\n",
" # 间隔损失\n",
" n_edges = pos_score.shape[0]\n",
" return (1 - pos_score.unsqueeze(1) + neg_score.view(n_edges, -1)).clamp(min=0).mean()\n",
"\n",
"node_features = graph.ndata['feat']\n",
"n_features = node_features.shape[1]\n",
"k = 5\n",
"model = Model(n_features, 100, 100)\n",
"opt = torch.optim.Adam(model.parameters())\n",
"for epoch in range(10):\n",
" negative_graph = construct_negative_graph(graph, k)\n",
" pos_score, neg_score = model(graph, negative_graph, node_features)\n",
" loss = compute_loss(pos_score, neg_score)\n",
" opt.zero_grad()\n",
" loss.backward()\n",
" opt.step()\n",
" print(loss.item())"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [],
"source": [
"node_embeddings = model.sage(graph, node_features)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 图分类"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([3., 6.])"
]
},
"execution_count": 28,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"## 批次计算\n",
"import dgl\n",
"import torch\n",
"\n",
"g1 = dgl.graph(([0, 1], [1, 0]))\n",
"g1.ndata['h'] = torch.tensor([1., 2.])\n",
"g2 = dgl.graph(([0, 1], [1, 2]))\n",
"g2.ndata['h'] = torch.tensor([1., 2., 3.])\n",
"\n",
"dgl.readout_nodes(g1, 'h')\n",
"# tensor([3.]) # 1 + 2\n",
"\n",
"bg = dgl.batch([g1, g2])\n",
"dgl.readout_nodes(bg, 'h')\n",
"# tensor([3., 6.]) # [1 + 2, 1 + 2 + 3]"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [],
"source": [
"import dgl.nn.pytorch as dglnn\n",
"import torch.nn as nn\n",
"\n",
"class Classifier(nn.Module):\n",
" def __init__(self, in_dim, hidden_dim, n_classes):\n",
" super(Classifier, self).__init__()\n",
" self.conv1 = dglnn.GraphConv(in_dim, hidden_dim)\n",
" self.conv2 = dglnn.GraphConv(hidden_dim, hidden_dim)\n",
" self.classify = nn.Linear(hidden_dim, n_classes)\n",
"\n",
" def forward(self, g, h):\n",
" # 应用图卷积和激活函数\n",
" h = F.relu(self.conv1(g, h))\n",
" h = F.relu(self.conv2(g, h))\n",
" with g.local_scope():\n",
" g.ndata['h'] = h\n",
" # 使用平均读出计算图表示\n",
" hg = dgl.mean_nodes(g, 'h')\n",
" return self.classify(hg)"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Downloading C:\\Users\\Administrator\\.dgl\\GINDataset.zip from https://raw.githubusercontent.com/weihua916/powerful-gnns/master/dataset.zip...\n",
"Extracting file to C:\\Users\\Administrator\\.dgl\\GINDataset\n"
]
}
],
"source": [
"import dgl.data\n",
"dataset = dgl.data.GINDataset('MUTAG', False)"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [],
"source": [
"from dgl.dataloading import GraphDataLoader\n",
"dataloader = GraphDataLoader(\n",
" dataset,\n",
" batch_size=1024,\n",
" drop_last=False,\n",
" shuffle=True)"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"epoch: 0 loss: 1.5607649087905884\n",
"epoch: 1 loss: 1.555953025817871\n",
"epoch: 2 loss: 1.5511653423309326\n",
"epoch: 3 loss: 1.546396017074585\n",
"epoch: 4 loss: 1.541630506515503\n",
"epoch: 5 loss: 1.5368280410766602\n",
"epoch: 6 loss: 1.5320494174957275\n",
"epoch: 7 loss: 1.5272836685180664\n",
"epoch: 8 loss: 1.522479772567749\n",
"epoch: 9 loss: 1.517690658569336\n",
"epoch: 10 loss: 1.5129148960113525\n",
"epoch: 11 loss: 1.508127212524414\n",
"epoch: 12 loss: 1.5033358335494995\n",
"epoch: 13 loss: 1.4985377788543701\n",
"epoch: 14 loss: 1.4937174320220947\n",
"epoch: 15 loss: 1.4888674020767212\n",
"epoch: 16 loss: 1.4839526414871216\n",
"epoch: 17 loss: 1.478992223739624\n",
"epoch: 18 loss: 1.4739632606506348\n",
"epoch: 19 loss: 1.4688645601272583\n"
]
}
],
"source": [
"import torch.nn.functional as F\n",
"\n",
"# 这仅是个例子，特征尺寸是7\n",
"model = Classifier(7, 20, 5)\n",
"opt = torch.optim.Adam(model.parameters())\n",
"for epoch in range(20):\n",
" count=0\n",
" loss_sum=0\n",
" for batched_graph, labels in dataloader:\n",
" count+=1\n",
" feats = batched_graph.ndata['attr']\n",
" logits = model(batched_graph, feats)\n",
" loss = F.cross_entropy(logits, labels)\n",
" loss_sum+=loss.item()\n",
" opt.zero_grad()\n",
" loss.backward()\n",
" opt.step()\n",
" print(\"epoch:\",epoch,\"loss:\",loss_sum/count)"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "lbb",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.20"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment