hometransformerscompressive

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

#

සම්පීඩ්යතාට්රාන්ස්ෆෝමර්

මෙය PyTorch හි දිගු පරාස අනුක්රමික ආකෘති නිර්මාණය සඳහා සම්පීඩ්යතා ට්රාන්ස්ෆෝමර් ක්රියාත්මක කිරීමයි.

මෙය ට්රාන්ස්ෆෝමර් එක්ස්එල් හි දිගුවකි, එහිදී අතීත මතකයන් දිගු අවධානයක් ලබා දීම සඳහා සම්පීඩිත වේ. එනම්, furthest ncm​c මතකයන් ncm​ මතකයන් බවට සම්පීඩනය කරනු ලැබේ, සම්පීඩන අනුපාතය කොහෙද c .

සම්පීඩනමෙහෙයුම

සම්පීඩනමෙහෙයුම ලෙස අර්ථ දැක්වේ fc​:Rnc×d→Rn×d. කඩදාසි සඳහා බහු තේරීම් හඳුන්වා දෙන fc​ අතර අප ක්රියාත්මක කර ඇත්තේ 1D කැටි ගැස්ම පමණක් වන අතර එය හොඳම ප්රති. ල ලබා දෙන බව පෙනේ. සෑම ස්ථරයකම වෙනම සම්පීඩන මෙහෙයුමක් fc​(i) ඇත. i

සම්පීඩනමෙහෙයුම පුහුණු කිරීම

බීපීටීටීසමඟ සම්පීඩන පුහුණු කිරීම සඳහා ඉතා විශාල පරිගණකමය ප්රස්ථාරයක් (බොහෝ කාල පියවර) පවත්වා ගැනීම අවශ්ය වන බැවින්, කඩදාසි ස්වයංක්රීයව කේතීකරණ අලාභයක් සහ අවධානය ප්රතිනිර්මාණය කිරීමේ අලාභයක් යෝජනා කරයි. ස්වයංක්රීය කේතීකරණ අලාභය සම්පීඩිත මතකයන් වලින් මුල් මතකයන් විකේතනය කර අලාභය ගණනය කරයි. අවධානය ප්රතිනිර්මාණය අහිමි සම්පීඩිත මතකය මත සහ සම්පීඩිත නොවන මතකය මත බහු-ප්රධානත්වයෙන් අවධානය යොමු ප්රතිඵල ගණනය හා ඔවුන් අතර මධ්යන්ය වර්ග දෝෂයක් ලැබෙන. වඩා හොඳ ප්රති. ල ලබා දෙන බැවින් අපි මෙහි දෙවැන්න ක්රියාත්මක කර ඇත්තෙමු.

මෙමක්රියාත්මක කිරීම පූර්ව ස්ථර සාමාන්යකරණය භාවිතා කරන අතර කඩදාසි පශ්චාත්-ස්ථර සාමාන්යකරණය භාවිතා කරයි. පූර්ව ස්ථර සම්මතය FFN සහ ස්වයං අවධානයට පෙර ස්ථර සම්මතය සිදු කරයි, සහ අවශේෂ සම්බන්ධතාවයේ ගමන් කිරීම සාමාන්ය තත්වයට පත් නොවේ. සම්මත ට්රාන්ස්ෆෝමර් සැකසුම්වලදී මෙය වඩාත් ස්ථායී විය යුතුය.

කුඩාෂේක්ස්පියර් දත්ත කට්ටලයේ සම්පීඩ්යතා ට්රාන්ස්ෆෝමර් ආකෘතියක් පුහුණු කිරීම සඳහා පුහුණු කේතය සහ සටහන් පොතක් මෙන්න.

54fromtypingimportOptional,List5556importtorch57importtorch.nn.functionalasF58fromtorchimportnn5960fromlabml\_helpers.moduleimportModule,TypedModuleList61fromlabml\_nn.transformers.feed\_forwardimportFeedForward62fromlabml\_nn.transformers.mhaimportPrepareForMultiHeadAttention63fromlabml\_nn.transformers.xl.relative\_mhaimportRelativeMultiHeadAttention64fromlabml\_nn.utilsimportclone\_module\_list

