def __init__(self,
generator,
adversary,
encoder,
x_dim,
z_dim,
y_dim,
optim=None,
optim_kwargs=None,
lambda_KL=10,
lambda_x=10,
adv_type="Discriminator",
feature_layer=None,
fixed_noise_size=32,
device=None,
ngpu=0,
folder="./veganModels/cVAEGAN",
secure=True):
super().__init__(generator=generator,
adversary=adversary,
encoder=encoder,
x_dim=x_dim,
z_dim=z_dim,
y_dim=y_dim,
optim=optim,
optim_kwargs=optim_kwargs,
adv_type=adv_type,
feature_layer=feature_layer,
fixed_noise_size=fixed_noise_size,
device=device,
folder=folder,
ngpu=ngpu,
secure=secure)
self.mu = nn.Sequential(
nn.Flatten(),
nn.Linear(np.prod(self.encoder.output_size), np.prod(z_dim)),
LayerReshape(shape=z_dim)).to(self.device)
self.log_variance = nn.Sequential(
nn.Flatten(),
nn.Linear(np.prod(self.encoder.output_size), np.prod(z_dim)),
LayerReshape(shape=z_dim)).to(self.device)
self.lambda_KL = lambda_KL
self.lambda_x = lambda_x
self.hyperparameters["lambda_KL"] = lambda_KL
self.hyperparameters["lambda_x"] = lambda_x
self.hyperparameters["adv_type"] = adv_type
if self.secure:
# TODO: Remove those lines or use them again, but not commented
# if self.encoder.output_size == self.z_dim:
# raise ValueError(
# "Encoder output size is equal to z_dim, but for VAE algorithms the encoder last layers for mu and sigma " +
# "are constructed by the algorithm itself.\nSpecify up to the second last layer for this particular encoder."
# )
assert (self.generator.output_size == self.x_dim), (
"Decoder output shape must be equal to x_dim. {} vs. {}.".
format(self.generator.output_size, self.x_dim))
def __init__(self,
encoder,
decoder,
x_dim,
z_dim,
optim=None,
optim_kwargs=None,
lambda_KL=10,
fixed_noise_size=32,
device=None,
ngpu=0,
folder="./veganModels/VanillaVAE",
secure=True):
self.decoder = Decoder(decoder,
input_size=z_dim,
device=device,
ngpu=ngpu,
secure=secure)
self.encoder = Encoder(encoder,
input_size=x_dim,
device=device,
ngpu=ngpu,
secure=secure)
self.autoencoder = Autoencoder(self.encoder, self.decoder)
self.neural_nets = {"Autoencoder": self.autoencoder}
super().__init__(x_dim=x_dim,
z_dim=z_dim,
optim=optim,
optim_kwargs=optim_kwargs,
feature_layer=None,
fixed_noise_size=fixed_noise_size,
device=device,
folder=folder,
ngpu=ngpu,
secure=secure)
self.mu = nn.Sequential(
nn.Flatten(),
nn.Linear(np.prod(self.encoder.output_size), np.prod(z_dim)),
LayerReshape(shape=z_dim)).to(self.device)
self.log_variance = nn.Sequential(
nn.Flatten(),
nn.Linear(np.prod(self.encoder.output_size), np.prod(z_dim)),
LayerReshape(shape=z_dim)).to(self.device)
self.lambda_KL = lambda_KL
self.hyperparameters["lambda_KL"] = lambda_KL
if self.secure:
# if self.encoder.output_size == self.z_dim:
# raise ValueError(
# "Encoder output size is equal to z_dim, but for VAE algorithms the encoder last layers for mu and sigma " +
# "are constructed by the algorithm itself.\nSpecify up to the second last layer for this particular encoder."
# )
assert (self.decoder.output_size == self.x_dim), (
"Decoder output shape must be equal to x_dim. {} vs. {}.".
format(self.decoder.output_size, self.x_dim))
def __init__(self,
generator,
adversary,
encoder,
x_dim,
z_dim,
y_dim,
optim=None,
optim_kwargs=None,
lambda_KL=10,
lambda_x=10,
lambda_z=10,
adv_type="Discriminator",
feature_layer=None,
fixed_noise_size=32,
device=None,
ngpu=0,
folder="./veganModels/cBicycleGAN",
secure=True):
super().__init__(generator=generator,
adversary=adversary,
encoder=encoder,
x_dim=x_dim,
z_dim=z_dim,
y_dim=y_dim,
optim=optim,
optim_kwargs=optim_kwargs,
adv_type=adv_type,
feature_layer=feature_layer,
fixed_noise_size=fixed_noise_size,
device=device,
folder=folder,
ngpu=ngpu,
secure=secure)
self.mu = nn.Sequential(
nn.Flatten(),
nn.Linear(np.prod(self.encoder.output_size), np.prod(z_dim)),
LayerReshape(z_dim)).to(self.device)
self.log_variance = nn.Sequential(
nn.Flatten(),
nn.Linear(np.prod(self.encoder.output_size), np.prod(z_dim)),
LayerReshape(z_dim)).to(self.device)
self.lambda_KL = lambda_KL
self.lambda_x = lambda_x
self.lambda_z = lambda_z
self.hyperparameters["lambda_KL"] = lambda_KL
self.hyperparameters["lambda_x"] = lambda_x
self.hyperparameters["lambda_z"] = lambda_z
if self.secure:
assert (self.generator.output_size == self.x_dim), (
"Generator output shape must be equal to x_dim. {} vs. {}.".
format(self.generator.output_size, self.x_dim))
def __init__(
self,
generator,
adversary,
encoder,
x_dim,
z_dim,
optim=None,
optim_kwargs=None,
lambda_KL=10,
lambda_x=10,
lambda_z=10,
adv_type="Discriminator",
feature_layer=None,
fixed_noise_size=32,
device=None,
ngpu=0,
folder="./veganModels/BicycleGAN",
secure=True):
super().__init__(
generator=generator, adversary=adversary, encoder=encoder,
x_dim=x_dim, z_dim=z_dim, optim=optim, optim_kwargs=optim_kwargs, adv_type=adv_type, feature_layer=feature_layer,
fixed_noise_size=fixed_noise_size, device=device, ngpu=ngpu, folder=folder, secure=secure
)
self.mu = nn.Sequential(
nn.Flatten(),
nn.Linear(np.prod(self.encoder.output_size), np.prod(z_dim)),
LayerReshape(shape=z_dim)
).to(self.device)
self.log_variance = nn.Sequential(
nn.Flatten(),
nn.Linear(np.prod(self.encoder.output_size), np.prod(z_dim)),
LayerReshape(shape=z_dim)
).to(self.device)
self.lambda_KL = lambda_KL
self.lambda_x = lambda_x
self.lambda_z = lambda_z
self.hyperparameters["lambda_KL"] = lambda_KL
self.hyperparameters["lambda_x"] = lambda_x
self.hyperparameters["lambda_z"] = lambda_z
if self.secure:
assert self.encoder.output_size != self.z_dim, (
"Encoder output size is equal to z_dim, but for VAE algorithms the encoder last layers for mu and sigma " +
"are constructed by the algorithm itself.\nSpecify up to the second last layer for this particular encoder."
)
def __init__(self, x_dim, dec_in_dim):
super().__init__()
self.hidden_part = nn.Sequential(
nn.Linear(in_features=np.prod(dec_in_dim),
out_features=np.prod([1, 8, 8])),
LayerReshape(shape=[1, 8, 8]),
nn.ConvTranspose2d(in_channels=1,
out_channels=64,
kernel_size=4,
stride=2,
padding=1),
nn.BatchNorm2d(num_features=64),
nn.LeakyReLU(0.2),
nn.ConvTranspose2d(in_channels=64,
out_channels=32,
kernel_size=4,
stride=2,
padding=1),
nn.BatchNorm2d(num_features=32),
nn.LeakyReLU(0.2),
nn.ConvTranspose2d(in_channels=32,
out_channels=x_dim[0],
kernel_size=3,
stride=1,
padding=1),
)
self.output = nn.Sigmoid()
def __init__(self, x_dim, dec_in_dim):
super().__init__()
self.hidden_part = nn.Sequential(
nn.Flatten(),
nn.Linear(in_features=np.prod(dec_in_dim), out_features=np.prod([1, 8, 8])),
LayerReshape(shape=[1, 8, 8]),
)
desired_output = x_dim[1]
current_output = 8
in_channels = 1
i = 2
while current_output != desired_output:
out_channels = in_channels * 2
current_output *= 2
if current_output != desired_output:
self.hidden_part.add_module("ConvTraspose{}".format(i), nn.ConvTranspose2d(
in_channels=in_channels, out_channels=out_channels, kernel_size=4, stride=2, padding=1
)
)
self.hidden_part.add_module("Batchnorm{}".format(i), nn.BatchNorm2d(num_features=out_channels))
self.hidden_part.add_module("LeakyRelu{}".format(i), nn.LeakyReLU(0.1))
else: # Last layer
self.hidden_part.add_module("ConvTraspose{}".format(i), nn.ConvTranspose2d(
in_channels=in_channels, out_channels=3, kernel_size=4, stride=2, padding=1
)
)
in_channels = in_channels * 2
i += 1
self.output = nn.Sigmoid()
def __init__(self, in_dim, last_layer, out_dim):
super().__init__()
in_dim = np.prod(in_dim)
out_dim = [out_dim] if isinstance(out_dim, int) else out_dim
self.hidden_part = torch.nn.Sequential(
torch.nn.Flatten(), torch.nn.Linear(in_dim, 16),
torch.nn.LeakyReLU(0.2), torch.nn.Linear(16, np.prod(out_dim)),
LayerReshape(out_dim))
self.output = last_layer()
def __init__(self, z_dim):
super().__init__()
self.hidden_part = nn.Sequential(
nn.Linear(z_dim, 128), nn.LeakyReLU(0.2), nn.Linear(128, 256),
nn.LeakyReLU(0.2), nn.BatchNorm1d(256), nn.Linear(256, 512),
nn.LeakyReLU(0.2), nn.BatchNorm1d(512), nn.Linear(512, 1024),
nn.LeakyReLU(0.2), nn.BatchNorm1d(1024),
nn.Linear(1024, int(np.prod(im_dim))), LayerReshape(im_dim))
self.output = nn.Sigmoid()
def __init__(self, x_dim, dec_in_dim):
super().__init__()
self.hidden_part = nn.Sequential(nn.Flatten(),
nn.Linear(np.prod(dec_in_dim),
256), nn.LeakyReLU(0.2),
nn.Linear(256, 128),
nn.LeakyReLU(0.2),
nn.Linear(128, np.prod(x_dim)),
LayerReshape(x_dim))
self.output = nn.Identity()
def __init__(self, enc_in_dim, z_dim, first_layer):
super().__init__()
self.hidden_part = nn.Sequential(first_layer, nn.Flatten(),
nn.Linear(np.prod(enc_in_dim),
256), nn.LeakyReLU(0.2),
nn.Linear(256, 128),
nn.LeakyReLU(0.2),
nn.Linear(128, np.prod(z_dim)),
LayerReshape(z_dim))
self.output = nn.Identity()
def __init__(self, x_dim, gen_in_dim):
super().__init__()
if len(gen_in_dim) == 1:
out_shape = (128, 8, 8)
self.linear_part = nn.Sequential(
nn.Linear(in_features=gen_in_dim[0], out_features=1024),
nn.LeakyReLU(0.1),
nn.Linear(in_features=1024, out_features=np.prod(out_shape)),
nn.LeakyReLU(0.1),
LayerReshape(shape=out_shape)
)
gen_in_dim = out_shape
else:
self.linear_part = nn.Identity()
self.hidden_part = nn.Sequential(
nn.ConvTranspose2d(in_channels=gen_in_dim[0], out_channels=128, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(num_features=128),
nn.LeakyReLU(0.1),
nn.ConvTranspose2d(in_channels=128, out_channels=128, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(num_features=128),
nn.LeakyReLU(0.1),
)
desired_output = x_dim[1]
current_output = gen_in_dim[1]
in_channels = 128
i = 3
while current_output != desired_output:
out_channels = in_channels // 2
current_output *= 2
if current_output != desired_output:
self.hidden_part.add_module("ConvTraspose{}".format(i), nn.ConvTranspose2d(
in_channels=in_channels, out_channels=out_channels, kernel_size=4, stride=2, padding=1
)
)
self.hidden_part.add_module("Batchnorm{}".format(i), nn.BatchNorm2d(num_features=out_channels))
self.hidden_part.add_module("LeakyRelu{}".format(i), nn.LeakyReLU(0.1))
else: # Last layer
self.hidden_part.add_module("ConvTraspose{}".format(i), nn.ConvTranspose2d(
in_channels=in_channels, out_channels=3, kernel_size=4, stride=2, padding=1
)
)
in_channels = in_channels // 2
i += 1
self.output = nn.Sigmoid()
def __init__(self, enc_in_dim, z_dim):
super().__init__()
self.hidden_part = nn.Sequential(
nn.Conv2d(in_channels=enc_in_dim[0], out_channels=32, kernel_size=3, stride=1, padding=1),
nn.ReLU(),
nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, stride=1, padding=1),
nn.ReLU(),
nn.MaxPool2d(kernel_size=5, stride=2, padding=2),
nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=1, padding=1),
nn.ReLU(),
nn.MaxPool2d(kernel_size=5, stride=2, padding=2),
nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, stride=1, padding=1),
nn.ReLU(),
nn.MaxPool2d(kernel_size=5, stride=2, padding=2),
nn.Conv2d(in_channels=128, out_channels=128, kernel_size=3, stride=1, padding=1),
nn.Flatten(),
)
sample_input = torch.rand([2, *enc_in_dim])
flattened_nodes = tuple(self.hidden_part(sample_input).shape)[1]
self.linear = nn.Linear(in_features=flattened_nodes, out_features=np.prod(z_dim))
self.reshape = LayerReshape(shape=z_dim)
self.output = nn.Identity()
def __init__(self,
generator,
adversary,
encoder,
x_dim,
z_dim,
y_dim,
c_dim_discrete,
c_dim_continuous,
optim=None,
optim_kwargs=None,
lambda_z=10,
feature_layer=None,
fixed_noise_size=32,
device=None,
ngpu=0,
folder="./veganModels/cInfoGAN",
secure=True):
c_dim_discrete = [c_dim_discrete] if isinstance(
c_dim_discrete, int) else c_dim_discrete
assert c_dim_discrete == [0] or 0 not in c_dim_discrete, (
"`c_dim_discrete` has multiple elements. Zero not allowed. Given: {}."
.format(c_dim_discrete))
assert isinstance(
c_dim_continuous,
int), ("`c_dim_continuous` must be of type int. Given: {}.".format(
type(c_dim_continuous)))
self.c_dim_discrete = tuple([i for i in list(c_dim_discrete)])
self.c_dim_continuous = tuple([c_dim_continuous])
self.c_dim = tuple(
[sum(self.c_dim_discrete) + sum(self.c_dim_continuous)])
if len(y_dim) == 3:
intermediate_in_dim = get_input_dim(dim1=z_dim, dim2=y_dim)
gen_in_dim = get_input_dim(dim1=intermediate_in_dim,
dim2=self.c_dim)
else:
gen_in_dim = get_input_dim(dim1=z_dim,
dim2=sum(self.c_dim) + sum(y_dim))
adv_in_dim = get_input_dim(dim1=x_dim, dim2=y_dim)
if secure:
AbstractConditionalGenerativeModel._check_conditional_network_input(
generator, in_dim=z_dim, y_dim=self.c_dim, name="Generator")
self.generator = Generator(generator,
input_size=gen_in_dim,
device=device,
ngpu=ngpu,
secure=secure)
self.adversary = Adversary(adversary,
input_size=adv_in_dim,
adv_type="Discriminator",
device=device,
ngpu=ngpu,
secure=secure)
self.encoder = Encoder(encoder,
input_size=adv_in_dim,
device=device,
ngpu=ngpu,
secure=secure)
self.neural_nets = {
"Generator": self.generator,
"Adversary": self.adversary,
"Encoder": self.encoder
}
super().__init__(x_dim=x_dim,
z_dim=z_dim,
y_dim=y_dim,
optim=optim,
optim_kwargs=optim_kwargs,
feature_layer=feature_layer,
fixed_noise_size=fixed_noise_size,
device=device,
folder=folder,
ngpu=ngpu,
secure=secure)
if self.c_dim_discrete != (0, ):
self.multinomial = nn.Sequential(
nn.Flatten(),
nn.Linear(np.prod(self.encoder.output_size),
np.sum(self.c_dim_discrete)),
nn.Sigmoid()).to(self.device)
if self.c_dim_continuous != (0, ):
self.mu = nn.Sequential(
nn.Flatten(),
nn.Linear(np.prod(self.encoder.output_size),
np.sum(self.c_dim_continuous)),
LayerReshape(self.c_dim_continuous)).to(self.device)
self.log_variance = nn.Sequential(
nn.Flatten(),
nn.Linear(np.prod(self.encoder.output_size),
np.sum(self.c_dim_continuous)), nn.ReLU(),
LayerReshape(self.c_dim_continuous)).to(self.device)
self.lambda_z = lambda_z
self.hyperparameters["lambda_z"] = lambda_z
if self.secure:
assert (self.generator.output_size == self.x_dim), (
"Generator output shape must be equal to x_dim. {} vs. {}.".
format(self.generator.output_size, self.x_dim))
def __init__(self, x_dim, gen_in_dim):
super().__init__()
if len(gen_in_dim) == 1:
self.prepare = nn.Sequential(
nn.Linear(in_features=gen_in_dim[0], out_features=256),
LayerReshape(shape=[1, 16, 16]))
nr_channels = 1
else:
current_dim = z_dim[1]
nr_channels = gen_in_dim[0]
self.prepare = []
while current_dim < 16:
self.prepare.append(
nn.ConvTranspose2d(in_channels=nr_channels,
out_channels=5,
kernel_size=4,
stride=2,
padding=1))
nr_channels = 5
current_dim *= 2
self.prepare = nn.Sequential(*self.prepare)
self.encoding = nn.Sequential(
nn.Conv2d(in_channels=nr_channels,
out_channels=64,
kernel_size=5,
stride=2,
padding=2),
nn.BatchNorm2d(num_features=64),
nn.LeakyReLU(0.2),
nn.Conv2d(in_channels=64,
out_channels=128,
kernel_size=5,
stride=2,
padding=2),
nn.BatchNorm2d(num_features=128),
nn.LeakyReLU(0.2),
nn.Conv2d(in_channels=128,
out_channels=256,
kernel_size=3,
stride=1,
padding=1),
nn.BatchNorm2d(num_features=256),
nn.LeakyReLU(0.2),
)
self.decoding = nn.Sequential(
nn.ConvTranspose2d(in_channels=256,
out_channels=128,
kernel_size=4,
stride=2,
padding=1),
nn.BatchNorm2d(num_features=128),
nn.LeakyReLU(0.2),
nn.ConvTranspose2d(in_channels=128,
out_channels=64,
kernel_size=4,
stride=2,
padding=1),
nn.BatchNorm2d(num_features=64),
nn.LeakyReLU(0.2),
nn.ConvTranspose2d(in_channels=64,
out_channels=32,
kernel_size=4,
stride=2,
padding=1),
nn.BatchNorm2d(num_features=32),
nn.LeakyReLU(0.2),
nn.ConvTranspose2d(in_channels=32,
out_channels=x_dim[0],
kernel_size=3,
stride=1,
padding=1),
)
self.output = nn.Sigmoid()
im_dim = X_train.shape[1:]
generator = nn.Sequential(
nn.Linear(z_dim, 128),
nn.LeakyReLU(0.2),
nn.Linear(128, 256),
nn.LeakyReLU(0.2),
nn.BatchNorm1d(256),
nn.Linear(256, 512),
nn.LeakyReLU(0.2),
nn.BatchNorm1d(512),
nn.Linear(512, 1024),
nn.LeakyReLU(0.2),
nn.BatchNorm1d(1024),
nn.Linear(1024, int(np.prod(im_dim))),
LayerReshape(im_dim),
nn.Sigmoid()
)
adversariat = nn.Sequential(
nn.Flatten(),
nn.Linear(int(np.prod(im_dim)), 512),
nn.LeakyReLU(0.2),
nn.Linear(512, 256),
nn.LeakyReLU(0.2),
nn.Linear(256, 1),
nn.Sigmoid()
)
call_gan_training(generator, adversariat)
#########################################################################
# Flat network: OO
call_gan_training(generator, adversary)
#########################################################################
# Flat network: Sequential
#########################################################################
z_dim = 2
x_dim = X_train.shape[1:]
generator = nn.Sequential(nn.Linear(z_dim, 128), nn.LeakyReLU(0.2),
nn.Linear(128, 256), nn.LeakyReLU(0.2),
nn.BatchNorm1d(256), nn.Linear(256, 512),
nn.LeakyReLU(0.2), nn.BatchNorm1d(512),
nn.Linear(512, 1024), nn.LeakyReLU(0.2),
nn.BatchNorm1d(1024),
nn.Linear(1024, int(np.prod(x_dim))),
LayerReshape(x_dim), nn.Sigmoid())
adversary = nn.Sequential(nn.Flatten(), nn.Linear(int(np.prod(x_dim)),
512), nn.LeakyReLU(0.2),
nn.Linear(512, 256), nn.LeakyReLU(0.2),
nn.Linear(256, 1), nn.Sigmoid())
call_gan_training(generator, adversary)
#########################################################################
# Flat network: OO
#########################################################################
z_dim = 128
class MyGenerator(nn.Module):
def __init__(self, z_dim):
super().__init__()
self.hidden_part = nn.Sequential(