ग्राफ न्यूरल नेटवर्क्स (GNNs) का व्यापक परिचय

ग्राफ क्या है?

ग्राफ एक प्रकार की डेटा संरचना है जिसमें नोड्स और एजेज होते हैं। एक नोड व्यक्ति, स्थान या वस्तु हो सकता है, और एजेज नोड्स के बीच संबंध परिभाषित करते हैं। दिशा-निर्भरता के आधार पर एजेज निर्देशित या अनिर्देशित हो सकते हैं। 

नीचे दिए गए उदाहरण में, नीले वृत्त नोड्स हैं और तीर एजेज हैं। एजेज की दिशा दो नोड्स के बीच निर्भरता को परिभाषित करती है। 

चित्र: लेखक द्वारा 

आइए एक जटिल ग्राफ डेटासेट के बारे में जानें: Jazz Musicians Network। इसमें 198 नोड्स और 2742 एजेज हैं। नीचे दिए गए कम्युनिटी ग्राफ प्लॉट में, नोड्स के अलग-अलग रंग जैज़ संगीतकारों के विभिन्न समुदायों और उन्हें जोड़ने वाले एजेज का प्रतिनिधित्व करते हैं। सहयोग का एक जाल है जिसमें एक ही संगीतकार के समुदाय के भीतर और बाहर संबंध होते हैं। 

 कम्युनिटी ग्राफ प्लॉट: Jazz Musicians Network

रिश्तों और इंटरेक्शंस से जुड़े जटिल समस्याओं को हल करने में ग्राफ उत्कृष्ट हैं। इनका उपयोग पैटर्न पहचान, सोशल नेटवर्क विश्लेषण, रिकमेंडेशन सिस्टम और सेमांटिक विश्लेषण में किया जाता है। ग्राफ-आधारित समाधान बनाना एक ऐसा क्षेत्र है जो जटिल और परस्पर जुड़े डेटासेट्स पर समृद्ध अंतर्दृष्टि प्रदान करता है।

NetworkX के साथ ग्राफ

इस खंड में, हम NetworkX का उपयोग करके ग्राफ बनाना सीखेंगे। 

नीचे दिया गया कोड Daniel Holmberg के Python में ग्राफ न्यूरल नेटवर्क्स पर लिखे ब्लॉग से प्रेरित है।

1. networkx का DiGraph ऑब्जेक्ट “H” बनाएं
2. अलग-अलग लेबल, रंग और आकार वाले नोड्स जोड़ें
3. दो नोड्स के बीच संबंध बनाने के लिए एजेज जोड़ें। उदाहरण के लिए, “(0,1)” का अर्थ है कि 0 की दिशा-निर्भरता 1 पर है। हम “(1,0)” जोड़कर द्विदिश संबंध बनाएंगे
4. रंगों और आकारों को सूचियों के रूप में निकालें
5. networkx के draw फ़ंक्शन का उपयोग करके ग्राफ प्लॉट करें

import networkx as nx
H = nx.DiGraph()

#adding nodes
H.add_nodes_from([
  (0, {"color": "blue", "size": 250}),

  (1, {"color": "yellow", "size": 400}),

  (2, {"color": "orange", "size": 150}),

  (3, {"color": "red", "size": 600})


])

#adding edges
H.add_edges_from([
  (0, 1),

  (1, 2),

  (1, 0),

  (1, 3),

  (2, 3),

  (3,0)


])

node_colors = nx.get_node_attributes(H, "color").values()
colors = list(node_colors)
node_sizes = nx.get_node_attributes(H, "size").values()
sizes = list(node_sizes)

#Plotting Graph
nx.draw(H, with_labels=True, node_color=colors, node_size=sizes)

अगले चरण में, हम to_undirected() फ़ंक्शन का उपयोग करके डेटा संरचना को निर्देशित से अनिर्देशित ग्राफ में बदलेंगे। 

