#

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

මෙය PyTorch කඩදාසි ක්රියාත්මක කිරීමකි අවධානය නිදහස් ට්රාන්ස්ෆෝමර් .

මෙමලිපිය ස්වයං අවධානය ස්තරය නව කාර්යක්ෂම මෙහෙයුමකින් ප්රතිස්ථාපනය කරයි, $T$ එය මතක සංකීර්ණතාවයක් ඇත $O (T d)$ , අනුක්රමයේ දිග කොතැනද $d$ ? කාවැද්දීම් වල මානය.

කඩදාසිAFT සහ AFT හඳුන්වා දෙයි AFT සහ AFT-conv. මෙන්න අපි ස්වයංක්රීය ප්රතිගාමී ආකෘතියක් තුළ සමීප ටෝකන කෙරෙහි අවධානය යොමු කරන AFT- දේශීය ක්රියාත්මක කර ඇත්තෙමු.

අවධානයනිදහස් ට්රාන්ස්ෆෝමර්

AFT( MHAසමාන) පළමු විමසුම $X$ බවට කාවැද්දීම් පරිවර්තනය $Q = X W^{Q}$ , සමග ප්රධාන $K = X W^{K}$ හා අගය $V = X W^{V}$ tensors ඉගෙන ගත් බර. එක් එක් ස්ථානය සඳහා ප්රතිදානය පහත සඳහන් මෙහෙයුම සමඟ ගණනය කරනු $t \in [1, T]$ ලැබේ.

