#

නොපැහැදිලි ටයිල් සක්රීය කිරීමේ අත්හදා බැලීම

මෙන්න අපි Feed-Forward ජාලයේ Fuzzy Tiling Activation භාවිතා කරන ට්රාන්ස්ෆෝමරයක් පුහුණු කරමු. අපි එය භාෂා ආකෘතියක් සඳහා භාවිතා කරන අතර නිරූපණය සඳහා කුඩා ෂේක්ස්පියර් දත්ත කට්ටලය මත එය පුහුණු කරමු.

කෙසේ වෙතත්, මෙය බොහෝ විට FTA සඳහා සුදුසුම කාර්යය නොවන අතර අඛණ්ඩ විචල්යයන් සහිත දත්ත ආකෘතිකරණය සඳහා FTA වඩාත් සුදුසු යැයි අපි විශ්වාස කරමු.

21import copy
22
23import torch
24import torch.nn as nn
25
26from labml import experiment
27from labml.configs import option
28from labml_helpers.module import Module
29from labml_nn.activations.fta import FTA
30from labml_nn.experiments.nlp_autoregression import NLPAutoRegressionConfigs
31from labml_nn.transformers import MultiHeadAttention, TransformerLayer
32from labml_nn.transformers.utils import subsequent_mask

#

FTA සක්රිය කිරීම සමඟ FFN මොඩියුලය

35class FeedForwardFTA(nn.Module):

#

d_model යනු ටෝකන කාවැද්දීම තුළ ඇති විශේෂාංග ගණන
d_ff යනු FFN හි සැඟවුණු ස්ථරයේ ඇති ලක්ෂණ ගණන
activation FTA සක්රිය කිරීමේ මොඩියුලය
dropout සැඟවුණු ස්තරය සඳහා අතහැර දැමීමේ සම්භාවිතාව

40    def __init__(self, d_model: int, d_ff: int,
41                 activation: FTA,
42                 dropout: float = 0.1):

#

49        super().__init__()

#

බර $W_{1}$ හා නැඹුරුව අනුව පරාමිතිකරණය කරන ලද එක් ස්ථරය $b_{1}$

51        self.layer1 = nn.Linear(d_model, d_ff)

#

බර $W_{1}$ හා නැඹුරුව අනුව පරාමිතිකරණය කරන ලද ස්ථර දෙකක් $b_{1}$

53        self.layer2 = nn.Linear(d_ff * activation.expansion_factor, d_model)

#

සැඟවුණුස්ථර හැලීම

55        self.dropout = nn.Dropout(dropout)

#

සක්රියකිරීමේ කාර්යය $f$

57        self.activation = activation

#

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

#

$f (x W_{1} + b_{1})$

61        x = self.activation(self.layer1(x))

#

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

63        x = self.dropout(x)

#

65        return self.layer2(x)

#

ස්වයංක්රීයප්රතිගාමී ආකෘතිය

මෙය(නොපැහැදිලි ටයිලිං ඇක්ටිවේෂන්) (index.html) සමඟ ෆීඩ්-ෆෝවර්ඩ් නෙට්වර්ක් භාවිතා කරන ස්වයංක්රීය ප්රතිගාමී ට්රාන්ස්ෆෝමර් ආකෘතියකි.

68class AutoregressiveTransformer(Module):

#

n_tokens යනු වචන මාලාවේ ටෝකන ගණන
d_model කාවැද්දීම ප්රමාණය වේ
n_layers ට්රාන්ස්ෆෝමර් ස්ථර ගණන
layer ස්තරය වේ. අපි ට්රාන්ස්ෆෝමර් සඳහා මෙහි n_layers පිටපත් භාවිතා කරමු.

76    def __init__(self, n_tokens: int, d_model: int, n_layers: int, layer: TransformerLayer):

#

83        super().__init__()

#

n_layers ස්ථර සහිත ට්රාන්ස්ෆෝමර්

85        self.transformer_layers = nn.ModuleList([copy.deepcopy(layer) for _ in range(n_layers)])

#

ටෝකන්කාවැද්දීම ස්ථරය

88        self.emb = nn.Embedding(n_tokens, d_model)

#

කියවීමේස්ථරය

90        self.readout = nn.Linear(d_model, n_tokens)

#

පළමුඇමතුමෙන් වෙස්මුහුණ ආරම්භ කරනු ඇත

93        self.mask = None

#

x හැඩයේ ආදාන ටෝකන වේ [seq_len, batch_size]

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

#

ස්වයංක්රීයප්රතිගාමී වෙස් මුහුණක් සාදන්න

100        if self.mask is None or self.mask.size(0) != len(x):

#