#converting to undirected graph
G = H.to_undirected()
nx.draw(G, with_labels=True, node_color=colors, node_size=sizes)

ग्राफ का विश्लेषण करना कठिन क्यों है?

ग्राफ-आधारित डेटा संरचनाओं में कुछ कमियाँ होती हैं, और ग्राफ-आधारित समाधान विकसित करने से पहले डेटा वैज्ञानिकों को इन्हें समझना चाहिए।

1. ग्राफ नॉन-यूक्लिडियन स्पेस में मौजूद होते हैं। वे 2D या 3D स्पेस में नहीं होते, जिससे डेटा की व्याख्या करना कठिन हो जाता है। 2D स्पेस में संरचना को विज़ुअलाइज़ करने के लिए आपको विभिन्न डायमेंशनलिटी रिडक्शन टूल्स का उपयोग करना होगा।
2. ग्राफ गतिशील होते हैं; उनका कोई निश्चित रूप नहीं होता। दो ग्राफ दृश्य रूप से अलग हो सकते हैं, लेकिन उनका adjacency मैट्रिक्स प्रतिनिधित्व समान हो सकता है। इससे पारंपरिक सांख्यिकीय टूल्स से डेटा का विश्लेषण करना कठिन हो जाता है। 
3. आकार और आयाम बढ़ने से मानव व्याख्या के लिए ग्राफ की जटिलता बढ़ जाती है। कई नोड्स और हजारों एजेज वाली सघन संरचना को समझना और अंतर्दृष्टि निकालना कठिन है। 

ग्राफ न्यूरल नेटवर्क (GNN) क्या है?

ग्राफ न्यूरल नेटवर्क्स ऐसे विशेष प्रकार के न्यूरल नेटवर्क हैं जो ग्राफ डेटा संरचना के साथ काम करने में सक्षम होते हैं। ये Convolutional Neural Networks (CNNs) और ग्राफ एम्बेडिंग से काफी प्रभावित हैं। GNNs का उपयोग नोड्स, एजेज और ग्राफ-आधारित कार्यों की भविष्यवाणी में होता है। 

• CNNs इमेज वर्गीकरण के लिए उपयोग किए जाते हैं। उसी तरह, GNNs को ग्राफ संरचना (पिक्सल की ग्रिड) पर किसी क्लास की भविष्यवाणी के लिए लागू किया जाता है। 
• Recurrent Neural Networks टेक्स्ट वर्गीकरण में उपयोग किए जाते हैं। उसी तरह, GNNs को उन ग्राफ संरचनाओं पर लागू किया जाता है जहाँ किसी वाक्य में हर शब्द एक नोड होता है।  

GNNs का परिचय तब हुआ जब Convolutional Neural Networks ग्राफ के मनमाने आकार और जटिल संरचना के कारण इष्टतम परिणाम प्राप्त करने में विफल रहे। 

चित्र: Purvanshi Mehta

इनपुट ग्राफ को न्यूरल नेटवर्क्स की एक श्रृंखला से पास किया जाता है। इनपुट ग्राफ संरचना को ग्राफ एम्बेडिंग में बदला जाता है, जिससे नोड्स, एजेज और ग्लोबल संदर्भ की जानकारी संरक्षित रहती है। 

फिर नोड्स A और C के फीचर वेक्टर को न्यूरल नेटवर्क लेयर से पास किया जाता है। यह इन विशेषताओं को एकत्रित करता है और उन्हें अगली परत—neptune.ai—को पास करता है।

हमारा Deep Learning ट्यूटोरियल पढ़ें या हमारा Introduction to Deep Learning कोर्स लें ताकि डीप लर्निंग एल्गोरिदम और अनुप्रयोगों के बारे में और जान सकें। 

ग्राफ न्यूरल नेटवर्क्स के प्रकार

कई प्रकार के न्यूरल नेटवर्क होते हैं, और उनमें से अधिकांश में Convolutional Neural Networks का कोई न कोई रूपांतर होता है। इस खंड में, हम सबसे लोकप्रिय GNNs के बारे में जानेंगे। 

