def test_somatic_classifer(self, epoch, performance_estimators=None): print('\nTesting, epoch: %d' % epoch) if performance_estimators is None: performance_estimators = PerformanceList() performance_estimators += [LossHelper("test_loss")] performance_estimators += [LossHelper("classification_loss")] performance_estimators += [LossHelper("frequency_loss")] self.net.eval() for performance_estimator in performance_estimators: performance_estimator.init_performance_metrics() cross_entropy_loss = CrossEntropyLoss() mse_loss = MSELoss() for batch_idx, (_, data_dict) in enumerate( self.problem.validation_loader_range( 0, self.args.num_validation)): inputs = data_dict["input"] is_mutated_base_target = data_dict["isBaseMutated"] # transform one-hot encoding into a class index: max, indices = is_mutated_base_target.max(dim=1) is_mutated_base_target = indices somatic_frequency_target = data_dict["somaticFrequency"] if self.use_cuda: inputs, is_mutated_base_target, somatic_frequency_target = inputs.cuda(), \ is_mutated_base_target.cuda(), \ somatic_frequency_target.cuda() inputs, mut_targets, freq_targets = Variable(inputs), Variable(is_mutated_base_target, volatile=True), \ Variable(somatic_frequency_target, volatile=True) is_base_mutated, output_frequency = self.net(inputs) classification_loss = cross_entropy_loss(is_base_mutated, mut_targets) frequency_loss = mse_loss(output_frequency, freq_targets) test_loss = classification_loss + frequency_loss performance_estimators.set_metric(batch_idx, "test_loss", test_loss.data[0]) performance_estimators.set_metric(batch_idx, "classification_loss", classification_loss.data[0]) performance_estimators.set_metric(batch_idx, "frequency_loss", frequency_loss.data[0]) progress_bar( batch_idx * self.mini_batch_size, self.max_validation_examples, performance_estimators.progress_message(["test_loss"])) if ((batch_idx + 1) * self.mini_batch_size) > self.max_validation_examples: break # print() # Apply learning rate schedule: test_accuracy = performance_estimators.get_metric("test_loss") assert test_accuracy is not None, "test_loss must be found among estimated performance metrics" if not self.args.constant_learning_rates: self.scheduler_train.step(test_accuracy, epoch) return performance_estimators
def test_semi_sup(self, epoch): print('\nTesting, epoch: %d' % epoch) performance_estimators = PerformanceList() performance_estimators += [LossHelper("test_supervised_loss")] performance_estimators += [LossHelper("test_reconstruction_loss")] performance_estimators += [AccuracyHelper("test_")] self.net.eval() for performance_estimator in performance_estimators: performance_estimator.init_performance_metrics() validation_loader_subset = self.problem.validation_loader_range(0, self.args.num_validation) data_provider = MultiThreadedCpuGpuDataProvider(iterator=zip(validation_loader_subset), is_cuda=self.use_cuda, batch_names=["validation"], requires_grad={"validation": []}, volatile={"validation": ["input", "softmaxGenotype"]}) try: for batch_idx, (_, data_dict) in enumerate(data_provider): input_s = data_dict["validation"]["input"] target_s = data_dict["validation"]["softmaxGenotype"] # we need copies of the same tensors: input_u, target_u = Variable(input_s.data, volatile=True), Variable(input_s.data, volatile=True) output_s = self.net(input_s) output_u = self.net.autoencoder(input_u) output_s_p = self.get_p(output_s) _, target_index = torch.max(target_s, dim=1) supervised_loss = self.criterion_classifier(output_s, target_s) reconstruction_loss = self.criterion_autoencoder(output_u, target_u) performance_estimators.set_metric(batch_idx, "test_supervised_loss", supervised_loss.data[0]) performance_estimators.set_metric(batch_idx, "test_reconstruction_loss", reconstruction_loss.data[0]) performance_estimators.set_metric_with_outputs(batch_idx, "test_accuracy", supervised_loss.data[0], output_s_p, targets=target_index) progress_bar(batch_idx * self.mini_batch_size, self.max_validation_examples, performance_estimators.progress_message(["test_supervised_loss", "test_reconstruction_loss", "test_accuracy"])) if ((batch_idx + 1) * self.mini_batch_size) > self.max_validation_examples: break # print() finally: data_provider.close() test_metric = performance_estimators.get_metric(self.get_test_metric_name()) assert test_metric is not None, self.get_test_metric_name() + "must be found among estimated performance metrics" if not self.args.constant_learning_rates: self.scheduler_train.step(test_metric, epoch) return performance_estimators
def test_autoencoder(self, epoch, performance_estimators=None): print('\nTesting, epoch: %d' % epoch) if performance_estimators is None: performance_estimators = PerformanceList() performance_estimators += [LossHelper("test_loss")] self.net.eval() for performance_estimator in performance_estimators: performance_estimator.init_performance_metrics() for batch_idx, (_, data_dict) in enumerate( self.problem.validation_loader_range( 0, self.args.num_validation)): inputs = data_dict["input"] if self.use_cuda: inputs = inputs.cuda() inputs, targets = Variable(inputs, volatile=True), Variable(inputs, volatile=True) outputs = self.net(inputs) loss = self.criterion(outputs, targets) performance_estimators.set_metric_with_outputs( batch_idx, "test_loss", loss.data[0], outputs, targets) progress_bar( batch_idx * self.mini_batch_size, self.max_validation_examples, performance_estimators.progress_message(["test_loss"])) if ((batch_idx + 1) * self.mini_batch_size) > self.max_validation_examples: break # print() # Apply learning rate schedule: test_accuracy = performance_estimators.get_metric("test_loss") assert test_accuracy is not None, "test_loss must be found among estimated performance metrics" if not self.args.constant_learning_rates: self.scheduler_train.step(test_accuracy, epoch) return performance_estimators
def test_semisup_aae(self, epoch, performance_estimators=None): print('\nTesting, epoch: %d' % epoch) if performance_estimators is None: performance_estimators = PerformanceList() performance_estimators += [FloatHelper("reconstruction_loss")] performance_estimators += [LossHelper("test_loss")] performance_estimators += [AccuracyHelper("test_")] performance_estimators += [FloatHelper("weight")] self.net.eval() for performance_estimator in performance_estimators: performance_estimator.init_performance_metrics() validation_loader_subset = self.problem.validation_loader_range( 0, self.args.num_validation) data_provider = MultiThreadedCpuGpuDataProvider( iterator=zip(validation_loader_subset), is_cuda=self.use_cuda, batch_names=["validation"], requires_grad={"validation": []}, volatile={ "validation": ["input", "softmaxGenotype"], }, recode_functions={"input": self.normalize_inputs}) self.net.eval() try: for batch_idx, (_, data_dict) in enumerate(data_provider): input_s = data_dict["validation"]["input"] target_s = data_dict["validation"]["softmaxGenotype"] # Estimate the reconstruction loss on validation examples: reconstruction_loss = self.net.get_crossconstruction_loss( input_s, input_s, target_s) # now evaluate prediction of categories: categories_predicted, latent_code = self.net.encoder(input_s) # categories_predicted+=self.net.latent_to_categories(latent_code) categories_predicted_p = self.get_p(categories_predicted) categories_predicted_p[ categories_predicted_p != categories_predicted_p] = 0.0 _, target_index = torch.max(target_s, dim=1) categories_loss = self.net.semisup_loss_criterion( categories_predicted, target_s) weight = self.estimate_example_density_weight(latent_code) performance_estimators.set_metric(batch_idx, "reconstruction_loss", reconstruction_loss.data[0]) performance_estimators.set_metric(batch_idx, "weight", weight) performance_estimators.set_metric_with_outputs( batch_idx, "test_accuracy", reconstruction_loss.data[0], categories_predicted_p, target_index) performance_estimators.set_metric_with_outputs( batch_idx, "test_loss", categories_loss.data[0] * weight, categories_predicted_p, target_s) if not self.args.no_progress: progress_bar( batch_idx * self.mini_batch_size, self.max_validation_examples, performance_estimators.progress_message([ "test_loss", "test_accuracy", "reconstruction_loss" ])) if ((batch_idx + 1) * self.mini_batch_size) > self.max_validation_examples: break # print() finally: data_provider.close() # Apply learning rate schedules: test_metric = performance_estimators.get_metric( self.get_test_metric_name()) assert test_metric is not None, ( self.get_test_metric_name() + "must be found among estimated performance metrics") if not self.args.constant_learning_rates: for scheduler in self.schedulers: scheduler.step(test_metric, epoch) # Run the garbage collector to try to release memory we no longer need: import gc gc.collect() return performance_estimators