#

1Dසම්මුති සම්පීඩනය fc​

මෙයසමහර tensor මානයක් permutations nn.Conv1d සමග පමණ සරල දවටනය වේ.

67classConv1dCompression(Module):

#

• compression_ratec
• d_model කාවැද්දීම ප්රමාණය වේ

75def\_\_init\_\_(self,compression\_rate:int,d\_model:int):

#

80super().\_\_init\_\_()81self.conv=nn.Conv1d(d\_model,d\_model,kernel\_size=compression\_rate,stride=compression\_rate)

#

mem හැඩය ඇත [seq_len, batch, d_model]

83defforward(self,mem:torch.Tensor):

#

සංවහනස්තරය හරහා එය ධාවනය කළ හැකි වන mem පරිදි මානයන් පරිපූර්ණ කරන්න. කැටි ගැසුණු ස්තරය ස්වරූපයෙන් පිළිගනී [batch, features, sequence]

90mem=mem.permute(1,2,0)

#

සම්පීඩිතමතකය කැටි ගැසුණු ස්තරය හරහා ධාවනය කිරීමෙන් ලබා ගන්න

92c\_mem=self.conv(mem)

#

නැවතපිහිටුවීමට අවසර දෙන්න [seq_len, batch, d_model]

94returnc\_mem.permute(2,0,1)

#

සම්පීඩ්යතා ට්රාන්ස්ෆෝමර් ස්ථරය

මෙයතනි සම්පීඩ්යතා ට්රාන්ස්ෆෝමර් තට්ටුවක් ක්රියාත්මක කිරීමයි

97classCompressiveTransformerLayer(Module):

#

• d_model ටෝකනය කාවැද්දීමේ ප්රමාණයයි
• self_attnස්වයං අවධානය මොඩියුලය
• feed_forward යනු ආහාර ඉදිරි මොඩියුලයයි
• dropout_prob ස්වයං අවධානයෙන් පසු ඉවත් වීමේ සම්භාවිතාව සහ FFN
• compress සම්පීඩන ශ්රිතය fc​

103def\_\_init\_\_(self,\*,104d\_model:int,105self\_attn:RelativeMultiHeadAttention,106feed\_forward:FeedForward,107dropout\_prob:float,108compress:Conv1dCompression):

#

116super().\_\_init\_\_()117self.compress=compress118self.size=d\_model119self.self\_attn=self\_attn120self.feed\_forward=feed\_forward121self.dropout=nn.Dropout(dropout\_prob)122self.norm\_self\_attn=nn.LayerNorm([d\_model])123self.norm\_ff=nn.LayerNorm([d\_model])

#

මතකයසහ සම්පීඩිත මතකය සමඟ සාමාන්යකරණය කළ ටෝකන් කාවැද්දීම් සංයුක්ත කරන්න.

• z ස්ථර සාමාන්යකරණය කරන ලද ටෝකන් කාවැද්දීම් වේ.
• mem``c_mem සහ මතකය සහ සම්පීඩිත මතකය (සාමාන්යකරණය නොවේ).

125defconcat\_memory(self,z:torch.Tensor,mem:Optional[torch.Tensor],c\_mem:Optional[torch.Tensor]):

#

මතකයක්නොමැති නම් ටෝකන් කාවැද්දීම් නැවත ලබා දෙන්න

134ifmemisNone:135returnz

#

සම්පීඩිතමතකය තිබේ නම් එය මතකය සමඟ සංයුක්ත වේ

138ifc\_memisnotNone:139mem=torch.cat((c\_mem,mem),dim=0)

#

සාමාන්යකරණස්තරය හරහා මතකය ධාවනය කරන්න

142mem=self.norm\_self\_attn(mem)

#

සාමාන්යකරණයකළ මතකය සහ සාමාන්යකරණය කළ ටෝකන් කාවැද්දීම් සංයුක්ත කරන්න

144returntorch.cat((mem,z),dim=0)

#