• Graph Convolutional Networks (GCNs) पारंपरिक CNNs के समान होते हैं। यह पड़ोसी नोड्स का निरीक्षण करके फीचर्स सीखता है। GNNs नोड वेक्टर्स को एग्रीगेट करते हैं, परिणाम को डेंस लेयर में पास करते हैं और एक्टिवेशन फ़ंक्शन का उपयोग करके नॉन-लाइनियरिटी लागू करते हैं। संक्षेप में, इसमें ग्राफ कन्वोल्यूशन, लीनियर लेयर और नॉन-लीनियर एक्टिवेशन फ़ंक्शन शामिल होते हैं। GCNs के दो मुख्य प्रकार हैं: स्पैशियल कन्वोल्यूशनल नेटवर्क्स और स्पेक्ट्रल कन्वोल्यूशनल नेटवर्क्स।
• Graph Auto-Encoder Networks एक एन्कोडर का उपयोग करके ग्राफ प्रतिनिधित्व सीखते हैं और एक डिकोडर का उपयोग करके इनपुट ग्राफ्स का पुनर्निर्माण करने का प्रयास करते हैं। एन्कोडर और डिकोडर एक बॉटलनेक लेयर द्वारा जुड़े होते हैं। लिंक प्रिडिक्शन में इनका अक्सर उपयोग होता है क्योंकि ऑटो-एन्कोडर्स क्लास बैलेंस से निपटने में अच्छे होते हैं। 
• Recurrent Graph Neural Networks (RGNNs) सर्वोत्तम प्रसार पैटर्न सीखते हैं और मल्टी-रिलेशनल ग्राफ्स को संभाल सकते हैं जहाँ एक ही नोड के कई संबंध होते हैं। इस प्रकार के ग्राफ न्यूरल नेटवर्क स्मूदनेस बढ़ाने और ओवर-पैरामीटराइज़ेशन को हटाने के लिए रेग्युलराइज़र्स का उपयोग करते हैं। RGNNs कम कंप्यूटेशन पावर में बेहतर परिणाम देते हैं। इनका उपयोग टेक्स्ट जनरेशन, मशीन अनुवाद, स्पीच रिकग्निशन, इमेज विवरण जनरेशन, वीडियो टैगिंग और टेक्स्ट सार-संक्षेप में किया जाता है।
• Gated Graph Neural Networks (GGNNs) लंबी-अवधि निर्भरताओं वाले कार्यों में RGNNs से बेहतर हैं। Gated Graph Neural Networks, Recurrent Graph Neural Networks में नोड, एज और समय के गेट्स जोड़कर सुधार करते हैं। Gated Recurrent Units (GRUs) की तरह, ये गेट्स अलग-अलग अवस्थाओं में सूचना को याद रखने और भूलने के लिए उपयोग किए जाते हैं। 

यदि आप Recurrent Neural Networks (RNNs) में रुचि रखते हैं, तो हमारा कोर्स देखें। यह आपको विभिन्न RNN मॉडल आर्किटेक्चर, Keras फ्रेमवर्क्स और RNN अनुप्रयोगों से परिचित कराएगा। 

ग्राफ न्यूरल नेटवर्क्स के कार्यों के प्रकार

नीचे हमने उदाहरणों के साथ कुछ GNN कार्यों के प्रकार रेखांकित किए हैं:

• ग्राफ क्लासिफिकेशन: इसका उपयोग ग्राफ्स को विभिन्न श्रेणियों में वर्गीकृत करने के लिए किया जाता है। इसके अनुप्रयोग सोशल नेटवर्क विश्लेषण और टेक्स्ट क्लासिफिकेशन हैं। 
• नोड क्लासिफिकेशन: इस कार्य में किसी ग्राफ में गायब नोड लेबल्स की भविष्यवाणी के लिए पड़ोसी नोड लेबल्स का उपयोग किया जाता है। 
• लिंक प्रिडिक्शन: एक अपूर्ण adjacency मैट्रिक्स वाले ग्राफ में नोड्स की एक जोड़ी के बीच लिंक की भविष्यवाणी करता है। इसे आमतौर पर सोशल नेटवर्क्स में उपयोग किया जाता है। 
• कम्युनिटी डिटेक्शन: एज संरचना के आधार पर नोड्स को विभिन्न क्लस्टर्स में विभाजित करता है। यह एज वेट्स, दूरी और ग्राफ ऑब्जेक्ट्स से समान रूप से सीखता है। 
• ग्राफ एम्बेडिंग: ग्राफ्स को वेक्टर्स में मैप करता है, नोड्स, एजेज और संरचना पर प्रासंगिक जानकारी को संरक्षित रखते हुए।
• ग्राफ जनरेशन: सैंपल ग्राफ वितरण से सीखकर एक नया लेकिन समान ग्राफ संरचना उत्पन्न करता है। 

चित्र: लेखक द्वारा

ग्राफ न्यूरल नेटवर्क्स की कमियाँ

GNNs के उपयोग में कुछ कमियाँ हैं। इन्हें समझना हमें यह तय करने में मदद करेगा कि GNNs का उपयोग कब करें और हमारे मशीन लर्निंग मॉडलों के प्रदर्शन को कैसे अनुकूलित करें। 

1. अधिकांश न्यूरल नेटवर्क बेहतर प्रदर्शन पाने के लिए गहरे हो सकते हैं, जबकि GNNs उथले नेटवर्क होते हैं, जिनमें प्रायः तीन लेयर्स होती हैं। यह हमें बड़े डेटासेट्स पर अत्याधुनिक प्रदर्शन हासिल करने से सीमित करता है।
2. ग्राफ संरचनाएँ लगातार बदलती रहती हैं, जिससे उन पर मॉडल को प्रशिक्षित करना कठिन हो जाता है। 
3. मॉडल को प्रोडक्शन में परिनियोजित करना स्केलेबिलिटी समस्याओं का सामना करता है क्योंकि ये नेटवर्क कम्प्यूटेशनली महंगे होते हैं। यदि आपके पास एक बड़ा और जटिल ग्राफ स्ट्रक्चर है, तो प्रोडक्शन में GNNs को स्केल करना कठिन होगा। 

ग्राफ कन्वोल्यूशनल नेटवर्क (GCN) क्या है?

अधिकांश GNNs, ग्राफ कन्वोल्यूशनल नेटवर्क्स होते हैं, और नोड क्लासिफिकेशन ट्यूटोरियल में जाने से पहले इनके बारे में सीखना महत्वपूर्ण है।  

GCN में कन्वोल्यूशन वही है जो कन्वोल्यूशनल न्यूरल नेटवर्क्स में होता है। यह न्यूरॉन्स को वेट्स (फ़िल्टर्स) से गुणा करके डेटा फीचर्स से सीखता है। 

यह पूरी इमेज पर स्लाइडिंग विंडोज की तरह कार्य करता है ताकि पड़ोसी सेल्स से फीचर्स सीखे। फ़िल्टर वेट शेयरिंग का उपयोग करके इमेज रिकग्निशन सिस्टम्स में विभिन्न चेहरे की विशेषताओं को सीखता है — Towards Data Science। 

अब वही कार्यक्षमता ग्राफ कन्वोल्यूशनल नेटवर्क्स पर लागू करें, जहाँ मॉडल पड़ोसी नोड्स से फीचर्स सीखता है। GCN और CNN के बीच मुख्य अंतर यह है कि GCN नॉन-यूक्लिडियन डेटा संरचनाओं पर काम करने के लिए विकसित किया गया है, जहाँ नोड्स और एजेज का क्रम बदल सकता है। 

CNN बनाम GCN | इमेज स्रोत