පසුකාලීනවෙස්මුහුණ, අනාගත ටෝකන දැකීමෙන් ටෝකන වසං කරනු ඇත

102            self.mask = subsequent_mask(len(x)).to(x.device)

#

ටෝකන්කාවැද්දීම් ලබා ගන්න

105        x = self.emb(x)

#

ට්රාන්ස්ෆෝමර්එන්කෝඩරය

107        for layer in self.transformer_layers:
108            x = layer(x=x, mask=self.mask)

#

පිවිසුම්ලබා ගන්න

110        x = self.readout(x)

#

ආපසුප්රතිඵල

113        return x, None

#

වින්යාසකිරීම්

මෙයඋරුම වන්නේ NLPAutoRegressionConfigs

116class Configs(NLPAutoRegressionConfigs):

#

ආකෘතිය

125    model: AutoregressiveTransformer

#

ස්ථරගණන

128    n_layers: int = 4

#

$α$ සහ ගැඹුරු සම්මතය $β$ සඳහා

131    deep_norm_alpha: float
132    deep_norm_beta: float

#

අවධානයයොමු කරන හිස් ගණන

135    n_heads: int = 4

#

කාවැද්දීමප්රමාණය

137    d_model: int = 256

#

එක්එක් අවධානය හිස ප්රමාණය

139    d_k: int = 16

#

ඉදිරිස්ථරයේ ප්රමාණය පෝෂණය කරන්න

141    d_ff: int = 256

#

FTA

144    fta_lower_limit: float = -1.
145    fta_upper_limit: float = +1.
146    fta_delta: float = 0.2
147    fta_eta: float = 0.05

#

ආකෘතියආරම්භ කරන්න

150@option(Configs.model)
151def _model(c: Configs):

#

FTAසක්රිය කිරීමේ මොඩියුලය සාදන්න

157    fta = FTA(c.fta_lower_limit, c.fta_upper_limit, c.fta_delta, c.fta_eta)

#

ට්රාන්ස්ෆෝමරයසාදන්න. අපි නැවත භාවිතා කිරීම TransformerLayer MultiHeadAttention සහ ක්රියාත්මක කිරීම.

161    m = AutoregressiveTransformer(c.n_tokens, c.d_model, c.n_layers,
162                                  TransformerLayer(d_model=c.d_model,
163                                                   feed_forward=FeedForwardFTA(d_model=c.d_model,
164                                                                               d_ff=c.d_ff,
165                                                                               activation=fta,
166                                                                               dropout=0.1),
167                                                   self_attn=MultiHeadAttention(c.n_heads, c.d_model,
168                                                                                dropout_prob=0.0),
169                                                   dropout_prob=0.0))

#

උපාංගයවෙත ගෙන යන්න

172    return m.to(c.device)

#

අත්හදාබැලීම නිර්මාණය කර ක්රියාත්මක කරන්න

175def main():

#

අත්හදාබැලීම සාදන්න

180    experiment.create(name="fta", writers={'screen', 'labml'})

#

වින්යාසසාදන්න

182    conf = Configs()

#

වින්යාසයන්අභිබවා යන්න

184    experiment.configs(conf, {

#

අක්ෂරමට්ටමේ ටෝකනයිසර් භාවිතා කරන්න

186        'tokenizer': 'character',

#

කඩිනම්බෙදුම්කරු හිස් ය

188        'prompt_separator': '',

#

නියැදීමසඳහා විමසුමක් ආරම්භ කිරීම

190        'prompt': 'It is ',

#

කුඩාෂේක්ස්පියර් දත්ත කට්ටලය භාවිතා කරන්න

192        'text': 'tiny_shakespeare',

#

කසන්දර්භය ප්රමාණය භාවිතා $256$

195        'seq_len': 256,

#

32වයස අවුරුදු සඳහා දුම්රිය

197        'epochs': 32,

#

කණ්ඩායම්ප්රමාණය $16$

199        'batch_size': 16,

#

එක් $10$ යුගයකට වරක් පුහුණුව සහ වලංගු කිරීම අතර මාරු වන්න

201        'inner_iterations': 10,

#

උනුසුම්වීමක් නොමැති ආදම් ප්රශස්තකරණය

204        'optimizer.optimizer': 'Adam',
205        'optimizer.learning_rate': 3e-4,
206    })

#

ඉතිරිකිරීම සහ පැටවීම සඳහා ආකෘතිය (ය) සකසන්න

209    experiment.add_pytorch_models({'model': conf.model})

#

අත්හදාබැලීම ආරම්භ කරන්න

212    with experiment.start():

#

පුහුණුධාවනය

214        conf.run()

#

218if __name__ == '__main__':
219    main()