#

පුනරාවර්තනඅධිවේගී මාර්ග ජාල

මෙය පුනරාවර්තන අධිවේගී මාර්ග ජාල වල PyTorch ක්රියාත්මක කිරීමයි.

11from typing import Optional
12
13import torch
14from torch import nn
15
16from labml_helpers.module import Module

#

පුනරාවර්තනඅධිවේගී මාර්ගයේ ජාලය කල

මෙයසමීකරණ ක්රියාත්මක කරයි $(6) - (9)$ .

$s_{d}^{t} = h_{d}^{t} ⊙ g_{d}^{t} + s_{d - 1}^{t} ⊙ c_{d}^{t}$

කොහේද

h_{0}^{t} g_{0}^{t} c_{0}^{t} = tanh (l i n_{h x} (x) + l i n_{h s} (s_{D}^{t - 1})) = σ (l i n_{g x} (x) + l i n_{g s}^{1} (s_{D}^{t - 1})) = σ (l i n_{c x} (x) + l i n_{cs}^{1} (s_{D}^{t - 1}))

සහසඳහා $0 < d < D$

h_{d}^{t} g_{d}^{t} c_{d}^{t} = tanh (l i n_{h s}^{d} (s_{d}^{t})) = σ (l i n_{g s}^{d} (s_{d}^{t})) = σ (l i n_{cs}^{d} (s_{d}^{t}))

$⊙$ මූලද්රව්ය-නැණවත් ගුණ කිරීම සඳහා වේ.

මෙන්නඅපි කඩදාසි වලින් අංකවල වෙනස්කම් කිහිපයක් කර ඇත්තෙමු. කාලය සමඟ ව්යාකූලත්වය වළක්වා ගැනීම සඳහා $g$ , ගේට්ටුව කඩදාසි $t$ තුළ ඇති විය. බහු ස්ථර සමඟ ව්යාකූලත්වය වළක්වා ගැනීම $d$ සඳහා අපි කඩදාසි වෙනුවට සහ ඉන් $l$ ගැඹුර $D$ සඳහා ගැඹුර සඳහා භාවිතා කරමු. $L$

සමීකරණවලින් බර මැට්ට්රිස් සහ පක්ෂග්රාහී දෛශික රේඛීය පරිවර්තනයන් සමඟ ප්රතිස්ථාපනය කර ඇත, මන්ද එය ක්රියාත්මක කිරීම පෙනෙන්නේ එලෙසිනි.

කඩදාසිවල විස්තර කර ඇති පරිදි අපි බර ගැටගැසීම ක්රියාත්මක කරමු $c_{d}^{t} = 1 - g_{d}^{t}$ .

19class RHNCell(Module):

#

input_size යනු ආදානයේ විශේෂාංග දිග hidden_size වන අතර එය සෛලයේ විශේෂාංග දිග වේ. depth වේ $D$ .

57    def __init__(self, input_size: int, hidden_size: int, depth: int):

#

63        super().__init__()
64
65        self.hidden_size = hidden_size
66        self.depth = depth

#

අපිතනි රේඛීය ස්ථරයක් සමඟ ඒකාබද්ධ $l i n_{h s}$ කරමු. $l i n_{g s}$ එවිට අපට $l i n_{h s}$ සහ $l i n_{g s}$ සංරචක ලබා ගැනීම සඳහා ප්රති results ල බෙදිය හැකිය. මෙය $l i n_{h s}^{d}$ සහ $l i n_{g s}^{d}$ සඳහා $0 \leq d < D$ ය.

70        self.hidden_lin = nn.ModuleList([nn.Linear(hidden_size, 2 * hidden_size) for _ in range(depth)])

#

ඒහා සමානව අපි ඒකාබද්ධ $l i n_{h x}$ වෙමු $l i n_{g x}$ .

73        self.input_lin = nn.Linear(input_size, 2 * hidden_size, bias=False)

#

x හැඩය s ඇති [batch_size, input_size] අතර හැඩය [batch_size, hidden_size] ඇත.

75    def forward(self, x: torch.Tensor, s: torch.Tensor):

#

පුනරාවර්තනයකරන්න $0 \leq d < D$