• x යනු හැඩයේ ටෝකන් මට්ටමේ විශේෂාංග දෛශිකවල ආතකයකි [seq_len, batch_size, d_model]
• mem යනු අතීත ටෝකන් මට්ටමේ විශේෂාංග දෛශික (මතකය) හැඩයේ ටෙන්සරයකි [mem_len, batch_size, d_model]
• c_mem සම්පීඩිත මතකයේ ආතතියක් වේ [c_mem_len, batch_size, d_model]
• mask යනු හැඩයේ අනුකෘතියක් [seq_len, c_mem_len + mem_len + seq_len, batch_size] හෝ [seq_len, c_mem_len + mem_len + seq_len, 1] . mask[i, j] ටෝකන් වලට ටෝකනය දැකිය i හැකි නම් j සත්යයකි.

146defforward(self,\*,147x:torch.Tensor,148mem:Optional[torch.Tensor],149c\_mem:Optional[torch.Tensor],150mask:torch.Tensor):

#

ස්වයංඅවධානය යොමු කිරීමට පෙර දෛශික සාමාන්යකරණය කරන්න

160z=self.norm\_self\_attn(x)

#

මතකයසහ සම්පීඩිත මතකය සාමාන්යකරණය කර සංයුක්ත කරන්න

162m\_z=self.concat\_memory(z,mem,c\_mem)

#

අවධානය

164self\_attn=self.self\_attn(query=z,key=m\_z,value=m\_z,mask=mask)

#

අවධානයයොමු ප්රතිඵල එකතු කරන්න

166x=x+self.dropout(self\_attn)

#

පෝෂණයසඳහා සාමාන්යකරණය කරන්න

169z=self.norm\_ff(x)

#

Feed-forwardජාලය හරහා ගමන් කරන්න

171ff=self.feed\_forward(z)

#

ප්රතිපෝෂණඉදිරි ප්රති results ල නැවත එක් කරන්න

173x=x+self.dropout(ff)

#

176returnx

#

සම්පීඩ්යතා ට්රාන්ස්ෆෝමර් ආකෘතිය

මෙයබහු සම්පීඩ්යතා ට්රාන්ස්ෆෝමර් ස්ථර වලින් සමන්විත වේ

179classCompressiveTransformer(Module):

#

186def\_\_init\_\_(self,layer:CompressiveTransformerLayer,n\_layers:int):187super().\_\_init\_\_()

#

ට්රාන්ස්ෆෝමර්ස්ථරයේ පිටපත් සාදන්න

189self.layers=clone\_module\_list(layer,n\_layers)

#

අවසානසාමාන්යකරණ ස්තරය

191self.norm=nn.LayerNorm([layer.size])

#

• x යනු හැඩයේ ටෝකන් කාවැද්දීමේ දෛශිකවල ආතකයකි [seq_len, batch_size, d_model]
• mem යනු එක් එක් ස්තරය [mem_len, batch_size, d_model] සඳහා හැඩයේ දෛශික අතීත ටෝකන් මට්ටමේ ආතති ලැයිස්තුවකි
• c_mem යනු එක් එක් ස්ථරය [c_mem_len, batch_size, d_model] සඳහා සම්පීඩිත මතකයේ ආතති ලැයිස්තුවකි
• mask ආවරණ අනුකෘතිය වේ

193defforward(self,x:torch.Tensor,mem:List[torch.Tensor],c\_mem:List[torch.Tensor],mask:torch.Tensor):

#

ටෝකන්මට්ටමේ විශේෂාංග දෛශික ගබඩා කිරීම සඳහා ලැයිස්තු ගත කරන්න, එය ඊළඟ අනුක්රමික කණ්ඩායම සඳහා මතකයන් බවට පත්වනු ඇත.

204new\_mem=[]

#

එක්එක් ට්රාන්ස්ෆෝමර් ස්ථරය හරහා ධාවනය කරන්න

206fori,layerinenumerate(self.layers):

#

විශේෂාංගදෛශික ලැයිස්තුවට එක් කරන්න

208new\_mem.append(x.detach())

