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))