TensorFlow के साथ Convolutional Neural Networks (CNN) ट्यूटोरियल का अनुसरण करके बुनियादी CNNs के बारे में और जानें। 

GCNs के दो प्रकार हैं: 

• स्पैशियल ग्राफ कन्वोल्यूशनल नेटवर्क्स उन ग्राफ्स से सीखने के लिए स्पैशियल फीचर्स का उपयोग करते हैं जो स्पैशियल स्पेस में स्थित होते हैं।  
• स्पेक्ट्रल ग्राफ कन्वोल्यूशनल नेटवर्क्स नोड्स के साथ सूचना के प्रसार के लिए ग्राफ लैप्लासियन मैट्रिक्स के Eigen-decomposition का उपयोग करते हैं। ये नेटवर्क सिग्नल्स और सिस्टम्स में वेव प्रोपेगेशन से प्रेरित हैं। 

GNNs कैसे काम करते हैं? Pytorch के साथ ग्राफ न्यूरल नेटवर्क बनाना

हम नोड क्लासिफिकेशन मॉडल के लिए स्पेक्ट्रल ग्राफ कन्वोल्यूशन का निर्माण और प्रशिक्षण करेंगे। कोड स्रोत इस DataLab वर्कबुक में उपलब्ध है ताकि आप अपना पहला ग्राफ-आधारित मशीन लर्निंग मॉडल चला सकें और अनुभव कर सकें। 

कोडिंग उदाहरण Pytorch geometric डॉक्यूमेंटेशन से प्रेरित हैं। 

शुरू करना

हम Pytorch पैकेज इंस्टॉल करेंगे क्योंकि pytorch_geometric उस पर आधारित है। 

!pip install -q torch

फिर हम torch के संस्करण का उपयोग करके torch-scatter और torch-sparse इंस्टॉल करेंगे। उसके बाद, हम GitHub से pytorch_geometric का नवीनतम रिलीज़ इंस्टॉल करेंगे। 

%%capture
import os
import torch
os.environ['TORCH'] = torch.__version__
os.environ['PYTHONWARNINGS'] = "ignore"
!pip install torch-scatter -f https://data.pyg.org/whl/torch-${TORCH}.html
!pip install torch-sparse -f https://data.pyg.org/whl/torch-${TORCH}.html
!pip install git+https://github.com/pyg-team/pytorch_geometric.git

Planetoid Cora डेटासेट

Planetoid एक उद्धरण नेटवर्क डेटासेट है जो Cora, CiteSeer और PubMed से आता है। नोड्स 1433-डायमेंशनल बैग-ऑफ-वर्ड्स फीचर वेक्टर्स वाले डॉक्यूमेंट्स हैं, और एजेज शोध पत्रों के बीच उद्धरण लिंक हैं। 7 क्लासेस हैं, और हम मॉडल को गायब लेबल्स की भविष्यवाणी करने के लिए प्रशिक्षित करेंगे। 

हम Planetoid Cora डेटासेट को इन्गेस्ट करेंगे और बैग-ऑफ-वर्ड्स इनपुट फीचर्स को पंक्ति-सामान्यीकृत करेंगे। उसके बाद हम डेटासेट और पहले ग्राफ ऑब्जेक्ट का विश्लेषण करेंगे। 

from torch_geometric.datasets import Planetoid
from torch_geometric.transforms import NormalizeFeatures

dataset = Planetoid(root='data/Planetoid', name='Cora', transform=NormalizeFeatures())

print(f'Dataset: {dataset}:')
print('======================')
print(f'Number of graphs: {len(dataset)}')
print(f'Number of features: {dataset.num_features}')
print(f'Number of classes: {dataset.num_classes}')

data = dataset[0]  # Get the first graph object.
print(data)

Cora डेटासेट में 2708 नोड्स, 10,556 एजेज, 1433 फीचर्स, और 7 क्लासेस हैं। पहले ऑब्जेक्ट में 2708 ट्रेन, वैलिडेशन और टेस्ट मास्क हैं। हम मॉडल को प्रशिक्षित और मूल्यांकित करने के लिए इन मास्क्स का उपयोग करेंगे। 

