#

කැප්සියුලජාල

මෙය PyTorch ක්රියාත්මක කිරීම/නිබන්ධනයකි ඩයිනමික් රවුටින් කැප්සියුල අතර .

කැප්සියුලජාලය යනු ස්නායුක ජාල ගෘහ නිර්මාණ ශිල්පයක් වන අතර එය කැප්සියුල ලෙස ලක්ෂණ කාවැද්දීම සහ ඡන්දය ප්රකාශ කිරීමේ යාන්ත්රණයක් සමඟ ඊළඟ ස්ථරයට ගමන් කරයි.

ආකෘතිවලවෙනත් ක්රියාත්මක කිරීම් වලදී මෙන් නොව, අපි නියැදියක් ඇතුළත් කර ඇත, මන්ද මොඩියුල සමඟ සමහර සංකල්ප තේරුම් ගැනීමට අපහසු බැවිනි. MNIST දත්ත සමුදාය වර්ගීකරණය කිරීම සඳහා කැප්සියුල භාවිතා කරන ආකෘතියක් සඳහා වියුක්ත කේතය මෙයයි

කැප්සියුලනෙට්වර්ක් හි මූලික මොඩියුලවල ක්රියාත්මක කිරීම් මෙම ගොනුව සතුව ඇත.

කඩදාසිසමඟ මා සතුව තිබූ ව්යාකූලතා පැහැදිලි කිරීම සඳහා මම ජින්ඩොන්ග්වාන්ග්/පයිටෝච්-කැප්සුලෙනෙට් භාවිතා කළෙමි.

MNISTදත්ත කට්ටලය පිළිබඳ කැප්සියුල ජාලයක් පුහුණු කිරීම සඳහා සටහන් පොතක් මෙන්න.

33import torch.nn as nn
34import torch.nn.functional as F
35import torch.utils.data
36
37from labml_helpers.module import Module

#

ස්කොෂ්

මෙයසමීකරණයෙන් ලබා දී ඇති කඩදාසි වලින් ස්කොෂ් $(1)$ ශ්රිතයකි.

$v_{j} = \frac{∥ s _{j} ∥ ^{2}}{1 + ∥ s _{j} ∥ ^{2}} \frac{s _{j}}{∥ s _{j} ∥}$

$\frac{s _{j}}{∥ s _{j} ∥}$ එක් එක් ප්රමාණයට වඩා කුඩා දිගක් ඇති කැප්සියුල $\frac{∥ s _{j} ∥ ^{2}}{1 + ∥ s _{j} ∥ ^{2}}$ හැකිලෙන අතර, සියලු කැප්සියුල වල දිග සාමාන්යකරණය කරයි.

40class Squash(Module):

#

55    def __init__(self, epsilon=1e-8):
56        super().__init__()
57        self.epsilon = epsilon

#

හි s හැඩය [batch_size, n_capsules, n_features]

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

#

$∥ s_{j} ∥^{2}$

65        s2 = (s ** 2).sum(dim=-1, keepdims=True)

#

අපිඑය ශුන්ය බවට පත් නොවන බවට වග බලා ගන්න $∥ s_{j} ∥$ කිරීමට ගණනය විට epsilon එකතු. මෙය ශුන්ය බවට පත් වුවහොත් එය nan සාරධර්ම ලබා දීම ආරම්භ කරන අතර පුහුණුව අසමත් වේ. $v_{j} = \frac{∥ s _{j} ∥ ^{2}}{1 + ∥ s _{j} ∥ ^{2}} \frac{s _{j}}{∥ s _{j} ∥ ^{2} + ϵ}$

71        return (s2 / (1 + s2)) * (s / torch.sqrt(s2 + self.epsilon))

#

රවුටින්ඇල්ගොරිතම

කඩදාසිවල විස්තර කර ඇති මාර්ගගත කිරීමේ යාන්ත්රණය මෙයයි. ඔබේ මාදිලිවල බහු රවුටින් ස්ථර භාවිතා කළ හැකිය.

මෙයමෙම ස්තරය $s_{j}$ සඳහා ගණනය කිරීම සහ ක්රියා පටිපාටිය 1හි විස්තර කර ඇති රවුටින් ඇල්ගොරිතම ඒකාබද්ධ කරයි.

74class Router(Module):

#

in_caps යනු කැප්සියුල ගණන in_d වන අතර පහත ස්ථරයෙන් කැප්සියුලයකට ඇති ලක්ෂණ ගණන වේ. out_caps මෙම ස්තරය සඳහා සමාන වේ. out_d

iterations යනු කඩදාසි වලින් සංකේතවත් කරන $r$ මාර්ගගත කිරීමේ පුනරාවර්තන සංඛ්යාවකි.

85    def __init__(self, in_caps: int, out_caps: int, in_d: int, out_d: int, iterations: int):

#

92        super().__init__()
93        self.in_caps = in_caps
94        self.out_caps = out_caps
95        self.iterations = iterations
96        self.softmax = nn.Softmax(dim=1)
97        self.squash = Squash()

#

මෙයබර අනුකෘතියකි $W_{i j}$ . මෙම ස්ථරයේ එක් එක් කැප්සියුලයට පහළ ස්ථරයේ එක් එක් කැප්සියුලය සිතියම්

ගත කරයි

101        self.weight = nn.Parameter(torch.randn(in_caps, out_caps, in_d, out_d), requires_grad=True)