#

මතකය

210m=mem[i]ifmemelseNone

#

සම්පීඩිතමතකය

212cm=c\_mem[i]ifc\_memelseNone

#

ට්රාන්ස්ෆෝමර්XL ස්තරය හරහා ධාවනය කරන්න

214x=layer(x=x,mem=m,c\_mem=cm,mask=mask)

#

අවසානවශයෙන්, දෛශික සාමාන්යකරණය කරන්න

216returnself.norm(x),new\_mem

#

අවධානයප්රතිසංස්කරණ අලාභය

අවධානයප්රතිනිර්මාණය කිරීමේ අලාභය ස්වයං අවධානය ප්රතිදානය සම්පීඩිත නොවන මතකය සමඟ සහ සම්පීඩිත මතකය සමඟ ප්රතිනිර්මාණය කරන අතර මේ දෙක අතර මධ්යන්ය කොටු දෝෂය ගණනය කරයි. ස්ථානීය කේතීකරණයකින් තොරව මෙය සිදු කරයි.

අවධානයප්රතිනිර්මාණය අහිමි සම්පීඩන කාර්යය fc​ ගණනය හා පුහුණු කරන විට, සියලු fc​ පරාමිතීන් නමුත් ශීත කළ ඇත. මෙයට යතුර/වටිනාකම් ප්රක්ෂේපණ සහ සාමාන්යකරණයෙන් පසු පක්ෂග්රාහී/පරිමාණය ඇතුළත් වේ.

මෙමඅලාභය ආකෘතියේ හරස් එන්ට්රොපිය-අලාභයෙන් ස්වාධීනව ගණනය කළ හැකි බැවින් ඔබට යාවත්කාලීන කිරීම් පමණක් වෙනම ප්රශස්තිකරණයක් තිබිය හැකිය fc​. කෙසේ වෙතත්, අපි යාවත්කාලීන කිරීමට එම ප්රශස්තකරණය භාවිතා අවධානය ප්රතිසංස්කරණය අහිමි ගණනය කිරීමේදී fc​ එසේ, අපි ඵලය අනුක්රමික ගණනය fc​ සිට හැර අනෙකුත් සියලු පරාමිතීන් වෙන්.

219classAttentionReconstructionLoss:

#

layers සම්පීඩ්යතා ට්රාන්ස්ෆෝමර් ස්ථර ලැයිස්තුවයි

237def\_\_init\_\_(self,layers:TypedModuleList[CompressiveTransformerLayer]):

#

241self.layers=layers242self.loss\_func=nn.MSELoss()

#

මෙයනැවත ක්රියාත්මක කිරීමකි 'සූදානම් කිරීමේ සූත්රයඅවධානය යොමු කිරීම' ප්රක්ෂේපණ ශ්රේණියේ ගණනය කිරීම් වලින් වෙන් කර ඇති පරාමිතීන් සමඟ සිදු කරනු ලැබේ.

• pmha යනු 'සූදානම් කිරීමේ සූත්රයහෙඩ්අවධානය යොමු කිරීම' මොඩියුලය
• x ටෝකන් කාවැද්දීම් සමඟ ආතතියෙන් යුක්ත වේ

244defprepare\_for\_attn(self,pmha:PrepareForMultiHeadAttention,x:torch.Tensor):

#

කාවැද්දීමමානයක් හැර ආදාන හැඩය; [seq_len, batch_size] .

254head\_shape=x.shape[:-1]

#

ප්රක්ෂේපණබර සහ නැඹුරුව වෙන් කරන්න

257weight=pmha.linear.weight.detach()258bias=pmha.linear.bias.detach()ifpmha.linear.biasisnotNoneelseNone

#

රේඛීයපරිණාමනය

260x=F.linear(x,weight,bias)

#

අවසානමානය හිස් බවට බෙදන්න

263x=x.view(\*head\_shape,pmha.heads,pmha.d\_k)

#

නිමැවුමේහැඩය [seq_len, batch_size, heads, d_k] හෝ [batch_size, d_model]

266returnx

#

