CGANs：标签是如何被使用的？

\min _G \max _D V(D, G)=\mathbb{E}x[\log D(x \mid \gamma)]+\mathbb{E}{x^}\left[\log \left(1-D\left(x^ \mid \gamma\right)\right)\right]

1import torch
2import torch.nn as nn
3import torch.nn.functional as F
4import numpy as np

1class Generator(nn.Module):
2    def __init__(self, classes, channels, img_size, latent_dim):
3        super(Generator, self).__init__()
4        self.classes = classes
5        self.channels = channels
6        self.img_size = img_size
7        self.latent_dim = latent_dim
8        self.img_shape = (self.channels, self.img_size, self.img_size)
9        self.label_embedding = nn.Embedding(self.classes, self.classes)
10        self.model = nn.Sequential(
11            *self._create_layer(self.latent_dim + self.classes, 128, False),
12            *self._create_layer(128, 256),
13            *self._create_layer(256, 512),
14            *self._create_layer(512, 1024),
15            nn.Linear(1024, int(np.prod(self.img_shape))),
16            nn.Tanh())
17    def _create_layer(self, size_in, size_out, normalize=True):
18        layers = [nn.Linear(size_in, size_out)]
19        if normalize:
20            layers.append(nn.BatchNorm1d(size_out))
21        layers.append(nn.LeakyReLU(0.2, inplace=True))
22        return layers
23    def forward(self, noise, labels):
24        z = torch.cat((self.label_embedding(labels), noise), -1)
25        x = self.model(z)
26        x = x.view(x.size(0), *self.img_shape)
27        return x

1class Discriminator(nn.Module):
2    def __init__(self, classes, channels, img_size, latent_dim):
3        super(Discriminator, self).__init__()
4        self.classes = classes
5        self.channels = channels
6        self.img_size = img_size
7        self.latent_dim = latent_dim
8        self.img_shape = (self.channels, self.img_size, self.img_size)
9        self.label_embedding = nn.Embedding(self.classes, self.classes)
10        self.adv_loss = torch.nn.BCELoss()
11                self.model = nn.Sequential(
12               *self._create_layer(self.classes +int(np.prod(self.img_shape)), 1024, False, True),
13               *self._create_layer(1024, 512, True, True),
14               *self._create_layer(512, 256, True, True),
15               *self._create_layer(256, 128, False, False),
16               *self._create_layer(128, 1, False, False), nn.Sigmoid()
17                )
18       def _create_layer(self, size_in, size_out, drop_out=True, act_func=True):
19           layers = [nn.Linear(size_in, size_out)]
20           if drop_out:
21               layers.append(nn.Dropout(0.4))
22           if act_func:
23               layers.append(nn.LeakyReLU(0.2, inplace=True))
24           return layers
25       def forward(self, image, labels):
26           x = torch.cat((image.view(image.size(0), -1), self.label_embedding(labels)), -1)
27           return self.model(x)
28       def loss(self, output, label):
29           return self.adv_loss(output, label)