示例#1
0
def main():
    # parse arguments
    args = parse_args()
    if args is None:
      exit()

    # open session
    with tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) as sess:
        gan = GAN(sess, args)

        # build graph
        gan.build_model()

        if args.phase == 'train' :
            gan.train()
            print(" [*] Training finished!")

        if args.phase == 'test' :
            gan.test()
            print(" [*] Test finished!")
示例#2
0
def main(argv):
    # Load configs from file

    config = json.load(open(FLAGS.config))
    # set_backend()

    # Set name
    #name = '{}_{}_'.format(config['INPUT_NAME'], config['TARGET_NAME'])
    #for l in config['LABELS']:
    #    name += str(l)
    #config['NAME'] += '_' + name

    if FLAGS.use_wandb:
        import wandb
        resume_wandb = True if FLAGS.wandb_resume_id is not None else False
        wandb.init(config=config,
                   resume=resume_wandb,
                   id=FLAGS.wandb_resume_id,
                   project='EchoGen',
                   name=FLAGS.wandb_run_name)

    # Initialize GAN
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    print(device)

    model = GAN(config, FLAGS.use_wandb, device, FLAGS.dataset_path)

    # load trained models if they exist
    if FLAGS.ckpt_load is not None:
        model.load(f'{FLAGS.ckpt_load}/generator_last_checkpoint.bin',
                   model='generator')
        model.load(f'{FLAGS.ckpt_load}/discriminator_last_checkpoint.bin',
                   model='discriminator')

    if FLAGS.test:
        model.test()
    else:
        model.train()
示例#3
0
文件: main.py 项目: dkdl1234/DLDK-GAN
                     (FLAGS.updates_per_epoch * FLAGS.batch_size)

                    #every 10th batch, write summaries to disk
                    if (i % 10) == 0:
                        model.write_summaries(sum_epoch=i +
                                              (num_batches * epoch))
                        model.calculate_accuracy(nova_params,
                                                 epoch=i +
                                                 (num_batches * epoch))

                    del real_images, nova_params

                #calculate testing loss and accuracy
                inputs = novaSet.test_info(which_config=[config, 'data'],
                                           which_type=config_type)
                gen_tst_loss, gen_tst_accur, disc_tst_loss, disc_tst_accur = model.test(
                    imgs=inputs[0], data=inputs[1], epoch=epoch)
                print("Epoch %d : Gen Test Loss %f,  Gen Test Accur %f, Disc Test Loss %f, Disc Test Accur %f, Gen Train Loss %f"\
                  % (epoch, gen_tst_loss, gen_tst_accur, disc_tst_loss, disc_tst_accur, training_loss))
                del inputs

                #every 10 epochs, write the models' parameters to the disk an save images
                if (epoch % 10) == 0:
                    model.save_model(epoch)

                    #save images
                    print("Saving Image Summaries")
                    images = novaSet.next_batch(which_config=[config, 'data'],
                                                which_type=config_type,
                                                batch_size=5)
                    model.save_image_summary(r_inputs=images[0],
                                             f_inputs=images[1],