Exemple #1
0
def px(pae_dict):
    saver = tf.train.Saver()

    # P(x) Session
    config = tf.ConfigProto()
    config.gpu_options.allow_growth = True
    with tf.Session(config=config) as sess:
        # Restore pretrained model
        saver.restore(sess, pxfinestr.split('.meta')[0])

        if cp.get('Experiment', 'PREFIX') == 'MNIST':
            # Save hidden/output layer results for pipeline training
            px_Z_latent = utils.run_OOM(sess,
                                        pae_dict['conv_in'],
                                        XX_full,
                                        pae_dict['conv_z'],
                                        batch_size=batch_size)
        else:
            px_Z_latent = utils.run_OOM(sess,
                                        pae_dict['sda_in'],
                                        XX_full,
                                        pae_dict['sda_hidden'],
                                        batch_size=batch_size)

        # Print clustering ACC
        utils.log_accuracy(cp, YY_full, px_Z_latent, 'PX - ACC FULL', SEED)

        # Print clustering NMI
        utils.log_NMI(cp, YY_full, px_Z_latent, 'PX - NMI FULL', SEED)

        # Print clustering CHS score
        utils.log_CHS(cp, XX_full, px_Z_latent, 'PX - CHS FULL', SEED)

    sess.close()
Exemple #2
0
def evitram(evitramd):
    saver = tf.train.Saver()

    config = tf.ConfigProto()
    config.gpu_options.allow_growth = True
    with tf.Session(config=config) as sess:
        # Restore pretrained model
        saver.restore(sess, evitramfinestr.split('.meta')[0])

        if cp.get('Experiment', 'PREFIX') == 'MNIST':
            # Save hidden/output layer results for pipeline training
            px_Z_latent = utils.run_OOM(sess,
                                        evitram_dict['conv_in'],
                                        XX_full,
                                        evitram_dict['conv_z'],
                                        batch_size=batch_size)
            # Save latent space
            utils.save_OOM(sess,
                           evitram_dict['conv_in'],
                           XX_full,
                           evitram_dict['conv_z'],
                           path='COND_' + cp.get('Experiment', 'PX_Z_FULL'),
                           batch_size=batch_size)

            # Save reconstruction
            utils.save_OOM(sess,
                           evitram_dict['conv_in'],
                           XX_full,
                           evitram_dict['conv_out'],
                           path='COND_' +
                           cp.get('Experiment', 'PX_XREC_TRAIN'),
                           batch_size=batch_size)
        else:
            px_Z_latent = utils.run_OOM(sess,
                                        evitram_dict['sda_in'],
                                        XX_full,
                                        evitram_dict['sda_hidden'],
                                        batch_size=batch_size)

            utils.save_OOM(sess,
                           evitram_dict['sda_in'],
                           XX_full,
                           evitram_dict['sda_hidden'],
                           path='COND_' + cp.get('Experiment', 'PX_Z_FULL'),
                           batch_size=batch_size)

        # Print clustering ACC
        utils.log_accuracy(cp, YY_full, px_Z_latent, 'COND - ACC FULL', SEED)

        # Print clustering NMI
        utils.log_NMI(cp, YY_full, px_Z_latent, 'COND - NMI FULL', SEED)

        # Print clustering CHS score
        utils.log_CHS(cp, XX_full, px_Z_latent, 'COND - CHS FULL', SEED)

    sess.close()
Exemple #3
0
def evitram(evitramd):
    saver = tf.train.Saver()

    config = tf.ConfigProto()
    config.gpu_options.allow_growth = True
    with tf.Session(config=config) as sess:
        # Restore pretrained model
        saver.restore(sess, evitramfinestr.split('.meta')[0])

        if cp.get('Experiment', 'PREFIX') == 'MNIST' or \
            cp.get('Experiment', 'PREFIX') == 'AMNIST':
            # Save hidden/output layer results for pipeline training
            px_Z_latent = utils.run_OOM(sess, evitram_dict['conv_in'], XX_full,
                          evitram_dict['conv_z'],
                          batch_size=batch_size)
        elif cp.get('Experiment', 'PREFIX') == 'WEATHER':
            # Save hidden/output layer results for pipeline training
            px_Z_latent_tr = utils.run_OOM(sess, evitram_dict['conv_in'], XX_full,
                                        evitram_dict['conv_z'],
                                        batch_size=batch_size)
            px_Z_latent_te = utils.run_OOM(sess, evitram_dict['conv_in'], XX_test,
                                        evitram_dict['conv_z'],
                                        batch_size=batch_size)
        else:
            px_Z_latent_tr = utils.run_OOM(sess, evitram_dict['sda_in'], XX_full,
                                        evitram_dict['sda_hidden'],
                                        batch_size=batch_size)
            if not(np.array_equal(XX_test, np.zeros(shape=(1,1)))):
                px_Z_latent_te = utils.run_OOM(sess, evitram_dict['sda_in'], XX_test,
                                            evitram_dict['sda_hidden'],
                                            batch_size=batch_size)


        if 'WEATHER' in cp.get('Experiment', 'PREFIX'):
           # Print clustering ACC
            utils.log_accuracy_isof(cp, YY_full, px_Z_latent_tr,
                               'COND - ACC FULL (Train)', SEED)
            if not(np.array_equal(XX_test, np.zeros(shape=(1,1)))):
                utils.log_accuracy_isof(cp, YY_test, px_Z_latent_te,
                                   'COND - ACC FULL (Test)', SEED)

            utils.log_anomalyPRF_isof(cp, YY_full, px_Z_latent_tr,
                               'COND - PRF FULL (Test)', SEED)
            if not(np.array_equal(XX_test, np.zeros(shape=(1,1)))):
                utils.log_anomalyPRF_isof(cp, YY_test, px_Z_latent_te,
                                   'COND - PRF FULL (Test)', SEED)

        else:
            # Print clustering ACC
            utils.log_accuracy(cp, YY_full, px_Z_latent,
                               'PX - ACC FULL', SEED)

            # Print clustering NMI
            utils.log_NMI(cp, YY_full, px_Z_latent,
                          'PX - NMI FULL', SEED)

            # Print clustering CHS score
            utils.log_CHS(cp, XX_full, px_Z_latent,
                      'PX - CHS FULL', SEED)

    sess.close()