def __init__(self, config, root, model, *args, **kwargs): super().__init__(config, root, model, *args, **kwargs) self.logger = get_logger("Iterator") assert config["model"] in [ "model.vae_gan.VAE_GAN", "model.vae_gan.VAE_WGAN" ], "This Iterator only supports the VAE GAN models: VAE_GAN and VAE_WGAN." # export to the right gpu if specified in the config self.device = set_gpu(config) self.logger.debug(f"Model will pushed to the device: {self.device}") # get the config and the logger self.config = config set_random_state(random_seed=self.config["random_seed"]) self.batch_size = config['batch_size'] # Config will be tested inside the Model class even for the iterator # Log the architecture of the model self.logger.debug(f"{model}") self.model = model.to(self.device) self.optimizer_G = torch.optim.Adam(itertools.chain( self.model.netG.parameters()), lr=self.config["learning_rate"]) D_lr_factor = self.config["optimization"][ "D_lr_factor"] if "D_lr_factor" in config["optimization"] else 1 self.optimizer_D = torch.optim.Adam(self.model.netD.parameters(), lr=D_lr_factor * self.config["learning_rate"]) self.real_labels = torch.ones(self.batch_size, device=self.device) self.fake_labels = torch.zeros(self.batch_size, device=self.device)
def __init__(self, config, root, model, *args, **kwargs): super().__init__(config, root, model, *args, **kwargs) assert config[ "model"] == "model.gan.DCGAN", "This iterator only supports the model: model.gan.DCGAN" self.logger = get_logger("Iterator") # export to the right gpu if specified in the config self.device = set_gpu(config) self.logger.debug(f"Model will pushed to the device: {self.device}") # get the config and the logger self.config = config set_random_state(self.config["random_seed"]) self.batch_size = config['batch_size'] # Log the architecture of the model self.logger.debug(f"{model}") self.model = model.to(self.device) self.optimizer_G = torch.optim.Adam(self.model.netG.parameters(), lr=self.config["learning_rate"], betas=(.5, .999)) D_lr_factor = self.config["optimization"][ "D_lr_factor"] if "D_lr_factor" in config["optimization"] else 1 self.optimizer_D = torch.optim.Adam(self.model.netD.parameters(), lr=D_lr_factor * self.config["learning_rate"], betas=(.5, .999)) self.real_labels = torch.ones(self.batch_size, device=self.device) self.fake_labels = torch.zeros(self.batch_size, device=self.device) self.wasserstein = bool( self.config["losses"]['adversarial_loss'] == 'wasserstein')
def __init__(self, config, root, model, *args, **kwargs): """Initialise all important parameters of the iterator.""" super().__init__(config, root, model, *args, **kwargs) assert config[ "model_type"] != "sketch2face", "This iterator does not support sketch2face models only single GAN models supported." assert config[ "model"] == "model.vae_gan.VAE_WGAN", "This iterator only supports the model: model.vae_gan.VAE_WGAN" # get the config and the logger self.config = config self.logger = get_logger("Iterator") set_random_state(self.config["random_seed"]) # Check if cuda is available self.device = set_gpu(self.config) self.logger.debug(f"Model will pushed to the device: {self.device}") # Log the architecture of the model self.logger.debug(f"{model}") self.model = model.to(self.device) # save important constants self.learning_rate = self.config["learning_rate"] self.batch_size = self.config["batch_size"] self.critic_iter = self.config["losses"][ "update_disc"] if "update_disc" in self.config["losses"] else 5 # WGAN values from paper b1, b2 = 0.5, 0.999 # use ADAM optimizer self.optimizer_G = torch.optim.Adam(self.model.netG.parameters(), lr=self.learning_rate, betas=(b1, b2)) # check if there is a different learning rate for the discriminators D_lr_factor = self.config["optimization"][ "D_lr_factor"] if "D_lr_factor" in config["optimization"] else 1 self.optimizer_D = torch.optim.Adam(self.model.netD.parameters(), lr=self.learning_rate * D_lr_factor, betas=(b1, b2))
def __init__(self, config, root, model, *args, **kwargs): super().__init__(config, root, model, *args, **kwargs) assert config[ "model"] == "model.cycle_gan.Cycle_GAN", "This CycleGAN iterator only works with with the Cycle_GAN model." assert config["losses"][ "adversarial_loss"] != "wasserstein", "This CycleGAN does not support an adversarial wasserstein loss" self.logger = get_logger("Iterator") # export to the right gpu if specified in the config self.device = set_gpu(config) self.logger.debug(f"Model will pushed to the device: {self.device}") # get the config and the logger self.config = config set_random_state(self.config["random_seed"]) self.batch_size = config['batch_size'] # Config will be tested inside the Model class even for the iterator # Log the architecture of the model self.logger.debug(f"{model}") self.model = model.to(self.device) # load pretrained models if specified in the config self.model, log_string = load_pretrained_vaes(config=self.config, model=self.model) self.logger.debug(log_string) self.optimizer_G = torch.optim.Adam( itertools.chain(self.model.netG_A.parameters(), self.model.netG_B.parameters()), lr=self.config["learning_rate"]) # betas=(opt.beta1, 0.999)) D_lr_factor = self.config["optimization"][ "D_lr_factor"] if "D_lr_factor" in config["optimization"] else 1 self.optimizer_D_A = torch.optim.Adam( self.model.netD_A.parameters(), lr=D_lr_factor * self.config["learning_rate"]) # betas=(opt.beta1, 0.999)) self.optimizer_D_B = torch.optim.Adam( self.model.netD_B.parameters(), lr=D_lr_factor * self.config["learning_rate"]) # betas=(opt.beta1, 0.999)) self.add_latent_layer = bool( 'num_latent_layer' in self.config['variational'] and self.config['variational']['num_latent_layer'] > 0) self.only_latent_layer = bool( 'only_latent_layer' in self.config['optimization'] and self.config['optimization']['only_latent_layer']) if self.only_latent_layer: self.optimizer_Lin = torch.optim.Adam( itertools.chain(self.model.netG_A.latent_layer.parameters(), self.model.netG_B.latent_layer.parameters()), lr=self.config["learning_rate"]) self.logger.debug( "Only latent layers are optimized\nNumber of latent layers: {}" .format(self.config['variational']['num_latent_layer'])) self.real_labels = torch.ones(self.batch_size, device=self.device) self.fake_labels = torch.zeros(self.batch_size, device=self.device)
def __init__(self, config, root, model, *args, **kwargs): super().__init__(config, root, model, *args, **kwargs) self.logger = get_logger("Iterator") # export to the right gpu if specified in the config self.device = set_gpu(config) self.logger.debug(f"Model will pushed to the device: {self.device}") # get the config and the logger self.config = config set_random_state(random_seed=self.config["random_seed"]) # Config will be tested inside the Model class even for the iterator # Log the architecture of the model self.logger.debug(f"{model}") self.vae = model b1, b2 = 0.5, 0.999 self.optimizer = torch.optim.Adam(self.vae.parameters(), lr=self.config["learning_rate"], betas=(b1, b2)) self.vae.to(self.device)
def __init__(self, config, root, model, *args, **kwargs): """Initialise all important parameters of the iterator.""" super().__init__(config, root, model, *args, **kwargs) assert self.config[ "model"] == "model.cycle_gan.Cycle_WGAN", "This iterator only supports the model: model.wgan.Cycle_WGAN" # get the config and the logger self.config = config self.logger = get_logger("Iterator") set_random_state(self.config["random_seed"]) # Check if cuda is available self.device = set_gpu(self.config) self.logger.debug(f"Model will pushed to the device: {self.device}") # Log the architecture of the model self.logger.debug(f"{model}") self.model = model.to(self.device) # save important constants self.learning_rate = self.config["learning_rate"] self.batch_size = self.config["batch_size"] self.critic_iter = self.config["losses"][ "update_disc"] if "update_disc" in self.config["losses"] else 5 # WGAN values from paper b1, b2 = 0.5, 0.999 # load pretrained models if specified in the config self.model, log_string = load_pretrained_vaes(config=self.config, model=self.model) self.logger.debug(log_string) # check if there are latent layers self.add_latent_layer = bool( 'num_latent_layer' in self.config['variational'] and self.config['variational']['num_latent_layer'] > 0) # check if only the latent layers should be updated self.only_latent_layer = bool( 'only_latent_layer' in self.config['optimization'] and self.config['optimization']['only_latent_layer']) if self.only_latent_layer: self.critic_iter = 1 self.logger.debug( "critic_iter set to 1 since only_latent_layer is True.") self.optimizer_Lin = torch.optim.Adam( itertools.chain(self.model.netG_A.latent_layer.parameters(), self.model.netG_B.latent_layer.parameters()), lr=self.config["learning_rate"], betas=(b1, b2)) self.logger.debug( "Only latent layers are optimized\nNumber of latent layers: {}" .format(self.config['variational']['num_latent_layer'])) else: # use ADAM optimizer self.optimizer_G = torch.optim.Adam(itertools.chain( self.model.netG_A.parameters(), self.model.netG_B.parameters()), lr=self.learning_rate, betas=(b1, b2)) # check if there is a different learning rate for the discriminators D_lr_factor = self.config["optimization"][ "D_lr_factor"] if "D_lr_factor" in config["optimization"] else 1 self.optimizer_D = torch.optim.Adam( itertools.chain(self.model.netD_A.parameters(), self.model.netD_B.parameters()), lr=D_lr_factor * self.config["learning_rate"], betas=(b1, b2))