#

රොපර් ජෝර්ජස් හාරික් (@gharik)විසින් වැඩ කරනු ලබන අතර, මෙම ක්රියාත්මක කිරීම ඔහුගේ මුල් කේතය මත පදනම් වේ.

සාපේක්ෂදුර (ROPER) සහිත රොටරි ස්ථානීය කාවැද්දීම්

රොටරි ස්ථානීය කාවැද්දීම් (කඹය) අවධානය ලකුණු ගණනය කිරීමේදී සාපේක්ෂ ස්ථාන ඇතුළත් වේ. කෙසේ වෙතත්, කාවැද්දීම් තමන්ම කිසිදු ස්ථානීය තොරතුරක් ලබා නොගනී, එය හේතුකාරක අවධානයෙන් ව්යංගයෙන් ලබා ගත හැකි දේ හැර.

ROPERඅගය කාවැද්දීම් සඳහා සාපේක්ෂ ස්ථානීය තොරතුරු පැහැදිලිව එකතු කරයි. විශේෂයෙන්, එය අවධානය යොමු කළ ටෝකන වල සාපේක්ෂ ස්ථාන එක් කරයි. අපි අවධානය යොමු අගයන් භ්රමණය කිරීමට එම භමණ ස්ථානීය කාවැද්දීම් භාවිතා කරන්න, එවිට, බර තැබූ මුදල ගැනීමෙන් පසු, අපි අවසාන ප්රතිවිරුද්ධ දිශාවට භ්රමණය කරමු. වර්තමාන ස්ථානයට සාපේක්ෂව එක් එක් අගයන් (අවධානයට පෙර) භ්රමණය වීමට සමාන වේ.

රෝප්වලට වඩා සැලකිය යුතු දියුණුවක් දැකිය හැකි අංක ගණිතමය එකතු කිරීමක් මත ROPER සමඟ ට්රාන්ස්ෆෝමර් ආකෘතියක් පුහුණු කිරීම සඳහා පුහුණු කේතය මෙන්න.

කාවැද්දීම්වල සාපේක්ෂ දුර

ඕනෑමහිසක් සඳහා, ස්ථානයේ සිට ස්ථානයට $n$ අවධානය යොමු $v_{i}$ කළ යුතු අතර $i$ , ස්ථානයේ අගය කාවැද්දීම් විය යුතුය $a_{n, i}$ $i$ . අපි තනි ලක්ෂණ ලෙස දක්වයි $v_{i}^{(1)}, v_{i}^{(2)}, \dots$ .

සාමාන්යයෙන්, අපි වටිනාකම් කාවැද්දීම් වල බර එකතුව ගන්නෙමු

$o_{n}^{(j)} = i \sum a_{n, i} v_{i}^{(j)}$

මෙයපැහැදිලිවම අවසාන ප්රති $o_{n}^{(j)}$ . $i$ ලයට තනතුරු පිළිබඳ දුර තොරතුරු එකතු නොකරයි.

ROPERයුගල කඹය වැනි ලක්ෂණ සහ ඒවා පරිවර්තනය කරන්න. යුගලයක් $v_{m}^{(1)}$ සඳහා $v_{m}^{(2)}$ එය ඒවා පරිවර්තනය $R o PE (v_{m}^{(1)}, v_{m}^{(2)}, m)$ කරයි. පරිවර්තනය කරන ලද විශේෂාංග සමඟ පරිත්යාග කරමු $\overset{v}{^}_{m}^{(1)}, \overset{v}{^}_{m}^{(2)}$ . එවිට එය ප්රතිවිරුද්ධ දිශාවට බර තැබූ මුදල $\overset{o}{^}_{n}^{(j)}$ භ්රමණය වේ $R o PE (\overset{o}{^}_{n}^{(1)}, \overset{o}{^}_{n}^{(2)}, - n)$ . සටහන්කරන්න $- n$ .

එයසැලකිල්ලට ගන්න,

R o PE (x_{m}^{(1)}, x_{m}^{(2)}, m) = (c o s m θ s i n m θ - s i n m θ c o s m θ) (x_{m}^{(1)} x_{m}^{(2)}) = (x_{m}^{(1)} c o s m θ - x_{m}^{(2)} s i n m θ x_{m}^{(2)} c o s m θ + x_{m}^{(1)} s i n m θ)

