กราฟเป็นวิธีที่มีประสิทธิภาพในการแสดงข้อมูล โดยสามารถจับภาพความสัมพันธ์ระหว่างเอนทิตีต่างๆ ในแอปพลิเคชันที่หลากหลายได้อย่างเฉพาะเจาะจง ไม่ว่าคุณจะกำลังสร้างแบบจำลองเครือข่ายโซเชียล ปฏิสัมพันธ์ระหว่างโปรตีน ระบบขนส่ง หรือเครื่องมือแนะนำ กราฟก็แสดงและวิเคราะห์ความสัมพันธ์ที่ซับซ้อนเหล่านี้ได้อย่างเป็นธรรมชาติ ในโลกปัจจุบันที่ขับเคลื่อนด้วยข้อมูล การทำความเข้าใจความสัมพันธ์ระหว่างเอนทิตีนั้นมักมีความสำคัญพอๆ กับการทำความเข้าใจเอนทิตีนั้นๆ เอง นี่คือจุดที่กราฟมีความสำคัญอย่างแท้จริง เป็นหนึ่งในงานพื้นฐานในการวิเคราะห์กราฟ ซึ่งเกี่ยวข้องกับการทำนายการเชื่อมต่อ (หรือลิงก์) ระหว่างโหนด (เอนทิตีที่แสดงในกราฟ) ลองนึกภาพการแนะนำเพื่อนใหม่ในเครือข่ายสังคม การทำนายความร่วมมือที่อาจเกิดขึ้นในกราฟการอ้างอิงทางวิชาการ หรือการคาดการณ์การโต้ตอบในอนาคตระหว่างผู้ใช้และผลิตภัณฑ์ในการตั้งค่าอีคอมเมิร์ซ นี่คือตัวอย่างการทำนายลิงก์ในการดำเนินการ งานนี้ช่วยขยายเครือข่าย อนุมานข้อมูลที่ขาดหายไป และตรวจจับความผิดปกติ สำหรับแอปพลิเคชันตั้งแต่การปรับปรุงประสบการณ์ของผู้ใช้ไปจนถึงการปรับปรุงการตรวจจับการฉ้อโกง การทำนายลิงก์เป็นส่วนผสมสำคัญสำหรับความสำเร็จ การทำนายลิงก์ เพื่อแสดงการคาดการณ์ลิงก์ เราจะใช้ จาก Stanford Network Analysis Project (SNAP) ชุดข้อมูลนี้รวบรวมการเชื่อมต่อทางสังคมระหว่างผู้ใช้บนแพลตฟอร์มสตรีมมิ่ง Twitch โดยที่โหนดแสดงถึงผู้ใช้ Twitch และเอจแสดงถึงมิตรภาพระหว่างโหนดเหล่านั้น ชุดข้อมูลมีโครงสร้างที่ดี ทำให้ง่ายต่อการประมวลผลล่วงหน้าและใช้งาน ชุดข้อมูลเครือข่ายสังคม Twitch เมื่อทำตามนี้ คุณจะได้เรียนรู้วิธีการตั้งค่าโครงการ ประมวลผลข้อมูลเบื้องต้น สร้างแบบจำลอง และประเมินผลเพื่อทำนายลิงก์บนชุดข้อมูลในโลกแห่งความเป็นจริง เครือข่ายประสาทกราฟและไลบรารีกราฟเชิงลึก การทำงานกับข้อมูลที่มีโครงสร้างเป็นกราฟนั้นท้าทายไม่ซ้ำใคร และนี่คือที่มาของ GNN เป็นเครือข่ายประสาทชนิดหนึ่งที่ออกแบบมาโดยเฉพาะเพื่อทำงานกับข้อมูลกราฟ ซึ่งแตกต่างจากเครือข่ายประสาทแบบเดิมที่ทำงานบนอินพุตที่มีขนาดคงที่ GNN สามารถจัดการกับขนาดกราฟตามอำเภอใจและใช้ประโยชน์จากรูปแบบการเชื่อมต่อภายในข้อมูลได้ ด้วยการรวบรวมข้อมูลจากเพื่อนบ้านของโหนด GNN จึงเรียนรู้การแสดงที่จับภาพทั้งแอตทริบิวต์ของโหนดและโครงสร้างของกราฟ ทำให้มีประสิทธิภาพสูงสำหรับงานต่างๆ เช่น การจำแนกโหนด การทำนายลิงก์ และการจำแนกกราฟ Graph Neural Networks (GNNs) เป็นชุดเครื่องมืออันทรงพลังสำหรับการสร้าง GNN ได้อย่างง่ายดายและมีประสิทธิภาพ ด้วย DGL นักพัฒนาสามารถใช้ประโยชน์จากสถาปัตยกรรม GNN ที่ทันสมัยเพื่อจัดการกับงานต่างๆ รวมถึงการทำนายลิงก์ DGL นำเสนอยูทิลิตี้ต่างๆ สำหรับการทำงานกับกราฟที่เป็นเนื้อเดียวกันและไม่เป็นเนื้อเดียวกัน ทำให้เป็นเครื่องมืออเนกประสงค์สำหรับนักวิจัยและผู้ปฏิบัติงาน ด้วยการทำให้การนำ GNN ไปใช้ง่ายขึ้น DGL ช่วยให้คุณสามารถมุ่งเน้นไปที่การพัฒนาโซลูชันที่สร้างสรรค์มากขึ้น แทนที่จะจมอยู่กับความซับซ้อนทางเทคนิคพื้นฐาน Deep Graph Library ( ) DGL.ai เมื่อคำนึงถึงรากฐานนี้แล้ว มาสร้างแบบจำลองการทำนายลิงก์โดยใช้ GNN และ กัน DGL.ai การตั้งค่าโครงการ ขั้นตอนแรกคือการตั้งค่าโครงการของเราโดยนำเข้าไลบรารีที่จำเป็น: import json import numpy as np import pandas as pd import dgl from dgl.data import DGLDataset from dgl.nn import SAGEConv import torch import torch.nn as nn from torch.nn.functional import binary_cross_entropy_with_logits, relu, dropout from torch.nn.utils import clip_grad_norm_ from torch.optim.lr_scheduler import ReduceLROnPlateau import itertools import scipy.sparse as sp from sklearn.metrics import roc_auc_score การประมวลผลข้อมูลเบื้องต้นและการแยกระหว่างการฝึกและการทดสอบ ในการเตรียมข้อมูลสำหรับการฝึกอบรม เราจะโหลดชุดข้อมูล Twitch ก่อน จากนั้นแสดงเป็นกราฟ จากนั้นจึงแยกข้อมูลออกเป็นชุดฝึกอบรมและชุดทดสอบ เราจะสร้างคลาสแบบกำหนดเองที่สืบทอดมาจาก ซึ่งจะช่วยกำหนดโครงสร้างกระบวนการโหลดข้อมูลและปรับปรุงการดำเนินการที่เกี่ยวข้องกับกราฟให้มีประสิทธิภาพยิ่งขึ้น DGLDataset : ในฟังก์ชันกระบวนการ เราเริ่มต้นด้วยการอ่านรายการขอบจากชุดข้อมูล เนื่องจากขอบในชุดข้อมูลดั้งเดิมไม่มีทิศทาง (แสดงถึงมิตรภาพซึ่งกันและกัน) เราจึงเพิ่มขอบย้อนกลับเพื่อให้แน่ใจว่าการเชื่อมต่อมีทิศทางสองทางในกราฟของเรา การโหลดข้อมูลกราฟ : ต่อไป เราจะโหลดคุณลักษณะของโหนดจากไฟล์ JSON แต่ละโหนดจะมีรายการคุณลักษณะที่มีความยาวแตกต่างกัน ดังนั้นเราจึงเพิ่มศูนย์ในรายการคุณลักษณะที่สั้นกว่าเพื่อรักษาความยาวที่สม่ำเสมอกันในทุกโหนด การโหลดคุณลักษณะของโหนด นี่คือโค้ดสำหรับสร้างและประมวลผลข้อมูลล่วงหน้า: # create a dataset that inherits DGLDataset class SocialNetworkDataset(DGLDataset): def __init__(self): super().__init__(name='social_network') def process(self): # load edges edges_df = pd.read_csv('./twitch/ENGB/musae_ENGB_edges.csv') # ensure edges are bidirectional edges_df_rev = edges_df.copy() edges_df_rev.columns = ['to', 'from'] edges_df_rev = edges_df_rev[['from', 'to']] edges_df = pd.concat([edges_df, edges_df_rev], ignore_index=True) edges_df.drop_duplicates(inplace=True) # create a graph using DGL max_node_id = max(edges_df['from'].max(), edges_df['to'].max()) edges_src = torch.from_numpy(edges_df['from'].to_numpy()) edges_dst = torch.from_numpy(edges_df['to'].to_numpy()) self.graph = dgl.graph( (edges_src, edges_dst), num_nodes=max_node_id + 1, ) # load and node features with open('./twitch/ENGB/musae_ENGB_features.json') as f: node_features_dict = json.load(f) # feature lists have various lengths, pad them with zeros max_feature_list_len = max([len(l) for l in node_features_dict.values()]) for k in node_features_dict: if len(node_features_dict[k]) < max_feature_list_len: node_features_dict[k] += [0] * (max_feature_list_len - len(node_features_dict[k])) # set node features in graph node_features_df = pd.DataFrame.from_dict(node_features_dict).T.astype('float64') node_features_np = node_features_df.to_numpy() self.graph.ndata['feat'] = torch.from_numpy(node_features_np).float() def __len__(self): return 1 # only the whole graph is returned def __getitem__(self, idx): return self.graph ตอนนี้เรากำลังเริ่มต้นชุดข้อมูลของเราเพื่อโหลดข้อมูลกราฟ # init the dataset dataset = SocialNetworkDataset() g = dataset[0] ขั้นตอนต่อไปคือ เราจะแบ่งขอบออกเป็น สำหรับการฝึกอบรมและการทดสอบ เราสร้างทั้งตัวอย่าง และตัวอย่างเชิงลบ สำหรับทั้งสองชุด สำหรับกราฟขนาดใหญ่ ยูทิลิตี้ ของ DGL อาจเป็นประโยชน์ แต่ในกรณีนี้ กราฟทั้งหมดจะพอดีกับหน่วยความจำ นี่คือโค้ดสำหรับสร้างชุดฝึกอบรมและการทดสอบ: การสร้างชุดฝึกอบรมและการทดสอบ อัตราส่วน 80/20 เชิงบวก (ขอบที่มีอยู่) (ขอบที่ไม่มีอยู่) dgl.sampling # pick edges for train and test sets (80/20 split) # (for larger graphs, we can use dgl.sampling.negative etc) u, v = g.edges() edge_ids = np.random.permutation(g.num_edges()) test_set_size = int(len(edge_ids) * 0.2) train_set_size = len(edge_ids) - test_set_size # positive samples: existing edges test_positive_u, test_positive_v = u[edge_ids[:test_set_size]], v[edge_ids[:test_set_size]] train_positive_u, train_positive_v = u[edge_ids[test_set_size:]], v[edge_ids[test_set_size:]] # negative samples: nonexistent edges adj = sp.coo_matrix((np.ones(len(u)), (u.numpy(), v.numpy()))) adj_negative = 1 - adj.todense() - np.eye(g.num_nodes()) negative_u, negative_v = np.where(adj_negative != 0) negative_edge_ids = np.random.choice(len(negative_u), g.num_edges()) test_negative_u, test_negative_v = ( negative_u[negative_edge_ids[:test_set_size]], negative_v[negative_edge_ids[:test_set_size]], ) train_negative_u, train_negative_v = ( negative_u[negative_edge_ids[test_set_size:]], negative_v[negative_edge_ids[test_set_size:]], ) # create a training graph by copying the original graph and removing test edges train_g = dgl.remove_edges(g, edge_ids[:test_set_size]) # define positive and negative graphs for train and test sets train_positive_g = dgl.graph((train_positive_u, train_positive_v), num_nodes=g.num_nodes()) train_negative_g = dgl.graph((train_negative_u, train_negative_v), num_nodes=g.num_nodes()) test_positive_g = dgl.graph((test_positive_u, test_positive_v), num_nodes=g.num_nodes()) test_negative_g = dgl.graph((test_negative_u, test_negative_v), num_nodes=g.num_nodes()) โมเดล: GraphSAGE Convolutional Layers และ MLP Predictor เราจะใช้เครือข่ายประสาทเทียม เพื่อเรียนรู้การแสดงโหนด ซึ่งเรียกอีกอย่างว่า ซึ่งจะจับทั้งโครงสร้างและคุณสมบัติของแต่ละโหนดภายในกราฟ GraphSAGE ทำงานโดยรวบรวมข้อมูลคุณสมบัติจากเพื่อนบ้านของแต่ละโหนดเพื่อสร้างการแสดงที่มีความหมายสำหรับแต่ละโหนด กระบวนการนี้เรียกว่า ซึ่งช่วยให้โมเดลสามารถเรียนรู้รูปแบบเฉพาะที่หลากหลายในกราฟได้ แบบกราฟตัวอย่างและการรวม (GraphSAGE) การฝังตัว การรวมเพื่อนบ้าน ในแต่ละเลเยอร์ของ GraphSAGE โมเดลจะใช้ เพื่อรวบรวมข้อมูลจากโหนดข้างเคียง จากนั้นจึงรวมเข้ากับฟีเจอร์ของโหนดนั้นเอง การวางซ้อนเลเยอร์ ทำให้โมเดลสามารถ ทำให้มุมมองของโหนดแต่ละโหนดภายในกราฟขยายออกไปอย่างมีประสิทธิภาพ ฟังก์ชันการรวมข้อมูล (ในกรณีนี้คือฟังก์ชัน "ค่าเฉลี่ย") คอนโวลูชั่นหลายเลเยอร์ รวบรวมข้อมูลจากโหนดที่อยู่ห่างไกลออกไปมากขึ้น เพื่อปรับปรุงประสิทธิภาพของโมเดลและลดการติดตั้งเกิน เราจะใช้ หลังจากแต่ละเลเยอร์ การดร็อปเอาต์ ตอนนี้เรามาสร้างโมเดล GraphSAGE ที่มี พร้อมด้วยฟังก์ชัน เพื่อกำหนดว่าข้อมูลจะไหลผ่านเลเยอร์นั้นอย่างไร: เลเยอร์การบิดเบือนสามเลเยอร์ forward # define the GraphSAGE model with 3 convolutional layers class GraphSAGE(nn.Module): def __init__( self, input_features, hidden_features, output_features, dropout_probability=0.3, ): super(GraphSAGE, self).__init__() self.conv_layer_1 = SAGEConv(input_features, hidden_features, "mean") self.conv_layer_2 = SAGEConv(hidden_features, hidden_features, "mean") self.conv_layer_3 = SAGEConv(hidden_features, output_features, "mean") self.dropout_probability = dropout_probability def forward(self, graph, input_features): # first layer with ReLU activation and dropout h = relu(self.conv_layer_1(graph, input_features)) h = dropout(h, p=self.dropout_probability) # second layer with ReLU activation and dropout h = relu(self.conv_layer_2(graph, h)) h = dropout(h, p=self.dropout_probability) # third layer without dropout h = self.conv_layer_3(graph, h) return h ผลลัพธ์หลังจากเลเยอร์ที่สาม ( ) ประกอบด้วยการฝังตัวของโหนด เพื่อทำนายความน่าจะเป็นของขอบ (หรือลิงก์) ระหว่างโหนดสองโหนด เราจะใช้ ที่ระบุความน่าจะเป็นของขอบที่มีอยู่ระหว่างโหนดทั้งสอง h ตัวทำนายมัลติเลเยอร์เพอร์เซพตรอน (MLP) MLP นี้ใช้การฝังตัวของโหนดสองโหนดเป็นอินพุต และคำนวณ คะแนน # define the MLP predictor class MLPPredictor(nn.Module): def __init__(self, hidden_features): super().__init__() # first linear layer to combine node embeddings self.W1 = nn.Linear(hidden_features * 2, hidden_features) # second linear layer to produce a single score output self.W2 = nn.Linear(hidden_features, 1) def apply_edges(self, edges): # concatenate source and destination node embeddings h = torch.cat([edges.src["h"], edges.dst["h"]], dim=1) # pass through MLP layers to get the edge score score = self.W2(relu(self.W1(h))).squeeze(1) return {'score': score} def forward(self, g, h): with g.local_scope(): g.ndata["h"] = h g.apply_edges(self.apply_edges) return g.edata["score"] ทำงานดังต่อไปนี้: ตัวทำนาย MLP ขนาดอินพุตของตัวทำนายจะขึ้นอยู่กับการฝังตัวของโหนดที่เรียนรู้ เนื่องจากแต่ละขอบเชื่อมต่อโหนดสองโหนด (แต่ละโหนดมีขนาดเท่ากับ hidden_features) ส่งผลให้ขนาดอินพุตเท่ากับ hidden_features * 2 ขนาดอินพุต: เราจึงเชื่อมโยงการฝังตัวของโหนดเหล่านั้นเข้าด้วยกัน เลเยอร์นี้ประมวลผลการฝังแบบเชื่อมโยงและ กลับเป็น hidden_features โดยรักษาข้อมูลเชิงสัมพันธ์ที่สำคัญระหว่างโหนดไว้ เลเยอร์ 1 (W1): ลดมิติเอาต์พุต เลเยอร์สุดท้ายนี้สร้าง เดียวสำหรับโหนดแต่ละคู่ ซึ่งแสดงถึง จะมีอยู่ระหว่างโหนดเหล่านั้น เลเยอร์ 2 (W2): คะแนน สเกลาร์ ความน่าจะเป็นที่ขอบ แนวทางแบบแบ่งชั้นนี้ช่วยให้เครื่องทำนายสามารถจับภาพความสัมพันธ์ที่ซับซ้อนระหว่างคู่โหนดและคำนวณคะแนนขอบที่สามารถตีความได้ว่าน่าจะเป็นของการมีอยู่ของขอบนั้น ฟังก์ชั่นการสูญเสียและ AUC เพื่อฝึกโมเดลของเราอย่างมีประสิทธิภาพ เราต้องมีฟังก์ชันการสูญเสียที่สามารถ ในการทำนายลิงก์ได้ เนื่องจากงานนี้เป็น ซึ่งแต่ละลิงก์มีอยู่หรือไม่มี เราจึงใช้ เป็นฟังก์ชันการสูญเสียของเรา Binary cross-entropy วัดความแตกต่างระหว่างคะแนนที่ทำนายของโมเดลกับป้ายกำกับจริง (1 สำหรับลิงก์ที่มีอยู่ 0 สำหรับไม่มีลิงก์) เราใช้เวอร์ชัน เนื่องจากโมเดลของเราแสดงคะแนนดิบ (logits) แทนที่จะเป็นความน่าจะเป็น BCE เวอร์ชันนี้มีเสถียรภาพมากกว่าเมื่อทำงานกับ logits เนื่องจากรวมฟังก์ชัน sigmoid และ cross-entropy ไว้ในขั้นตอนเดียว วัดประสิทธิภาพของโมเดล ปัญหาการจำแนกแบบไบนารี Binary cross-entropy (BCE) _with_logits นี่คือโค้ดที่คำนวณการสูญเสีย: def compute_loss(positive_logits, negative_logits): # concatenate positive and negative scores y_predicted = torch.cat([positive_logits, negative_logits]) # create true labels (1 for existing links, 0 for nonexistent) y_true = torch.cat([torch.ones(positive_logits.shape[0]), torch.zeros(negative_logits.shape[0])]) return binary_cross_entropy_with_logits(y_predicted, y_true) ในการประเมินโมเดล เราใช้เมตริก AUC เหมาะมากสำหรับการคาดการณ์ลิงก์ เนื่องจาก อย่างมีประสิทธิภาพ โดยตัวอย่างเชิงลบ (ขอบที่ไม่มีอยู่) มักเกิดขึ้นบ่อยกว่าตัวอย่างเชิงบวกมาก คะแนน AUC ช่วยให้เราทราบว่าโมเดลจัดอันดับลิงก์ที่มีอยู่สูงกว่าลิงก์ที่ไม่มีอยู่จริงมากเพียงใด พื้นที่ใต้เส้นโค้ง ROC (AUC) สามารถจัดการข้อมูลที่ไม่สมดุลได้ นี่คือโค้ดสำหรับคำนวณ AUC: def compute_auc(positive_logits, negative_logits): y_predicted = torch.cat([positive_logits, negative_logits]).detach().numpy() y_true = torch.cat([torch.ones(positive_logits.shape[0]), torch.zeros(negative_logits.shape[0])]).detach().numpy() return roc_auc_score(y_true, y_predicted) หมายเหตุ: เราใช้ เพื่อลบเทนเซอร์ออกจากกราฟการคำนวณ ช่วยให้เราสามารถคำนวณ AUC ได้โดยไม่ส่งผลกระทบต่อการไล่ระดับ detach() การฝึกอบรมโมเดล ตอนนี้เราพร้อมที่จะฝึกโมเดลแล้ว ในการเริ่มต้น เราจะ เราจะระบุอัตราการเรียนรู้ ขนาดเลเยอร์ที่ซ่อนอยู่ และอัตราการหลุดออกจากระบบ รวมถึงไฮเปอร์พารามิเตอร์อื่นๆ ด้วย แม้ว่า ที่นี่ แต่ เพื่อปรับอัตราการเรียนรู้หากการสูญเสียถึงจุดคงที่ ซึ่งหมายความว่าอัตราการเรียนรู้จะหยุดลดลงเป็นจำนวนยุคที่กำหนด (ในกรณีนี้คือ 25) เมื่อสิ่งนี้เกิดขึ้น ตัวกำหนดตารางจะลดอัตราการเรียนรู้ลงครึ่งหนึ่ง ซึ่งสามารถช่วยให้โมเดลบรรจบกันได้อย่างมีประสิทธิภาพมากขึ้น สร้างอินสแตนซ์โมเดล ตัวทำนาย และตัวเพิ่มประสิทธิภาพ และกำหนดลูปการฝึก เราจะไม่ครอบคลุมการเพิ่มประสิทธิภาพไฮเปอร์พารามิเตอร์ เราจะใช้ตัวกำหนดตารางอัตราการเรียนรู้ นี่คือโค้ดสำหรับการเริ่มต้นโมเดลและตั้งค่าการฝึกอบรม: # init the model num_hidden_features = 32 model = GraphSAGE( train_g.ndata['feat'].shape[1], num_hidden_features, num_hidden_features, ) predictor = MLPPredictor(num_hidden_features) # create an optimizer and a learning rate scheduler learning_rate = 0.01 optimizer = torch.optim.Adam( itertools.chain(model.parameters(), predictor.parameters()), lr=learning_rate, ) lr_scheduler = ReduceLROnPlateau(optimizer, mode='min', factor=0.5, patience=25) # train the model num_epochs = 1000 for epoch in range(num_epochs + 1): # forward h = model(train_g, train_g.ndata['feat']) positive_logits = predictor(train_positive_g, h) negative_logits = predictor(train_negative_g, h) loss = compute_loss(positive_logits, negative_logits) # backward optimizer.zero_grad() loss.backward() # clip gradients clip_grad_norm_(model.parameters(), 1.0) optimizer.step() # adjust learning rate based on the loss lr_scheduler.step(loss) # print loss, current learning rate, and AUC if epoch % 100 == 0: last_lr = lr_scheduler.get_last_lr()[0] train_auc = compute_auc(positive_logits, negative_logits) print(f'Epoch: {epoch}, learning rate: {last_lr}, loss: {loss}, AUC: {train_auc}') มาลองรันโค้ดและตรวจสอบผลลัพธ์กัน: Epoch: 0, learning rate: 0.01, loss: 262.4156188964844, AUC: 0.4934097124994463 Epoch: 100, learning rate: 0.01, loss: 0.5642552375793457, AUC: 0.7473735298706314 Epoch: 200, learning rate: 0.01, loss: 0.4622882306575775, AUC: 0.8431058751115716 Epoch: 300, learning rate: 0.01, loss: 0.40566185116767883, AUC: 0.8777374138645864 Epoch: 400, learning rate: 0.01, loss: 0.38118976354599, AUC: 0.8944719038039551 Epoch: 500, learning rate: 0.01, loss: 0.3690297603607178, AUC: 0.9039401673234729 Epoch: 600, learning rate: 0.005, loss: 0.3579995930194855, AUC: 0.9112366798940639 Epoch: 700, learning rate: 0.005, loss: 0.3557407557964325, AUC: 0.9128097572016495 Epoch: 800, learning rate: 0.005, loss: 0.3510144352912903, AUC: 0.9152937255697913 Epoch: 900, learning rate: 0.00125, loss: 0.3425179123878479, AUC: 0.9202487786553115 Epoch: 1000, learning rate: 0.00015625, loss: 0.3432360589504242, AUC: 0.9198250134354529 ดังที่เราเห็น โมเดลนี้บรรลุ สังเกตว่าอัตราการเรียนรู้จะลดลงระหว่างยุค 500 ถึง 600 เมื่อการสูญเสียคงที่ การปรับเปลี่ยนนี้ช่วยให้ปรับแต่งได้ละเอียดขึ้น ส่งผลให้การสูญเสียลดลงเล็กน้อย หลังจากจุดหนึ่ง การสูญเสียและ AUC จะคงที่ ซึ่งบ่งชี้ว่าโมเดลได้ AUC ประมาณ 0.92 ซึ่งบ่งชี้ถึงประสิทธิภาพการทำนายที่แข็งแกร่ง บรรจบกันแล้ว มา (ซึ่งไม่ได้ใช้ระหว่างการฝึก) และดูว่าสามารถสรุปผลได้ดีหรือไม่: ประเมินโมเดลจากข้อมูลทดสอบ # evaluate the model on the test data with torch.no_grad(): test_positive_scores = predictor(test_positive_g, h) test_negative_scores = predictor(test_negative_g, h) test_loss = compute_loss(test_positive_scores, test_negative_scores) test_auc = compute_auc(test_positive_scores, test_negative_scores) print(f'Test loss: {test_loss}, Test AUC: {test_auc}') ผลลัพธ์ที่ได้คือ: Test loss: 0.675215482711792, Test AUC: 0.866213400711374 การปรับไฮเปอร์พารามิเตอร์เพิ่มเติมอาจช่วยปรับปรุงการสรุปทั่วไปได้ โดยเฉพาะอย่างยิ่งหากการโอเวอร์ฟิตติ้งเป็นปัญหา ค่า AUC ของการทดสอบนั้นต่ำกว่าค่า AUC ของการฝึกเล็กน้อย ซึ่งบ่งชี้ถึงการโอเวอร์ฟิตติ้งเล็กน้อย อย่างไรก็ตาม ค่า AUC ที่ 0.866 แสดงให้เห็นว่าแบบจำลองยังคงทำงานได้ดีกับข้อมูลที่มองไม่เห็น การใช้โมเดลที่ผ่านการฝึกอบรมเพื่อคาดการณ์ลิงก์ใหม่ ด้วยโมเดลที่ผ่านการฝึกอบรมของเรา ระหว่างโหนดในกราฟได้แล้ว เราจะสร้าง ซึ่งช่วยให้เราสามารถระบุการเชื่อมต่อใหม่ที่อาจเกิดขึ้นได้ ตอนนี้เราสามารถคาดการณ์ความน่าจะเป็นของการเชื่อมโยง การคาดการณ์สำหรับคู่โหนดที่เป็นไปได้ทั้งหมด : ก่อนอื่น เราจะสร้างคู่โหนดที่เป็นไปได้ทั้งหมด ยกเว้นการเชื่อมต่อแบบ self-loop (การเชื่อมต่อจากโหนดไปยังโหนดเอง) ซึ่งจะทำให้เราได้คู่โหนดตัวเลือกซึ่งเราต้องการทำนายความน่าจะเป็นของลิงก์ การสร้างคู่โหนดตัวเลือก จากนั้นเราจะสร้างกราฟ DGL ที่มีขอบผู้สมัครเหล่านี้ และใช้โมเดลที่มีการฝังโหนดจากกราฟต้นฉบับ การฝังเหล่านี้ซึ่งจัดเก็บในแอตทริบิวต์ ของกราฟผู้สมัคร จะทำหน้าที่เป็นอินพุตสำหรับการทำนายลิงก์ การสร้างกราฟผู้สมัคร: ndata['h'] นี่คือโค้ดสำหรับขั้นตอนเหล่านี้: # build node pairs, avoid self-loops (with_replacement=False) node_pairs = torch.combinations(torch.arange(g.num_nodes()), r=2, with_replacement=False) candidate_u = node_pairs[:, 0] candidate_v = node_pairs[:, 1] # build a graph with all node pairs candidate_graph = dgl.graph((candidate_u, candidate_v)) candidate_graph_node_embeddings = model(g, g.ndata['feat']) # we use embeddings from the original graph candidate_graph.ndata['h'] = candidate_graph_node_embeddings # use the predictor to predict the existence of links between nodes predicted_scores = predictor(candidate_graph, candidate_graph_node_embeddings) ตอนนี้ ได้ ตัวอย่างเช่น ลองตรวจสอบคะแนนและความน่าจะเป็นของการเชื่อมโยงระหว่างโหนด 1773 และ 7005 ซึ่งไม่ได้เชื่อมต่อโดยตรงในชุดข้อมูลเริ่มต้น: เรามีการคาดการณ์สำหรับคู่ผู้สมัครทั้งหมดแล้ว เราสามารถตรวจสอบความน่าจะเป็นของการเชื่อมโยงระหว่างโหนดเฉพาะใดๆ # find the index of the node pair (1773, 7005) pair_index = torch.where((candidate_u == 1773) & (candidate_v == 7005))[0] print(f'Pair index: {pair_index}') # get the logit score for this pair and compute probability of link existence pair_link_score = predicted_scores[pair_index].item() # logit score print(f'Pair link score: {pair_link_score}') link_probability = torch.sigmoid(torch.tensor(pair_link_score)).item() # apply sigmoid to convert score into probability print(f'Link probability: {link_probability * 100}%') ผลลัพธ์ที่ได้คือ: Pair index: tensor([11066978]) Pair link score: 0.7675977945327759 Link probability: 68.30010414123535% ตามแบบจำลองของเรา มี ความน่าจะเป็น 68.3% ที่จะมีลิงก์ระหว่างผู้ใช้ 1773 และ 7005 บทสรุป ในโพสต์นี้ โดยสาธิตการใช้ Graph Neural Networks และ DGL สำหรับทำนายลิงก์ อย่างไรก็ตาม เนื่องจากกราฟขยายขนาดเป็นโหนดและขอบจำนวนล้านหรือพันล้านโหนด การจัดการกับโหนดและขอบเหล่านี้จึงต้องใช้โซลูชันขั้นสูง เช่น การฝึกอบรมแบบกระจายบนคลัสเตอร์ GPU เราได้สร้างแบบจำลองสำหรับทำนายลิงก์ใหม่ในกราฟโซเชียลสำเร็จแล้ว การใช้ชุดข้อมูลที่ค่อนข้างเล็กทำให้เราทำงานบนเครื่องภายในได้อย่างมีประสิทธิภาพ ในขั้นตอนถัดไป เราจะสำรวจแนวทางในการจัดการกราฟขนาดใหญ่และการนำการคาดการณ์ลิงก์ไปใช้ในสภาพแวดล้อมคลาวด์ ซึ่งทำให้คุณสามารถประยุกต์ใช้เทคนิคเหล่านี้กับชุดข้อมูลระดับการผลิตได้