Dataset: Cora():
======================
Number of graphs: 1
Number of features: 1433
Number of classes: 7
Data(x=[2708, 1433], edge_index=[2, 10556], y=[2708], train_mask=[2708], val_mask=[2708], test_mask=[2708])

GNN के साथ नोड क्लासिफिकेशन

हम एक GCN मॉडल संरचना बनाएंगे जिसमें दो GCNConv लेयर्स, relu एक्टिवेशन और 0.5 का ड्रॉपआउट रेट होगा। मॉडल में 16 हिडन चैनल्स होंगे।  

GCN लेयर:

ऊपर के समीकरण में W(ℓ+1) एक ट्रेन करने योग्य वेट मैट्रिक्स है और Cw,v प्रत्येक एज के लिए एक फिक्स्ड नॉर्मलाइज़ेशन गुणांक को दर्शाता है।

from torch_geometric.nn import GCNConv
import torch.nn.functional as F

class GCN(torch.nn.Module):
    def __init__(self, hidden_channels):
        super().__init__()
        torch.manual_seed(1234567)
        self.conv1 = GCNConv(dataset.num_features, hidden_channels)
        self.conv2 = GCNConv(hidden_channels, dataset.num_classes)

    def forward(self, x, edge_index):
        x = self.conv1(x, edge_index)
        x = x.relu()
        x = F.dropout(x, p=0.5, training=self.training)
        x = self.conv2(x, edge_index)
        return x

model = GCN(hidden_channels=16)
print(model)

>>> GCN(
    (conv1): GCNConv(1433, 16)
    (conv2): GCNConv(16, 7)
  )

अनट्रेंड GCN नेटवर्क का विज़ुअलाइज़ेशन

आइए sklearn.manifold.TSNE और matplotlib.pyplot का उपयोग करके अनट्रेंड GCN नेटवर्क्स के नोड एम्बेडिंग्स को विज़ुअलाइज़ करें। यह 7-डायमेंशनल नोड एम्बेडिंग को 2D स्कैटर प्लॉट में प्लॉट करेगा।  

%matplotlib inline
import matplotlib.pyplot as plt
from sklearn.manifold import TSNE

def visualize(h, color):
    z = TSNE(n_components=2).fit_transform(h.detach().cpu().numpy())

    plt.figure(figsize=(10,10))
    plt.xticks([])
    plt.yticks([])

    plt.scatter(z[:, 0], z[:, 1], s=70, c=color, cmap="Set2")
    plt.show()

हम मॉडल का मूल्यांकन करेंगे, फिर विभिन्न नोड्स और श्रेणियों को विज़ुअलाइज़ करने के लिए अनट्रेंड मॉडल में प्रशिक्षण डेटा जोड़ेंगे। 

model.eval()

out = model(data.x, data.edge_index)
visualize(out, color=data.y)

GNN का प्रशिक्षण

हम अपने मॉडल को 100 epochs पर Adam ऑप्टिमाइज़ेशन और Cross-Entropy Loss फ़ंक्शन का उपयोग करके प्रशिक्षित करेंगे। 

train फ़ंक्शन में, हम:

1. ग्रेडिएंट साफ़ करते हैं
2. एक सिंगल फॉरवर्ड पास करते हैं
3. ट्रेनिंग नोड्स का उपयोग करके loss की गणना करते हैं
4. ग्रेडिएंट की गणना कर पैरामीटर्स अपडेट करते हैं

test फ़ंक्शन में, हम:

1. नोड क्लास की भविष्यवाणी करते हैं
2. सबसे अधिक प्रायिकता वाले क्लास लेबल को निकालते हैं
3. देखते हैं कि कितने मान सही भविष्यवाणी हुए
4. कुल नोड्स की संख्या से विभाजित सही भविष्यवाणियों के योग का उपयोग करके एक्यूरेसी अनुपात बनाते हैं। 

