#

පොන්ඩර්නෙට්: මෙනෙහි කිරීමට ඉගෙනීම

මෙය PonderNet කඩදාසි PyTorch ක්රියාත්මක කිරීම: පොන්ඩර් වෙත ඉගෙනීම .

PonderNetආදානය මත පදනම්ව ගණනය කිරීම අනුවර්තනය කරයි. ආදානය මත පදනම්ව පුනරාවර්තන ජාලයක් සඳහා ගත යුතු පියවර ගණන එය වෙනස් කරයි. පොන්ඩර්නෙට් මෙය ඉගෙන ගන්නේ අවසානය සිට අවසානය දක්වා වූ ශ්රේණියේ සම්භවයක් සමඟය.

පොන්ඩර්නෙට්හි ආකෘතියේ පියවර ශ්රිතයක් ඇත

$\overset{y}{^}_{n}, h_{n + 1}, λ_{n} = s (x, h_{n})$

$x$ ආදානය කොතැනද, $\overset{y}{^}_{n}$ ප්රාන්තය ද $n$ , පියවරෙන් පියවර පුරෝකථනය $λ_{n}$ ද, $h_{n}$ වර්තමාන පියවරේදී නතර කිරීමේ සම්භාවිතාව (නතර කිරීම).

$s$ ඕනෑම ස්නායුක ජාලයක් විය හැකිය (උදා: LSTM, MLP, GRU, අවධානය යොමු කිරීමේ ස්ථරය).

පියවරෙන්පියවර නතර කිරීමේ කොන්දේසි විරහිත සම්භාවිතාව $n$ නම්,

$p_{n} = λ_{n} j = 1 \prod n - 1 (1 - λ_{j})$

පෙරකිසිදු පියවරකින් නතර නොවී පියවරෙන් පියවර නතර කිරීමේ සම්භාවිතාව මෙයයි $n$ .

අනුමානයඅතරතුර, අපි නතර කිරීමේ සම්භාවිතාව මත පදනම්ව නියැදීමෙන් නතර $λ_{n}$ කර අවසාන නිමැවුම $\overset{y}{^}_{n}$ ලෙස අඩක් ස්ථරයේ පුරෝකථනය ලබා ගනිමු.

පුහුණුවඅතරතුර, අපි සියලු ස්ථරවලින් අනාවැකි ලබා ගන්නා අතර ඒවා එක් එක් සඳහා පාඩු ගණනය කරමු. ඉන්පසු එක් එක් ස්ථරයේ නතර වීමේ සම්භාවිතාව මත පදනම්ව අලාභයේ බර තැබූ සාමාන්යය ගන්න $p_{n}$ .

පියවරශ්රිතය පරිත්යාග කරන ලද උපරිම පියවර ගණනකට අදාළ $N$ වේ.

පොන්ඩර්නෙට්හි සමස්ත අලාභය වන්නේ

L L_{R ec} L_{R e g} = L_{R ec} + β L_{R e g} = n = 1 \sum N p_{n} L (y, \overset{y}{^}_{n}) = K L (p_{n} ∥ p_{G} (λ_{p}))

$L$ ඉලක්කය $y$ හා අනාවැකිය අතර සාමාන්ය පාඩු කාර්යය $\overset{y}{^}_{n}$ වේ.

$K L$ යනු කුල්බැක් - ලයිබ්ලර් අපසරනයයි.

$p_{G}$ යනු පරාමිතිකරණය කරන ලද ජ්යාමිතික බෙදා $λ_{p}$ හැරීමයි . $λ_{p}$ සමග කිසිදු සම්බන්ධයක් නැත $λ_{n}$ ; අපි හුදෙක් කඩදාසි ලෙස එම අංකනය ඇලී සිටිති. $P r_{p_{G} (λ_{p})} (X = k) = (1 - λ_{p})^{k} λ_{p}$ .

