#

生成对抗网络 (GAN)

生成@@

器 $G (z z; θ_{g})$ 生成与数据分布相匹配的样本，而鉴别器则 $D (x x; θ_{g})$ 给出来自数据而不是 $x x$ 来自数据的概率 $G$ 。

我们在具有值功能的双人最小最大游戏中 $G$ 同时进行训练 $D$ $V (G, D)$ 。

$G min D max V (D, G) = E_{x x \sim p_{d a t a} (x x)} [lo g D (x x)] + E_{z z \sim p_{z z} (z z)} [lo g (1 - D (G (z z))]$

$p_{d a t a} (x x)$ 是数据的概率分布，而 $p_{z z} (z z)$ 概率分 $z z$ 布则设置为高斯噪声。

这个文件定义了损失函数。这是一个 MNIST 示例，其中包含两个用于生成器和鉴别器的多层感知器。

34import torch
35import torch.nn as nn
36import torch.utils.data
37import torch.utils.data
38
39from labml_helpers.module import Module

#

鉴别器丢失

鉴别器应该在梯度上升，

$\nabla_{θ_{d}} \frac{1}{m} i = 1 \sum m [lo g D (x x^{(i)}) + lo g (1 - D (G (z z^{(i)})))]$

$m$ 是微型批次大小， $(i)$ 用于索引微型批次中的样本。 $x x$ 是来自的样本 $p_{d a t a}$ ， $z z$ 也是来自的样本 $p_{z}$ 。

42class DiscriminatorLogitsLoss(Module):

#

57    def __init__(self, smoothing: float = 0.2):
58        super().__init__()

#

我们使用 PyTorch 二进制交叉熵损失 $- \sum [y lo g (\overset{y}{^}) + (1 - y) lo g (1 - \overset{y}{^})]$ ，也就是说，标签在 $y$ 哪里，预测在 $\overset{y}{^}$ 哪里。注意负号。我们使用等于 for fro $1$ m $x x$ 的标签 $p_{d a t a}$ 和等于 f $0$ or from $x x$ 的标签 $p_{G} .$ 然后按这些总和降序与上面的梯度上升相同。

BCEWithLogitsLoss 结合了 softmax 和二进制交叉熵损失。

69        self.loss_true = nn.BCEWithLogitsLoss()
70        self.loss_false = nn.BCEWithLogitsLoss()

#

我们使用标签平滑，因为它在某些情况下效果更好

73        self.smoothing = smoothing

#

标签注册为缓冲区，并将持久性设置为False 。

76        self.register_buffer('labels_true', _create_labels(256, 1.0 - smoothing, 1.0), False)
77        self.register_buffer('labels_false', _create_labels(256, 0.0, smoothing), False)

#

logits_true 是 logits 来自 $D (x x^{(i)})$ ，logits_false logits 来自 $D (G (z z^{(i)}))$

79    def forward(self, logits_true: torch.Tensor, logits_false: torch.Tensor):

#

84        if len(logits_true) > len(self.labels_true):
85            self.register_buffer("labels_true",
86                                 _create_labels(len(logits_true), 1.0 - self.smoothing, 1.0, logits_true.device), False)
87        if len(logits_false) > len(self.labels_false):
88            self.register_buffer("labels_false",
89                                 _create_labels(len(logits_false), 0.0, self.smoothing, logits_false.device), False)
90
91        return (self.loss_true(logits_true, self.labels_true[:len(logits_true)]),
92                self.loss_false(logits_false, self.labels_false[:len(logits_false)]))

#

发电机损失

发电机应该下降到梯度上，

$\nabla_{θ_{g}} \frac{1}{m} i = 1 \sum m [lo g (1 - D (G (z z^{(i)})))]$

95class GeneratorLogitsLoss(Module):

#

105    def __init__(self, smoothing: float = 0.2):
106        super().__init__()
107        self.loss_true = nn.BCEWithLogitsLoss()
108        self.smoothing = smoothing

#

我们使用等于 f $1$ or fro $x x$ m 的标签， $p_{G} .$ 然后在此损失上降序与上面梯度上的降序相同。

112        self.register_buffer('fake_labels', _create_labels(256, 1.0 - smoothing, 1.0), False)

#

114    def forward(self, logits: torch.Tensor):
115        if len(logits) > len(self.fake_labels):
116            self.register_buffer("fake_labels",
117                                 _create_labels(len(logits), 1.0 - self.smoothing, 1.0, logits.device), False)
118
119        return self.loss_true(logits, self.fake_labels[:len(logits)])

#

创建经过平滑处理的标注

122def _create_labels(n: int, r1: float, r2: float, device: torch.device = None):

#

126    return torch.empty(n, 1, requires_grad=False, device=device).uniform_(r1, r2)