model = GCN(hidden_channels=16)
optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)
criterion = torch.nn.CrossEntropyLoss()

def train():
      model.train()
      optimizer.zero_grad()
      out = model(data.x, data.edge_index)
      loss = criterion(out[data.train_mask], data.y[data.train_mask])
      loss.backward()
      optimizer.step()
      return loss

def test():
      model.eval()
      out = model(data.x, data.edge_index)
      pred = out.argmax(dim=1)
      test_correct = pred[data.test_mask] == data.y[data.test_mask]
      test_acc = int(test_correct.sum()) / int(data.test_mask.sum())
      return test_acc


for epoch in range(1, 101):
    loss = train()
    print(f'Epoch: {epoch:03d}, Loss: {loss:.4f}')
GAT(
  (conv1): GATConv(1433, 8, heads=8)
  (conv2): GATConv(64, 7, heads=8)
)

.. .. .. ..
.. .. .. ..
Epoch: 098, Loss: 0.5989
Epoch: 099, Loss: 0.6021
Epoch: 100, Loss: 0.5799

मॉडल मूल्यांकन

अब हम test फ़ंक्शन का उपयोग करके अनदेखे डेटासेट पर मॉडल का मूल्यांकन करेंगे, और जैसा कि आप देख सकते हैं, हमें 81.5% एक्यूरेसी पर काफ़ी अच्छे परिणाम मिले हैं।  

test_acc = test()
print(f'Test Accuracy: {test_acc:.4f}')


>>> Test Accuracy: 0.8150

अब हम प्रशिक्षित मॉडल के आउटपुट एम्बेडिंग को विज़ुअलाइज़ करेंगे ताकि परिणामों की पुष्टि हो सके।

model.eval()
out = model(data.x, data.edge_index)
visualize(out, color=data.y)

जैसा कि हम देख सकते हैं, प्रशिक्षित मॉडल ने उसी श्रेणी के लिए नोड्स का बेहतर क्लस्टरिंग उत्पन्न किया है।

GATConv मॉडल का प्रशिक्षण

दूसरे चरण में, हम GCNConv को GATConv लेयर्स से बदलेंगे। Graph Attention Networks ने GCNConv की कमियों को दूर करने और अत्याधुनिक परिणाम प्राप्त करने के लिए मास्क्ड सेल्फ-अटेंशनल लेयर्स का उपयोग किया है। 

आप अन्य GNN लेयर्स भी आज़मा सकते हैं और बेहतर प्रदर्शन के लिए ऑप्टिमाइज़ेशन, ड्रॉपआउट्स और हिडन चैनल्स की संख्या के साथ प्रयोग कर सकते हैं। 

नीचे दिए गए कोड में, हमने पहले लेयर में 8 attention heads और दूसरी लेयर में 1 head के साथ केवल GCNConv को GATConv से बदल दिया है। 

हम यह भी सेट करेंगे:

• ड्रॉपआउट रेट 0.6
• हिडन चैनल्स 8
• लर्निंग रेट 0.005

हमने test फ़ंक्शन में संशोधन किया है ताकि किसी विशिष्ट मास्क (valid, test) की एक्यूरेसी निकाली जा सके। इससे हमें मॉडल प्रशिक्षण के दौरान वैलिडेशन और टेस्ट स्कोर प्रिंट करने में मदद मिलती है। हम बाद में लाइन चार्ट प्लॉट करने के लिए वैलिडेशन और टेस्ट परिणामों को भी स्टोर कर रहे हैं। 

from torch_geometric.nn import GATConv

class GAT(torch.nn.Module):
    def __init__(self, hidden_channels, heads):
        super().__init__()
        torch.manual_seed(1234567)
        self.conv1 = GATConv(dataset.num_features, hidden_channels,heads)
        self.conv2 = GATConv(heads*hidden_channels, dataset.num_classes,heads)

    def forward(self, x, edge_index):
        x = F.dropout(x, p=0.6, training=self.training)
        x = self.conv1(x, edge_index)
        x = F.elu(x)
        x = F.dropout(x, p=0.6, training=self.training)
        x = self.conv2(x, edge_index)
        return x