පරිවර්තනයන්සමඟ පසු අවසාන ප්රතිදානය වන්නේ,

R o PE (\overset{o}{^}_{n}^{(1)}, \overset{o}{^}_{n}^{(2)}, - n) (\overset{o}{^}_{n}^{(1)} c o s n θ + \overset{o}{^}_{n}^{(2)} s i n n θ \overset{o}{^}_{n}^{(2)} c o s n θ - \overset{o}{^}_{n}^{(1)} s i n n θ) =

එයසටහන් කර ගන්න $s i n (- n θ) = - s i n n θ$ .

පළමුවාරය පුළුල් කරමු $\overset{o}{^}_{n}^{(1)} c o s n θ + \overset{o}{^}_{n}^{(2)} s i n n θ$ ,

\overset{o}{^}_{n}^{(1)} c o s n θ + \overset{o}{^}_{n}^{(2)} s i n n θ i \sum a_{n, i} \overset{v}{^}_{i}^{(1)} c o s n θ + i \sum a_{n, i} \overset{v}{^}_{i}^{(2)} s i n n θ i \sum a_{n, i} (v_{i}^{(1)} c o s i θ - v_{i}^{(2)} s i n i θ) c o s n θ i \sum a_{n, i} (v_{i}^{(2)} c o s i θ + v_{i}^{(1)} s i n i θ) s i n m θ i \sum a_{n, i} v_{i}^{(1)} (c o s i θ c o s n θ + s i n i θ s i n n θ) i \sum a_{n, i} v_{i}^{(2)} (c o s i θ s i n n θ - s i n i θ c o s n θ) i \sum a_{n, i} v_{i}^{(1)} c o s (i - n) θ - i \sum a_{n, i} v_{i}^{(2)} s i n (i - n) θ i \sum a_{n, i} v_{i}^{(1)} c o s (i - n) θ - i \sum a_{n, i} v_{i}^{(2)} s i n (i - n) θ = = + = + = =

Simiarlyඅපට දෙවන වාරය සමාන බව පෙන්විය හැකිය,

$i \sum a_{n, i} v_{i}^{(1)} c o s (i - n) θ + i \sum a_{n, i} v_{i}^{(2)} s i n (i - n) θ$

ලබාදෙන,

R o PE (\overset{o}{^}_{n}^{(1)}, \overset{o}{^}_{n}^{(2)}, - n) (\sum_{i} a_{n, i} v_{i}^{(1)} c o s (i - n) θ - \sum_{i} a_{n, i} v_{i}^{(2)} s i n (i - n) θ \sum_{i} a_{n, i} v_{i}^{(1)} c o s (i - n) θ + \sum_{i} a_{n, i} v_{i}^{(2)} s i n (i - n) θ) i \sum a_{n, i} R o PE (v_{i}^{(1)}, v_{i}^{(1)}, (i - n) θ) = =

එනම්, වර්තමාන ස්ථානයට සාපේක්ෂව භ්රමණය වන අගයන්හි බරිත සාමාන්යය.

ආර්තමෙටික්එකතු කිරීමේ කාර්යයක් සඳහා ROPER භාවිතා කරනඅත්හදා බැලීමක් මෙන්න .

118from typing import Optional
119
120import torch
121
122from labml_nn.transformers.rope import RotaryPositionalEmbeddings, RotaryPEMultiHeadAttention

#

ප්රතිවිරුද්ධදිශාවට භ්රමණය වන කඹය මොඩියුලය

මෙය කඹය භ්රමණය ක්රියාත්මක කිරීමෙන් උරුම වන අතර දිශාව වෙනස් කරයි.

125class ReverseRotaryPositionalEmbeddings(RotaryPositionalEmbeddings):

#

x යනු යතුරක හිසෙහි ටෙන්සර් හෝ හැඩය සහිත විමසුමකි [seq_len, batch_size, n_heads, d]

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

#

හැඹිලි $c o s$ සහ $s i n$ අගයන්

137        self._build_cache(x)

#

විශේෂාංගබෙදන්න, අපට භ්රමණ කාවැද්දීම් යෙදීමට තෝරා ගත හැක්කේ අර්ධ විශේෂාංග සමූහයකට පමණි.

140        x_rope, x_pass = x[..., :self.d], x[..., self.d:]

#

