docs/si/transformers/mha.html
මෙය කඩදාසි වලින් බහු-ශීර්ෂ අවධානය යොමු කිරීමේ නිබන්ධනයක්/ක්රියාත්මක කිරීමකි අවධානයPyTorch හි ඔබට අවශ්ය සියල්ල වේ. ක්රියාත්මක කිරීම ආනුභාව ලත් ට්රාන්ස්ෆෝමර් වෙතින් දේවානුභාවයෙන් ය.
NLP ස්වයංක්රීය-ප්රතිගාමී සඳහා MHA සමඟ මූලික ට්රාන්ස්ෆෝමරයක් භාවිතා කරන පුහුණු කේතය මෙන්න.
සරල ට්රාන්ස්ෆෝමරයක් පුහුණු කරන අත්හදා බැලීමේ ක්රියාත්මක කිරීමක් මෙන්න.
24importmath25fromtypingimportOptional,List2627importtorch28fromtorchimportnn2930fromlabmlimporttracker
මෙමමොඩියුලය රේඛීය පරිවර්තනයක් සිදු කරන අතර බහු හිස අවධානය සඳහා දෛශිකය ලබා දී ඇති හිස් ගණනට බෙදේ. යතුර , විමසුම සහ අගය දෛශික පරිවර්තනය කිරීමට මෙය භාවිතා කරයි.
33classPrepareForMultiHeadAttention(nn.Module):
44def\_\_init\_\_(self,d\_model:int,heads:int,d\_k:int,bias:bool):45super().\_\_init\_\_()
රේඛීයපරිණාමනය සඳහා රේඛීය ස්ථරය
47self.linear=nn.Linear(d\_model,heads\*d\_k,bias=bias)
හිස්ගණන
49self.heads=heads
එක්එක් හිසෙහි දෛශිකවල මානයන් ගණන
51self.d\_k=d\_k
53defforward(self,x:torch.Tensor):
ආදානයටහැඩය [seq_len, batch_size, d_model] හෝ [batch_size, d_model] ඇත. අපි රේඛීය පරිවර්තනය අවසාන මානයට අදාළ වන අතර එය හිස් බවට බෙදී යයි.
57head\_shape=x.shape[:-1]
රේඛීයපරිණාමනය
60x=self.linear(x)
අවසානමානය හිස් බවට බෙදන්න
63x=x.view(\*head\_shape,self.heads,self.d\_k)
නිමැවුමේහැඩය [seq_len, batch_size, heads, d_k] හෝ [batch_size, heads, d_model]
66returnx
මෙයලබා දී query ඇති key සහ value දෛශික සඳහා බහු-ශීර්ෂ අවධානය පරිමාණය කරයි.
Attention(Q,K,V)=seqsoftmax(dkQK⊤)V
සරළවකිවහොත්, එය විමසුමට ගැලපෙන යතුරු සොයා ගන්නා අතර එම යතුරු වල අගයන් ලබා ගනී.
එයඔවුන් කෙතරම් ගැලපෙන දර්ශකයක් ලෙස විමසුම හා ප්රධාන තිත්-නිෂ්පාදන භාවිතා කරයි. softmax තිත්-නිෂ්පාදන ගැනීමට පෙර පරිමාණය කරනු ලැබේ dk1. මෙය සිදු කරනු ලබන්නේ විශාල තිත් නිෂ්පාදන අගයන් වළක්වා ගැනීම සඳහා වන අතර එමඟින් සොෆ්ට්මැක්ස් විශාල dk වන විට ඉතා කුඩා අනුක්රමික ප්රමාණයක් ලබා දේ.
Softmaxඅනුක්රමය (හෝ කාලය) අක්ෂය ඔස්සේ ගණනය කරනු ලැබේ.
69classMultiHeadAttention(nn.Module):
heads හිස් ගණන වේ.d_model යනු query , key සහ value දෛශිකවල ඇති ලක්ෂණ ගණන වේ.90def\_\_init\_\_(self,heads:int,d\_model:int,dropout\_prob:float=0.1,bias:bool=True):
96super().\_\_init\_\_()
හිසකටවිශේෂාංග ගණන
99self.d\_k=d\_model//heads
හිස්ගණන
101self.heads=heads
මේවාබහු-ශීර්ෂ අවධානය සඳහා key සහ value දෛශික පරිවර්තනය කරයි. query
104self.query=PrepareForMultiHeadAttention(d\_model,heads,self.d\_k,bias=bias)105self.key=PrepareForMultiHeadAttention(d\_model,heads,self.d\_k,bias=bias)106self.value=PrepareForMultiHeadAttention(d\_model,heads,self.d\_k,bias=True)
කාලමානය ඔස්සේ අවධානය යොමු කිරීම සඳහා සොෆ්ට්මැක්ස් key
109self.softmax=nn.Softmax(dim=1)
ප්රතිදානස්ථරය
112self.output=nn.Linear(d\_model,d\_model)
හැලීම
114self.dropout=nn.Dropout(dropout\_prob)
සොෆ්ට්මැක්ස්වලට පෙර පරිමාණ සාධකය
116self.scale=1/math.sqrt(self.d\_k)
අවශ්යනම් ලොග් වීම හෝ වෙනත් ගණනය කිරීම් සඳහා භාවිතා කළ හැකි වන පරිදි අපි අවධානය ගබඩා කරමු
119self.attn=None
සාපේක්ෂඅවධානය වැනි වෙනත් වෙනස්කම් සඳහා මෙම ක්රමය ඉක්මවා යා හැකිය.
121defget\_scores(self,query:torch.Tensor,key:torch.Tensor):
ගණනයකරන්න QK⊤ හෝ Sijbh=∑dQibhdKjbhd
129returntorch.einsum('ibhd,jbhd-\>ijbh',query,key)
mask හැඩය ඇත [seq_len_q, seq_len_k, batch_size] , එහිදී පළමු මානය විමසුම් මානයක් වේ. විමසුම මානයක් සමාන වේ නම් 1 එය විකාශනය කරනු ඇත.
131defprepare\_mask(self,mask:torch.Tensor,query\_shape:List[int],key\_shape:List[int]):
137assertmask.shape[0]==1ormask.shape[0]==query\_shape[0]138assertmask.shape[1]==key\_shape[0]139assertmask.shape[2]==1ormask.shape[2]==query\_shape[1]
සියලුමහිස් සඳහා එකම ආවරණ යොදනු ලැබේ.
142mask=mask.unsqueeze(-1)
එහිප්රති ing ලයක් ලෙස වෙස් [seq_len_q, seq_len_k, batch_size, heads]
145returnmask
query , key සහ valueවිමසුම, _යතුර_සහ _අගය_දෛශික එකතු කිරීම ගබඩා කරන ආතන්ය වේ. ඒවායේ හැඩය ඇත [seq_len, batch_size, d_model] .
mask හැඩය ඇති [seq_len, seq_len, batch_size] අතර කණ්ඩායම සඳහා b , ස්ථානයේ විමසුමට ප්රවේශය i තිබේද යන්න mask[i, j, b] දක්වයි ස්ථානයේ ප්රධාන-අගය j .
147defforward(self,\*,148query:torch.Tensor,149key:torch.Tensor,150value:torch.Tensor,151mask:Optional[torch.Tensor]=None):
query , key``value සහ හැඩය [seq_len, batch_size, d_model]
163seq\_len,batch\_size,\_=query.shape164165ifmaskisnotNone:166mask=self.prepare\_mask(mask,query.shape,key.shape)
සූදානම්වන්න query , key සහ අවධානය ගණනය කිරීම value සඳහා. මේවාට පසුව හැඩය ඇත [seq_len, batch_size, heads, d_k] .
170query=self.query(query)171key=self.key(key)172value=self.value(value)
අවධානයලකුණු ගණනය කරන්න QK⊤. මෙය හැඩයේ ආතතිකයක් ලබා දෙයි [seq_len, seq_len, batch_size, heads] .
176scores=self.get\_scores(query,key)
පරිමාණලකුණු dkQK⊤
179scores\*=self.scale
වෙස්යොදන්න
182ifmaskisnotNone:183scores=scores.masked\_fill(mask==0,float('-inf'))
softmax ප්රධාන අනුක්රමය මානයක් ඔස්සේ අවධානය seqsoftmax(dkQK⊤)
187attn=self.softmax(scores)
නිදොස්කරණයනම් අවධානය සුරකින්න
190tracker.debug('attn',attn)
අතහැරදැමීම යොදන්න
193attn=self.dropout(attn)
අගයන්අනුව ගුණ කරන්න seqsoftmax(dkQK⊤)V
197x=torch.einsum("ijbh,jbhd-\>ibhd",attn,value)
වෙනත්ගණනය කිරීම් සඳහා අවධානය සුරකින්න
200self.attn=attn.detach()
බහුහිස් සංයුක්ත කරන්න
203x=x.reshape(seq\_len,batch\_size,-1)
ප්රතිදානස්ථරය
206returnself.output(x)