#

හැඩය u වේ [batch_size, n_capsules, n_features] . මේවා පහළ ස්ථරයේ සිට කැප්සියුල වේ.

103    def forward(self, u: torch.Tensor):

#

$\hat{u}_{j ∣ i} = W_{i j} u_{i}$ මෙන්න $j$ මෙම ස්ථරයේ කැප්සියුල දර්ශකය සඳහා භාවිතා $i$ වන අතර පහත ස්ථරයේ (පෙර) කැප්සියුල දර්ශකය කිරීමට භාවිතා කරයි.

112        u_hat = torch.einsum('ijnm,bin->bijm', self.weight, u)

#

ආරම්භකපිවිසුම් $b_{i j}$ යනු කැප්සියුලය සමඟ සම්බන්ධ විය $i$ යුතු ලොග් පූර්ව $j$ සම්භාවිතාවයි. අපි මේවා ශුන්යයෙන් ආරම්භ කරමු

117        b = u.new_zeros(u.shape[0], self.in_caps, self.out_caps)
118
119        v = None

#

පුනරාවර්තනයකරන්න

122        for i in range(self.iterations):

#

සොෆ්ට්මැක්ස්රවුටින් $c_{i j} = \frac{exp ( b _{i j} )}{\sum _{k} exp ( b _{i k} )}$

124            c = self.softmax(b)

#

$s_{j} = i \sum c_{i j} \hat{u}_{j ∣ i}$

126            s = torch.einsum('bij,bijm->bjm', c, u_hat)

#

$v_{j} = s q u a s h (s_{j})$

128            v = self.squash(s)

#

$a_{i j} = v_{j} \cdot \hat{u}_{j ∣ i}$

130            a = torch.einsum('bjm,bijm->bij', v, u_hat)

#

$b_{i j} \leftarrow b_{i j} + v_{j} \cdot \hat{u}_{j ∣ i}$

132            b = b + a
133
134        return v

#

පන්තිපැවැත්ම සඳහා ආන්තික අලාභය

එක්එක් නිමැවුම් කැප්සියුලය සඳහා වෙනම ආන්තික අලාභයක් භාවිතා වන අතර සම්පූර්ණ අලාභය ඒවායේ එකතුවයි. එක් එක් නිමැවුම් කැප්සියුලයේ දිග යනු ආදානයේ පන්තිය පවතින සම්භාවිතාවයි.

එක්එක් නිමැවුම් කැප්සියුලය හෝ පන්තිය සඳහා $k$ නැතිවීම, $L_{k} = T_{k} m a x (0, m^{+} - ∥ v_{k} ∥)^{2} + λ (1 - T_{k}) m a x (0, ∥ v_{k} ∥ - m^{-})^{2}$

$T_{k}$ $k$ යනු පන්තිය පවතින අතර $0$ වෙනත් ආකාරයකින් $1$ නම්. අලාභයේ පළමු සංරචකය වන්නේ පන්තිය නොමැති $0$ විට වන අතර දෙවන සංරචකය වන්නේ පන්තිය පවතී $0$ නම් වේ. අනාවැකි අන්තයට $max (0, x)$ යාම වළක්වා ගැනීමට මෙම භාවිතා කරයි. $m^{+}$ කඩදාසි $0.1$ තුළ සිටීමට $0 .9$ හා $m^{-}$ වීමට සකසා ඇත.

$λ$ පහතට-බර පුහුණු ආරම්භක අදියර තුළ පහත වැටීම සිට සියලු කරල් දිග නතර කිරීම සඳහා භාවිතා වේ.

137class MarginLoss(Module):

#

157    def __init__(self, *, n_labels: int, lambda_: float = 0.5, m_positive: float = 0.9, m_negative: float = 0.1):
158        super().__init__()
159
160        self.m_negative = m_negative
161        self.m_positive = m_positive
162        self.lambda_ = lambda_
163        self.n_labels = n_labels

#

v , $v_{j}$ මෙම squashed ප්රතිදානය කැප්සියුල වේ. මෙය හැඩය ඇත [batch_size, n_labels, n_features] ; එනම්, එක් එක් ලේබලය සඳහා කැප්සියුලයක් ඇත.

labels ලේබල, සහ හැඩය ඇත [batch_size] .

165    def forward(self, v: torch.Tensor, labels: torch.Tensor):

#

$∥ v_{j} ∥$

173        v_norm = torch.sqrt((v ** 2).sum(dim=-1))

#

$L$ labels හැඩයේ එක් උණුසුම් කේතනය කරන ලද ලේබල [batch_size, n_labels]

177        labels = torch.eye(self.n_labels, device=labels.device)[labels]

#

$L_{k} = T_{k} m a x (0, m^{+} - ∥ v_{k} ∥)^{2} + λ (1 - T_{k}) m a x (0, ∥ v_{k} ∥ - m^{-})^{2}$ loss හැඩය ඇත [batch_size, n_labels] . අපි සියලු $L_{k}$ සඳහා ගණනය කිරීම සමාන්තරකරණය කර $k$ ඇත.

183        loss = labels * F.relu(self.m_positive - v_norm) + \
184               self.lambda_ * (1.0 - labels) * F.relu(v_norm - self.m_negative)

#

$k \sum L_{k}$

187        return loss.sum(dim=-1).mean()