ගණනයකරන්න $[- x^{(\frac{d}{2} + 1)}, - x^{(\frac{d}{2} + 2)}, ..., - x^{(d)}, x^{(1)}, x^{(2)}, ..., x^{(\frac{d}{2})}]$

144        neg_half_x = self._neg_half(x_rope)

#

ගණනයකරන්න

(x_{m}^{(i)} c o s - m θ_{i} - x_{m}^{(i + \frac{d}{2})} s i n - m θ_{i} x_{m}^{(i + \frac{d}{2})} c o s - m θ_{i} + x_{m}^{(i)} s i n - m θ_{i}) = (x_{m}^{(i)} c o s m θ_{i} + x_{m}^{(i + \frac{d}{2})} s i n m θ_{i} x_{m}^{(i + \frac{d}{2})} c o s m θ_{i} - x_{m}^{(i)} s i n m θ_{i})

සඳහා $i \in 1, 2, ..., \frac{d}{2}$

160        x_rope = (x_rope * self.cos_cached[:x.shape[0]]) - (neg_half_x * self.sin_cached[:x.shape[0]])

#

163        return torch.cat((x_rope, x_pass), dim=-1)

#

භ්රමණස්ථානීය කාවැද්දීම් සහිත බහු-හිස අවධානය

මුල් ට්රාන්ස්ෆෝමරයෙන් අපි බහු-හිස අවධානයඅභිබවා යමු.

166class RotaryValuePEMultiHeadAttention(RotaryPEMultiHeadAttention):

#

173    def __init__(self, heads: int, d_model: int,
174                 rope_percentage: float = 0.5, rope_value_percentage: float = 0.5,
175                 dropout_prob: float = 0.0):
176        super().__init__(heads, d_model, rope_percentage, dropout_prob)

#

භ්රමණස්ථානීය කාවැද්දීමේ ස්ථර

179        d_rope_value = int(self.d_k * rope_value_percentage)
180
181        self.value_rotary_pe = RotaryPositionalEmbeddings(d_rope_value)
182        self.value_reverse_rotary_pe = ReverseRotaryPositionalEmbeddings(d_rope_value)

#

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

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

184    def forward(self, *,
185                query: torch.Tensor,
186                key: torch.Tensor,
187                value: torch.Tensor,
188                mask: Optional[torch.Tensor] = None):

#

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

200        seq_len, batch_size, _ = query.shape
201
202        if mask is not None:
203            mask = self.prepare_mask(mask, query.shape, key.shape)

#

සූදානම්වන්න query , key සහ අවධානය ගණනය කිරීම value සඳහා. මේවාට පසුව හැඩය ඇත [seq_len, batch_size, heads, d_k] .

207        query = self.query(query)
208        key = self.key(key)
209        value = self.value(value)

#

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

213        scores = self.get_scores(query, key)

#

පරිමාණලකුණු $\frac{Q K ^{⊤}}{d _{k}}$

216        scores *= self.scale

#

වෙස්යොදන්න

219        if mask is not None:
220            scores = scores.masked_fill(mask == 0, float('-inf'))

#

$so f t ma x$ ප්රධාන අනුක්රමය මානයක් ඔස්සේ අවධානය $se q so f t ma x (\frac{Q K ^{⊤}}{d _{k}})$

224        attn = self.softmax(scores)

#

අතහැරදැමීම යොදන්න

227        attn = self.dropout(attn)

#

බරතැබූ මුදල ගැනීමට පෙර අගය කාවැද්දීම් කරකවන්න එවිට ස්ථානීය තොරතුරු අඩංගු වේ

230        value = self.value_rotary_pe(value)

#

අගයන්අනුව ගුණ කරන්න $se q so f t ma x (\frac{Q K ^{⊤}}{d _{k}}) V$

234        x = torch.einsum("ijbh,jbhd->ibhd", attn, self.value_rotary_pe(value))

#

එක්එක් කාවැද්දීම සාපේක්ෂ තනතුරු පැවැත්වීමට බව එසේ විරුද්ධ දිශාවට කරකවන්න

237        x = self.value_reverse_rotary_pe(x)

#

වෙනත්ගණනය කිරීම් සඳහා අවධානය සුරකින්න

240        self.attn = attn.detach()

#

බහුහිස් සංයුක්ත කරන්න

243        x = x.reshape(seq_len, batch_size, -1)

#

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

246        return self.output(x)