def __init__(
self,
generator,
adversary,
x_dim,
z_dim,
adv_type,
optim=None,
optim_kwargs=None,
feature_layer=None,
fixed_noise_size=32,
device=None,
folder=None,
ngpu=0,
secure=True,
_called_from_conditional=False):
self.generator = Generator(generator, input_size=z_dim, device=device, ngpu=ngpu, secure=secure)
self.adversary = Adversary(adversary, input_size=x_dim, adv_type=adv_type, device=device, ngpu=ngpu, secure=secure)
self.neural_nets = {"Generator": self.generator, "Adversary": self.adversary}
super().__init__(
x_dim=x_dim, z_dim=z_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 not _called_from_conditional and 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,
adversariat,
encoder,
x_dim,
z_dim,
optim=None,
optim_kwargs=None,
lambda_L1=10,
fixed_noise_size=32,
device=None,
folder="./AbstractGAN1v1",
ngpu=0):
if device is None:
device = "cuda" if torch.cuda.is_available() else "cpu"
self.generator = Generator(generator,
input_size=z_dim,
device=device,
ngpu=ngpu)
self.adversariat = Adversariat(adversariat,
input_size=x_dim,
adv_type="Discriminator",
device=device,
ngpu=ngpu)
self.encoder = Encoder(encoder,
input_size=x_dim,
device=device,
ngpu=ngpu)
self.neural_nets = {
"Generator": self.generator,
"Adversariat": self.adversariat,
"Encoder": self.encoder
}
AbstractGenerativeModel.__init__(self,
x_dim=x_dim,
z_dim=z_dim,
optim=optim,
optim_kwargs=optim_kwargs,
fixed_noise_size=fixed_noise_size,
device=device,
folder=folder,
ngpu=ngpu)
self.lambda_L1 = lambda_L1
self.hyperparameters["lambda_L1"] = lambda_L1
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))
assert (self.encoder.output_size == self.z_dim), (
"Encoder output shape must be equal to z_dim. {} vs. {}.".format(
self.encoder.output_size, self.z_dim))
def __init__(self,
generator,
adversariat,
x_dim,
z_dim,
adv_type,
optim=None,
optim_kwargs=None,
fixed_noise_size=32,
device=None,
folder="./AbstractGAN1v1",
ngpu=0):
if device is None:
device = "cuda" if torch.cuda.is_available() else "cpu"
self.generator = Generator(generator,
input_size=z_dim,
device=device,
ngpu=ngpu)
self.adversariat = Adversariat(adversariat,
input_size=x_dim,
adv_type=adv_type,
device=device,
ngpu=ngpu)
self.neural_nets = {
"Generator": self.generator,
"Adversariat": self.adversariat
}
super().__init__(x_dim=x_dim,
z_dim=z_dim,
optim=optim,
optim_kwargs=optim_kwargs,
fixed_noise_size=fixed_noise_size,
device=device,
folder=folder,
ngpu=ngpu)
if hasattr(self, "_is_conditional"):
assert (self.generator.output_size[1:] == self.x_dim[1:]), (
"Generator output shape must be equal to x_dim. {} vs. {}.".
format(self.generator.output_size, self.x_dim))
else:
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,
y_dim,
optim=None,
optim_kwargs=None,
adv_type="Discriminator",
feature_layer=None,
fixed_noise_size=32,
device=None,
folder="./veganModels/cAbstractConditionalGANGAE",
ngpu=0,
secure=True,
_called_from_conditional=False):
enc_in_dim = get_input_dim(dim1=x_dim, dim2=y_dim)
gen_in_dim = get_input_dim(dim1=z_dim, dim2=y_dim)
adv_in_dim = get_input_dim(dim1=x_dim, dim2=y_dim)
if secure:
AbstractConditionalGenerativeModel._check_conditional_network_input(encoder, in_dim=x_dim, y_dim=y_dim, name="Encoder")
AbstractConditionalGenerativeModel._check_conditional_network_input(generator, in_dim=z_dim, y_dim=y_dim, name="Generator")
AbstractConditionalGenerativeModel._check_conditional_network_input(adversary, in_dim=x_dim, y_dim=y_dim, name="Adversary")
self.adv_type = adv_type
self.encoder = Encoder(encoder, input_size=enc_in_dim, device=device, ngpu=ngpu, secure=secure)
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=adv_type, 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, ngpu=ngpu, folder=folder, secure=secure
)
self.hyperparameters["adv_type"] = adv_type
if not _called_from_conditional and 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,
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,
generatorX_Y,
adversaryX_Y,
generatorY_X,
adversaryY_X,
x_dim,
z_dim,
y_dim,
optim=None,
optim_kwargs=None,
lambda_x=10,
adv_type="Discriminator",
fixed_noise_size=32,
device=None,
ngpu=0,
folder="./veganModels/cCycleGAN",
secure=True):
gen_in_dim = get_input_dim(dim1=z_dim, dim2=y_dim)
adv_in_dim = get_input_dim(dim1=x_dim, dim2=y_dim)
if secure:
assert x_dim == y_dim, (
"`x_dim` and `y_dim` must be equal in the current implementation of CycleGAN. Given: {} and {}."
.format(x_dim, y_dim))
AbstractConditionalGenerativeModel._check_conditional_network_input(
generatorX_Y, in_dim=z_dim, y_dim=x_dim, name="GeneratorX_Y")
AbstractConditionalGenerativeModel._check_conditional_network_input(
adversaryX_Y, in_dim=y_dim, y_dim=x_dim, name="AdversaryX_Y")
AbstractConditionalGenerativeModel._check_conditional_network_input(
generatorY_X, in_dim=z_dim, y_dim=y_dim, name="GeneratorY_X")
AbstractConditionalGenerativeModel._check_conditional_network_input(
adversaryY_X, in_dim=x_dim, y_dim=y_dim, name="AdversaryY_X")
self.adv_type = adv_type
self.generatorX_Y = Generator(generatorX_Y,
input_size=gen_in_dim,
device=device,
ngpu=ngpu,
secure=secure)
self.adversaryX_Y = Adversary(adversaryX_Y,
input_size=adv_in_dim,
adv_type=adv_type,
device=device,
ngpu=ngpu,
secure=secure)
self.generatorY_X = Generator(generatorY_X,
input_size=gen_in_dim,
device=device,
ngpu=ngpu,
secure=secure)
self.adversaryY_X = Adversary(adversaryY_X,
input_size=adv_in_dim,
adv_type=adv_type,
device=device,
ngpu=ngpu,
secure=secure)
self.autoencoder = Autoencoder(encoder=self.generatorX_Y,
decoder=self.generatorY_X)
self.neural_nets = {
"Autoencoder": self.autoencoder,
"AdversaryX_Y": self.adversaryX_Y,
"AdversaryY_X": self.adversaryY_X
}
self.generator = self.generatorX_Y
self.adversary = self.adversaryX_Y
super().__init__(x_dim=x_dim,
z_dim=z_dim,
y_dim=y_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.lambda_x = lambda_x
self.hyperparameters["lambda_x"] = lambda_x
if self.secure:
assert (self.generatorX_Y.output_size == self.x_dim), (
"GeneratorX_Y output shape must be equal to x_dim. {} vs. {}.".
format(self.generatorX_Y.output_size, self.x_dim))
assert (self.generatorY_X.output_size == self.x_dim), (
"GeneratorY_X output shape must be equal to x_dim. {} vs. {}.".
format(self.generatorY_X.output_size, self.x_dim))
def __init__(self,
generator,
adversary,
encoder,
x_dim,
z_dim,
optim=None,
optim_kwargs=None,
lambda_z=10,
adv_type="Discriminator",
feature_layer=None,
fixed_noise_size=32,
device=None,
ngpu=0,
folder="./veganModels/AAE",
secure=True):
self.adv_type = adv_type
self.encoder = Encoder(encoder,
input_size=x_dim,
device=device,
ngpu=ngpu,
secure=secure)
self.generator = Generator(generator,
input_size=z_dim,
device=device,
ngpu=ngpu,
secure=secure)
self.adversary = Adversary(adversary,
input_size=z_dim,
device=device,
ngpu=ngpu,
adv_type=adv_type,
secure=secure)
self.neural_nets = {
"Generator": self.generator,
"Encoder": self.encoder,
"Adversary": self.adversary
}
super().__init__(x_dim=x_dim,
z_dim=z_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)
self.lambda_z = lambda_z
self.hyperparameters["lambda_z"] = lambda_z
self.hyperparameters["adv_type"] = adv_type
if self.secure:
assert self.encoder.output_size == self.z_dim, (
"Encoder output shape must be equal to z_dim. {} vs. {}.".
format(self.encoder.output_size, self.z_dim))
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))