homegraphsgat

[View code on Github](https://github.com/labmlai/annotated_deep_learning_paper_implementations/tree/master/labml_nn/graphs/gat/ init.py)

#

ප්රස්තාරයඅවධානය ජාල (GAT)

මෙය PyTorch කඩදාසි ප්රස්ථාර අවධානය යොමු කිරීමේ ජාල ක්රියාත්මක කිරීමයි.

GATSප්රස්තාර දත්ත මත ක්රියා කරයි. ප්රස්ථාරයක් නෝඩ් සහ දාර සම්බන්ධ කරන නෝඩ් වලින් සමන්විත වේ. උදාහරණයක් ලෙස, කෝරා දත්ත කට්ටලයේ නෝඩ් පර්යේෂණ පත්රිකා වන අතර දාර යනු පත්රිකා සම්බන්ධ කරන උපුටා දැක්වීම් වේ.

GATවිසින් වෙස්මූඩ් ස්වයං අවධානය භාවිතා කරයි, ට්රාන්ස්ෆෝමර්වලට සමාන ආකාරයේ. GAT එකිනෙකට ඉහළින් ගොඩගැසී ඇති ප්රස්ථාර අවධානය ස්ථර වලින් සමන්විත වේ. එක් එක් ප්රස්තාරය අවධානය ස්ථරය යෙදවුම් සහ ප්රතිදානයන් පරිවර්තනය කාවැද්දීම් ලෙස node එකක් මතම ඊට අදාල කාවැද්දීම් ලැබෙන. නෝඩ් කාවැද්දීම් එය සම්බන්ධ කර ඇති වෙනත් නෝඩ් වල කාවැද්දීම් කෙරෙහි අවධානය යොමු කරයි. ක්රියාත්මක කිරීම සමඟ ප්රස්ථාර අවධානය ස්ථර පිළිබඳ විස්තර ඇතුළත් වේ.

කෝරා දත්ත කට්ටලය මත ස්ථර දෙකක GAT පුහුණු කිරීම සඳහා පුහුණු කේතය මෙන්න.

30importtorch31fromtorchimportnn3233fromlabml\_helpers.moduleimportModule

#

ප්රස්තාරයඅවධානය ස්ථරය

මෙයතනි ප්රස්ථාර අවධානය යොමු කරන ස්ථරයකි. GAT එවැනි ස්ථර කිහිපයකින් සෑදී ඇත.

ආදානසහ ප්රතිදානයන් hi​​∈RF ලෙස කොතැනද h′={h1′​​,h2′​​,…,hN′​​}, එය අවශ්ය වේ h={h1​​,h2​​,…,hN​​}hi′​​∈RF′.

36classGraphAttentionLayer(Module):

#

• in_features , F, node එකක් මතම ඊට අදාල ආදාන ලක්ෂණ සංඛ්යාව
• out_features , F′, node එකක් මතම ඊට අදාල ප්රතිදානය විශේෂාංග සංඛ්යාව වේ
• n_heads , K, අවධානය යොමු ප්රධානීන් සංඛ්යාව වේ
• is_concat බහු-හිස ප්රති results ල සංයුක්ත කළ යුතුද නැතහොත් සාමාන්යය විය යුතුද යන්න
• dropout අතහැර දැමීමේ සම්භාවිතාව
• leaky_relu_negative_slope යනු කාන්දු වන රිලූ සක්රිය කිරීම සඳහා negative ණ බෑවුමයි

50def\_\_init\_\_(self,in\_features:int,out\_features:int,n\_heads:int,51is\_concat:bool=True,52dropout:float=0.6,53leaky\_relu\_negative\_slope:float=0.2):

#

62super().\_\_init\_\_()6364self.is\_concat=is\_concat65self.n\_heads=n\_heads

#

හිසකටමානයන් ගණන ගණනය කරන්න

68ifis\_concat:69assertout\_features%n\_heads==0

#

අපිබහු හිස් සංකෝචනය කරන්නේ නම්

71self.n\_hidden=out\_features//n\_heads72else:

#

අපිබහු හිස් සාමාන්යය කරන්නේ නම්

74self.n\_hidden=out\_features

#

මූලිකපරිවර්තනය සඳහා රේඛීය ස්ථරය; i.e. ස්වයං අවධානය පෙර node එකක් මතම ඊට අදාල කාවැද්දීම් පරිවර්තනය කිරීමට

78self.linear=nn.Linear(in\_features,self.n\_hidden\*n\_heads,bias=False)

#

අවධානයලකුණු ගණනය කිරීම සඳහා රේඛීය ස්ථරය eij​

80self.attn=nn.Linear(self.n\_hidden\*2,1,bias=False)

#

අවධානයලකුණු සඳහා සක්රිය eij​

82self.activation=nn.LeakyReLU(negative\_slope=leaky\_relu\_negative\_slope)

#

අවධානයගණනය කිරීමට සොෆ්ට්මැක්ස් αij​

84self.softmax=nn.Softmax(dim=1)

#

අවධානයසඳහා යෙදිය යුතු ස්තරය

86self.dropout=nn.Dropout(dropout)

#

• h , h හැඩයේ ආදාන නෝඩ් කාවැද්දීම් [n_nodes, in_features] වේ.
• adj_mat යනු හැඩයේ විඝටන අනුකෘතියකි [n_nodes, n_nodes, n_heads] . එක් එක් හිස සඳහා adjacency එක සමාන [n_nodes, n_nodes, 1] බැවින් අපි හැඩය භාවිතා කරමු.

සමපාතඅනුකෘතිය නෝඩ් අතර දාර (හෝ සම්බන්ධතා) නියෝජනය කරයි. adj_mat[i][j] නෝඩ් සිට නෝඩ් සිට නෝඩ් i දක්වා දාරයක් තිබේ True නම් j .

88defforward(self,h:torch.Tensor,adj\_mat:torch.Tensor):

#

නෝඩ්ගණන

99n\_nodes=h.shape[0]

#

එක්එක් හිස gik​​=Wkhi​​ සඳහා ආරම්භක පරිවර්තනය. අපි තනි රේඛීය පරිවර්තනයක් කර එක් එක් හිස සඳහා එය බෙදුවෙමු.

104g=self.linear(h).view(n\_nodes,self.n\_heads,self.n\_hidden)

#

අවධානයලකුණු ගණනය කරන්න

එක්එක් හිස සඳහා අපි මේවා ගණනය කරමු k. සරලබව ⋅k සඳහා අපි මඟ හරවා ඇත්තෙමු.

eij​=a(Whi​​,Whj​​)=a(gi​​,gj​​)

eij​ අවධානය ලකුණු (වැදගත්කම) node එකක් මතම ඊට අදාල සිට node j එකක් iමතම ඊට අදාල අපි එක් එක් හිස සඳහා මෙය ගණනය කරමු.

a අවධානය යොමු කිරීමේ යාන්ත්රණය, එය අවධානය ලකුණු ගණනය කරයි. කඩදාසි concatenates gi​​, gj​​ සහ a විසින් a∈R2F′ අනුගමනය බර දෛශිකයක් සමග රේඛීය පරිවර්තනයක් කරන්නේ LeakyReLU.

eij​=LeakyReLU(a⊤[gi​​∥gj​​])

#

පළමුවඅපි සියලු යුගල [gi​​∥gj​​] සඳහා ගණනය කරමු i,j.

g_repeat එක් එක් node එකක් මතම ඊට අදාල කාවැද්දීම නැවත නැවත n_nodes වතාවක් {g1​​,g2​​,…,gN​​,g1​​,g2​​,…,gN​​,...} කොහෙද ලැබෙන.

135g\_repeat=g.repeat(n\_nodes,1,1)

#

g_repeat_interleave එක් එක් node එකක් මතම ඊට අදාල කාවැද්දීම නැවත නැවත n_nodes වතාවක් {g1​​,g1​​,…,g1​​,g2​​,g2​​,…,g2​​,...} කොහෙද ලැබෙන.

140g\_repeat\_interleave=g.repeat\_interleave(n\_nodes,dim=0)

#

දැන්අපි ලබා ගැනීමට එකඟ වෙමු {g1​​∥g1​​,g1​​∥g2​​,…,g1​​∥gN​​,g2​​∥g1​​,g2​​∥g2​​,…,g2​​∥gN​​,...}

148g\_concat=torch.cat([g\_repeat\_interleave,g\_repeat],dim=-1)

#

ඒනිසා නැවත g_concat[i, j] හැඩගස්වා gi​​∥gj​​

150g\_concat=g\_concat.view(n\_nodes,n\_nodes,self.n\_heads,2\*self.n\_hidden)

#

ගණනයහැඩයෙන් eij​=LeakyReLU(a⊤[gi​​∥gj​​]) e යුක්ත වේ [n_nodes, n_nodes, n_heads, 1]

158e=self.activation(self.attn(g\_concat))

#

ප්රමාණයේඅවසාන මානය ඉවත් කරන්න 1

160e=e.squeeze(-1)

#

මෙමadjacency න්යාසය හැඩය [n_nodes, n_nodes, n_heads] හෝ තිබිය යුතුය[n_nodes, n_nodes, 1]

164assertadj\_mat.shape[0]==1oradj\_mat.shape[0]==n\_nodes165assertadj\_mat.shape[1]==1oradj\_mat.shape[1]==n\_nodes166assertadj\_mat.shape[2]==1oradj\_mat.shape[2]==self.n\_heads

#

මැස්සිඅනුකෘතිය මත eij​ පදනම් වූ මාස්ක්. eij​ සිට i දාරයක් නොමැති −∞ නම් දක්වා සකසා jඇත.

169e=e.masked\_fill(adj\_mat==0,float('-inf'))

#

ඉන්පසුඅපි අවධානය යොමු කිරීමේ ලකුණු සාමාන්යකරණය කරමු (හෝ සංගුණක) αij​=softmaxj​(eij​)=∑k∈Ni​​exp(eik​)exp(eij​)​

සම්බන්ධවූ නෝඩ් කට්ටලය Ni​ iකොහේද?

අපිමෙය කරන්නේ අසම්බන්ධිත eij​ යුගල exp(eij​)∼0 සඳහා සම්බන්ධ නොවූ සැකසීමෙනි. −∞

179a=self.softmax(e)

#

අතහැරදැමීමේ විධිමත් කිරීම යොදන්න

182a=self.dropout(a)

#

එක්එක් හිස සඳහා අවසාන ප්රතිදානය ගණනය කරන්න hi′k​​=j∈Ni​∑​αijk​gjk​​

සටහන: කඩදාසි σ වල අවසාන සක්රිය කිරීම ඇතුළත් වේ hi​​ අපි මෙය ප්රස්තාරය අවධානය යොමු කිරීමේ ස්ථර ක්රියාත්මක කිරීමෙන් මඟ හැර ඇති අතර වෙනත් PyTorch මොඩියුල අර්ථ දක්වා ඇති ආකාරය සමඟ ගැලපෙන පරිදි GAT ආකෘතිය මත එය භාවිතා කරන්න - සක්රිය කිරීම වෙනම ස්ථරයක් ලෙස.

191attn\_res=torch.einsum('ijh,jhf-\>ihf',a,g)

#

ප්රධානීන්සංයුක්ත කරන්න

194ifself.is\_concat:

#

hi′​​=∥∥​k=1K​hi′k​​

196returnattn\_res.reshape(n\_nodes,self.n\_heads\*self.n\_hidden)

#

ප්රධානීන්ගේමධ්යන්යය ගන්න

198else:

#

hi′​​=K1​k=1∑K​hi′k​​

200returnattn\_res.mean(dim=1)

Trending Research Paperslabml.ai