def generate_sample(self, configuration: Configuration, metadata: Metadata, architecture: Architecture, **additional_inputs: Tensor) -> Tensor: noise = to_gpu_if_available( FloatTensor(configuration.batch_size, architecture.arguments.noise_size).normal_()) architecture.autoencoder.eval() architecture.generator.eval() code = architecture.generator(noise, **additional_inputs) return architecture.autoencoder.decode(code, **additional_inputs)
def train_generator_step(configuration: Configuration, metadata: Metadata, architecture: Architecture, batch: Batch) -> float: # clean previous gradients architecture.generator_optimizer.zero_grad() # generate a batch of fake features with the same size as the real feature batch generated = architecture.generator(batch["features"], missing_mask=batch["missing_mask"]) # replace the missing features by the generated imputed = compose_with_mask( mask=batch["missing_mask"], differentiable=True, # now there are no NaNs and this should be used where_one=generated, where_zero=batch["raw_features"]) # generate hint hint = generate_hint(batch["missing_mask"], configuration.hint_probability, metadata) # calculate loss loss = architecture.generator_loss(architecture=architecture, features=batch["raw_features"], generated=generated, imputed=imputed, hint=hint, non_missing_mask=inverse_mask( batch["missing_mask"])) # calculate gradients loss.backward() # update the generator weights architecture.generator_optimizer.step() # return the loss return to_cpu_if_was_in_gpu(loss).item()
def impute(self, configuration: Configuration, metadata: Metadata, architecture: Architecture, batch: Dict[str, Tensor]) -> Tensor: return architecture.generator(batch["features"], missing_mask=batch["missing_mask"])
def sample_fake(self, architecture: Architecture, size: int, **additional_inputs: Tensor) -> Tensor: # for now the noise comes from a normal distribution but could be other distribution noise = to_gpu_if_available(FloatTensor(size, architecture.arguments.noise_size).normal_()) return architecture.generator(noise, **additional_inputs)
def impute(self, configuration: Configuration, metadata: Metadata, architecture: Architecture, batch: Dict[str, Tensor]) -> Tensor: # loss function loss_function = create_component(architecture, metadata, configuration.reconstruction_loss) masked_loss_function = MaskedReconstructionLoss(loss_function) batch_size = batch["features"].shape[0] * batch["features"].shape[1] # we need the non missing mask for the loss non_missing_mask = inverse_mask(batch["missing_mask"]) # initial noise noise = to_gpu_if_available( FloatTensor(len(batch["features"]), architecture.arguments.noise_size).normal_()) noise.requires_grad_() # it is not the generator what we are updating # it is the noise optimizer = Adam([noise], weight_decay=0, lr=configuration.noise_learning_rate) architecture.generator.eval() # logger log_path = create_parent_directories_if_needed(configuration.logs) logger = TrainLogger(self.logger, log_path, False) # initial generation logger.start_timer() generated = architecture.generator(noise, condition=batch.get("labels")) # iterate until we reach the maximum number of iterations or until the non missing loss is too small max_iterations = configuration.max_iterations for iteration in range(1, max_iterations + 1): # compute the loss on the non-missing values non_missing_loss = masked_loss_function(generated, batch["features"], non_missing_mask) logger.log(iteration, max_iterations, "non_missing_loss", to_cpu_if_was_in_gpu(non_missing_loss).item()) # this loss only makes sense if the ground truth is present # only used for debugging if configuration.get("log_missing_loss", False): # this part should not affect the gradient calculation with torch.no_grad(): missing_loss = masked_loss_function( generated, batch["raw_features"], batch["missing_mask"]) logger.log(iteration, max_iterations, "missing_loss", to_cpu_if_was_in_gpu(missing_loss).item()) loss = loss_function(generated, batch["raw_features"]) / batch_size logger.log(iteration, max_iterations, "loss", to_cpu_if_was_in_gpu(loss).item()) # if the generation is good enough we stop if to_cpu_if_was_in_gpu(non_missing_loss).item( ) < configuration.get("tolerance", 1e-5): break # clear previous gradients optimizer.zero_grad() # compute the gradients non_missing_loss.backward() # update the noise optimizer.step() # generate next logger.start_timer() generated = architecture.generator(noise, condition=batch.get("labels")) return generated
def val_batch(architecture: Architecture, batch: Batch, post_processing: PostProcessing) -> float: generated = architecture.generator(batch["features"], missing_mask=batch["missing_mask"]) loss = architecture.val_loss(post_processing, generated, batch) return to_cpu_if_was_in_gpu(loss).item()