model = GAT(hidden_channels=8, heads=8)
print(model)

optimizer = torch.optim.Adam(model.parameters(), lr=0.005, weight_decay=5e-4)
criterion = torch.nn.CrossEntropyLoss()

def train():
      model.train()
      optimizer.zero_grad()
      out = model(data.x, data.edge_index)
      loss = criterion(out[data.train_mask], data.y[data.train_mask])
      loss.backward()
      optimizer.step()
      return loss

def test(mask):
      model.eval()
      out = model(data.x, data.edge_index)
      pred = out.argmax(dim=1)
      correct = pred[mask] == data.y[mask]
      acc = int(correct.sum()) / int(mask.sum())
      return acc

val_acc_all = []
test_acc_all = []

for epoch in range(1, 101):
    loss = train()
    val_acc = test(data.val_mask)
    test_acc = test(data.test_mask)
    val_acc_all.append(val_acc)
    test_acc_all.append(test_acc)
    print(f'Epoch: {epoch:03d}, Loss: {loss:.4f}, Val: {val_acc:.4f}, Test: {test_acc:.4f}')

.. .. .. ..
.. .. .. ..
Epoch: 098, Loss: 1.1283, Val: 0.7960, Test: 0.8030

Epoch: 099, Loss: 1.1352, Val: 0.7940, Test: 0.8050

Epoch: 100, Loss: 1.1053, Val: 0.7960, Test: 0.8040

जैसा कि हम देख सकते हैं, हमारा मॉडल GCNConv से बेहतर प्रदर्शन नहीं कर पाया। अत्याधुनिक परिणाम पाने के लिए इसे हाइपरपैरामीटर ऑप्टिमाइज़ेशन या अधिक epochs की आवश्यकता है। 

मॉडल मूल्यांकन

मूल्यांकन भाग में, हम matplotlib.pyplot की लाइन प्लॉट का उपयोग करके वैलिडेशन और टेस्टिंग स्कोर को विज़ुअलाइज़ करते हैं।  

import numpy as np

plt.figure(figsize=(12,8))
plt.plot(np.arange(1, len(val_acc_all) + 1), val_acc_all, label='Validation accuracy', c='blue')
plt.plot(np.arange(1, len(test_acc_all) + 1), test_acc_all, label='Testing accuracy', c='red')
plt.xlabel('Epochs')
plt.ylabel('Accurarcy')
plt.title('GATConv')
plt.legend(loc='lower right', fontsize='x-large')
plt.savefig('gat_loss.png')
plt.show()

60 epochs के बाद, वैलिडेशन और टेस्टिंग एक्यूरेसी 0.8 +/- 0.02 के स्थिर मान पर पहुँच गई है। 

फिर से, आइए GATConv मॉडल की नोड क्लस्टरिंग को विज़ुअलाइज़ करें।

model.eval()

out = model(data.x, data.edge_index)
visualize(out, color=data.y)

जैसा कि हम देख सकते हैं, GATConv लेयर ने समान श्रेणी के नोड्स पर क्लस्टरिंग में वही परिणाम उत्पन्न किए हैं। 

हम ओवरफिटिंग को कम करने के लिए दूसरा वैलिडेशन डेटासेट जोड़ सकते हैं और pytoch_geometric के विभिन्न GCN लेयर्स के साथ प्रयोग करके मॉडल प्रदर्शन में सुधार कर सकते हैं। 

Deep Learning कौशल को अपने रेज़्यूमे में जोड़ें—Deep Learning in Python स्किल ट्रैक लेकर। यह आपको डीप लर्निंग एल्गोरिदम, Keras, Pytorch और Tensorflow फ्रेमवर्क से परिचित कराएगा।