docs/si/transformers/alibi/index.html
[View code on Github](https://github.com/labmlai/annotated_deep_learning_paper_implementations/tree/master/labml_nn/transformers/alibi/ init.py)
මෙයක්රියාත්මක කිරීමකි රේඛීය අගතීන් සමඟ අවධානය (අලිබී) කඩදාසි වලින් දුම්රිය කෙටි, දිගු පරීක්ෂණය: රේඛීය අගතීන් සමඟ අවධානය යොමු කිරීම ආදාන දිග නිස්සාරණය සක්රීය කරයි.
මෙයස්ථානීය කේතීකරණ වෙනුවට අවධානය යොමු කිරීමේ ලකුණු වලට එකතු කරන ලද අගතීන් සමඟ ප්රතිස්ථාපනය කරයි (අවධානය යොමු කිරීම්, සොෆ්ට්මැක්ස් වලට පෙර). මෙය ස්වයංක්රීය ප්රතිගාමී කාර්යයන් මත පරීක්ෂා කරන ලද සාපේක්ෂ යෝජනා ක්රමයක් වන අතර සමීප ටෝකන සඳහා නැඹුරුව ඉහළ අගයක් ගන්නා අතර දුර බැහැර ටෝකන සඳහා අඩු වේ. අගතීන් ලොග් පරිමාණයේ රේඛීයව අඩු වේ (එය සොෆ්ට්මැක්ස් වලට පෙර නිසා) සහ එක් එක් හිස වෙනස් බෑවුමක් ඇත.
මෙන්න i-th ටෝකනය සඳහා අවධානය යොමු කිරීමේ සූත්රය,
ai=softmax(qiK⊤+m⋅[−(i−1),…,1,0])=softmax(qiK⊤+m⋅[0,1,…,(i−1)])
i-th ටෝකනයේ විමසුම qi∈Rd K∈Ri×d කොහේද, යතුරු දක්වා ඇත i, සහ d හිසකට විශේෂාංග ගණන. ඉහත සමානාත්මතාවය නතර softmax වන බව සලකන්න පරිවර්තන වලට වෙනස් නොවේ (ප්රති result ලය වෙනස් නොකර ඔබට සියලු අංග සඳහා නියත එකතු කළ හැකිය).
අලිබීආකෘතියක් සඳහා පුහුණු කේතය මෙන්න.
35importmath36fromtypingimportOptional3738importtorch39fromtorchimportnn4041fromlabml.loggerimportinspect42fromlabml\_nn.transformers.mhaimportMultiHeadAttention
n_heads යනු අවධානය යොමු කිරීමේ ස්ථරයේ හිස් ගණන nපළමුහිස සඳහා බෑවුම
2n81=2−n8
සෙසුහිස් සඳහා බෑවුම් ඉහත සමාන අනුපාතයක් සහිත ජ්යාමිතික ශ්රේණියක් වේ.
උදාහරණයක්ලෙස හිස් ගණන බෑවුම් 8 වන විට 211,221,…,281
45defget\_slopes(n\_heads:int):
2ට ආසන්නතම බලය ලබා ගන්න n_heads . 2 බලයක් n_heads නොවේ නම්, අපි මුලින්ම 2 හි සමීපතම (කුඩා) බලයට බෑවුම් ගණනය කර ඉතිරි බෑවුම් එකතු කරමු.
64n=2\*\*math.floor(math.log2(n\_heads))
2−n8
66m\_0=2.0\*\*(-8.0/n)
2−1n8,2−2n8,2−3n8,…
68m=torch.pow(m\_0,torch.arange(1,1+n))
2බලයක් n_heads නොවේ නම්, අපි ඉතිරි බෑවුම් එකතු කරමු. අපි ඉතිරි බෑවුම් ගණනය කරමු n∗2 (කලින් එකතු කරන ලද බෑවුම් මග හැරීම). බෑවුම් ඉහළට ගන්න n_heads .
73ifn\<n\_heads:
2−2n8
75m\_hat\_0=2.0\*\*(-4.0/n)
2−12n8,2−32n8,2−52n8,… කලින් එකතු කරන ලද බෑවුම් වළක්වා 2 ගැනීමට අපි පියවර ගන්නා බව සලකන්න.
78m\_hat=torch.pow(m\_hat\_0,torch.arange(1,1+2\*(n\_heads-n),2))
ඉතිරිබෑවුම් සහිත බෑවුම් සහිත බෑවුම් සංයුක්ත කරන්න.
80m=torch.cat([m,m\_hat])8182returnm
n_heads යනු අවධානය යොමු කිරීමේ ස්ථරයේ හිස් ගණනmask හැඩයේ අවධානය යොමු කිරීමේ ආවරණයයි [seq_len_q, seq_len_k]මෙමAliBi අවධානය අගතීන් [seq_len_q, seq_len_k, n_heads,] සමග හැඩය අනුකෘතියක් නැවත.
[email protected]\_grad()86defget\_alibi\_biases(n\_heads:int,mask:torch.Tensor):
එක්එක් හිස m සඳහා බෑවුම් ලබා ගන්න
97m=get\_slopes(n\_heads).to(mask.device)
දුරගණනය කරන්න [0,1,…,N] මෙන්න අපි ආවරණ භාවිතා කරන දුර ගණනය කරමු.
එයහේතු වෙස් මුහුණක් බැවින් [0,1,…,N] අපටද භාවිතා කළ හැකිය. distance = torch.arange(mask.shape[1], dtype=torch.long, device=mask.device)[None, :]
104distance=mask.cumsum(dim=-1)
අලිබීනැඹුරුව න්යාසය ලබා ගැනීම සඳහා ඒවා යුගල වශයෙන් ගුණ කරන්න
107returndistance[:,:,None]\*m[None,None,:]
අපි බහු-ප්රධාන අවධානයඅභිබවා යමු.
110classAlibiMultiHeadAttention(MultiHeadAttention):
117def\_\_init\_\_(self,heads:int,d\_model:int,dropout\_prob:float=0.1):118super().\_\_init\_\_(heads,d\_model,dropout\_prob)
අලිබීඅගතීන් හැඹිලි කිරීමට
121self.alibi\_biases=None
query , key සහ valueවිමසුම, _යතුර_සහ _අගය_දෛශික එකතු කිරීම ගබඩා කරන ආතන්ය වේ. ඒවායේ හැඩය ඇත [seq_len, batch_size, d_model] .
mask හැඩය ඇති [seq_len, seq_len, batch_size] අතර කණ්ඩායම සඳහා b , ස්ථානයේ විමසුමට ප්රවේශය i තිබේද යන්න mask[i, j, b] දක්වයි ස්ථානයේ ප්රධාන-අගය j .
123defforward(self,\*,124query:torch.Tensor,125key:torch.Tensor,126value:torch.Tensor,127mask:Optional[torch.Tensor]=None):
අලිබීක්රියා කරන්නේ හේතු වෙස් මුහුණු සමඟ පමණි.
139assertmaskisnotNone140assertmask.shape[0]==mask.shape[1]andmask.shape[2]==1
query , key``value සහ හැඩය [seq_len, batch_size, d_model]
143seq\_len,batch\_size,\_=query.shape
ආවරණසඳහා හිස මානයක් එක් කර එහි හැඩය පරීක්ෂා කරන්න.
146mask=self.prepare\_mask(mask,query.shape,key.shape)
සූදානම්වන්න query , key සහ අවධානය ගණනය කිරීම value සඳහා. මේවාට පසුව හැඩය ඇත [seq_len, batch_size, heads, d_k] .
150query=self.query(query)151key=self.key(key)152value=self.value(value)
අවධානයලකුණු ගණනය කරන්න QK⊤. මෙය හැඩයේ ආතතිකයක් ලබා දෙයි [seq_len, seq_len, batch_size, heads] .
156scores=self.get\_scores(query,key)
පරිමාණලකුණු dkQK⊤
159scores\*=self.scale
එයහැඹිලි නොවේ නම් AliBi අගතීන් නිර්මාණය
162ifself.alibi\_biasesisNoneorself.alibi\_biases.shape[1]\<seq\_len:
maskseq_len, seq_len, 1, 1 හැඩය ඇත
164self.alibi\_biases=get\_alibi\_biases(scores.shape[-1],mask[:,:,0,0])
අවධානයලකුණු AliBi අගතීන් එකතු කරන්න. අලිබී අගතීන් හැඩයක් scores ඇති [seq_len, seq_len, n_heads] අතර හැඩයක්
ඇත [seq_len, seq_len, batch_size, n_heads]
169scores+=self.alibi\_biases[:seq\_len,:seq\_len,None,:]
වෙස්යොදන්න
172scores=scores.masked\_fill(mask==0,float('-inf'))
softmax ප්රධාන අනුක්රමය මානයක් ඔස්සේ අවධානය seqsoftmax(dkQK⊤)
176attn=self.softmax(scores)
අතහැරදැමීම යොදන්න
179attn=self.dropout(attn)
අගයන්අනුව ගුණ කරන්න seqsoftmax(dkQK⊤)V
183x=torch.einsum("ijbh,jbhd-\>ibhd",attn,value)
බහුහිස් සංයුක්ත කරන්න
186x=x.reshape(seq\_len,batch\_size,-1)
ප්රතිදානස්ථරය
189returnself.output(x)
බෑවුම්දැකීමට සරල පරීක්ෂණ කාර්යය.
192def\_test\_alibi():
196inspect(get\_slopes(12).tolist(),\_n=-1)197fromlabml\_nn.transformers.utilsimportsubsequent\_mask198199mask=subsequent\_mask(8)[:,:,0]200inspect(mask)201202inspect(get\_alibi\_biases(12,mask)[:,:,3],\_n=-1)
206if\_\_name\_\_=='\_\_main\_\_':207\_test\_alibi()