def __init__(self,
num_channels=3,
image_size=64,
num_classes=2,
num_fc_layers=7,
fc_layer_size=1000):
super().__init__(256,
num_classes=num_classes,
num_layers=num_fc_layers,
layer_size=fc_layer_size)
assert image_size == 64, 'The SimpleDiscriminatorConv64 architecture is hardcoded for 64x64 images.'
self.conv_encode = nn.Sequential(
nn.Conv2d(num_channels, 32, 4, 2, 1),
nn.ReLU(True),
nn.Conv2d(32, 32, 4, 2, 1),
nn.ReLU(True),
nn.Conv2d(32, 64, 4, 2, 1),
nn.ReLU(True),
nn.Conv2d(64, 128, 4, 2, 1),
nn.ReLU(True),
nn.Conv2d(128, 256, 4, 2, 1),
nn.ReLU(True),
nn.Conv2d(256, 256, 4, 2, 1),
nn.ReLU(True),
self.Flatten(),
)
init_layers(self._modules)
def __init__(self, input_dim, image_size):
super().__init__()
self.main = nn.ModuleList()
for i in range(input_dim):
self.main.append(SingleTo2DChannel(image_size))
init_layers(self._modules)
def __init__(self, latent_dim, num_channels, image_size):
super().__init__(latent_dim, num_channels, image_size)
self.main = nn.Sequential(
nn.Linear(latent_dim, 400), nn.ReLU(),
nn.Linear(400, image_size * image_size * num_channels),
Reshape([num_channels, image_size, image_size]))
init_layers(self._modules)
def __init__(self, latent_dim, num_channels, image_size):
super().__init__(latent_dim, num_channels, image_size)
self.main = nn.Sequential(
Flatten3D(),
nn.Linear(image_size * image_size * num_channels, 400),
nn.ReLU())
self.head_mu = nn.Linear(400, latent_dim)
self.head_logvar = nn.Linear(400, latent_dim)
init_layers(self._modules)
def __init__(self, image_size):
super().__init__()
self.main = nn.Sequential(
nn.Linear(1, 64),
nn.LeakyReLU(0.2, True),
nn.Linear(64, 256),
nn.LeakyReLU(0.2, True),
nn.Linear(256, image_size * image_size),
Reshape([1, image_size, image_size])
)
init_layers(self._modules)
def __init__(self, latent_dim, num_channels, image_size):
super().__init__(latent_dim, num_channels, image_size)
assert image_size == 64, 'This model only works with image size 64x64.'
self.main = nn.Sequential(nn.Conv2d(num_channels, 32, 3, 2, 0),
nn.ReLU(True), nn.Conv2d(32, 32, 3, 2, 0),
nn.ReLU(True), nn.Conv2d(32, 64, 3, 2, 0),
nn.ReLU(True), nn.Conv2d(64, 128, 3, 2, 0),
nn.ReLU(True), nn.Conv2d(128, 256, 3, 2, 0),
nn.ReLU(True), Flatten3D(),
nn.Linear(256, latent_dim, bias=True))
init_layers(self._modules)
def __init__(self, input_dim, num_classes, num_layers=7, layer_size=1000):
super().__init__()
self.main = nn.Sequential(
nn.Linear(input_dim, layer_size),
nn.LeakyReLU(0.2, True),
)
for i in range(num_layers - 2):
self.main.add_module(module=nn.Linear(layer_size, layer_size),
name='linear' + str(i))
self.main.add_module(module=nn.LeakyReLU(0.2, True),
name='lrelu' + str(i))
self.main.add_module(module=nn.Linear(layer_size, num_classes),
name='output')
init_layers(self._modules)
def __init__(self, latent_dim, num_channels, image_size):
super().__init__(latent_dim, num_channels, image_size)
assert image_size == 64, 'This model only works with image size 64x64.'
self.main = nn.Sequential(Unsqueeze3D(),
nn.Conv2d(latent_dim, 256, 1, 2),
nn.ReLU(True),
nn.ConvTranspose2d(256, 256, 4, 2, 1),
nn.ReLU(True),
nn.ConvTranspose2d(256, 128, 4, 2),
nn.ReLU(True),
nn.ConvTranspose2d(128, 128, 4, 2),
nn.ReLU(True),
nn.ConvTranspose2d(128, 64, 4, 2),
nn.ReLU(True),
nn.ConvTranspose2d(64, 64, 4, 2),
nn.ReLU(True),
nn.ConvTranspose2d(64, num_channels, 3, 1))
# output shape = bs x 3 x 64 x 64
init_layers(self._modules)