def test_epoch_end(self, outputs):
        # avg_loss = torch.stack([x['test_loss'] for x in outputs]).mean()
        self.combine_movies_with_z_values()

        avg_loss = np.array([x['test_loss'] for x in outputs]).mean()
        mse_test = np.array([x['MSE-Test'] for x in outputs])
        kld_test =np.array([x['KLD-Test'] for x in outputs])
        # ls_mce = {x['mce'] for x in outputs}
        utils.save_dict_as_json(self.mce_batch_test, 'mce_results.json', self.experiment_path_test)
        # avg_mce = dict(utils.calculate_mean_of_ls_dict(ls_mce))

        # avg_rmse = np.array([x['rmse'] for x in outputs]).mean()
        # avg_rmse_w_zeros = np.array([x['rmse_w_zeros'] for x in outputs]).mean()
        # avg_mse = np.array([x['mse'] for x in outputs]).mean()
        # avg_mse_w_zeros = np.array([x['mse_w_zeros'] for x in outputs]).mean()

        tensorboard_logs = {'test_loss': avg_loss, 'MSE-Test':mse_test,'KLD-Test': kld_test }
        assert len(mse_test)==len(kld_test)
        for i in range(0, len(mse_test)):
            wandb_logger.log_metrics({'MSE-Test': mse_test[i],'KLD-Test': kld_test[i]} )

        # wandb_logger.log_metrics({'rmse': avg_rmse,
        #                           'rmse_w_zeros':avg_rmse_w_zeros,
        #                           'mse': avg_mse,
        #                           'mse_w_zeros': avg_mse_w_zeros})#, 'kld_matrix':self.kld_matrix

        return {'test_loss': avg_loss,
                'log': tensorboard_logs,
                # 'rmse': avg_rmse,
                'MSE-Test':mse_test,
                'KLD-test': kld_test }#, , 'mce':avg_mce
    def training_epoch_end(self, outputs):
        #print("Saving MCE before KLD is applied...")
        avg_logvar = np.array([x['logvar'] for x in outputs]).mean(axis=0)
        # avg_var = np.array([x['var'] for x in outputs]).mean(axis=0)
        avg_mu = np.array([x['mu'] for x in outputs]).mean(axis=0)

        self.np_logvar_train = np.append(self.np_logvar_train, [avg_logvar], axis=0)
        self.np_mu_train = np.append(self.np_mu_train, [avg_mu], axis=0)



        if(self.current_epoch == self.sigmoid_annealing_threshold ):
            utils.save_dict_as_json(self.mce_batch_train, 'mce_results_wo_kld.json', self.experiment_path_train)
        return {}
Exemplo n.º 3
0
    def test_epoch_end(self, outputs):
        # avg_loss = torch.stack([x['test_loss'] for x in outputs]).mean()
        self.combine_movies_with_z_values()

        avg_loss = np.array([x['test_loss'] for x in outputs]).mean()
        mse_test = np.array([x['MSE-Test'] for x in outputs])
        kld_test = np.array([x['KLD-Test'] for x in outputs])
        avg_var = np.array([x['var'] for x in outputs]).mean(axis=0)
        avg_mean = np.array([x['mean'] for x in outputs]).mean(axis=0)
        self.np_var_test = np.append(self.np_var_test, [avg_var], axis=0)

        # ls_mce = {x['mce'] for x in outputs}
        # utils.save_dict_as_json(outputs[0]['mce'], 'mce_results.json', self.experiment_path) #TODO This is wrong as only one batch is processed, should be all
        utils.save_dict_as_json(self.mce_batch_test, 'mce_results.json',
                                self.experiment_path_test)
        # avg_mce = dict(calculate_mean_of_ls_dict(ls_mce))

        avg_rmse = np.array([x['rmse'] for x in outputs]).mean()
        avg_rmse_w_zeros = np.array([x['rmse_w_zeros']
                                     for x in outputs]).mean()
        avg_mse = np.array([x['mse'] for x in outputs]).mean()
        avg_mse_w_zeros = np.array([x['mse_w_zeros'] for x in outputs]).mean()

        tensorboard_logs = {
            'test_loss': avg_loss,
            'MSE-Test': mse_test,
            'KLD-Test': kld_test
        }
        assert len(mse_test) == len(kld_test)
        for i in range(0, len(mse_test)):
            wandb_logger.log_metrics({
                'MSE-Test': mse_test[i],
                'KLD-Test': kld_test[i]
            })

        wandb_logger.log_metrics({
            'rmse': avg_rmse,
            'rmse_w_zeros': avg_rmse_w_zeros,
            'mse': avg_mse,
            'mse_w_zeros': avg_mse_w_zeros
        })  #, 'kld_matrix':self.kld_matrix

        return {
            'test_loss': avg_loss,
            'log': tensorboard_logs,
            'rmse': avg_rmse,
            'MSE-Test': mse_test,
            'KLD-test': kld_test
        }  #, , 'mce':avg_mce
def generate_distribution_df():
    dct_attribute_distribution = utils.compute_relative_frequency(
        pd.read_csv('../data/generated/syn.csv'))
    utils.save_dict_as_json(dct_attribute_distribution, 'syn_attribute_distribution.json')