නියාමනයකිරීමේ අලාභය ජාලය $\frac{1}{λ _{p}}$ පියවර ගැනීම සඳහා නැඹුරුව ඇති අතර සියලු පියවර සඳහා ශුන්ය නොවන සම්භාවිතාවන් දිරිගන්වයි; එනම් ගවේෂණය ප්රවර්ධනය කරයි.

Pority Task පිළිබඳ පොන්ඩර්නෙට් පුහුණු experiment.py කිරීම සඳහා පුහුණු කේතය මෙන්න.

65from typing import Tuple
66
67import torch
68from torch import nn
69
70from labml_helpers.module import Module

#

සමානාත්මතාකාර්ය සඳහා GRU සමඟ පොන්ඩර්නෙට්

මෙයපියවර ශ්රිතය ලෙස GRU සෛලයක් භාවිතා කරන සරල ආකෘතියකි.

මෙමආකෘතිය ආදාන දෛශිකයක් වන Parity Task සඳහා වේ n_elems . දෛශිකයේ සෑම මූලද්රව්යයක්ම එක්කෝ 0 , 1 නැතහොත් -1 ප්රතිදානය යනු සමානාත්මතාවයයි - 1 s ගණන ඔත්තේ නම් සත්ය වන ද්විමය අගයකි සහ වෙනත් ආකාරයකින් අසත්යය.

ආකෘතියේපුරෝකථනය යනු සමානාත්මතාවයේ ලොග් $1$ සම්භාවිතාවයි.

73class ParityPonderGRU(Module):

#

n_elems ආදාන දෛශිකයේ මූලද්රව්ය ගණන
n_hidden GRU හි රාජ්ය දෛශික ප්රමාණය වේ
max_steps පියවර උපරිම සංඛ්යාව $N$

87    def __init__(self, n_elems: int, n_hidden: int, max_steps: int):

#

93        super().__init__()
94
95        self.max_steps = max_steps
96        self.n_hidden = n_hidden

#

GRU $h_{n + 1} = s_{h} (x, h_{n})$

100        self.gru = nn.GRUCell(n_elems, n_hidden)

#

$\overset{y}{^}_{n} = s_{y} (h_{n})$ අපට ආදානය $x$ ලෙස $h$ සහ ආදානය ලෙස ස්තරයක් භාවිතා කළ හැකි නමුත් සරල බව සඳහා අපි මෙය සමඟ ගියෙමු.

104        self.output_layer = nn.Linear(n_hidden, 1)

#

$λ_{n} = s_{λ} (h_{n})$

106        self.lambda_layer = nn.Linear(n_hidden, 1)
107        self.lambda_prob = nn.Sigmoid()

#

ගණනයඇත්තටම අනුමාන කාලය නතර කරන බව එසේ අනුමානය තුළ සකස් කිරීමට විකල්පයක්

109        self.is_halt = False

#

x හැඩයේ ආදානය වේ [batch_size, n_elems]

මෙමtensors හතරක් tuple ප්රතිදානය:

1. $p_{1} \dots p_{N}$ හැඩයේ ආතතියෙන් [N, batch_size] 2. $\overset{y}{^}_{1} \dots \overset{y}{^}_{N}$ හැඩයේ ආතතියක් තුළ [N, batch_size] - සමානාත්මතාවයේ ලොග් සම්භාවිතාව $1$ 3. $p_{m}$ හැඩය [batch_size] 4. $\overset{y}{^}_{m}$ මෙම ගණනය පියවර නතර කරන ලදී [batch_size] එහිදී හැඩය $m$

