def evaluate()

in src/evaluation.py [0:0]

• 54 lines of code
• 9 McCabe index (conditional complexity)

    def evaluate(self, n_epoch):
        """
        Evaluate all models / log evaluation results.
        """
        params = self.params
        logger.info('')

        # reconstruction loss
        ae_loss = self.eval_reconstruction_loss()

        # latent discriminator accuracy
        log_lat_dis = []
        if params.n_lat_dis:
            lat_dis_accu = self.eval_lat_dis_accuracy()
            log_lat_dis.append(('lat_dis_accu', np.mean(lat_dis_accu)))
            for accu, (name, _) in zip(lat_dis_accu, params.attr):
                log_lat_dis.append(('lat_dis_accu_%s' % name, accu))
            logger.info('Latent discriminator accuracy:')
            print_accuracies(log_lat_dis)

        # patch discriminator accuracy
        log_ptc_dis = []
        if params.n_ptc_dis:
            ptc_dis_real_preds, ptc_dis_fake_preds = self.eval_ptc_dis_accuracy()
            accu_real = (np.array(ptc_dis_real_preds).astype(np.float32) >= 0.5).mean()
            accu_fake = (np.array(ptc_dis_fake_preds).astype(np.float32) <= 0.5).mean()
            log_ptc_dis.append(('ptc_dis_preds_real', np.mean(ptc_dis_real_preds)))
            log_ptc_dis.append(('ptc_dis_preds_fake', np.mean(ptc_dis_fake_preds)))
            log_ptc_dis.append(('ptc_dis_accu_real', accu_real))
            log_ptc_dis.append(('ptc_dis_accu_fake', accu_fake))
            log_ptc_dis.append(('ptc_dis_accu', (accu_real + accu_fake) / 2))
            logger.info('Patch discriminator accuracy:')
            print_accuracies(log_ptc_dis)

        # classifier discriminator accuracy
        log_clf_dis = []
        if params.n_clf_dis:
            clf_dis_accu = self.eval_clf_dis_accuracy()
            k = 0
            log_clf_dis += [('clf_dis_accu', np.mean(clf_dis_accu))]
            for name, n_cat in params.attr:
                log_clf_dis.append(('clf_dis_accu_%s' % name, np.mean(clf_dis_accu[k:k + n_cat])))
                log_clf_dis.extend([('clf_dis_accu_%s_%i' % (name, j), clf_dis_accu[k + j])
                                    for j in range(n_cat)])
                k += n_cat
            logger.info('Classifier discriminator accuracy:')
            print_accuracies(log_clf_dis)

        # classifier accuracy
        log_clf = []
        clf_accu = self.eval_clf_accuracy()
        k = 0
        log_clf += [('clf_accu', np.mean(clf_accu))]
        for name, n_cat in params.attr:
            log_clf.append(('clf_accu_%s' % name, np.mean(clf_accu[k:k + n_cat])))
            log_clf.extend([('clf_accu_%s_%i' % (name, j), clf_accu[k + j])
                            for j in range(n_cat)])
            k += n_cat
        logger.info('Classifier accuracy:')
        print_accuracies(log_clf)

        # log autoencoder loss
        logger.info('Autoencoder loss: %.5f' % ae_loss)

        # JSON log
        to_log = dict([
            ('n_epoch', n_epoch),
            ('ae_loss', ae_loss)
        ] + log_lat_dis + log_ptc_dis + log_clf_dis + log_clf)
        logger.debug("__log__:%s" % json.dumps(to_log))

        return to_log