මෙයප්රක්ෂේපණ පරාමිතීන් වෙන් කිරීම සඳහා 'සූදානම් කිරීමේ සූත්රයහෙඩ්අවධානය prepare_for_attn වෙනුවට කැඳවන 'බහු-ප්රධාන අවධානය' නැවත ක්රියාත්මක කිරීමකි.

268defattn(self,layer:RelativeMultiHeadAttention,query:torch.Tensor,key:torch.Tensor,value:torch.Tensor):

#

විමසුමගණනය කරන්න, යතුර සහ අගය ප්රක්ෂේපණ

275query=self.prepare\_for\_attn(layer.query,query)276key=self.prepare\_for\_attn(layer.key,key)277value=self.prepare\_for\_attn(layer.value,value)

#

අවධානයලකුණු ගණනය කරන්න QK⊤. මෙය හැඩයේ ආතතිකයක් ලබා දෙයි [seq_len, seq_len, batch_size, heads] .

281scores=torch.einsum('ibhd,jbhd-\>ijbh',query,key)

#

පරිමාණලකුණු dk​​QK⊤​

284scores\*=layer.scale

#

softmax ප්රධාන අනුක්රමය මානයක් ඔස්සේ අවධානය seqsoftmax​(dk​​QK⊤​)

288attn=layer.softmax(scores)

#

අගයන්අනුව ගුණ කරන්න seqsoftmax​(dk​​QK⊤​)V

292returntorch.einsum("ijbh,jbhd-\>ibhd",attn,value)

#

වෙන්කරන ලද මාරුව සහ පරිමාණ පරාමිතීන් සමඟ ස්ථර සාමාන්යකරණය සිදු කරන්න.

294defnorm(self,ln:nn.LayerNorm,x:torch.Tensor):

#

වෙන්මාරුව (bias ) සහ පරිමාණය (weight ) පරාමිතීන්

300weight=ln.weight.detach()ifln.weightisnotNoneelseNone301bias=ln.bias.detach()ifln.biasisnotNoneelseNone

#

ස්ථරයසාමාන්යකරණය

304returnF.layer\_norm(x,ln.normalized\_shape,weight,bias,ln.eps)

#

මෙයස්ථරයක් සඳහා අලාභය ගණනය කරයි

306defcalc\_loss(self,layer:CompressiveTransformerLayer,h:torch.Tensor,mem:torch.Tensor):

#

ටෝකන්කාවැද්දීම් සහ මතකය වෙන් කරන්න.

312h=h.detach()313mem=mem.detach()

#

සමඟමතකය සංකෝචනය කරන්න fc​(i). හි පරාමිතීන් fc​(i) යනු ශ්රේණියේ ගණනය කිරීම් වලින් වෙන් කර නොමැති එකම පරාමිතීන් වේ.

317c\_mem=layer.compress(mem)

#

කාවැද්දීම්සහ මතකයන් සාමාන්යකරණය කරන්න

320h=self.norm(layer.norm\_self\_attn,h)321mem=self.norm(layer.norm\_self\_attn,mem)322c\_mem=self.norm(layer.norm\_self\_attn,c\_mem)

#

සම්පීඩිතනොවන මතකය සමඟ අවධානය ගණනය කරන්න

325attn\_mem=self.attn(layer.self\_attn,h,mem,mem)

#

සම්පීඩිතමතකය සමඟ අවධානය ගණනය කරන්න

327attn\_cmem=self.attn(layer.self\_attn,h,c\_mem,c\_mem)

#

මධ්යන්යවර්ග දෝෂය ගණනය කරන්න

330returnself.loss\_func(attn\_cmem,attn\_mem)

#

332def\_\_call\_\_(self,h:List[torch.Tensor],mem:List[torch.Tensor]):

#

එක්එක් ස්ථරය සඳහා පාඩු ගණනය කරන්න

334losses=[self.calc\_loss(layer,h[n],mem[n])forn,layerinenumerate(self.layers)]

#

අලාභවලඑකතුව

336returnsum(losses)

Trending Research Paperslabml.ai