111    def forward(self, x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:

#

124        batch_size = x.shape[0]

#

අපටආරම්භක තත්වය ලැබේ $h_{1} = s_{h} (x)$

127        h = x.new_zeros((x.shape[0], self.n_hidden))
128        h = self.gru(x, h)

#

ගබඩාකිරීමට ලැයිස්තු $p_{1} \dots p_{N}$ සහ $\overset{y}{^}_{1} \dots \overset{y}{^}_{N}$

131        p = []
132        y = []

#

$\prod_{j = 1}^{n - 1} (1 - λ_{j})$

134        un_halted_prob = h.new_ones((batch_size,))

#

සාම්පලගණනය කිරීම නවතා දමා ඇති නඩත්තු කිරීම සඳහා දෛශිකයක්

137        halted = h.new_zeros((batch_size,))

#

$p_{m}$ හා $\overset{y}{^}_{m}$ එහිදී ගණනය පියවර නතර කරන ලදී $m$

139        p_m = h.new_zeros((batch_size,))
140        y_m = h.new_zeros((batch_size,))

#

$N$ පියවර සඳහා අවධාරණය කරන්න

143        for n in range(1, self.max_steps + 1):

#

අවසානපියවර $λ_{N} = 1$ සඳහා නතර කිරීමේ සම්භාවිතාව

145            if n == self.max_steps:
146                lambda_n = h.new_ones(h.shape[0])

#

$λ_{n} = s_{λ} (h_{n})$

148            else:
149                lambda_n = self.lambda_prob(self.lambda_layer(h))[:, 0]

#

$\overset{y}{^}_{n} = s_{y} (h_{n})$

151            y_n = self.output_layer(h)[:, 0]

#

$p_{n} = λ_{n} j = 1 \prod n - 1 (1 - λ_{j})$

154            p_n = un_halted_prob * lambda_n

#

යාවත්කාලීනකරන්න $\prod_{j = 1}^{n - 1} (1 - λ_{j})$

156            un_halted_prob = un_halted_prob * (1 - lambda_n)

#

නතරකිරීමේ සම්භාවිතාව මත පදනම්ව නතර කරන්න $λ_{n}$

159            halt = torch.bernoulli(lambda_n) * (1 - halted)

#

එකතුකරන්න $p_{n}$ සහ $\overset{y}{^}_{n}$

162            p.append(p_n)
163            y.append(y_n)

#

යාවත්කාලීනකිරීම $p_{m}$ සහ වර්තමාන පියවරේදී නවතා දැමූ දේ මත $\overset{y}{^}_{m}$ පදනම්ව $n$

166            p_m = p_m * (1 - halt) + p_n * halt
167            y_m = y_m * (1 - halt) + y_n * halt

#

නතරකරන ලද සාම්පල යාවත්කාලීන කරන්න

170            halted = halted + halt

#

ඊළඟතත්වය ලබා ගන්න $h_{n + 1} = s_{h} (x, h_{n})$

172            h = self.gru(x, h)

#

සියලුමසාම්පල නතර කර ඇත්නම් ගණනය කිරීම නවත්වන්න

175            if self.is_halt and halted.sum() == batch_size:
176                break

#

179        return torch.stack(p), torch.stack(y), p_m, y_m

#

ප්රතිසංස්කරණඅලාභය

$L_{R ec} = n = 1 \sum N p_{n} L (y, \overset{y}{^}_{n})$

$L$ ඉලක්කය $y$ හා අනාවැකිය අතර සාමාන්ය පාඩු කාර්යය $\overset{y}{^}_{n}$ වේ.

182class ReconstructionLoss(Module):

#

loss_func පාඩු ශ්රිතය වේ $L$

191    def __init__(self, loss_func: nn.Module):

#

195        super().__init__()
196        self.loss_func = loss_func

#

p හැඩයේ ආතතියෙන් යුක්ත වේ $p_{1} \dots p_{N}$ [N, batch_size]
y_hat හැඩයේ ආතතියෙන් යුක්ත වේ $\overset{y}{^}_{1} \dots \overset{y}{^}_{N}$ [N, batch_size, ...]
y හැඩයේ ඉලක්කයයි [batch_size, ...]

198    def forward(self, p: torch.Tensor, y_hat: torch.Tensor, y: torch.Tensor):

#

එකතුව $\sum_{n = 1}^{N} p_{n} L (y, \overset{y}{^}_{n})$

206        total_loss = p.new_tensor(0.)

#

නැවතනැවත කරන්න $N$

208        for n in range(p.shape[0]):

#

$p_{n} L (y, \overset{y}{^}_{n})$ එක් එක් නියැදිය සහ ඒවායේ මධ්යන්යය සඳහා

210            loss = (p[n] * self.loss_func(y_hat[n], y)).mean()

#

සම්පූර්ණඅලාභයට එකතු කරන්න

212            total_loss = total_loss + loss

#

215        return total_loss

#

අලාභයවිධිමත් කිරීම

$L_{R e g} = K L (p_{n} ∥ p_{G} (λ_{p}))$

$K L$ යනු කුල්බැක් - ලයිබ්ලර් අපසරනයයි.

$p_{G}$ යනු පරාමිතිකරණය කරන ලද ජ්යාමිතික බෙදා $λ_{p}$ හැරීමයි . $λ_{p}$ සමග කිසිදු සම්බන්ධයක් නැත $λ_{n}$ ; අපි හුදෙක් කඩදාසි ලෙස එම අංකනය ඇලී සිටිති. $P r_{p_{G} (λ_{p})} (X = k) = (1 - λ_{p})^{k} λ_{p}$ .

විධිමත්කිරීමේ අලාභය ජාලය $\frac{1}{λ _{p}}$ පියවර ගැනීම කෙරෙහි නැඹුරුවීම සහ සියලු පියවර සඳහා ශුන්ය නොවන සම්භාවිතාවන් දිරිගැන්වීම; එනම් ගවේෂණය ප්රවර්ධනය කරයි.

218class RegularizationLoss(Module):

#

lambda_p යනු $λ_{p}$ - ජ්යාමිතික ව්යාප්තියේ සාර්ථක සම්භාවිතාව
max_steps ඉහළම $N$ ; අපි මෙය පූර්ව ගණනය කිරීමට භාවිතා කරමු $p_{G} (λ_{p})$

234    def __init__(self, lambda_p: float, max_steps: int = 1_000):

#

239        super().__init__()

#

ගණනයකිරීම සඳහා හිස් දෛශිකය $p_{G} (λ_{p})$

242        p_g = torch.zeros((max_steps,))

#

$(1 - λ_{p})^{k}$

244        not_halted = 1.

#

නැවතනැවත කරන්න max_steps

246        for k in range(max_steps):

#

$P r_{p_{G} (λ_{p})} (X = k) = (1 - λ_{p})^{k} λ_{p}$

248            p_g[k] = not_halted * lambda_p

#

යාවත්කාලීනකරන්න $(1 - λ_{p})^{k}$

250            not_halted = not_halted * (1 - lambda_p)

#

සුරකින්න $P r_{p_{G} (λ_{p})}$

253        self.p_g = nn.Parameter(p_g, requires_grad=False)

#

එල්. එල්-අපසරනය අහිමි

256        self.kl_div = nn.KLDivLoss(reduction='batchmean')

#

p හැඩයේ ආතතියෙන් යුක්ත වේ $p_{1} \dots p_{N}$ [N, batch_size]

258    def forward(self, p: torch.Tensor):

#

p වෙත සම්ප්රේෂණය කරන්න [batch_size, N]

263        p = p.transpose(0, 1)

#

$P r_{p_{G} (λ_{p})}$ දක්වා ලබා ගැනීමට $N$ හා කණ්ඩායම මානයක් හරහා එය පුළුල්

265        p_g = self.p_g[None, :p.shape[1]].expand_as(p)

#

කේඑල්-අපසරනයගණනය කරන්න. Pytorch KL-අපසරනය ක්රියාත්මක කිරීම ලොග් සම්භාවිතාව පිළිගනී.

270        return self.kl_div(p.log(), p_g)