Comment implémenter la classification et la visualisation des nœuds en python basé sur Node2Vec

Introduction

Node2vec est une méthode d'intégration de graphiques qui peut être utilisée pour des tâches telles que la classification des nœuds, la découverte de communauté et la prédiction de connexion.

Processus d'implémentation

Chargement de l'ensemble de données

Tout d'abord, chargeons la bibliothèque Python requise et exécutons le code suivant pour charger l'ensemble de données Cora :

import networkx as nx 
import numpy as np 
import pandas as pd 
import matplotlib.pyplot as plt 
%matplotlib inline 
from sklearn.manifold import TSNE 
from node2vec import Node2Vec 
# 加载Cora数据集
cora = pd.read_csv('cora/cora.content', sep='\t', header=None)
cited_in = pd.read_csv('cora/cora.cites', sep='\t', header=None,
                       names=['target', 'source'])
nodes, features = cora.iloc[:, :-1], cora.iloc[:, -1]

où cora.content contient toutes les fonctionnalités du nœud Informations , avec un total de 2 708 nœuds et 1 433 fonctionnalités ; et cora.cites utilise le mappage de citations pour établir une relation de bord dirigée entre les nœuds pour chacun des nœuds, avec un total de 5 429 bords. Ensuite, nous devons fusionner les fonctionnalités des nœuds et les informations de référence pour créer la structure du graphique. cora.content 包含了所有节点特征信息，一共具有2708个节点和1433个特征；而 cora.cites 通过引文映射分别针对所述每个节点建立一个节点间的有向边关系，共有5429个边。接下来，我们需要将节点特征和引用信息合并，构建图结构。

# 定义函数：构造基于Cora数据集的图结构
def create_graph(nodes, features, cited_in):
    nodes.index = nodes.index.map(str)
    graph = nx.from_pandas_edgelist(cited_in,
                                    source='source',
                                    target='target')
    for index, row in nodes.iterrows():
        node_id = str(row[0])
        features = row.drop(labels=[0])
        node_attrs = {f'attr_{i}': float(x) for i, x in enumerate(features)}
        if graph.has_node(node_id) == True:
            temp = graph.nodes[node_id]
            temp.update(node_attrs)
            graph.add_nodes_from([(node_id, temp)])
        else:
            graph.add_nodes_from([(node_id, node_attrs)])
    return graph
# 构建图
graph = create_graph(nodes, features, cited_in)

该函数将 cora.content 中的节点特征与 cora.cites

# 定义函数：创建基于Cora数据集的嵌入
def create_embeddings(graph):
    # 初始化node2vec实例，指定相关超参数
    n2v = Node2Vec(graph, dimensions=64, walk_length=30,
                   num_walks=200, p=1, q=1, weight_key='attr_weight')
    # 基于指定参数训练得到嵌入向量表达式
    model = n2v.fit(window=10, min_count=1, batch_words=4)
    # 获得所有图中节点的嵌入向量
    embeddings = pd.DataFrame(model.wv.vectors)
    ids = list(map(str, model.wv.index2word))
    # 将原有的特征和id与新获取到的嵌入向量按行合并
    lookup_table = nodes.set_index(0).join(embeddings.set_index(embeddings.index))
    return np.array(lookup_table.dropna().iloc[:, -64:]), np.array(list(range(1, lookup_table.shape[0] + 1)))
# 创建嵌入向量
cora_embeddings, cora_labels = create_embeddings(graph)

Cette fonction intègre les fonctionnalités du nœud dans cora.content avec les bords dirigés de cora.cites et les étiquette sur le graphique. Nous avons maintenant construit une vue graphique qui nous permet de visualiser nos idées.

Intégration de données à l'aide de Node2vec

Afin d'effectuer une classification des fonctionnalités des nœuds, nous devons extraire certaines informations du réseau et les transmettre en entrée au classificateur. Un exemple consiste à utiliser la méthode vectorielle du nœud 2 pour convertir les informations extraites en une expression vectorielle afin que chaque nœud ait au moins une dimension.

En prenant des échantillons de marche aléatoires du nœud de départ au nœud cible, le modèle Node2Vec apprend un vecteur représentant chaque nœud. Le modèle nœud 2Vec définit les probabilités de transition entre nœuds lors d'une marche aléatoire.

Nous utiliserons la bibliothèque node2vec pour générer une représentation intégrée du graphique et utiliserons un réseau neuronal pour la classification des nœuds.

from sklearn import svm, model_selection, metrics 
# 使用支持向量机作为示范的分类器
svm_model = svm.SVC(kernel='rbf', C=1, gamma=0.01)
# 进行交叉验证和分类训练
scores = model_selection.cross_val_score(
    svm_model, cora_embeddings, cora_labels, cv=5)
print(scores.mean())

Grâce au code ci-dessus, nous pouvons obtenir l'expression d'intégration de nœud à 64 dimensions de chaque nœud.

Former les classificateurs

Ensuite, nous spécifierons certains classificateurs et les entraînerons sur l'ensemble de données Cora afin d'effectuer des opérations de classification de nœuds précises basées sur des intégrations.

# 定义函数：可视化Nodes2Vec的结果
def visualize_results(embeddings, labels):
    # 使用t-SNE对数据进行降维并绘图
    tsne = TSNE(n_components=2, verbose=1, perplexity=40, n_iter=300)
    tsne_results = tsne.fit_transform(embeddings)
    plt.figure(figsize=(10, 5))
    plt.scatter(tsne_results[:,0], tsne_results[:,1], c=labels)
    plt.colorbar()
    plt.show()
# 可视化结果
visualize_results(cora_embeddings, cora_labels)

Afin d'obtenir de meilleures performances, lorsque la machine à vecteurs de support est utilisée comme classificateur, nous devons également effectuer des opérations d'ajustement des paramètres associées. Ici, une méthode de validation croisée 5 fois est utilisée pour évaluer ses performances.

Visualisation de l'intégration de nœuds

Pour une meilleure compréhension, nous devons réduire la dimensionnalité de l'expression des caractéristiques à 64 dimensions qui est difficile à comprendre pour les humains afin de réaliser la visualisation. Le t-SNE est une méthode spécialement conçue pour réduire la complexité des données de grande dimension, et nous l'utilisons ici. Il génère un graphique bidimensionnel dans lequel les nœuds similaires sont étroitement regroupés en produisant un vecteur de distribution de probabilité contenant seulement deux éléments.

rrreee

Le vecteur d'intégration généré par Node2Vec sera entré dans t-SNE, où t-SNE réduit la dimensionnalité de l'expression vectorielle à 64 dimensions et génère un nuage de points bidimensionnel que nous pouvons visualiser à l'aide de la bibliothèque matplotlib. Il est possible de vérifier si la plupart des nœuds pertinents sont étroitement regroupés dans l'interface graphique. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!