$Y_{t} = σ (Q_{t}) ⊙ \frac{\sum _{t^{'} = 1}^{T} e x p ( K _{t^{'}} + w _{t, t^{'}} ) ⊙ V _{t^{'}}}{\sum _{t^{'} = 1}^{T} e x p ( K _{t^{'}} + w _{t, t^{'}} )}$

,මූලද්රව්ය-wise ානවන්ත නිෂ්පාදනයක් කොහෙද $⊙$ , $σ$ -ෙර්ඛීය නොවන $w \in R^{T \times T}$ වේ (සිග්මෝයිඩ්) හා යුගල-නැණවත් තත්ත්වය අගතීන් උගත් න්යාසය වේ.

මෙයින්අදහස් කරන්නේ අපි අගයන් බරිත සාමාන්යය ගෙන විමසුම මගින් ඒවා ගුණ කරන බවයි. මෙමඟින් MHA අවශ්ය $T \times T$ අවධානය යොමු කිරීමේ අනුකෘතිය ගණනය කිරීමේ අවශ්යතාවය ඉවත් කරන අතර එම නිසා මතක අවශ්යතාවය අඩු කරයි.

AFTදේශීය

AFTදේශීය වශයෙන් උගත් යුගල-නැණවත් ස්ථාන අගතීන් පමණක් දේශීයව අදාළ වේ:

w_{t, t^{'}}^{'} = {w_{t, t^{'}}, 0, for ∣ t - t^{'} ∣ < s otherwi s e

,දේශීය කවුළු $s \leq T$ ප්රමාණය කොහේද?

දේශීයකවුළුවෙන් $0$ පිටත $w_{t, t^{'}}^{'}$ වුවද AFT මෙහෙයුම තවමත් වෙනත් ප්රදේශවලින් යතුරු වටිනාකම් යුගල භාවිතා කරයි. දේශීය කවුළුවෙන් පිටත කාවැද්දීම් සම්පූර්ණයෙන්ම නොපෙනෙන දේශීය ට්රාන්ස්ෆෝමර් වලට වඩා මෙය වෙනස් වේ.

AFTදේශීය ආකෘතියක් සඳහා පුහුණු කේතය මෙන්න.

61from typing import Optional
62
63import torch
64from torch import nn
65
66from labml_helpers.module import Module

#

AFTදේශීය මෙහෙයුම

$Y_{t} = σ (Q_{t}) ⊙ \frac{\sum _{t^{'} = 1}^{T} e x p ( K _{t^{'}} + w _{t, t^{'}} ) ⊙ V _{t^{'}}}{\sum _{t^{'} = 1}^{T} e x p ( K _{t^{'}} + w _{t, t^{'}} )}$

කොහෙද,

w_{t, t^{'}}^{'} = {w_{t, t^{'}}, 0, for ∣ t - t^{'} ∣ < s otherwi s e

69class AFTLocal(Module):

#

d_model යනු query , key සහ value දෛශිකවල ඇති ලක්ෂණ ගණන වේ.
seq_len වේ $T$
local_window_size දේශීය කවුළු ප්රමාණයයි $s$
bias සඳහා පරිවර්තනයන් සඳහා නැඹුරුව පරාමිතිය තිබිය යුතුද යන්න $Q$ , $K$ සහ $V$ .

88    def __init__(self, d_model: int, seq_len: int, local_window_size: int, bias: bool = True):

#

96        super().__init__()

#

දේශීයකවුළු ප්රමාණය $s$

99        self.local_window_size = local_window_size

#

මේවාපරිණාමනය කරයි query , key සහ value දෛශික.

101        self.query = nn.Linear(d_model, d_model, bias=bias)
102        self.key = nn.Linear(d_model, d_model, bias=bias)
103        self.value = nn.Linear(d_model, d_model, bias=bias)

#

යුගල-නැණවත්ස්ථානීය අගතීන් $w \in R^{T \times T}$

105        self.pos_bias = nn.Parameter(torch.zeros(seq_len, seq_len), requires_grad=True)

#

සඳහාමාස්ක් $w_{t, t^{'}}$

107        self.local_mask = nn.Parameter(self.create_local_mask(seq_len, local_window_size), requires_grad=False)

#

සක්‍රීයකිරීම $σ$

109        self.activation = nn.Sigmoid()

#

ප්රතිදානස්ථරය

111        self.output = nn.Linear(d_model, d_model)

#

දේශීයවෙස් මුහුණ සාදන්න

මෙයවෙස් මුහුණක් නිර්මාණය කරයි

m_{t, t^{'}} = {1, 0, for ∣ t - t^{'} ∣ < s otherwi s e

113    @staticmethod
114    def create_local_mask(seq_len, local_window_size):

#

ඒවාටමුල පුරන්න

130        local_mask = torch.ones(seq_len, seq_len, dtype=torch.bool)

#

$t^{'} - t \geq s$ ශුන්ය කරන්න

132        local_mask = torch.tril(local_mask, local_window_size - 1)

#

$t - t^{'} \geq s$ ශුන්ය කරන්න

134        local_mask = torch.triu(local_mask, -(local_window_size - 1))

#

137        return local_mask

#

query , key සහ value විමසුම, යතුරසහ වටිනාකමසඳහා ටෝකන් කාවැද්දීම් එකතු කිරීම ගබඩා කරන ආතතීන් වේ. ඒවායේ හැඩය ඇත [seq_len, batch_size, d_model] .

mask හැඩය ඇති [seq_len, seq_len, batch_size] අතර කණ්ඩායම සඳහා b , ස්ථානයේ විමසුමට ප්රවේශය i තිබේද යන්න mask[i, j, b] දක්වයි ස්ථානයේ ප්රධාන-අගය j .

139    def forward(self, *,
140                query: torch.Tensor,
141                key: torch.Tensor,
142                value: torch.Tensor,
143                mask: Optional[torch.Tensor] = None):

#

query , key value සහ හැඩය [seq_len, batch_size, d_model]

155        seq_len, _, _ = query.shape
156
157        if mask is not None:

#

mask හැඩය ඇත [seq_len_q, seq_len_k, batch_size] , එහිදී පළමු මානය විමසුම් මානයක් වේ. විමසුම මානයක් සමාන වේ නම් $1$ එය විකාශනය කරනු ඇත.

161            assert mask.shape[0] == 1 or mask.shape[0] == query.shape[0]
162            assert mask.shape[1] == key.shape[0]
163            assert mask.shape[2] == 1 or mask.shape[2] == query.shape[1]

#

විමසුම, යතුර සහ අගය කාවැද්දීම් පරිවර්තනය කරන්න

166        query = self.query(query)
167        key = self.key(key)
168        value = self.value(value)

#

ලබාගන්න

w_{t, t^{'}}^{'} = {w_{t, t^{'}}, 0, for ∣ t - t^{'} ∣ < s otherwi s e

වෙස්මුහුණභාවිතා කිරීම

181        pos_bias = self.pos_bias[:seq_len, :seq_len] * self.local_mask[:seq_len, :seq_len]
182        pos_bias = pos_bias.unsqueeze(-1)
183        pos_bias.masked_fill_(~mask, float('-inf'))

#

Y_{t} = σ (Q_{t}) ⊙ \frac{\sum _{t^{'} = 1}^{T} exp ( K _{t^{'}} + w _{t, t^{'}} ) ⊙ V _{t^{'}}}{\sum _{t^{'} = 1}^{T} exp ( K _{t^{'}} + w _{t, t^{'}} )} = σ (Q_{t}) ⊙ \frac{\sum _{t^{'} = 1}^{T} e x p ( w _{t, t^{'}} ) ⊙ e x p ( K _{t^{'}} ) ⊙ V _{t^{'}}}{\sum _{t^{'} = 1}^{T} e x p ( w _{t, t^{'}} ) ⊙ e x p ( K _{t^{'}} )}

අපිගණනය $e x p (K_{t^{'}}) ⊙ V_{t^{'}}$ කර $e x p (w_{t, t^{'}})$ , $e x p (K_{t^{'}})$ වෙන වෙනම සහ අනුකෘති ගුණ කිරීමක් කරන්නෙමු. අපි පැහැදිලි කිරීම සඳහා einsum භාවිතා කරමු.

#

සොෆ්ට්මැක්ස්ගණනය ස්ථාවර කිරීම සඳහා ඝාතකයන් ගණනය කිරීමට $m a x_{t^{'}} (w_{t, t^{'}})$ පෙර අපි අඩු $m a x_{t^{'}} (K_{t^{'}})$ කරන්නෙමු.

විශාල $x_{i}$ නම් විශාල $e x p (x_{i})$ වන අතර ගණනය කිරීම අස්ථායී $\frac{\sum e x p ( x _{i} ) y _{i}}{\sum e x p ( x _{i} )}$ වේ. numerator සහ නිකායකය සිට ඝාතීය ගණනය කිරීමට පෙර නියතයක් අඩු කිරීම අවලංගු වනු ඇත. හා ගණනය ස්ථාවර උදව් විය හැක. එබැවින් අපි ගණනය කිරීම ස්ථාවර $max (x_{i})$ කිරීමට අඩු කරමු.

205        max_key = key.max(dim=0, keepdims=True)[0]
206        max_pos_bias = pos_bias.max(dim=1,  keepdims=True)[0]

#

$exp (K_{t^{'}} - m a x_{t^{'}} (K_{t^{'}}))$

209        exp_key = torch.exp(key - max_key)

#

$exp (w_{t, t^{'}} - m a x_{t^{'}} (w_{t, t^{'}}))$

211        exp_pos_bias = torch.exp(pos_bias - max_pos_bias)

#

සංඛ්යාකොටස $\sum_{t^{'} = 1}^{T} e x p (w_{t, t^{'}}) ⊙ e x p (K_{t^{'}}) ⊙ V_{t^{'}}$

214        num = torch.einsum('ijb,jbd->ibd', exp_pos_bias, exp_key * value)

#

මෙමහරය කොටසක් $\sum_{t^{'} = 1}^{T} e x p (w_{t, t^{'}}) ⊙ e x p (K_{t^{'}})$

216        den = torch.einsum('ijb,jbd->ibd', exp_pos_bias, exp_key)

#

ප්රතිදාන $Y_{t} = σ (Q_{t}) ⊙ \frac{\sum _{t^{'} = 1}^{T} e x p ( w _{t, t^{'}} ) ⊙ e x p ( K _{t^{'}} ) ⊙ V _{t^{'}}}{\sum _{t^{'} = 1}^{T} e x p ( w _{t, t^{'}} ) ⊙ e x p ( K _{t^{'}} )}$

221        y = self.activation(query) * num / den

#

ප්රතිදානස්ථරය

224        return self.output(y)

#

දේශීයවෙස් මුහුණ පරීක්ෂා කරන්න

227def _test_local_mask():

#

231    from labml.logger import inspect
232    inspect(AFTLocal.create_local_mask(10, 4))

#

236if __name__ == '__main__':
237    _test_local_mask()