82        for d in range(self.depth):

#

රේඛීයපරිණාමයන්ගේ සංකෝචනය ගණනය කිරීම $h$ සහ $g$

84            if d == 0:

#

ආදානයභාවිතා $d$ වන්නේ කවදාද යන්න පමණි $0$ .

86                hg = self.input_lin(x) + self.hidden_lin[d](s)
87            else:
88                hg = self.hidden_lin[d](s)

#

ලබාගැනීමට පළමු භාගය භාවිතා hg කරන්න $h_{d}^{t}$

h_{0}^{t} h_{d}^{t} = tanh (l i n_{h x} (x) + l i n_{h s} (s_{D}^{t - 1})) = tanh (l i n_{h s}^{d} (s_{d}^{t}))

96            h = torch.tanh(hg[:, :self.hidden_size])

#

ලබාගැනීමට දෙවන භාගය භාවිතා hg කරන්න $g_{d}^{t}$

g_{0}^{t} g_{d}^{t} = σ (l i n_{g x} (x) + l i n_{g s}^{1} (s_{D}^{t - 1})) = σ (l i n_{g s}^{d} (s_{d}^{t}))

103            g = torch.sigmoid(hg[:, self.hidden_size:])
104
105            s = h * g + s * (1 - g)
106
107        return s

#

බහුස්ථර පුනරාවර්තන අධිවේගී මාර්ග ජාලය

110class RHN(Module):

#

පුනරාවර්තනඅධිවේගී මාර්ග ජාල ස්ථර ජාලයක් නිර්මාණය කරන්න, එක් එක් ගැඹුර depth , $D$ . n_layers

115    def __init__(self, input_size: int, hidden_size: int, depth: int, n_layers: int):

#

120        super().__init__()
121        self.n_layers = n_layers
122        self.hidden_size = hidden_size

#

එක්එක් ස්ථරය සඳහා සෛල සාදන්න. පළමු ස්ථරයට පමණක් ආදානය කෙලින්ම ලැබෙන බව සලකන්න. සෙසු ස්ථර පහත ස්ථරයෙන් ආදානය ලබා ගනී

125        self.cells = nn.ModuleList([RHNCell(input_size, hidden_size, depth)] +
126                                   [RHNCell(hidden_size, hidden_size, depth) for _ in range(n_layers - 1)])

#

x හැඩය state ඇති [seq_len, batch_size, input_size] අතර හැඩය [batch_size, hidden_size] ඇත.

128    def forward(self, x: torch.Tensor, state: Optional[torch.Tensor] = None):

#

133        time_steps, batch_size = x.shape[:2]

#

රාජ්යයආරම්භ කරන්න නම් None

136        if state is None:
137            s = [x.new_zeros(batch_size, self.hidden_size) for _ in range(self.n_layers)]
138        else:

#

එක්එක් ස්ථරයේ තත්වය ලබා ගැනීම සඳහා ප්රතිලෝම රාජ්යය ගොඩගසන්න

📝ඔබට ටෙන්සර් සමඟ වැඩ කළ හැකි නමුත් මෙය නිදොස් කිරීමට පහසුය

142            s = torch.unbind(state)

#

එක්එක් කාල පියවරේදී අවසාන ස්ථරයේ ප්රතිදානයන් එකතු කිරීමට අරා.

145        out = []

#

එක්එක් කාල පියවර සඳහා ජාලය හරහා ධාවනය කරන්න

148        for t in range(time_steps):

#

පළමුස්ථරයට ආදානය යනු ආදානය ම වේ

150            inp = x[t]

#

ස්ථරහරහා ලූප්

152            for layer in range(self.n_layers):

#

ස්ථරයේතත්වය ලබා ගන්න

154                s[layer] = self.cells[layer](inp, s[layer])

#

ඊළඟස්ථරයට ආදානය මෙම ස්ථරයේ තත්වයයි

156                inp = s[layer]

#

අවසානස්ථරයේ ප්රතිදානය එකතු කරන්න

158            out.append(s[-1])

#

ප්රතිදානයන්සහ ප්රාන්ත ගොඩගසන්න

161        out = torch.stack(out)
162        s = torch.stack(s)
163
164        return out, s