# Python图嵌入信息潜在表征算法

<details>

<summary>关键词</summary>

Python | 图 | 算法 | 社群 | 关系谱 | 图神经 | C++ | 通信 | 引文 | 道路 | 社评 | 电商 | 行为 | 模型 | 角色 | 图嵌入 | 全局结构 | 编码解码 | 半监督学习 | 富文本 | 表征 | 法律文本 | 语义

</details>

{% embed url="https://viadean.notion.site/Python-d886bd56943f4a7cb3873649be35e870" %}

{% content-ref url="../zhi-dian-mi-jin-brief" %}
[zhi-dian-mi-jin-brief](../zhi-dian-mi-jin-brief)
{% endcontent-ref %}

### 📜用例

📜[Python社群纽带关系谱和图神经](../gong-cheng-engineering/python-she-qun-niu-dai-guan-xi-pu-he-tu-shen-jing) | 📜[C++和Python通信引文道路社评电商大规模行为图结构数据模型](../ji-suan-computing/c++-he-python-tong-xin-yin-wen-dao-lu-she-ping-dian-shang-da-gui-mo-xing-wei-tu-jie-gou-shu-ju-mo-xi) | 📜角色图嵌入学习 | 📜图全局结构信息学习 | 📜图编码解码半监督学习 | 📜富文本表征学习 | 📜法律文本内容语义学习

### ✒️Python提取图节点嵌入信息

图可以定义为 G = (V, E)，其中 V 是一组节点，E 是一组边。 边是两个节点之间的连接，例如节点A和D有一条边。 另外，重要的是要注意图可以是有向图或无向图。 例如，下面的图是无向的，因为 A 与 D 连接，D 与 A 连接。还有一件事，图可以获取不同的节点属性以及边属性，但就我们的目的而言，今天并不重要。

{% @mermaid/diagram content="flowchart LR
B((B))---A((A))---D((D))---C((C)) & E((E))" %}

现在我们或多或少知道了图是什么，我们可以尝试从图中提取节点嵌入。

假设您需要解决如下场景：

* 我们在社交网络中进行用户交互，我们需要预测两个用户何时连接。节点代表用户，边代表两个用户是“朋友”。 （链接预测任务）
* 我们有一个研究出版物的引用网络，我们需要预测每个出版物的主题。节点代表出版物，边代表从一份出版物到另一份出版物的引用。 （节点预测任务）
* 我们有一组蛋白质，可分为酶或非酶。节点代表氨基酸，如果两个节点相距小于 6 埃，则通过边连接它们。 （图分类任务）

对于所有提到的任务，我们需要有节点的表示。因此，如果我们需要运行机器学习算法，我们需要将图结构转换为向量空间。

方法一：

随机游走是一种将图转换为节点序列以训练此模型的方法。 基本上，对于图中的每个节点，模型都会生成连接节点的随机路径。 一旦我们有了这些节点的随机路径，它就会训练此模型来获得节点嵌入。

出于学习目的，请在下面找到该算法的实现，请注意该代码尚未准备好用于大规模应用，可以进行一些并行化和内存改进。

```python
 import networkx as nx
 import random
 import numpy as np
 from typing import List
 from tqdm import tqdm
 ​
 ​
 class DWk:
     def __init__(self, window_size: int, embedding_size: int, walk_length: int, walks_per_node: int):
         self.window_size = window_size
         self.embedding_size = embedding_size
         self.walk_length = walk_length
         self.walk_per_node = walks_per_node
 ​
     def random_walk(self, g: nx.Graph, start: str, use_probabilities: bool = False) -> List[str]:
        
         walk = [start]
         for i in range(self.walk_length):
             neighbours = g.neighbors(walk[i])
             neighs = list(neighbours)
             if use_probabilities:
                 probabilities = [g.get_edge_data(walk[i], neig)["weight"] for neig in neighs]
                 sum_probabilities = sum(probabilities)
                 probabilities = list(map(lambda t: t / sum_probabilities, probabilities))
                 p = np.random.choice(neighs, p=probabilities)
             else:
                 p = random.choice(neighs)
             walk.append(p)
         return walk
 ​
     def get_walks(self, g: nx.Graph, use_probabilities: bool = False) -> List[List[str]]:
        
         random_walks = []
         for _ in range(self.walk_per_node):
             random_nodes = list(g.nodes)
             random.shuffle(random_nodes)
             for node in tqdm(random_nodes):
                 random_walks.append(self.random_walk(g=g, start=node, use_probabilities=use_probabilities))
         return random_walks
 ​
     def compute_embeddings(self, walks: List[List[str]]):
     
         model = Word2Vec(sentences=walks, window=self.window_size, vector_size=self.embedding_size)
         return model.wv
 ​
```

方法二：

该算法使用深度优先搜索和广度优先搜索算法的组合来提取随机游走。 这种算法组合由两个参数 P（返回参数）和 Q（输入输出参数）控制。

基本上，如果 P 很大，随机游走也会很大，所以它会进行探索，如果 P 很小，我们会停留在本地。 Q 也会发生类似但相反的行为，如果 Q 很小，它将进行探索，如果 Q 很大，它将停留在本地。

我们可以使用 PyTorch 几何测试算法。 该库实现了一系列图神经网络架构和方法来加速 GNN 的工作。 为了测试它，我将使用 Pytorch 几何上提出的教程的一小部分。 为此，他们使用 Cora 数据集。 Cora 数据集包含 2708 份科学出版物，分为七类。 引文网络由 5429 个链接组成。 数据集中的每个出版物都由 0/1 值词向量描述，指示词典中相应词的不存在/存在。该词典由 1433 个独特单词组成。

```python
 from torch_geometric.nn import Node2Vec
 import os.path as osp
 import torch
 from torch_geometric.datasets import Planetoid
 from tqdm.notebook import tqdm
 ​
 dataset = 'Cora'
 path = osp.join('.', 'data', dataset)
 dataset = Planetoid(path, dataset)  # dowload or load the Cora dataset
 data = dataset[0]
 device = 'cuda' if torch.cuda.is_available() else 'cpu'  # check if cuda is available to send the model and tensors to the GPU
 model = Node2Vec(data.edge_index, embedding_dim=128, walk_length=20,
                  context_size=10, walks_per_node=10,
                  num_negative_samples=1, p=1, q=1, sparse=True).to(device)
 ​
 def train():
     model.train() 
     total_loss = 0
     for pos_rw, neg_rw in tqdm(loader):
         optimizer.zero_grad() 
         loss = model.loss(pos_rw.to(device), neg_rw.to(device))  
         loss.backward()
         optimizer.step() 
         total_loss += loss.item()
     return total_loss / len(loader)
 ​
 ​
 for epoch in range(1, 100):
     loss = train()
     print(f'Epoch: {epoch:02d}, Loss: {loss:.4f}')
 ​
 all_vectors = ""
 for tensor in model(torch.arange(data.num_nodes, device=device)):
     s = "\t".join([str(value) for value in tensor.detach().cpu().numpy()])
     all_vectors += s + "\n"
 ​
 with open("vectors.txt", "w") as f:
     f.write(all_vectors)
 ​
 with open("labels.txt", "w") as f:
     f.write("\n".join([str(label) for label in data.y.numpy()]))
 ​
```

模型训练完成后，我们将为图中的每个节点提供一个嵌入，每个嵌入将为 128 维。 训练结束后，我们可以保存嵌入，并在嵌入投影仪中查看表示与标签相比有多“好”。 为此，我使用 T-SNE 算法将 128 维数据减少到 3 维数据，以便我们可以绘制它。
