#

ප්රාථමිකය: භාෂා ආකෘති නිර්මාණය සඳහා කාර්යක්ෂම ට්රාන්ස්ෆෝමර් සෙවීම

මෙය PyTorch කඩදාසි ප්රයිමර් ක්රියාත්මක කිරීම: භාෂා ආකෘති නිර්මාණය සඳහා කාර්යක්ෂම ට්රාන්ස්ෆෝමර් සෙවීම .

කතුවරුන්ට්රාන්ස්ෆෝමර් ගෘහ නිර්මාණ ශිල්පය සඳහා පරිණාමීය සෙවීමක් කරයි. සෙවුම් ප්රයිමර් භාවිතයෙන් සොයාගත් ගෘහ නිර්මාණ ශිල්පය ඔවුන් නම් කරයි (ප්රයිම්ටිව්ස් ට්රාන්ස්ෆෝමර් සෙවූ). ප්රයිමර්EZ යනු මුල් ට්රාන්ස්ෆෝමරය හා සසඳන විට ප්රයිමර් හි වඩාත්ම ශක්තිමත් වෙනස් කිරීම් දෙක සහිත ගෘහ නිර්මාණ ශිල්පයයි. ප්රයිමර් EZ වැනිලා ට්රාන්ස්ෆෝමරය වඩා වේගයෙන් දුම්රිය.

වර්ගRelu

සෙවුමමගින් සොයාගත් වඩාත්ම effective ලදායී වෙනස් කිරීම වන්නේ ස්ථාන-නැණවත් පෝෂක මොඩියුලයේRelU වෙනුවට චතුරස්රාකාර RelU භාවිතා කිරීමයි.

$y = m a x (x, 0)^{2}$

බහු-Dconv-හිසඅවධානය (MDHA)

ඊළඟeffective ලදායී වෙනස් කිරීම යනු විමසුම්, යතුරු සහ අගයන් සඳහා බහු-හිස ප්රක්ෂේපණය කිරීමෙන් පසු ගැඹුරට අනුව $3 \times 1$ කැටි ගැසුමකි. මෙම convolution අනුක්රමය මානයක් ඔස්සේ සහ නාලිකාව (ගැඹුර-අනුව) වේ. පැහැදිලි කිරීම සඳහා, එක් එක් හිසෙහි නාලිකා ගණන සංකෝචනය නම් එක් එක් $d_{k}$ නාලිකා සඳහා $1 \times 3$ කර්නල් ඇත. $d_{k}$

ප්රයිමර්EZ සඳහාඅත්හදා බැලීමේ කේතය මෙන්න.

40import torch
41from torch import nn
42
43from labml_helpers.module import Module
44from labml_nn.transformers import MultiHeadAttention

#

වර්ගRelu සක්රිය

$y = m a x (x, 0)^{2}$

SquaredRelU තත්ත්වය නැණවත් feedforward මොඩියුලයතුළ සක්රිය කාර්යය ලෙස භාවිතා කරයි.

47class SquaredReLU(Module):

#

57    def __init__(self):
58        super().__init__()
59        self.relu = nn.ReLU()

#

61    def forward(self, x: torch.Tensor):

#

Reluඅයදුම් කරන්න

63        x = self.relu(x)

#

එයවර්ග කරන්න

65        return x * x

#

අවකාශීයගැඹුර නැණවත් සම්මුතිය

68class SpatialDepthWiseConvolution(Module):

#

d_k එක් එක් හිසෙහි නාලිකා ගණන වේ

73    def __init__(self, d_k: int, kernel_size: int = 3):

#

77        super().__init__()
78        self.kernel_size = kernel_size

#

අපිපයිටෝර්ච් Conv1d මොඩියුලය භාවිතා කරමු. එක් එක් නාලිකාව සඳහා වෙනම සංවහනයක් (විවිධ කර්නල් සමඟ) සිදු වන පරිදි නාලිකා ගණනට සමාන වන පරිදි කණ්ඩායම් ගණන අපි සකස් කරමු. අපි දෙපැත්තටම පුරවන එකතු කර පසුව නිවැරදි වඩාත්ම kernel_size - 1 ප්රති

. ල ලබා ගනිමු

83        self.conv = nn.Conv1d(in_channels=d_k, out_channels=d_k,
84                              kernel_size=(kernel_size,), padding=(kernel_size - 1,), groups=d_k)

#

x හැඩය ඇත [seq_len, batch_size, heads, d_k]

86    def forward(self, x: torch.Tensor):

#

හැඩයලබා ගන්න

92        seq_len, batch_size, heads, d_k = x.shape

#

කිරීමටඅවසර [batch_size, heads, d_k, seq_len]

94        x = x.permute(1, 2, 3, 0)

#

හැඩයවෙනස් කරන්න [batch_size * heads, d_k, seq_len]

96        x = x.view(batch_size * heads, d_k, seq_len)

#

1Dකැටි ගැසුමේ ආකෘතියේ ආදානය පිළිගනී [N, channels, sequence]

99        x = self.conv(x)

#

අපිදෙපැත්තෙන්ම ආවරණයකින් සමන්විත බැවින් නිවැරදි වඩාත්ම kernel_size - 1 ප්රති results ල බෝග කරන්න

101        x = x[:, :, :-(self.kernel_size - 1)]

#

නැවතහැඩගස්වන්න [batch_size, heads, d_k, seq_len]

103        x = x.view(batch_size, heads, d_k, seq_len)

#

කිරීමටඅවසර [seq_len, batch_size, heads, d_k]

105        x = x.permute(3, 0, 1, 2)

#

108        return x

#

බහු-Dconv-හිසඅවධානය (MDHA)

අපි බහු-ප්රධාන අවධානය අපගේ මුල් ක්රියාත්මක කිරීම දීර් and කරන අතර විමසුම, යතුර සහ වටිනාකම් ප්රක්ෂේපණ සඳහා අවකාශීය ගැඹුර-නැණවත් සම්මුතිය එක් කරමු.

111class MultiDConvHeadAttention(MultiHeadAttention):

#

119    def __init__(self, heads: int, d_model: int, dropout_prob: float = 0.1):
120        super().__init__(heads, d_model, dropout_prob)

#

බහු-ප්රධාන අවධානය විමසුම නිර්මාණය කරනු ඇත, ප්රධාන සහ අගය ප්රක්ෂේපනය මොඩියුල self.query self.key , සහ self.value .

අපිඔවුන් එක් එක් කිරීමට අවකාශීය ගැඹුර-නැණවත් convolution ස්ථරය ඒකාබද්ධ හා වෙනුවට self.query self.key , සහ self.value .

📝 මෙය සහ වැනිලා ට්රාන්ස්ෆෝමර් බහු-හිස අවධානය අතර වෙනස පැහැදිලිව පෙන්වන බැවින් මෙම පිරිසිදු ක්රියාත්මක කිරීම තේරුම් ගැනීම පහසු යැයි අපට හැඟේ.

130        self.query = nn.Sequential(self.query, SpatialDepthWiseConvolution(self.d_k))
131        self.key = nn.Sequential(self.key, SpatialDepthWiseConvolution(self.d_k))
132        self.value = nn.Sequential(self.value, SpatialDepthWiseConvolution(self.d_k))